¿Cómo limitar la velocidad de cuadros al usar GLSurfaceView.RENDERMODE_CONTINUOUSLY de Android?

Question

Tengo un juego de C++ corriendo a través de JNI en Android. La velocidad de fotogramas varía de aproximadamente 20-45 fps debido a la complejidad de la escena. Cualquier cosa por encima de 30 fps es una tontería para el juego; solo quema la batería. Me gustaría limitar la velocidad de cuadros a 30 fps.

• pude cambiar a RENDERMODE_WHEN_DIRTY, y utilizar un temporizador o ScheduledThreadPoolExecutor a requestRender(). Pero eso agrega un lío completo de partes móviles adicionales que pueden funcionar o no de manera consistente y correcta.
• Intenté inyectar Thread.sleep() cuando las cosas se están ejecutando rápidamente, pero esto no parece funcionar en absoluto para valores de tiempo pequeños. Y de todos modos puede estar respaldando eventos en la cola, sin detenerse.

¿Hay un método "capFramerate()" escondido en la API? ¿Alguna forma confiable de hacer esto?

Answer 1

La solución de Mark es casi buena, pero no del todo correcta. El problema es que el intercambio en sí requiere una cantidad de tiempo considerable (especialmente si el controlador de video está almacenando en caché las instrucciones). Por lo tanto, debe tener esto en cuenta o finalizará con una velocidad de fotogramas inferior a la deseada. Así que la cosa debe ser:

algún lugar al inicio (como el constructor):

startTime = System.currentTimeMillis(); 

entonces en el bucle render:

public void onDrawFrame(GL10 gl) 
{  
    endTime = System.currentTimeMillis(); 
    dt = endTime - startTime; 
    if (dt < 33) 
     Thread.Sleep(33 - dt); 
    startTime = System.currentTimeMillis(); 

    UpdateGame(dt); 
    RenderGame(gl); 
} 

De esta manera se tendrá en cuenta el tiempo se necesita intercambiar los buffers y el tiempo para dibujar el marco.

Answer 2

Al usar GLSurfaceView, realiza el dibujo en el OnDrawFrame de su Renderer que se maneja en un subproceso separado por GLSurfaceView. Simplemente asegúrese de que cada llamada a onDrawFrame tome (1000/[cuadros]) milisegundos, en su caso algo así como 33 ms.

Para hacer esto: (en su onDrawFrame)

1. medir el tiempo actual antes de empezar a dibujar usando System.currentTimeMillis (Digamos que es horaInicio)
2. Realizar el dibujo
3. Medir el tiempo de nuevo (Digamos que es endTime)
4. delta T = endTime - Startime
5. si < delta T 33, el sueño (33-delta T)

Eso es todo.

Answer 3

También puede tratar de reducir la prioridad del hilo de onSurfaceCreated():

Process.setThreadPriority(Process.THREAD_PRIORITY_LESS_FAVORABLE); 

Answer 4

Fili's answer se veía genial para mí, mal tristemente limitado el FPS en mi dispositivo Android a 25 FPS, a pesar de que pidió 30. Descubrí que Thread.sleep() no funciona con la precisión suficiente y duerme más de lo debido.

me encontré con esta implementación del proyecto LWJGL para hacer el trabajo: https://github.com/LWJGL/lwjgl/blob/master/src/java/org/lwjgl/opengl/Sync.java

Answer 5

solución de Fili está fallando para algunas personas, por lo que sospecho que está durmiendo hasta inmediatamente después de la siguiente VSYNC en lugar de inmediatamente antes. También creo que mover la suspensión hasta el final de la función daría mejores resultados, porque allí puede rellenar el cuadro actual antes de la próxima vsync, en lugar de intentar compensar el anterior. Thread.sleep() es inexacto, pero afortunadamente solo necesitamos que sea preciso para el período vsync más cercano de 1/60 s. El código de LWJGL tyrondis publicó un enlace que parece demasiado complicado para esta situación, probablemente está diseñado para cuando vsync está deshabilitado o no disponible, lo que no debería ser el caso en el contexto de esta pregunta.

me gustaría probar algo como esto:

private long lastTick = System.currentTimeMillis(); 

public void onDrawFrame(GL10 gl) 
{ 
    UpdateGame(dt); 
    RenderGame(gl); 

    // Subtract 10 from the desired period of 33ms to make generous 
    // allowance for overhead and inaccuracy; vsync will take up the slack 
    long nextTick = lastTick + 23; 
    long now; 
    while ((now = System.currentTimeMillis()) < nextTick) 
     Thread.sleep(nextTick - now); 
    lastTick = now; 
}