4. Zeitmessung für Spiel

Zeitmessung für Spiel

  • M

    Was clock() eigentlich für eine Zeit misst ist mir auch ein Rätsel.Egal.
    Z.B die funktionen:

    #include <sys/time.h> 
int getitimer(int which, struct itimerval *value); 
int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue);
//Vielleicht das:
int gettimeofday(struct timeval *tv, struct timezone *tz);

    können dir helfen, oder noch bequemer funktionen aus glib:
    http://developer.gnome.org/doc/API/glib/glib-timers.html

    Schau noch ob Qt nicht zufällig irgendwelche Timer zu Verfügung stellt.

    0
  • C

    Also folgendes scheint zu funktionieren:

    #include <sys/time.h>

itimerval time;
double dTimeElapsed;

// jedes Frame ausführen
getitimer(ITIMER_REAL, &time);
dTimeElapsed = (double)((long)1000000 - time.it_value.tv_usec) / 10000000.0;
time.it_value.tv_sec  = 1;
time.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &time, 0);

    Ich hoffe nur, dass mir das nicht meinen QTimer beeinflusst. Ich benutze nämlich einen QTimer um mir die nötige Endlosschleife mit Qt zu basteln. (also einen Timer mit Interval 0) Wer überings eine bessere Idee hat, der soll bescheid sagen 😉
    Aber wie gesagt scheinbar geht es. 👍 🙂 Thx!!!

    Eine Frage hätte ich aber dazu noch:
    Der Typ 'itimerval' ist ja wie folgt definiert:

    struct timeval {
    long tv_sec;                /* seconds */
    long tv_usec;               /* microseconds */
};
struct itimerval {
    struct timeval it_interval; /* next value */
    struct timeval it_value;    /* current value */
};

    Was hat es mit diesem 'it_interval' aufsich?
    Und wie fange ich ein Signal ab, wenn der Timer bei 0 ankommt.

    When any timer expires, a signal is sent to the process, and the timer (potentially) restarts.

    ITIMER_REAL decrements in real time, and delivers SIGALRM upon expiration.

    Ne Doku gibt z.B. hier, aber wie gesagt, ich werde irgendwie nicht draus schlau... 😞

    Coolcat

    0
  • G

    Hey,

    ich würde zwar auch eher zu irgendeinem Timer raten, allerdings geht es auch so (der erste Entwurf war ja näh dran):

    #include <ctime>

using namespace std;

clock_t start, end;
float dTimeElapsed=0;

start = clock();
//irgendwelche fiesen Sachen machen...
end = clock();

dTimeElapsed = (float)(end - start) / (float)CLOCKS_PER_SEC;

    Aber wie gesagt, vernünftiger Timer ist besser geeignet.

    0
  • M

    @GPC
    Du hast das Problem falsch verstanden.Setze einfach ein sleep(10) wo die fiesen Sachen stehen sollen, das Ergebnis ist dann 0, obwohl das programm 10s lief.

    Vorweg, das ganze gilt für C, wie man das ganze sauber mit C++ macht weiss ich nicht.

    Und wie fange ich ein Signal ab, wenn der Timer bei 0 ankommt.

    Du musst einen Siganal-Handler einrichten, so etwa:

    # include <stdio.h>
# include <signal.h>

void sig_handler(int signum)
{
	fprintf(stderr, "signal\n");
	alarm(10);
}

int main()
{

	signal(SIGALRM, sig_handler);	 
	alarm(10);			

	while(1) { }
        return(0);
}

    Was hat es mit diesem 'it_interval' aufsich?

    So fern ich die Docu richtig verstanden habe(und englisch ist nicht grade meine muttersprache), wenn der Timer den gleichen Wert erreicht, wie der in it_interval, dann wird das Signal gesendet.

    0
  • G

    Marcin schrieb:

    @GPC
    Du hast das Problem falsch verstanden.Setze einfach ein sleep(10) wo die fiesen Sachen stehen sollen, das Ergebnis ist dann 0, obwohl das programm 10s lief.

    Stimmt, hatte eigentlich schon vor ein Vernichtungsposting zu schreiben 😉 , da hab ich's zur Sicherheit nochmal ausprobiert, und siehe da: sleep() scheint den Gesetzen von Zeit und Raum zu trotzen, sogar time funktioniert nicht:

    #include <time.h>
#include <stdio.h>

int main(int argc, char **argv) {
  time_t start, end;

  time(&start);
  sleep(5);
  time(&end);

  //Gibt das selbe Ergebnis zurück?!?!
  printf("\nStart: %f", start);
  printf("\nEnd: %f", end);

  return 0;
};

    Unter normalen Umständen, also Code wie

    while (i<1000) {
  //mach was
}

    funktioniert die Geschichte, aber sleep geht echt nicht. Würde mich mal interessieren warum.

    0
  • M

    Vielleicht ist das was clock() zurückliefert, die Rechenzeit was das Programm "verbraucht" hat ?

    Ich sage nur, ich habe keine Ahnung.

    0
  • C
     

    while(1) { }

    hm, ich zweifle doch sehr am Sinn dieser Zeile 😃

    signal(SIGALRM, sig_handler);

    Achso, ich geb dem also nur einfach einen Pointer auf eine Funktion.

    thx nochmal an alle

    Coolcat

    0
  • G

    imho:

    clock_t misst wirklich clock-ticks. Und wenn du dein Prog schlafen legst (mit sleep), dann tickt die Uhr nicht weiter.

    0
  • T

    boost::timer

    Class timer measures elapsed time. It is generally useful for minor timing tasks. Its supplied implementation offers moderate portability at the cost of depending on the unknown accuracy and precision of the C Standard Library clock() function. The maximum measurable elapsed time may be as low as 596.5 hours (or even less) for the supplied implementation. Because of these limitations, this timer cannot be depended upon to be robust, and should not be used if that is of any concern.

    mfg

    0
  • C

    Falls irgendwann mal wer mit der Suchfunktion auf diesen Tread stößt...

    Aufgrund doch recht großer Ungenauigkeiten der Lösung mit getitimer/setitimer, musste ich nach einer anderen Lösung suchen.

    Ich habe das ganze nun so gelößt:

    timeval m_timeLast, m_timeCur;
double m_dTimeElapsed;

// Initzialisierung fuer Synchronisation
gettimeofday(&m_timeCur, 0);
m_timeLast = m_timeCur;

// dann jedes Frame
gettimeofday( &m_timeCur, 0 );
m_dTimeElapsed =  (double)(m_timeCur.tv_sec  - m_timeLast.tv_sec) + ((double)(m_timeCur.tv_usec - m_timeLast.tv_usec)) / 1000000.0;
m_timeLast = m_timeCur;

    Marcin hatte mir die Funktion schon direkt am Anfang genannt, jedoch wusste ich nicht, dass sie auch Microsekunden zurückgibt.

    thx @ all

    Coolcat

    0
Anmelden zum Antworten