Uso del double-buffering hardware

Artículo por Club Developers · 31 May 2006

2770 vistas

Los programadores de Sun se dieron cuenta cuenta que el [iurl=90&all=0&fs=978#988]double-buffering software[/iurl] a veces se quedaba corto, sobretodo en aplicaciones gráficas pesadas y juegos. Por tanto, decidieron implementar el uso de la tarjeta gráfica para reducir el número de cálculos. El Page-flipping o double-buffering hardware es el hecho de usar un indicador vÃdeo para decidir que buffer sirve de memoria y cual para mostrado.

Principio: creamos un buffer que sirvirá de buffer de memoria, después crearemos otro que servirá de buffer gráfico. Dibujaremos sobre el buffer de memoria las imágenes, los textos,.. mientras que el buffer gráfico muestra lo que contiene. Después invertimos los buffers, es decir, el buffer memoria pasa a ser gráfico y viceversa. Normalmente se les llama BackBuffer para el buffer memoria y FrontBuffer para el gráfico.

Veamos un ejemplo:



java
  1. public class DoubleBufferingHardware extends Frame{
  2.    // bucle de mostrado
  3.    RenderingThread renderingThread = new RenderingThread(); 
  4.    // variable que permite usar la memoria VRAM
  5.    BufferStrategy strategy; 
  6.    // buffer memoria donde se dibuja y escribe
  7.    Graphics buffer; 
  8.    int x = 0; // coordenada x del mostrado del texto
  9.  
  10.    public DoubleBufferingHardware(){
  11.       setSize( 400, 400 );
  12.       setVisible( true );
  13.       // inhibe el método normal de mostrado del componente
  14.       setIgnoreRepaint( true );  
  15.       // creamos 2 buffers en la VRAM
  16.       createBufferStrategy( 2 ); 
  17.       // recuperamos los buffers gráficos de la memoria VRAM
  18.       strategy = getBufferStrategy(); 
  19.       buffer = strategy.getDrawGraphics();
  20.       renderingThread.start();  
  21.    }
  22.  
  23.    public void graphicalRender(){
  24.       buffer.setColor( Color.black ); 
  25.       buffer.fillRect( 0, 0, 400, 400 ); 
  26.       buffer.setColor( Color.white ); 
  27.       buffer.drawString( "mostramos una línea de texto", x, 200 );
  28.       x++; 
  29.       if ( x > 400 ) x = 0; 
  30.       // enviamos todos los datos del buffer de memoria al de mostrado
  31.       strategy.show(); 
  32.    }
  33.  
  34.    class RenderingThread extends Thread{
  35.      /**
  36.       *  Este thread llama al repintado de la ventana cada 10 milisegundos
  37.       */
  38.       public void run(){
  39.          while( true ){
  40.             try {
  41.                 // llamamos a nuestra propio método de refresco
  42.                graphicalRender();
  43.                sleep( 5 );
  44.             } catch ( Exception e ) {} 
  45.          }
  46.       }
  47.    }   
  48.    public static void main(String[] args){new DoubleBufferingHardware();}
  49. }