Ok, I tried the following, but it doesn't seem to be able to perform better (I mean faster) than the non-double-buffering approach when rendering 50000 pionts.

Am I using double-buffering correctly? and, is there part of code that can be optimized?

left image (using double buffering), right image (without double-buffering):


code:

1. // keys:
2. // [space] : toggle animation
3. PGraphics pg;
4. Mover[] movers = new Mover[50000];
5. boolean animationToggle = false;
6. //////////////////////////////////////////////////////
7. void setup(){
8.   size(700,350);
9.   for(int i=0; i<movers.length; i++){
10.     movers[i] = new Mover(random(0.5,3),random(0,width),random(0,height),
11.                           color(floor(random(255)),floor(random(255)),floor(random(255)))
12.                          );
13.   }
14.   pg = createGraphics(700,350);
15. }
16. //////////////////////////////////////////////////////
17. void draw() {
18.   PVector wind = new PVector(0.01,0);
19.   PVector gravity = new PVector(0,0.1);
20.  
21.   pg.beginDraw();
22.   if (animationToggle == true){
23.     pg.fill(0,10);
24.     pg.rect(0,0,width,height);
25.     for(int i=0; i<movers.length; i++){
26.       movers[i].applyForce(wind);
27.       movers[i].applyForce(gravity);
28.    
29.       movers[i].update();
30.       movers[i].display();
31.       movers[i].checkEdges();
32.     }
33.   }
34.   pg.endDraw();
35.   image(pg,0,0);
36. }
37. //////////////////////////////////////////////////////
38. class Mover{
39.   PVector location;
40.   PVector velocity;
41.   PVector acceleration;
42.   float mass;
43.   color c;
44.   Mover(float m_, float x_, float y_, color c_) {
45.     location = new PVector(x_,y_);
46.     velocity = new PVector(0,0);
47.     acceleration = new PVector(0,0);
48.     mass = m_;
49.     c = c_;
50.   }
51.  
52.   void applyForce(PVector force){
53.     PVector f = PVector.div(force,mass);
54.     acceleration.add(f);
55.   }
56.  
57.   void update() {
58.     velocity.add(acceleration);
59.     location.add(velocity);
60.     acceleration.mult(0);
61.   }
62.  
63.   void display() {
64.     pg.noStroke();
65.     pg.fill(c);
66.     pg.ellipse(location.x,location.y,mass*10,mass*10);//scale by mass
67.   }
68.   void checkEdges() {
69.     if (location.x > (width-mass*5)) {
70.       location.x = width-mass*5;
71.       velocity.x *= -1;
72.     } else if (location.x < (0-mass*5)) {
73.       velocity.x *= -1;
74.       location.x = mass*5;
75.     }
76.     if (location.y > (height-mass*5)) {
77.       velocity.y *= -1;
78.       location.y = height-mass*5;
79.     }
80.   }
81. }
82. //////////////////////////////////////////////////////
83. void keyPressed(){
84.   if ( key == ' ' ) {
85.     animationToggle = (animationToggle == true) ? (false):(true);
86.   } 
87. }

... it seems adding "P2D" to size(700,350) will make the double-buffering approach's advantage show up, and adding "OPENGL" to size() makes the improvement even more obvious (way faster) ...

can anybody explains why double-buffering works better in P2D, P3D and OPENGL mode?

Thanks!

for 100000 points after about 100+ frames:
image left (with double-buffering and OPENGL), image right(without double-buffering and display mode not specified)

Looking at your code I was surprised that you noticed a performance difference using an off-screen buffer (PGraphics pg) and the using the screen directly because ALL the work is being done in the draw method. So I did some experiments and as expected I found no discernable difference, in both cases the draw method took about 160 milliseconds (50,000 movers) using P2D, P3D and OPENGL and about 480 milliseconds for JAVA2D (default) renderer.

n Processing P2D, P3D and OPENGL all use the OpenGL rendering engine - which uses double buffering internally anyway. The defalut render (JAVA2D) uses the Java2D rendering engine. SO that would explain the difference there.

thanks, quarks!

However, the 160ms is quite faster than 480ms, especially as the frame accumulates, isn't it? Am I missing sth there...?