I have been trying for the life of me to make an Etch a sketch style game. The problem I am having is getting the drawPoint to continually draw instead of just moving the point around. I ended up putting each point into an array, but it slows down after a while, because it is redrawing every dot every time. Anyone have a solution?

Here is my complete code:


package com.DoodleDots.particularidiom;



import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.hardware.SensorListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.view.View;
import android.widget.FrameLayout;

public class DoodleDots extends Activity {

private SensorManager mSensorManager;
private DDView mDDView;

private int x = 160;
private int y = 200;
private int x2 = 0;
private int y2 = 0;
private int x3 = 0;
private int y3 = 0;
private int c = 0;
private int r = 0;
private int[] oldXs = new int[10000];
private int[] oldYs = new int[10000];

private class DDView extends View implements SensorListener {

private Paint mPaint = new Paint();

private float mOrientationValues[] = new float[3];

public DDView(Context context) {
super(context);
mPaint.setFlags(Paint.ANTI_ALIAS_FLAG);
}

@Override
protected void onDraw(Canvas canvas) {
mPaint.setColor(0xFF000000);
synchronized (this) {
float[] values = mOrientationValues;
x3 = (int) values[2];
y3 = (int) values[1];

if(x2 < x3 && (x3 - x2) > 15 && x != 299) {
x++;
}
else if(x2 > x3 && (x3 - x2) < -15 && x != 22) {
x--;
}
if(y2 < y3 && (y3 - y2) > 15 && y != 22) {
y--;
}
else if(y2 > y3 && (y3 - y2) < -15 && y != 409) {
y++;
}

mPaint.setColor(0xC2C20000);
canvas.drawRect(0, 0, 20, 480, mPaint);
canvas.drawRect(20, 410, 300, 440, mPaint);
canvas.drawRect(300, 0, 320, 440, mPaint);
canvas.drawRect(20, 0, 300, 20, mPaint);

oldXs[c] = x;
oldYs[r] = y;

mPaint.setColor(0xFF000000);
mPaint.setStrokeWidth(3);

for(int i = 0; i < c; i++)
{
canvas.drawPoint(oldXs[i], oldYs[i], mPaint);
}
}

invalidate();

r++;
c++;
}

public void onSensorChanged(int sensor, float[] values) {

synchronized (this) {
if (sensor == SensorManager.SENSOR_ORIENTATION) {
for (int i=0 ; i<3 ; i++) {
mOrientationValues[i] = values[i];
}
}
}
}

public void onAccuracyChanged(int arg0, int arg1) {
// TODO Auto-generated method stub
}
}

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
FrameLayout main = (FrameLayout) findViewById(R.id.main_view);
mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);

mDDView = new DDView(this);
main.addView(mDDView);
}

@Override
protected void onResume() {
super.onResume();
mSensorManager.registerListener(mDDView,
SensorManager.SENSOR_ACCELEROMETER |
SensorManager.SENSOR_MAGNETIC_FIELD |
SensorManager.SENSOR_ORIENTATION,
SensorManager.SENSOR_DELAY_FASTEST);
}

@Override
protected void onStop() {
mSensorManager.unregisterListener(mDDView);
super.onStop();
}
}

What you will want to do is essentially manually double buffer the drawing. Create a Bitmap (RGB_565) draw any stylized background into it. Then draw only new points into it as they come in. I'm not sure how the asynchronous nature of receiving sensor events will affect this process. IE sensor events coming in as you are drawing/rendering. Each cycle of your game loop you'll just draw this one RGB_565 image and performance will be snappy!

With TyphonRT which is my middleware for real time app development that is being released soon I have a custom event system that is cross platform (desktop & Android). It's nice because it supports polled input on Android which is something the Android SDK does not support. This means that at the beginning of your loop you can specifically ask for all events (including sensor events) that have occurred since the last poll / game loop cycle and you can process them in your game thread reliably.

Best of luck, but once you buffer the drawing with a Bitmap performance will scream and you can have an unlimited amount of points to draw. You should even be able to blur or distort this bitmap with a filter for the user shaking the screen to mimic a clearing effect.

Best of luck!

A FYI... I'm going to make a tutorial out of the procedure I described for TyphonRT including a blurred shake effect. ~2 months before public launch, but I'll be doing a closed beta and this tutorial should make the closed beta. Hit up my contact email on the TyphonRT web site if you'd like to get into the closed beta. Thanks for the idea as this provides a great way to demonstrate polled input and double buffering.

I feel stupid here, but could anyone give me an idea on where to start with dealing with bitmaps? I am pretty new to this stuff and can't seem to get anything working.

I can't figure out how to get it to draw a new dot! It just moves the object.

haven't worked with canvas, but if this was Opengl then you can simply have a float[] which you pass to a Lines class which draws the line you want (aka the etchasketch). each time the user moves the point you can add the new x and y to the float[]. thus everytime you render you render the line with the new float[].
e.g.



Thats the way id do it anyway. er the lines class should work as i currently use it on my apps. its a basic draw class which theres numerous versions of on the web. you can easily make it more efficient to. as for the OpenGL class (Etchasketch) its in basic pseudo code. if you do a nehe tutorial or any other basic opengl tutorial youll get the jist. hope this helps somewhat. currently _train_lagged (heaters on full... no open windows.... boiling weather... :'( ) so sorry if i havent typed coherently