Fast pixel rendering?

Tutorials concerning the OpenGL® ES cross-platform API for full-function 2D and 3D graphics on the Google-Android platform.

Fast pixel rendering?

Postby cheneysan » Thu Jul 03, 2008 11:22 am

Hi, with the following code I'm getting terrible terrible performance. I'm new to this SDK so any help speeding things up would be appreciated.


Syntax: [ Download ] [ Hide ]
Using java Syntax Highlighting
  1. import java.util.Random;
  2.  
  3.  
  4.  
  5. import android.app.Activity;
  6.  
  7. import android.content.Context;
  8.  
  9. import android.graphics.Bitmap;
  10.  
  11. import android.graphics.BitmapFactory;
  12.  
  13. import android.graphics.Canvas;
  14.  
  15. import android.graphics.Color;
  16.  
  17. import android.graphics.Paint;
  18.  
  19. import android.graphics.PointF;
  20.  
  21. import android.graphics.Rect;
  22.  
  23. import android.os.Bundle;
  24.  
  25. import android.util.Log;
  26.  
  27. import android.view.Surface;
  28.  
  29. import android.view.View;
  30.  
  31.  
  32.  
  33. public class DrawingTestActivity extends Activity {
  34.  
  35.         /** Called when the activity is first created. */
  36.  
  37.         @Override
  38.  
  39.         public void onCreate(Bundle icicle) {
  40.  
  41.                 super.onCreate(icicle);
  42.  
  43.                 setContentView(new DrawingTestView(getApplication()));
  44.  
  45.         }
  46.  
  47.  
  48.  
  49.         private static class DrawingTestView extends View {
  50.  
  51.  
  52.  
  53.                 protected final int WIDTH = 320;
  54.  
  55.  
  56.  
  57.                 protected final int HEIGHT = 240;
  58.  
  59.  
  60.  
  61.                 protected final int NBALLS = 2;
  62.  
  63.                
  64.  
  65.                 protected final float MAXBALLSIZE = 20.0f;
  66.  
  67.  
  68.  
  69.                 protected PointF mBallPositions[];
  70.  
  71.  
  72.  
  73.                 protected float mBallSizes[];
  74.  
  75.  
  76.  
  77.                 protected Bitmap mBitmap;
  78.  
  79.  
  80.  
  81.                 protected int[] mPixels;
  82.  
  83.  
  84.  
  85.                 protected Random mRnd = new Random();
  86.  
  87.  
  88.  
  89.                 public DrawingTestView(Context c) {
  90.  
  91.                         super(c);
  92.  
  93.                         mBitmap = Bitmap.createBitmap(WIDTH, HEIGHT, false);
  94.  
  95.                         mPixels = new int[WIDTH * HEIGHT];
  96.  
  97.                         mBallPositions = new PointF[NBALLS];
  98.  
  99.                         mBallSizes = new float[NBALLS];
  100.  
  101.                         for (int i = 0; i < NBALLS; i++) {
  102.  
  103.                                 mBallPositions[i] = new PointF(
  104.  
  105.                                                 mRnd.nextFloat() * WIDTH,
  106.  
  107.                                                 mRnd.nextFloat()* HEIGHT
  108.  
  109.                                 );
  110.  
  111.                                 mBallSizes[i] = mRnd.nextFloat() * MAXBALLSIZE;
  112.  
  113.                         }
  114.  
  115.                 }
  116.  
  117.  
  118.  
  119.                 @Override
  120.  
  121.                 protected void onDraw(Canvas canvas) {
  122.  
  123.                         long sTime, uTime, cTime;
  124.  
  125.                        
  126.  
  127.                         sTime = System.currentTimeMillis();
  128.  
  129.                        
  130.  
  131.                         // Update pixel buffer
  132.  
  133.                         for (int x = 0; x < WIDTH; x++) {
  134.  
  135.                                 for(int y = 0; y < HEIGHT; y++) {
  136.  
  137.                                         float fs = 0;
  138.  
  139.                                         for(int n = 0; n < NBALLS; n++) {
  140.  
  141.                                                 fs += mBallSizes[n] /
  142.  
  143.                                                        
  144.  
  145.                                                                         ((mBallPositions[n].x - x) * (mBallPositions[n].x - x)) +
  146.  
  147.                                                                         ((mBallPositions[n].y - y) * (mBallPositions[n].y - y));
  148.  
  149.                                                        
  150.  
  151.                                         }
  152.  
  153.                                
  154.  
  155.                                         int color = (fs > 0.5) ? 255 : 0;                                      
  156.  
  157.                                         mPixels[x + (y * WIDTH)] = color;
  158.  
  159.                                 }
  160.  
  161.                         }
  162.  
  163.                        
  164.  
  165.                         uTime = System.currentTimeMillis() - sTime;
  166.  
  167.  
  168.  
  169.                         // Draw pixel buffer
  170.  
  171.                         mBitmap.setPixels(mPixels, 0, WIDTH, 0, 0, WIDTH, HEIGHT);
  172.  
  173.  
  174.  
  175.                         // Draw to canvas
  176.  
  177.                         canvas.drawBitmap(mBitmap, 0, 0, null);
  178.  
  179.  
  180.  
  181.                         cTime = System.currentTimeMillis() - sTime;
  182.  
  183.                        
  184.  
  185.                         // Invalidate for next redraw
  186.  
  187.                         invalidate(0, 0, WIDTH, HEIGHT);
  188.  
  189.                        
  190.  
  191.                         Log.v("onDraw timing", "Frame:\tUT: " + uTime +"ms.\tCT:" + cTime + "ms.");
  192.  
  193.                 }
  194.  
  195.  
  196.  
  197.         }
  198.  
  199. }
Parsed in 0.042 seconds, using GeSHi 1.0.8.4


It's meant to draw some metaballs (sqrt removed from equation to try speed things up).

In the emulator the update loop is taking around 2 seconds and the calls to setPixels and drawBitmap are taking a further 2 seconds... Now 0.25 fps is pretty/very rubbish.

Is there a faster way of doing this?
cheneysan
Freshman
Freshman
 
Posts: 2
Joined: Thu Jul 03, 2008 11:11 am

Top

Return to Android 2D/3D Graphics - OpenGL Tutorials

Who is online

Users browsing this forum: No registered users and 3 guests