private void changeMapX(float radians) { Geocentric lookVector = mUser.getLookDir(); Geocentric crossVector = MathUtils.crossProduct(lookVector, mUser.getLookNormal()); Geocentric deltaLookVector = new Geocentric(crossVector.x * radians, crossVector.y * radians, crossVector.z * radians); Geocentric newLookDir = MathUtils.add(lookVector, deltaLookVector); newLookDir = MathUtils.normalize(newLookDir); mUser.setLookDir(newLookDir); }
private void rotate(float radians) { Geocentric lookVector = mUser.getLookDir(); Geocentric upVector = mUser.getLookNormal(); Matrix3x3 rotationMatrix = MathUtils.createRotationMatrix(radians, lookVector); Geocentric newUpVector = MathUtils.multiplyGeocentricAndMatrix3x3(rotationMatrix, upVector); newUpVector = MathUtils.normalize(newUpVector); mUser.setLookNormal(newUpVector); }
private void changeMapY(float radians) { Geocentric lookVector = mUser.getLookDir(); Geocentric upVector = mUser.getLookNormal(); Geocentric deltaLookVector = new Geocentric(upVector.x * -radians, upVector.y * -radians, upVector.z * -radians); Geocentric newLookDir = MathUtils.add(lookVector, deltaLookVector); newLookDir = MathUtils.normalize(newLookDir); Geocentric deltaUpVector = new Geocentric(lookVector.x * radians, lookVector.y * radians, lookVector.z * radians); Geocentric newUpDir = MathUtils.add(upVector, deltaUpVector); newUpDir = MathUtils.normalize(newUpDir); mUser.setLookDir(newLookDir); mUser.setLookNormal(newUpDir); }
private boolean processTouch(int action, MotionEvent e, boolean sensorMode) { switch (action) { case MotionEvent.ACTION_DOWN: if (mCurrentTouchState == TouchState.INIT) { mInitX = (int) e.getX(); mInitY = (int) e.getY(); if (sensorMode) { return true; } mCurrentTouchState = TouchState.DRAG_ONE; mPreviousX1 = e.getX(); mPreviousY1 = e.getY(); return true; } case MotionEvent.ACTION_POINTER_DOWN: if (sensorMode) { return true; } if (mCurrentTouchState == TouchState.DRAG_ONE) { mCurrentTouchState = TouchState.DRAG_TWO; mPointerIndex = e.getActionIndex(); mPreviousX1 = e.getX(); mPreviousY1 = e.getY(); mPreviousX2 = e.getX(mPointerIndex); mPreviousY2 = e.getY(mPointerIndex); return true; } case MotionEvent.ACTION_MOVE: if (sensorMode) { return true; } if (mCurrentTouchState == TouchState.DRAG_ONE) { float currentX = e.getX(); float currentY = e.getY(); float deltaX = currentX - mPreviousX1; float deltaY = currentY - mPreviousY1; float radsPerPixel = mStarMapperRenderer.mFovYRad / mStarMapperRenderer.mScreenHeight; changeMapX(-deltaX * radsPerPixel); changeMapY(-deltaY * radsPerPixel); mStarMapperRenderer.mLookX = mUser.getLookX(); mStarMapperRenderer.mLookY = mUser.getLookY(); mStarMapperRenderer.mLookZ = mUser.getLookZ(); mStarMapperRenderer.mUpX = mUser.getNormalX(); mStarMapperRenderer.mUpY = mUser.getNormalY(); mStarMapperRenderer.mUpZ = mUser.getNormalZ(); mPreviousX1 = currentX; mPreviousY1 = currentY; return true; } else if (mCurrentTouchState == TouchState.DRAG_TWO) { float currentX1 = e.getX(); float currentY1 = e.getY(); float currentX2 = e.getX(mPointerIndex); float currentY2 = e.getY(mPointerIndex); float deltaX1 = currentX1 - mPreviousX1; float deltaY1 = currentY1 - mPreviousY1; float deltaX2 = currentX2 - mPreviousX2; float deltaY2 = currentY2 - mPreviousY2; float radsPerPixel = mStarMapperRenderer.mFovYRad / mStarMapperRenderer.mScreenHeight; changeMapX(-((deltaX1 + deltaX2) / 2) * radsPerPixel); changeMapY(-((deltaY1 + deltaY2) / 2) * radsPerPixel); float vPreviousX = mPreviousX1 - mPreviousX2; float vPreviousY = mPreviousY1 - mPreviousY2; float vCurrentX = currentX1 - currentX2; float vCurrentY = currentY1 - currentY2; /* Need a 'stretch' function here for field of view once zoom is implemented */ float vectorRatio = (float) Math.sqrt( (vCurrentX * vCurrentX + vCurrentY * vCurrentY) / (vPreviousX * vPreviousX + vPreviousY * vPreviousY)); mStarMapperRenderer.mFovYRad = mZoomer.zoomBy(mStarMapperRenderer.mFovYRad, 1.0f / vectorRatio); mStarMapperRenderer.mUpdatePerspective = true; double anglePrevious = Math.atan2(vPreviousX, vPreviousY); double angleCurrent = Math.atan2(vCurrentX, vCurrentY); float angleDelta = (float) (anglePrevious - angleCurrent); rotate(angleDelta); mStarMapperRenderer.mLookX = mUser.getLookX(); mStarMapperRenderer.mLookY = mUser.getLookY(); mStarMapperRenderer.mLookZ = mUser.getLookZ(); mStarMapperRenderer.mUpX = mUser.getNormalX(); mStarMapperRenderer.mUpY = mUser.getNormalY(); mStarMapperRenderer.mUpZ = mUser.getNormalZ(); mPreviousX1 = currentX1; mPreviousY1 = currentY1; mPreviousX2 = currentX2; mPreviousY2 = currentY2; return true; } case MotionEvent.ACTION_UP: int last_X = (int) e.getX(); int last_Y = (int) e.getY(); int dx = Math.abs(last_X - mInitX); int dy = Math.abs(last_Y - mInitY); if (dx <= 20 && dy <= 20) { for (Label label : mStarMapperRenderer.mLabelManager.LabelSet) { int xll = label.screenPos_xll; int yll = label.screenPos_yll; int xur = label.screenPos_xur; int yur = label.screenPos_yur; LabelTypeEnum type = label.getType(); if (label.isOnScreen() && xll <= mInitX && xur >= mInitX && yll <= mInitY && yur >= mInitY && type != LabelTypeEnum.GRID) { String name = label.getText().replaceAll(" ", "_"); String URL = "http://en.wikipedia.org/wiki/" + name; if (type == LabelTypeEnum.CONSTELLATION || type == LabelTypeEnum.STAR || type == LabelTypeEnum.PLANET) { URL = URL + "_(" + label.getType().name().toLowerCase() + ")"; } Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(URL)); startActivity(browserIntent); // Toast.makeText(this, label.getText(), Toast.LENGTH_SHORT).show(); } } } if (sensorMode) { return true; } if (mCurrentTouchState != TouchState.INIT) { mCurrentTouchState = TouchState.INIT; return true; } case MotionEvent.ACTION_POINTER_UP: if (sensorMode) { return true; } if (mCurrentTouchState == TouchState.DRAG_TWO) { mCurrentTouchState = TouchState.INIT; } } return false; }
@Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); PreferenceManager.setDefaultValues(this, R.xml.preferences, false); settingsFragment = new SettingsFragment(); sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this); sharedPreferences.registerOnSharedPreferenceChangeListener(this); // Debug // setContentView(R.layout.title); mGLSurfaceView = new MyGLSurfaceView(this); // Create an OpenGL ES 2.0 context mGLSurfaceView.setEGLContextClientVersion(2); mGLSurfaceView.setPreserveEGLContextOnPause(true); // mGLSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY); setContentView(mGLSurfaceView); // The app user object mUser = new User(); mStarMapperRenderer = new StarMapperRenderer(this, mUser); // Set the StarMapperRenderer for drawing on the GLSurfaceView mGLSurfaceView.setRenderer(mStarMapperRenderer); // Retrieving location mLocationManager = (LocationManager) getSystemService(Context.LOCATION_SERVICE); Criteria locCriteria = new Criteria(); // gps locCriteria.setAccuracy(Criteria.ACCURACY_FINE); locCriteria.setBearingRequired(false); locCriteria.setAltitudeRequired(false); locCriteria.setCostAllowed(true); locCriteria.setSpeedRequired(false); locCriteria.setPowerRequirement(Criteria.POWER_LOW); String locProvider = mLocationManager.getBestProvider(locCriteria, true); Location loc = mLocationManager.getLastKnownLocation(locProvider); mUser.setGeoLocation((float) loc.getLatitude(), (float) loc.getLongitude()); mUser.setGeomagneticField(); mUser.setZenith(); // Initializing touch variables mPreviousX1 = 0; mPreviousY1 = 0; mPreviousX2 = 0; mPreviousY2 = 0; mPointerIndex = 0; mCurrentTouchState = TouchState.INIT; mZoomer = new Zoom(); // Initializing auto sensors mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); mAccelerometerSensor = null; mMagneticFieldSensor = null; mAccelerometerModel = null; mMagneticFieldModel = null; // Check for necessary sensors if ((mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) == null) || (mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) == null)) { // phone doesn't have appropriate sensors, only use manual mode mUseAutoSensorMode = false; } else { // phone has sensors, initialize them mAccelerometerSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); mMagneticFieldSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD); mUseAutoSensorMode = true; mAccelerometerModel = new AccelerometerModel(mUser, mStarMapperRenderer, mGLSurfaceView); mMagneticFieldModel = new MagneticFieldModel(mUser, mStarMapperRenderer, mGLSurfaceView); } if (mAccelerometerSensor != null) { mSensorManager.registerListener( mAccelerometerModel, mAccelerometerSensor, SensorManager.SENSOR_DELAY_FASTEST); } if (mMagneticFieldSensor != null) { mSensorManager.registerListener( mMagneticFieldModel, mMagneticFieldSensor, SensorManager.SENSOR_DELAY_FASTEST); } // ****** DEBUG ****** // mUseAutoSensorMode = false; // flinger flinger = new GestureDetector( this, new Flinger( new FlingListener() { public void fling(float distanceX, float distanceY) { float radsPerPixel = mStarMapperRenderer.mFovYRad / mStarMapperRenderer.mScreenHeight; changeMapX(-distanceX * radsPerPixel); changeMapY(-distanceY * radsPerPixel); mStarMapperRenderer.mLookX = mUser.getLookX(); mStarMapperRenderer.mLookY = mUser.getLookY(); mStarMapperRenderer.mLookZ = mUser.getLookZ(); mStarMapperRenderer.mUpX = mUser.getNormalX(); mStarMapperRenderer.mUpY = mUser.getNormalY(); mStarMapperRenderer.mUpZ = mUser.getNormalZ(); } })); }
@Override public void onSensorChanged(SensorEvent event) { // smoothing code for (int i = 0; i < 3; ++i) { last[i] = current[i]; float diff = event.values[i] - last[i]; float correction = diff * alpha; for (int j = 1; j < exponent; ++j) { correction *= Math.abs(diff); } if (correction > Math.abs(diff) || correction < -Math.abs(diff)) { correction = diff; } current[i] = last[i] + correction; } mNewAccelerationReading.x = -current[0]; mNewAccelerationReading.y = -current[1]; mNewAccelerationReading.z = -current[2]; mUser.setAcceleration(mNewAccelerationReading); Matrix3x3 phoneSpaceMatrix = mUser.getLocalNorthAndUpMatrix_PhoneSpace(); Matrix3x3 celestialSpaceMatrix = mUser.getLocalNorthAndUpMatrix_CelestialSpace(); Matrix3x3 viewTransform = MathUtils.multiplyMatrices(celestialSpaceMatrix, phoneSpaceMatrix); Geocentric lookVector = MathUtils.multiplyGeocentricAndMatrix3x3(viewTransform, Z_DOWN_VECTOR); Geocentric upVector = MathUtils.multiplyGeocentricAndMatrix3x3(viewTransform, INIT_UP_VECTOR); // Log.d("AccelerometerModel", "INSIDE ACCELEROMETER SENSORCHANGED"); // Log.d("AccelerometerModel", "ps_xx: " + String.valueOf(phoneSpaceMatrix.xx) + " ps_xy: " + // String.valueOf(phoneSpaceMatrix.xy) + " ps_xz: " + String.valueOf(phoneSpaceMatrix.xz)); // Log.d("AccelerometerModel", "ps_yx: " + String.valueOf(phoneSpaceMatrix.yx) + " ps_yy: " + // String.valueOf(phoneSpaceMatrix.yy) + " ps_yz: " + String.valueOf(phoneSpaceMatrix.yz)); // Log.d("AccelerometerModel", "ps_zx: " + String.valueOf(phoneSpaceMatrix.zx) + " ps_zy: " + // String.valueOf(phoneSpaceMatrix.zy) + " ps_zz: " + String.valueOf(phoneSpaceMatrix.zz)); // Log.d("AccelerometerModel", "vt_xx: " + String.valueOf(viewTransform.xx) + " vt_xy: " + // String.valueOf(viewTransform.xy) + " vt_xz: " + String.valueOf(viewTransform.xz)); // Log.d("AccelerometerModel", "vt_yx: " + String.valueOf(viewTransform.yx) + " vt_yy: " + // String.valueOf(viewTransform.yy) + " vt_yz: " + String.valueOf(viewTransform.yz)); // Log.d("AccelerometerModel", "vt_zx: " + String.valueOf(viewTransform.zx) + " vt_zy: " + // String.valueOf(viewTransform.zy) + " vt_zz: " + String.valueOf(viewTransform.zz)); // Log.d("AccelerometerModel", "event.values[0]: " + String.valueOf(event.values[0]) + " // event.values[1]: " + String.valueOf(event.values[1] + " event.values[2]: " + // String.valueOf(event.values[2]))); mUser.lookDir = lookVector; mUser.lookNormal = upVector; mRenderer.mLookX = mUser.getLookX(); mRenderer.mLookY = mUser.getLookY(); mRenderer.mLookZ = mUser.getLookZ(); mRenderer.mUpX = mUser.getNormalX(); mRenderer.mUpY = mUser.getNormalY(); mRenderer.mUpZ = mUser.getNormalZ(); // Log.d("AccelerometerModel", "lastX: " + String.valueOf(last[0]) + " lastY: " + // String.valueOf(last[1]) + " lastZ: " + String.valueOf(last[2])); // Log.d("AccelerometerModel", "currentX: " + String.valueOf(current[0]) + " currentY: " + // String.valueOf(current[1]) + " currentZ: " + String.valueOf(current[2])); // Log.d("AccelerometerModel", "mLookX: " + String.valueOf(mUser.getLookX()) + " mLookY: " + // String.valueOf(mUser.getLookY()) + " mLookZ: " + String.valueOf(mUser.getLookZ())); // Log.d("AccelerometerModel", "mUpX: " + String.valueOf(mUser.getNormalX()) + " mUpY: " + // String.valueOf(mUser.getNormalY()) + " mUpZ: " + String.valueOf(mUser.getNormalZ())); // mGLSurfaceView.requestRender(); }