java.lang.Objectjava.awt.image.BufferStrategy
public abstract class BufferStrategy
The 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.
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
strategies;
sequential ring
buffering, blit buffering, and stereo
buffering
and blit buffering.
are common types.
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 * * <------ * * <----- * * *********** *********** ***********
Stereo buffering is for hardware that supports rendering separate images for a left and right eye. It is similar to sequential ring buffering, but there are two buffer chains, one for each eye. Both buffer chains flip simultaneously:
Stereo buffering: *********** *********** * * ------> * * [To left eye]<---- * Front B * * Back B. * <---- Rendering * * <------ * * *********** *********** Show *********** *********** * * ------>* * [To right eye]<---* Front 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(); // Render loop while (!done) { Graphics g = strategy.getDrawGraphics(); //Call this each time through to see if the underlying surface // was recreated. If it was you may need to redraw. if (strategy.contentsRestored()) { // Surface was recreated and reset, may require redrawing. } // Draw to graphics ... strategy.show();
if (strategy.contentsLost()) { // The surface was lost since last call to getDrawGraphics, you // may need to redraw. }
} // Dispose the window w.setVisible(false); w.dispose();
Constructor Summary | |
---|---|
BufferStrategy
() |
Method Summary | |
---|---|
abstract boolean |
contentsLost
() Returns whether the drawing buffer was lost since the last call to getDrawGraphics. |
abstract boolean |
contentsRestored
() Returns whether the drawing buffer was recently restored from a lost state and reinitialized to the default background color (white). |
![]() |
![]() ![]() ![]() |
![]() ![]() |
![]() ![]() ![]() |
abstract
![]() ![]() |
![]() ![]() ![]() ![]() |
![]() ![]() |
![]() ![]() ![]() |
abstract void |
show
() Makes the next available buffer visible by either copying the memory (blitting) or changing the display pointer (flipping). |
Methods inherited from class java.lang. Object |
---|
clone , equals , finalize , getClass , hashCode , notify , notifyAll , toString , wait , wait , wait |
Constructor Detail |
---|
public BufferStrategy()
Method Detail |
---|
public abstract BufferCapabilities getCapabilities()
public abstract Graphics getDrawGraphics()
public abstract boolean contentsLost()
public abstract boolean contentsRestored()
public abstract void show()
public void
dispose
()