¿Cómo puedo limitar mi framerate a 60 fps en Java?

Question

Escribo un juego simple, y quiero limitar mi framerate a 60 fps sin hacer que el loop se coma mi CPU. ¿Cómo haría esto?

Answer 1

Puede leer el Game Loop Article. Es muy importante que primero comprenda las diferentes metodologías para el ciclo del juego antes de intentar implementar algo.

Answer 2

La respuesta simple es establecer un java.util.Timer para disparar cada 17 ms y hacer su trabajo en el evento del temporizador.

Answer 3

Así es como lo hice en C++ ... Estoy seguro de que puedes adaptarlo.

void capFrameRate(double fps) { 
    static double start = 0, diff, wait; 
    wait = 1/fps; 
    diff = glfwGetTime() - start; 
    if (diff < wait) { 
     glfwSleep(wait - diff); 
    } 
    start = glfwGetTime(); 
} 

Simplemente llámelo con capFrameRate(60) una vez por lazo. Dormirá, por lo que no pierde preciosos ciclos. glfwGetTime() devuelve el tiempo desde que el programa comenzó en segundos ... Estoy seguro de que puede encontrar un equivalente en Java en alguna parte.

Answer 4

En java puede hacer System.currentTimeMillis() para obtener el tiempo en milisegundos en lugar de glfwGetTime().

Thread.sleep(time in milliseconds) hace que el hilo espere en caso de que no lo sepa, y debe estar dentro de un bloque try.

Answer 5

Lo que he hecho es seguir recorriendo y hacer un seguimiento de la última vez que hice una animación. Si ha sido al menos 17 ms, entonces sigue la secuencia de animación.

De esta forma pude verificar si hay entradas de usuario y activar/desactivar notas musicales según sea necesario.

Pero, esto fue en un programa para ayudar a enseñar música a niños y mi aplicación estaba acaparando la computadora en que era pantalla completa, por lo que no funcionaba bien con los demás.

Answer 6

Si está utilizando Java Columpio la forma más sencilla de lograr un FPS 60 es mediante la creación de un javax.swing.Timer como este y es una forma común de hacer que los juegos:

public static int DELAY = 1000/60; 

Timer timer = new Timer(DELAY,new ActionListener() { 
    public void actionPerformed(ActionEvent event) 
    { 
     updateModel(); 
     repaintScreen(); 
    } 
}); 

Y en algún lugar de su código debe establecer este temporizador para repetir y iniciarlo:

timer.setRepeats(true); 
timer.start(); 

Cada segundo tiene 1000 ms y dividiendo esto con su fps (60) y la configuración del temporizador con este retraso (1000/60 = 16 ms redondeada abajo) obtendrás una tasa de cuadros fija. Digo "algo" porque esto depende en gran medida de lo que haga en las llamadas a updateModel() y repaintScreen() anteriores.

Para obtener resultados más predecibles, intente sincronizar las dos llamadas en el temporizador y asegúrese de que finalicen en 16 ms para mantener 60 fps. Con la preasignación inteligente de memoria, reutilización de objetos y otras cosas, también puede reducir el impacto del recolector de basura. Pero eso es por otra pregunta.

Answer 7

El temporizador es impreciso para controlar FPS en java. Lo he descubierto de segunda mano. Tendrá que implementar su propio temporizador o hacer FPS en tiempo real con limitaciones. Pero no use el temporizador ya que no es 100% exacto y, por lo tanto, no puede ejecutar las tareas correctamente.

Answer 8

que tomaron la Game Loop Article que @cherouvim publicada, y yo llevamos a la estrategia de "mejor" y trató de volver a escribir para una java Ejecutable, parece estar funcionando para mí

double interpolation = 0; 
final int TICKS_PER_SECOND = 25; 
final int SKIP_TICKS = 1000/TICKS_PER_SECOND; 
final int MAX_FRAMESKIP = 5; 

@Override 
public void run() { 
    double next_game_tick = System.currentTimeMillis(); 
    int loops; 

    while (true) { 
     loops = 0; 
     while (System.currentTimeMillis() > next_game_tick 
       && loops < MAX_FRAMESKIP) { 

      update_game(); 

      next_game_tick += SKIP_TICKS; 
      loops++; 
     } 

     interpolation = (System.currentTimeMillis() + SKIP_TICKS - next_game_tick 
       /(double) SKIP_TICKS); 
     display_game(interpolation); 
    } 
} 

Answer 9

He aquí un consejo para el uso de oscilación y obtener FPS razonablemente preciso sin usar un temporizador.

En primer lugar, no ejecute el bucle del juego en el hilo del asignador de eventos, debe ejecutarse en su propio hilo haciendo el trabajo duro y no interponiéndose en el camino de la IU.

