Reformat to Android style guidelines
Change-Id: Ib9d7e39464a246dbaae38e00fbb325f153f89f65
This commit is contained in:
Mathias Agopian
@@ -49,435 +49,412 @@ import android.view.WindowManager;
|
||||
|
||||
public class AccelerometerPlayActivity extends Activity {
|
||||
|
||||
private SimulationView mSimulationView;
|
||||
private SensorManager mSensorManager;
|
||||
private PowerManager mPowerManager;
|
||||
private WindowManager mWindowManager;
|
||||
private Display mDisplay;
|
||||
private WakeLock mWakeLock;
|
||||
private SimulationView mSimulationView;
|
||||
private SensorManager mSensorManager;
|
||||
private PowerManager mPowerManager;
|
||||
private WindowManager mWindowManager;
|
||||
private Display mDisplay;
|
||||
private WakeLock mWakeLock;
|
||||
|
||||
/** Called when the activity is first created. */
|
||||
@Override
|
||||
public void onCreate(Bundle savedInstanceState) {
|
||||
super.onCreate(savedInstanceState);
|
||||
/** Called when the activity is first created. */
|
||||
@Override
|
||||
public void onCreate(Bundle savedInstanceState) {
|
||||
super.onCreate(savedInstanceState);
|
||||
|
||||
// Get an instance of the SensorManager
|
||||
mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
|
||||
// Get an instance of the SensorManager
|
||||
mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
|
||||
|
||||
// Get an instance of the PowerManager
|
||||
mPowerManager = (PowerManager) getSystemService(POWER_SERVICE);
|
||||
// Get an instance of the PowerManager
|
||||
mPowerManager = (PowerManager) getSystemService(POWER_SERVICE);
|
||||
|
||||
// Get an instance of the WindowManager
|
||||
mWindowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
|
||||
mDisplay = mWindowManager.getDefaultDisplay();
|
||||
// Get an instance of the WindowManager
|
||||
mWindowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
|
||||
mDisplay = mWindowManager.getDefaultDisplay();
|
||||
|
||||
// Create a bright wake lock
|
||||
mWakeLock = mPowerManager.newWakeLock(
|
||||
PowerManager.SCREEN_BRIGHT_WAKE_LOCK, getClass().getName());
|
||||
// Create a bright wake lock
|
||||
mWakeLock = mPowerManager.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, getClass()
|
||||
.getName());
|
||||
|
||||
// instantiate our simulation view and set it as the activity's content
|
||||
mSimulationView = new SimulationView(this);
|
||||
setContentView(mSimulationView);
|
||||
}
|
||||
// instantiate our simulation view and set it as the activity's content
|
||||
mSimulationView = new SimulationView(this);
|
||||
setContentView(mSimulationView);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onResume() {
|
||||
super.onResume();
|
||||
/*
|
||||
* when the activity is resumed, we acquire a wake-lock so that the
|
||||
* screen stays on, since the user will likely not be fiddling with the
|
||||
* screen or buttons.
|
||||
*/
|
||||
mWakeLock.acquire();
|
||||
@Override
|
||||
protected void onResume() {
|
||||
super.onResume();
|
||||
/*
|
||||
* when the activity is resumed, we acquire a wake-lock so that the
|
||||
* screen stays on, since the user will likely not be fiddling with the
|
||||
* screen or buttons.
|
||||
*/
|
||||
mWakeLock.acquire();
|
||||
|
||||
// Start the simulation
|
||||
mSimulationView.startSimulation();
|
||||
}
|
||||
// Start the simulation
|
||||
mSimulationView.startSimulation();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onPause() {
|
||||
super.onPause();
|
||||
/*
|
||||
* When the activity is paused, we make sure to stop the simulation,
|
||||
* release our sensor resources and wake locks
|
||||
*/
|
||||
@Override
|
||||
protected void onPause() {
|
||||
super.onPause();
|
||||
/*
|
||||
* When the activity is paused, we make sure to stop the simulation,
|
||||
* release our sensor resources and wake locks
|
||||
*/
|
||||
|
||||
// Stop the simulation
|
||||
mSimulationView.stopSimulation();
|
||||
// Stop the simulation
|
||||
mSimulationView.stopSimulation();
|
||||
|
||||
// and release our wake-lock
|
||||
mWakeLock.release();
|
||||
}
|
||||
// and release our wake-lock
|
||||
mWakeLock.release();
|
||||
}
|
||||
|
||||
class SimulationView extends View implements SensorEventListener {
|
||||
// diameter of the balls in meters
|
||||
private static final float sBallDiameter = 0.004f;
|
||||
private static final float sBallDiameter2 = sBallDiameter
|
||||
* sBallDiameter;
|
||||
class SimulationView extends View implements SensorEventListener {
|
||||
// diameter of the balls in meters
|
||||
private static final float sBallDiameter = 0.004f;
|
||||
private static final float sBallDiameter2 = sBallDiameter * sBallDiameter;
|
||||
|
||||
// friction of the virtual table and air
|
||||
private static final float sFriction = 0.1f;
|
||||
// friction of the virtual table and air
|
||||
private static final float sFriction = 0.1f;
|
||||
|
||||
private Sensor mAccelerometer;
|
||||
private long mLastT;
|
||||
private float mLastDeltaT;
|
||||
private Sensor mAccelerometer;
|
||||
private long mLastT;
|
||||
private float mLastDeltaT;
|
||||
|
||||
private float mXDpi;
|
||||
private float mYDpi;
|
||||
private float mMetersToPixelsX;
|
||||
private float mMetersToPixelsY;
|
||||
private Bitmap mBitmap;
|
||||
private Bitmap mWood;
|
||||
private float mXOrigin;
|
||||
private float mYOrigin;
|
||||
private float mSensorX;
|
||||
private float mSensorY;
|
||||
private long mSensorTimeStamp;
|
||||
private long mCpuTimeStamp;
|
||||
private float mHorizontalBound;
|
||||
private float mVerticalBound;
|
||||
private final ParticleSystem mParticleSystem = new ParticleSystem();
|
||||
private float mXDpi;
|
||||
private float mYDpi;
|
||||
private float mMetersToPixelsX;
|
||||
private float mMetersToPixelsY;
|
||||
private Bitmap mBitmap;
|
||||
private Bitmap mWood;
|
||||
private float mXOrigin;
|
||||
private float mYOrigin;
|
||||
private float mSensorX;
|
||||
private float mSensorY;
|
||||
private long mSensorTimeStamp;
|
||||
private long mCpuTimeStamp;
|
||||
private float mHorizontalBound;
|
||||
private float mVerticalBound;
|
||||
private final ParticleSystem mParticleSystem = new ParticleSystem();
|
||||
|
||||
/*
|
||||
* Each of our particle holds its previous and current position, its
|
||||
* acceleration. for added realism each particle has its own friction
|
||||
* coefficient.
|
||||
*/
|
||||
class Particle {
|
||||
private float mPosX;
|
||||
private float mPosY;
|
||||
private float mAccelX;
|
||||
private float mAccelY;
|
||||
private float mLastPosX;
|
||||
private float mLastPosY;
|
||||
private float mOneMinusFriction;
|
||||
/*
|
||||
* Each of our particle holds its previous and current position, its
|
||||
* acceleration. for added realism each particle has its own friction
|
||||
* coefficient.
|
||||
*/
|
||||
class Particle {
|
||||
private float mPosX;
|
||||
private float mPosY;
|
||||
private float mAccelX;
|
||||
private float mAccelY;
|
||||
private float mLastPosX;
|
||||
private float mLastPosY;
|
||||
private float mOneMinusFriction;
|
||||
|
||||
Particle() {
|
||||
// make each particle a bit different by randomizing its
|
||||
// coefficient of friction
|
||||
final float r = ((float) Math.random() - 0.5f) * 0.2f;
|
||||
mOneMinusFriction = 1.0f - sFriction + r;
|
||||
}
|
||||
Particle() {
|
||||
// make each particle a bit different by randomizing its
|
||||
// coefficient of friction
|
||||
final float r = ((float) Math.random() - 0.5f) * 0.2f;
|
||||
mOneMinusFriction = 1.0f - sFriction + r;
|
||||
}
|
||||
|
||||
public void computePhysics(float sx, float sy, float dT, float dTC) {
|
||||
// Force of gravity applied to our virtual object
|
||||
final float m = 1000.0f; // mass of our virtual object
|
||||
final float gx = -sx * m;
|
||||
final float gy = -sy * m;
|
||||
public void computePhysics(float sx, float sy, float dT, float dTC) {
|
||||
// Force of gravity applied to our virtual object
|
||||
final float m = 1000.0f; // mass of our virtual object
|
||||
final float gx = -sx * m;
|
||||
final float gy = -sy * m;
|
||||
|
||||
/*
|
||||
* <20>F = mA <=> A = <20>F / m
|
||||
*
|
||||
* We could simplify the code by completely eliminating "m" (the
|
||||
* mass) from all the equations, but it would hide the concepts
|
||||
* from this sample code.
|
||||
*/
|
||||
final float invm = 1.0f / m;
|
||||
final float ax = gx * invm;
|
||||
final float ay = gy * invm;
|
||||
/*
|
||||
* <20>F = mA <=> A = <20>F / m We could simplify the code by
|
||||
* completely eliminating "m" (the mass) from all the equations,
|
||||
* but it would hide the concepts from this sample code.
|
||||
*/
|
||||
final float invm = 1.0f / m;
|
||||
final float ax = gx * invm;
|
||||
final float ay = gy * invm;
|
||||
|
||||
/*
|
||||
* Time-corrected Verlet integration
|
||||
*
|
||||
* The position Verlet integrator is defined as
|
||||
*
|
||||
* x(t+<2B>t) = x(t) + x(t) - x(t-<2D>t) + a(t)<29>t<EFBFBD>2
|
||||
*
|
||||
* However, the above equation doesn't handle variable <20>t very
|
||||
* well, a time-corrected version is needed:
|
||||
*
|
||||
* x(t+<2B>t) = x(t) + (x(t) - x(t-<2D>t)) * (<28>t/<2F>t_prev) + a(t)<29>t<EFBFBD>2
|
||||
*
|
||||
*
|
||||
* We also add a simple friction term (f) to the equation:
|
||||
*
|
||||
* x(t+<2B>t) = x(t) + (1-f) * (x(t) - x(t-<2D>t)) * (<28>t/<2F>t_prev) +
|
||||
* a(t)<29>t<EFBFBD>2
|
||||
*/
|
||||
final float dTdT = dT * dT;
|
||||
final float x = mPosX + mOneMinusFriction * dTC
|
||||
* (mPosX - mLastPosX) + mAccelX * dTdT;
|
||||
final float y = mPosY + mOneMinusFriction * dTC
|
||||
* (mPosY - mLastPosY) + mAccelY * dTdT;
|
||||
mLastPosX = mPosX;
|
||||
mLastPosY = mPosY;
|
||||
mPosX = x;
|
||||
mPosY = y;
|
||||
mAccelX = ax;
|
||||
mAccelY = ay;
|
||||
}
|
||||
/*
|
||||
* Time-corrected Verlet integration The position Verlet
|
||||
* integrator is defined as x(t+<2B>t) = x(t) + x(t) - x(t-<2D>t) +
|
||||
* a(t)<29>t<EFBFBD>2 However, the above equation doesn't handle variable
|
||||
* <20>t very well, a time-corrected version is needed: x(t+<2B>t) =
|
||||
* x(t) + (x(t) - x(t-<2D>t)) * (<28>t/<2F>t_prev) + a(t)<29>t<EFBFBD>2 We also add
|
||||
* a simple friction term (f) to the equation: x(t+<2B>t) = x(t) +
|
||||
* (1-f) * (x(t) - x(t-<2D>t)) * (<28>t/<2F>t_prev) + a(t)<29>t<EFBFBD>2
|
||||
*/
|
||||
final float dTdT = dT * dT;
|
||||
final float x = mPosX + mOneMinusFriction * dTC * (mPosX - mLastPosX) + mAccelX
|
||||
* dTdT;
|
||||
final float y = mPosY + mOneMinusFriction * dTC * (mPosY - mLastPosY) + mAccelY
|
||||
* dTdT;
|
||||
mLastPosX = mPosX;
|
||||
mLastPosY = mPosY;
|
||||
mPosX = x;
|
||||
mPosY = y;
|
||||
mAccelX = ax;
|
||||
mAccelY = ay;
|
||||
}
|
||||
|
||||
/*
|
||||
* Resolving constraints and collisions with the Verlet integrator
|
||||
* can be very simple, we simply need to move a colliding or
|
||||
* constrained particle in such way that the constraint is
|
||||
* satisfied.
|
||||
*/
|
||||
public void resolveCollisionWithBounds() {
|
||||
final float xmax = mHorizontalBound;
|
||||
final float ymax = mVerticalBound;
|
||||
final float x = mPosX;
|
||||
final float y = mPosY;
|
||||
if (x > xmax) {
|
||||
mPosX = xmax;
|
||||
} else if (x < -xmax) {
|
||||
mPosX = -xmax;
|
||||
}
|
||||
if (y > ymax) {
|
||||
mPosY = ymax;
|
||||
} else if (y < -ymax) {
|
||||
mPosY = -ymax;
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
* Resolving constraints and collisions with the Verlet integrator
|
||||
* can be very simple, we simply need to move a colliding or
|
||||
* constrained particle in such way that the constraint is
|
||||
* satisfied.
|
||||
*/
|
||||
public void resolveCollisionWithBounds() {
|
||||
final float xmax = mHorizontalBound;
|
||||
final float ymax = mVerticalBound;
|
||||
final float x = mPosX;
|
||||
final float y = mPosY;
|
||||
if (x > xmax) {
|
||||
mPosX = xmax;
|
||||
} else if (x < -xmax) {
|
||||
mPosX = -xmax;
|
||||
}
|
||||
if (y > ymax) {
|
||||
mPosY = ymax;
|
||||
} else if (y < -ymax) {
|
||||
mPosY = -ymax;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* A particle system is just a collection of particles
|
||||
*/
|
||||
class ParticleSystem {
|
||||
static final int NUM_PARTICLES = 15;
|
||||
private Particle mBalls[] = new Particle[NUM_PARTICLES];
|
||||
/*
|
||||
* A particle system is just a collection of particles
|
||||
*/
|
||||
class ParticleSystem {
|
||||
static final int NUM_PARTICLES = 15;
|
||||
private Particle mBalls[] = new Particle[NUM_PARTICLES];
|
||||
|
||||
ParticleSystem() {
|
||||
/*
|
||||
* Initially our particles have no speed or acceleration
|
||||
*/
|
||||
for (int i = 0; i < mBalls.length; i++) {
|
||||
mBalls[i] = new Particle();
|
||||
}
|
||||
}
|
||||
ParticleSystem() {
|
||||
/*
|
||||
* Initially our particles have no speed or acceleration
|
||||
*/
|
||||
for (int i = 0; i < mBalls.length; i++) {
|
||||
mBalls[i] = new Particle();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Update the position of each particle in the system using the
|
||||
* Verlet integrator.
|
||||
*/
|
||||
private void updatePositions(float sx, float sy, long timestamp) {
|
||||
final long t = timestamp;
|
||||
if (mLastT != 0) {
|
||||
final float dT = (float) (t - mLastT)
|
||||
* (1.0f / 1000000000.0f);
|
||||
if (mLastDeltaT != 0) {
|
||||
final float dTC = dT / mLastDeltaT;
|
||||
final int count = mBalls.length;
|
||||
for (int i = 0; i < count; i++) {
|
||||
Particle ball = mBalls[i];
|
||||
ball.computePhysics(sx, sy, dT, dTC);
|
||||
}
|
||||
}
|
||||
mLastDeltaT = dT;
|
||||
}
|
||||
mLastT = t;
|
||||
}
|
||||
/*
|
||||
* Update the position of each particle in the system using the
|
||||
* Verlet integrator.
|
||||
*/
|
||||
private void updatePositions(float sx, float sy, long timestamp) {
|
||||
final long t = timestamp;
|
||||
if (mLastT != 0) {
|
||||
final float dT = (float) (t - mLastT) * (1.0f / 1000000000.0f);
|
||||
if (mLastDeltaT != 0) {
|
||||
final float dTC = dT / mLastDeltaT;
|
||||
final int count = mBalls.length;
|
||||
for (int i = 0; i < count; i++) {
|
||||
Particle ball = mBalls[i];
|
||||
ball.computePhysics(sx, sy, dT, dTC);
|
||||
}
|
||||
}
|
||||
mLastDeltaT = dT;
|
||||
}
|
||||
mLastT = t;
|
||||
}
|
||||
|
||||
/*
|
||||
* Performs one iteration of the simulation. First updating the
|
||||
* position of all the particles and resolving the constraints and
|
||||
* collisions.
|
||||
*/
|
||||
public void update(float sx, float sy, long now) {
|
||||
// update the system's positions
|
||||
updatePositions(sx, sy, now);
|
||||
/*
|
||||
* Performs one iteration of the simulation. First updating the
|
||||
* position of all the particles and resolving the constraints and
|
||||
* collisions.
|
||||
*/
|
||||
public void update(float sx, float sy, long now) {
|
||||
// update the system's positions
|
||||
updatePositions(sx, sy, now);
|
||||
|
||||
// We do no more than a limited number of iterations
|
||||
final int NUM_MAX_ITERATIONS = 10;
|
||||
// We do no more than a limited number of iterations
|
||||
final int NUM_MAX_ITERATIONS = 10;
|
||||
|
||||
/*
|
||||
* Resolve collisions, each particle is tested against every
|
||||
* other particle for collision. If a collision is detected the
|
||||
* particle is moved away using a virtual spring of infinite
|
||||
* stiffness.
|
||||
*/
|
||||
boolean more = true;
|
||||
final int count = mBalls.length;
|
||||
for (int k = 0; k < NUM_MAX_ITERATIONS && more; k++) {
|
||||
more = false;
|
||||
for (int i = 0; i < count; i++) {
|
||||
Particle curr = mBalls[i];
|
||||
for (int j = i + 1; j < count; j++) {
|
||||
Particle ball = mBalls[j];
|
||||
float dx = ball.mPosX - curr.mPosX;
|
||||
float dy = ball.mPosY - curr.mPosY;
|
||||
float dd = dx * dx + dy * dy;
|
||||
// Check for collisions
|
||||
if (dd <= sBallDiameter2) {
|
||||
/*
|
||||
* add a little bit of entropy, after nothing is
|
||||
* perfect in the universe.
|
||||
*/
|
||||
dx += ((float) Math.random() - 0.5f) * 0.0001f;
|
||||
dy += ((float) Math.random() - 0.5f) * 0.0001f;
|
||||
dd = dx * dx + dy * dy;
|
||||
// simulate the spring
|
||||
final float d = (float) Math.sqrt(dd);
|
||||
final float c = (0.5f * (sBallDiameter - d))
|
||||
/ d;
|
||||
curr.mPosX -= dx * c;
|
||||
curr.mPosY -= dy * c;
|
||||
ball.mPosX += dx * c;
|
||||
ball.mPosY += dy * c;
|
||||
more = true;
|
||||
}
|
||||
}
|
||||
/*
|
||||
* Finally make sure the particle doesn't intersects
|
||||
* with the walls.
|
||||
*/
|
||||
curr.resolveCollisionWithBounds();
|
||||
}
|
||||
}
|
||||
}
|
||||
/*
|
||||
* Resolve collisions, each particle is tested against every
|
||||
* other particle for collision. If a collision is detected the
|
||||
* particle is moved away using a virtual spring of infinite
|
||||
* stiffness.
|
||||
*/
|
||||
boolean more = true;
|
||||
final int count = mBalls.length;
|
||||
for (int k = 0; k < NUM_MAX_ITERATIONS && more; k++) {
|
||||
more = false;
|
||||
for (int i = 0; i < count; i++) {
|
||||
Particle curr = mBalls[i];
|
||||
for (int j = i + 1; j < count; j++) {
|
||||
Particle ball = mBalls[j];
|
||||
float dx = ball.mPosX - curr.mPosX;
|
||||
float dy = ball.mPosY - curr.mPosY;
|
||||
float dd = dx * dx + dy * dy;
|
||||
// Check for collisions
|
||||
if (dd <= sBallDiameter2) {
|
||||
/*
|
||||
* add a little bit of entropy, after nothing is
|
||||
* perfect in the universe.
|
||||
*/
|
||||
dx += ((float) Math.random() - 0.5f) * 0.0001f;
|
||||
dy += ((float) Math.random() - 0.5f) * 0.0001f;
|
||||
dd = dx * dx + dy * dy;
|
||||
// simulate the spring
|
||||
final float d = (float) Math.sqrt(dd);
|
||||
final float c = (0.5f * (sBallDiameter - d)) / d;
|
||||
curr.mPosX -= dx * c;
|
||||
curr.mPosY -= dy * c;
|
||||
ball.mPosX += dx * c;
|
||||
ball.mPosY += dy * c;
|
||||
more = true;
|
||||
}
|
||||
}
|
||||
/*
|
||||
* Finally make sure the particle doesn't intersects
|
||||
* with the walls.
|
||||
*/
|
||||
curr.resolveCollisionWithBounds();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public int getParticleCount() {
|
||||
return mBalls.length;
|
||||
}
|
||||
public int getParticleCount() {
|
||||
return mBalls.length;
|
||||
}
|
||||
|
||||
public float getPosX(int i) {
|
||||
return mBalls[i].mPosX;
|
||||
}
|
||||
public float getPosX(int i) {
|
||||
return mBalls[i].mPosX;
|
||||
}
|
||||
|
||||
public float getPosY(int i) {
|
||||
return mBalls[i].mPosY;
|
||||
}
|
||||
}
|
||||
public float getPosY(int i) {
|
||||
return mBalls[i].mPosY;
|
||||
}
|
||||
}
|
||||
|
||||
public void startSimulation() {
|
||||
/*
|
||||
* It is not necessary to get accelerometer events at a very high
|
||||
* rate, by using a slower rate (SENSOR_DELAY_UI), we get an
|
||||
* automatic low-pass filter, which "extracts" the gravity component
|
||||
* of the acceleration. As an added benefit, we use less power and
|
||||
* CPU resources.
|
||||
*/
|
||||
mSensorManager.registerListener(this, mAccelerometer,
|
||||
SensorManager.SENSOR_DELAY_UI);
|
||||
}
|
||||
public void startSimulation() {
|
||||
/*
|
||||
* It is not necessary to get accelerometer events at a very high
|
||||
* rate, by using a slower rate (SENSOR_DELAY_UI), we get an
|
||||
* automatic low-pass filter, which "extracts" the gravity component
|
||||
* of the acceleration. As an added benefit, we use less power and
|
||||
* CPU resources.
|
||||
*/
|
||||
mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_UI);
|
||||
}
|
||||
|
||||
public void stopSimulation() {
|
||||
mSensorManager.unregisterListener(this);
|
||||
}
|
||||
public void stopSimulation() {
|
||||
mSensorManager.unregisterListener(this);
|
||||
}
|
||||
|
||||
public SimulationView(Context context) {
|
||||
super(context);
|
||||
mAccelerometer = mSensorManager
|
||||
.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
|
||||
public SimulationView(Context context) {
|
||||
super(context);
|
||||
mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
|
||||
|
||||
DisplayMetrics metrics = new DisplayMetrics();
|
||||
getWindowManager().getDefaultDisplay().getMetrics(metrics);
|
||||
mXDpi = metrics.xdpi;
|
||||
mYDpi = metrics.ydpi;
|
||||
mMetersToPixelsX = mXDpi / 0.0254f;
|
||||
mMetersToPixelsY = mYDpi / 0.0254f;
|
||||
DisplayMetrics metrics = new DisplayMetrics();
|
||||
getWindowManager().getDefaultDisplay().getMetrics(metrics);
|
||||
mXDpi = metrics.xdpi;
|
||||
mYDpi = metrics.ydpi;
|
||||
mMetersToPixelsX = mXDpi / 0.0254f;
|
||||
mMetersToPixelsY = mYDpi / 0.0254f;
|
||||
|
||||
// rescale the ball so it's about 0.5 cm on screen
|
||||
Bitmap ball = BitmapFactory.decodeResource(getResources(),
|
||||
R.drawable.ball);
|
||||
final int dstWidth = (int) (sBallDiameter * mMetersToPixelsX + 0.5f);
|
||||
final int dstHeight = (int) (sBallDiameter * mMetersToPixelsY + 0.5f);
|
||||
mBitmap = Bitmap
|
||||
.createScaledBitmap(ball, dstWidth, dstHeight, true);
|
||||
// rescale the ball so it's about 0.5 cm on screen
|
||||
Bitmap ball = BitmapFactory.decodeResource(getResources(), R.drawable.ball);
|
||||
final int dstWidth = (int) (sBallDiameter * mMetersToPixelsX + 0.5f);
|
||||
final int dstHeight = (int) (sBallDiameter * mMetersToPixelsY + 0.5f);
|
||||
mBitmap = Bitmap.createScaledBitmap(ball, dstWidth, dstHeight, true);
|
||||
|
||||
Options opts = new Options();
|
||||
opts.inDither = true;
|
||||
opts.inPreferredConfig = Bitmap.Config.RGB_565;
|
||||
mWood = BitmapFactory.decodeResource(getResources(),
|
||||
R.drawable.wood, opts);
|
||||
}
|
||||
Options opts = new Options();
|
||||
opts.inDither = true;
|
||||
opts.inPreferredConfig = Bitmap.Config.RGB_565;
|
||||
mWood = BitmapFactory.decodeResource(getResources(), R.drawable.wood, opts);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
|
||||
// compute the origin of the screen relative to the origin of
|
||||
// the bitmap
|
||||
mXOrigin = (w - mBitmap.getWidth()) * 0.5f;
|
||||
mYOrigin = (h - mBitmap.getHeight()) * 0.5f;
|
||||
mHorizontalBound = ((w / mMetersToPixelsX - sBallDiameter) * 0.5f);
|
||||
mVerticalBound = ((h / mMetersToPixelsY - sBallDiameter) * 0.5f);
|
||||
}
|
||||
@Override
|
||||
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
|
||||
// compute the origin of the screen relative to the origin of
|
||||
// the bitmap
|
||||
mXOrigin = (w - mBitmap.getWidth()) * 0.5f;
|
||||
mYOrigin = (h - mBitmap.getHeight()) * 0.5f;
|
||||
mHorizontalBound = ((w / mMetersToPixelsX - sBallDiameter) * 0.5f);
|
||||
mVerticalBound = ((h / mMetersToPixelsY - sBallDiameter) * 0.5f);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onSensorChanged(SensorEvent event) {
|
||||
if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER)
|
||||
return;
|
||||
/*
|
||||
* record the accelerometer data, the event's timestamp as well as
|
||||
* the current time. The latter is needed so we can calculate the
|
||||
* "present" time during rendering.
|
||||
*
|
||||
* In this application, we need to take into account how the
|
||||
* screen is rotated with respect to the sensors (which always
|
||||
* return data in a coordinate space aligned to with the screen
|
||||
* in its native orientation).
|
||||
*
|
||||
*/
|
||||
@Override
|
||||
public void onSensorChanged(SensorEvent event) {
|
||||
if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER)
|
||||
return;
|
||||
/*
|
||||
* record the accelerometer data, the event's timestamp as well as
|
||||
* the current time. The latter is needed so we can calculate the
|
||||
* "present" time during rendering. In this application, we need to
|
||||
* take into account how the screen is rotated with respect to the
|
||||
* sensors (which always return data in a coordinate space aligned
|
||||
* to with the screen in its native orientation).
|
||||
*/
|
||||
|
||||
switch (mDisplay.getRotation()) {
|
||||
case Surface.ROTATION_0:
|
||||
mSensorX = event.values[0];
|
||||
mSensorY = event.values[1];
|
||||
break;
|
||||
case Surface.ROTATION_90:
|
||||
mSensorX = -event.values[1];
|
||||
mSensorY = event.values[0];
|
||||
break;
|
||||
case Surface.ROTATION_180:
|
||||
mSensorX = -event.values[0];
|
||||
mSensorY = -event.values[1];
|
||||
break;
|
||||
case Surface.ROTATION_270:
|
||||
mSensorX = event.values[1];
|
||||
mSensorY = -event.values[0];
|
||||
break;
|
||||
}
|
||||
switch (mDisplay.getRotation()) {
|
||||
case Surface.ROTATION_0:
|
||||
mSensorX = event.values[0];
|
||||
mSensorY = event.values[1];
|
||||
break;
|
||||
case Surface.ROTATION_90:
|
||||
mSensorX = -event.values[1];
|
||||
mSensorY = event.values[0];
|
||||
break;
|
||||
case Surface.ROTATION_180:
|
||||
mSensorX = -event.values[0];
|
||||
mSensorY = -event.values[1];
|
||||
break;
|
||||
case Surface.ROTATION_270:
|
||||
mSensorX = event.values[1];
|
||||
mSensorY = -event.values[0];
|
||||
break;
|
||||
}
|
||||
|
||||
mSensorTimeStamp = event.timestamp;
|
||||
mCpuTimeStamp = System.nanoTime();
|
||||
}
|
||||
mSensorTimeStamp = event.timestamp;
|
||||
mCpuTimeStamp = System.nanoTime();
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onDraw(Canvas canvas) {
|
||||
@Override
|
||||
protected void onDraw(Canvas canvas) {
|
||||
|
||||
/*
|
||||
* draw the background
|
||||
*/
|
||||
/*
|
||||
* draw the background
|
||||
*/
|
||||
|
||||
canvas.drawBitmap(mWood, 0, 0, null);
|
||||
canvas.drawBitmap(mWood, 0, 0, null);
|
||||
|
||||
/*
|
||||
* compute the new position of our object, based on accelerometer
|
||||
* data and present time.
|
||||
*/
|
||||
/*
|
||||
* compute the new position of our object, based on accelerometer
|
||||
* data and present time.
|
||||
*/
|
||||
|
||||
final ParticleSystem particleSystem = mParticleSystem;
|
||||
final long now = mSensorTimeStamp
|
||||
+ (System.nanoTime() - mCpuTimeStamp);
|
||||
final float sx = mSensorX;
|
||||
final float sy = mSensorY;
|
||||
final ParticleSystem particleSystem = mParticleSystem;
|
||||
final long now = mSensorTimeStamp + (System.nanoTime() - mCpuTimeStamp);
|
||||
final float sx = mSensorX;
|
||||
final float sy = mSensorY;
|
||||
|
||||
particleSystem.update(sx, sy, now);
|
||||
particleSystem.update(sx, sy, now);
|
||||
|
||||
final float xc = mXOrigin;
|
||||
final float yc = mYOrigin;
|
||||
final float xs = mMetersToPixelsX;
|
||||
final float ys = mMetersToPixelsY;
|
||||
final Bitmap bitmap = mBitmap;
|
||||
final int count = particleSystem.getParticleCount();
|
||||
for (int i = 0; i < count; i++) {
|
||||
/*
|
||||
* We transform the canvas so that the coordinate system matches
|
||||
* the sensors coordinate system with the origin in the center
|
||||
* of the screen and the unit is the meter.
|
||||
*/
|
||||
final float xc = mXOrigin;
|
||||
final float yc = mYOrigin;
|
||||
final float xs = mMetersToPixelsX;
|
||||
final float ys = mMetersToPixelsY;
|
||||
final Bitmap bitmap = mBitmap;
|
||||
final int count = particleSystem.getParticleCount();
|
||||
for (int i = 0; i < count; i++) {
|
||||
/*
|
||||
* We transform the canvas so that the coordinate system matches
|
||||
* the sensors coordinate system with the origin in the center
|
||||
* of the screen and the unit is the meter.
|
||||
*/
|
||||
|
||||
final float x = xc + particleSystem.getPosX(i) * xs;
|
||||
final float y = yc - particleSystem.getPosY(i) * ys;
|
||||
canvas.drawBitmap(bitmap, x, y, null);
|
||||
}
|
||||
final float x = xc + particleSystem.getPosX(i) * xs;
|
||||
final float y = yc - particleSystem.getPosY(i) * ys;
|
||||
canvas.drawBitmap(bitmap, x, y, null);
|
||||
}
|
||||
|
||||
// and make sure to redraw asap
|
||||
invalidate();
|
||||
}
|
||||
// and make sure to redraw asap
|
||||
invalidate();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onAccuracyChanged(Sensor sensor, int accuracy) {
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public void onAccuracyChanged(Sensor sensor, int accuracy) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user