BufferStrategy (Java Platform SE 7 )

BufferStrategy class represents the mechanism with which
to organize complex memory on a particular Canvas or
Window. Hardware and software limitations determine whether and
how a particular buffer strategy can be implemented. These limitations
are detectible through the capabilities of the
GraphicsConfiguration used when creating the
Canvas or Window.

Theclass represents the mechanism with which to organize complex memory on a particularor. Hardware and software limitations determine whether and how a particular buffer strategy can be implemented. These limitations are detectible through the capabilities of theused when creating theor

It is worth noting that the terms buffer and surface are meant
to be synonymous: an area of contiguous memory, either in video device
memory or in system memory.

There are several types of complex buffer strategies, including
sequential ring buffering and blit buffering.
Sequential ring buffering (i.e., double or triple
buffering) is the most common; an application draws to a single back
buffer
and then moves the contents to the front (display) in a single
step, either by copying the data or moving the video pointer.
Moving the video pointer exchanges the buffers so that the first buffer
drawn becomes the front buffer, or what is currently displayed on the
device; this is called page flipping.

Alternatively, the contents of the back buffer can be copied, or
blitted forward in a chain instead of moving the video pointer.

 Double buffering:

                    ***********         ***********
                    *         * ------> *         *
 [To display] <---- * Front B *   Show  * Back B. * <---- Rendering
                    *         * <------ *         *
                    ***********         ***********

 Triple buffering:

 [To      ***********         ***********        ***********
 display] *         * --------+---------+------> *         *
    <---- * Front B *   Show  * Mid. B. *        * Back B. * <---- Rendering
          *         * <------ *         * <----- *         *
          ***********         ***********        ***********

 

Here is an example of how buffer strategies can be created and used:



 // Check the capabilities of the GraphicsConfiguration
 ...

 // Create our component
 Window w = new Window(gc);

 // Show our window
 w.setVisible(true);

 // Create a general double-buffering strategy
 w.createBufferStrategy(2);
 BufferStrategy strategy = w.getBufferStrategy();

 // Main loop
 while (!done) {
     // Prepare for rendering the next frame
     // ...

     // Render single frame
     do {
         // The following loop ensures that the contents of the drawing buffer
         // are consistent in case the underlying surface was recreated
         do {
             // Get a new graphics context every time through the loop
             // to make sure the strategy is validated
             Graphics graphics = strategy.getDrawGraphics();

             // Render to graphics
             // ...

             // Dispose the graphics
             graphics.dispose();

             // Repeat the rendering if the drawing buffer contents
             // were restored
         } while (strategy.contentsRestored());

         // Display the buffer
         strategy.show();

         // Repeat the rendering if the drawing buffer was lost
     } while (strategy.contentsLost());
 }

 // Dispose the window
 w.setVisible(false);
 w.dispose();