El componente Swing mostrar el juego debe dibujarse a sí mismo anulando este método:

@Override 
public void paintComponent(Graphics g){ 
    // draw stuff 
} 

El problema es que el bucle del juego no sabe cuándo el hilo de eventos distribuidor de hecho ha regresado a la realización de la acción, porque la pintura en el ciclo de juego, simplemente llamamos a component.repaint(), que solicita una pintura solo que pueda suceder más tarde.

Usando wait/notify se puede obtener el método de redibujado para esperar hasta que la pintura solicitada haya sucedido y luego continuar.

Aquí está el código completo de trabajo de https://github.com/davidmoten/game-exploration que hace un simple movimiento de una cuerda a través de un JFrame utilizando el método anterior:

import java.awt.BorderLayout; 
import java.awt.Component; 
import java.awt.Graphics; 
import java.awt.Image; 

import javax.swing.JFrame; 
import javax.swing.JPanel; 

/** 
* Self contained demo swing game for stackoverflow frame rate question. 
* 
* @author dave 
* 
*/ 
public class MyGame { 

    private static final long REFRESH_INTERVAL_MS = 17; 
    private final Object redrawLock = new Object(); 
    private Component component; 
    private volatile boolean keepGoing = true; 
    private Image imageBuffer; 

    public void start(Component component) { 
     this.component = component; 
     imageBuffer = component.createImage(component.getWidth(), 
       component.getHeight()); 
     Thread thread = new Thread(new Runnable() { 
      @Override 
      public void run() { 
       runGameLoop(); 
      } 
     }); 
     thread.start(); 
    } 

    public void stop() { 
     keepGoing = false; 
    } 

    private void runGameLoop() { 
     // update the game repeatedly 
     while (keepGoing) { 
      long durationMs = redraw(); 
      try { 
       Thread.sleep(Math.max(0, REFRESH_INTERVAL_MS - durationMs)); 
      } catch (InterruptedException e) { 
      } 
     } 
    } 

    private long redraw() { 

     long t = System.currentTimeMillis(); 

     // At this point perform changes to the model that the component will 
     // redraw 

     updateModel(); 

     // draw the model state to a buffered image which will get 
     // painted by component.paint(). 
     drawModelToImageBuffer(); 

     // asynchronously signals the paint to happen in the awt event 
     // dispatcher thread 
     component.repaint(); 

     // use a lock here that is only released once the paintComponent 
     // has happened so that we know exactly when the paint was completed and 
     // thus know how long to pause till the next redraw. 
     waitForPaint(); 

     // return time taken to do redraw in ms 
     return System.currentTimeMillis() - t; 
    } 

    private void updateModel() { 
     // do stuff here to the model based on time 
    } 

    private void drawModelToImageBuffer() { 
     drawModel(imageBuffer.getGraphics()); 
    } 

    private int x = 50; 
    private int y = 50; 

    private void drawModel(Graphics g) { 
     g.setColor(component.getBackground()); 
     g.fillRect(0, 0, component.getWidth(), component.getHeight()); 
     g.setColor(component.getForeground()); 
     g.drawString("Hi", x++, y++); 
    } 

    private void waitForPaint() { 
     try { 
      synchronized (redrawLock) { 
       redrawLock.wait(); 
      } 
     } catch (InterruptedException e) { 
     } 
    } 

    private void resume() { 
     synchronized (redrawLock) { 
      redrawLock.notify(); 
     } 
    } 

    public void paint(Graphics g) { 
     // paint the buffered image to the graphics 
     g.drawImage(imageBuffer, 0, 0, component); 

     // resume the game loop 
     resume(); 
    } 

    public static class MyComponent extends JPanel { 

     private final MyGame game; 

     public MyComponent(MyGame game) { 
      this.game = game; 
     } 

     @Override 
     protected void paintComponent(Graphics g) { 
      game.paint(g); 
     } 
    } 

    public static void main(String[] args) { 
     java.awt.EventQueue.invokeLater(new Runnable() { 
      @Override 
      public void run() { 
       MyGame game = new MyGame(); 
       MyComponent component = new MyComponent(game); 

       JFrame frame = new JFrame(); 
       // put the component in a frame 

       frame.setTitle("Demo"); 
       frame.setSize(800, 600); 

       frame.setLayout(new BorderLayout()); 
       frame.getContentPane().add(component, BorderLayout.CENTER); 
       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
       frame.setVisible(true); 

       game.start(component); 
      } 
     }); 
    } 

} 

Answer 10

Hay un montón de buena información aquí ya, pero quería compartir un problema que tuve con estas soluciones, y la solución a eso. Si, a pesar de todas estas soluciones, su juego/ventana parece omitirse (especialmente bajo X11), intente llamar al Toolkit.getDefaultToolkit().sync() una vez por cuadro.