Come effettuare il timer per un ciclo di gioco?

Question

Voglio che il tempo fps contare e impostare il suo limite a 60 e tuttavia ho visto attraverso un codice tramite Google, non lo capisco.

Answer 1

Non dovresti provare a limitare il fps.L'unico motivo per farlo è se non stai usando il tempo delta e ti aspetti che ogni fotogramma sia la stessa lunghezza.Anche il gioco più semplice non può garantirlo.

Puoi tuttavia portare il tempo del delta e tagliarlo in dimensioni fisse e quindi tenere premuto il resto.

Ecco alcuni codici che ho scritto di recente.Non è accuratamente testato.

void GameLoop::Run()
{
    m_Timer.Reset();

    while(!m_Finished())
    {
        Time delta = m_Timer.GetDelta();
        Time frameTime(0);
        unsigned int loopCount = 0;

        while (delta > m_TickTime && loopCount < m_MaxLoops)
        {
            m_SingTick();
            delta -= m_TickTime;
            frameTime += m_TickTime;
            ++loopCount;
        }
        m_Independent(frameTime);

        // add an exception flag later.
        // This is if the game hangs
        if(loopCount >= m_MaxLoops)
        {
            delta %= m_TickTime;
        }

        m_Render(delta);
        m_Timer.Unused(delta);
    }
}

.

Gli oggetti membri stanno aumentando gli slot in modo che il codice diverso può registrarsi con diversi metodi di temporizzazione.Lo slot indipendente è per cose come la mappatura delle chiavi o cambiare le cose musicali che non devono essere così precise.Singtick è buono per la fisica dove è più facile se sai che ogni segno di spunta sarà la stessa, ma non vuoi correre attraverso un muro.Il rendering prende il delta quindi le animazioni corrono liscio, ma devono ricordare di spiegarla sul prossimo Singtick.

Spero che ti aiuti.

Answer 2

Se si desidera 60 fps, è necessario capire quanto tempo hai su ogni fotogramma.In questo caso, 16.67 millisecondi.Quindi vuoi un ciclo che completa ogni 16.67 millisecondi.

Di solito va (semplicemente inserito): ottenere input, fare cose di fisica, rendering, pausa fino a 16.67ms è passato.

è solitamente fatto salvando il tempo nella parte superiore del ciclo e quindi calcolando la differenza alla fine e dormire o looping non facendo nulla per quella durata.

Questo articolo descrive alcuni modi diversi di fare loop di gioco, incluso quelloVuoi, anche se userei una delle alternative più avanzate in questo articolo.

Answer 3

Delta Time è l'ultima volta, meno il tempo originale.

dt= t-t0

.

Questo tempo delta, tuttavia, è semplicemente la quantità di tempo che passa mentre la velocità sta cambiando.

il derivato di una funzione rappresenta un cambiamento infinitesimale nella funzione rispetto a una delle sue variabili. Il derivato di una funzione rispetto alla variabile è definito come

                f(x + h) - f(x)
f'(x) = lim    -----------------
        h->0           h

.

http://mathworld.wolfram.com/Derivative.html

#include<time.h>
#include<stdlib.h>
#include<stdio.h>
#include<windows.h>
#pragma comment(lib,"winmm.lib")

void gotoxy(int x, int y);
void StepSimulation(float dt);

int main(){

  int NewTime = 0;
  int OldTime = 0;
  float dt = 0;
  float TotalTime = 0;
  int FrameCounter = 0;
  int RENDER_FRAME_COUNT = 60;

  while(true){

        NewTime = timeGetTime();    
        dt = (float) (NewTime - OldTime)/1000; //delta time
        OldTime = NewTime;

        if (dt > (0.016f)) dt = (0.016f);  //delta time
        if (dt < 0.001f) dt = 0.001f;

        TotalTime += dt;

        if(TotalTime > 1.1f){ 
            TotalTime=0;
            StepSimulation(dt);
            }

        if(FrameCounter >= RENDER_FRAME_COUNT){           
            // draw stuff
            //Render(); 

            gotoxy(1,2);
            printf(" \n");
            printf("OldTime      = %d \n",OldTime);
            printf("NewTime      = %d \n",NewTime);
            printf("dt           = %f  \n",dt);
            printf("TotalTime    = %f  \n",TotalTime);
            printf("FrameCounter = %d fps\n",FrameCounter);
            printf("   \n");
            FrameCounter = 0;

        } 
        else{
            gotoxy(22,7);
            printf("%d  ",FrameCounter);
            FrameCounter++;

        }


    }

    return 0;
}

void gotoxy(int x, int y){
    COORD coord;
    coord.X = x; coord.Y = y;
    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
    return;
}

void StepSimulation(float dt){
    // calculate stuff
   //vVelocity += Ae * dt;

}

.

Answer 4

Ci sono molti buoni motivi per cui non dovresti limitare il tasso di frame in tal modo. Una ragione è stata sottolineata Stijn, non ogni monitor può funzionare esattamente a 60 fps, un altro motivo è che la risoluzione dei timer non è sufficiente, tuttavia un altro motivo è che ha anche dato risoluzioni sufficienti, due timer separati (il monitor di aggiornamento e il tuo) in esecuzione Parallelamente uscirà sempre da sincronizzare con il tempo (devono!) A causa di inesattezze casuali e la ragione più importante essere che non è affatto necessario.

Si noti che la risoluzione del timer predefinita in Windows è 15ms e la migliore risoluzione possibile che è possibile ottenere (utilizzando TimeBeginPeriod) è 1ms. Quindi, puoi (al meglio) attendere 16 ms o 17ms. Un telaio a 60 fps è 16.6666ms Come aspetti 16.6666ms?

Se si desidera limitare la velocità del gioco alla frequenza di aggiornamento del monitor, abilitare la sincronizzazione verticale. Questo farà ciò che vuoi, precisamente, e senza problemi di sincronizzazione. La sincronizzazione verticale ha anche le sue peculiarie (come la divertente sorpresa che ottieni quando una cornice dura 16.67ms), ma è di gran lunga la migliore soluzione disponibile.

Se il motivo per cui volevi fare questo era quello di adattarsi alla tua simulazione nel ciclo di rendering, Questo è un deve leggere per te.

Answer 5

Controlla questo:

//Creating Digital Watch in C++
#include<iostream>
#include<Windows.h>
using namespace std;

struct time{

int hr,min,sec;
};
int main()
{
time a;
a.hr = 0;
a.min = 0;
a.sec = 0;

for(int i = 0; i<24; i++)
{
    if(a.hr == 23)
    {
        a.hr = 0;
    }

    for(int j = 0; j<60; j++)
    {
        if(a.min == 59)
        {
            a.min = 0;
        }

        for(int k = 0; k<60; k++)
        {
            if(a.sec == 59)
            {
                a.sec = 0;
            }

            cout<<a.hr<<" : "<<a.min<<" : "<<a.sec<<endl;
            a.sec++;
            Sleep(1000);
            system("Cls");
        }
    a.min++;

}

    a.hr++;
}

}

.