Mercurial > jmeCapture

     1 package com.aurellem.capture;

     2 

     3 import com.jme3.system.Timer;

     4 

     5 /**

     6  * A standard JME3 application that extends SimpleApplication or

     7  * Application tries as hard as it can to keep in sync with

     8  * user-time. If a ball is rolling at 1 game-mile per game-hour in the

     9  * game, and you wait for one user-hour as measured by the clock on

    10  * your wall, then the ball should have traveled exactly one

    11  * game-mile. In order to keep sync with the real world, the game

    12  * throttles its physics engine and graphics display. If the

    13  * computations involved in running the game are too intense, then the

    14  * game will first skip frames, then sacrifice physics accuracy. If

    15  * there are particularly demanding computations, then you may only

    16  * get 1 fps, and the ball may tunnel through the floor or obstacles

    17  * due to inaccurate physics simulation, but after the end of one

    18  * user-hour, that ball will have traveled one game-mile.

    19  *

    20  * When we're recording video or audio, we don't care if the game-time

    21  * syncs with user-time, but instead whether the time in the recorded

    22  * video (video-time) syncs with user-time. To continue the analogy,

    23  * if we recorded the ball rolling at 1 game-mile per game-hour and

    24  * watched the video later, we would want to see 30 fps video of the

    25  * ball rolling at 1 video-mile per user-hour. It doesn't matter how

    26  * much user-time it took to simulate that hour of game-time to make

    27  * the high-quality recording.  If an Application uses this IsoTimer

    28  * instead of the normal one, we can be sure that every call to

    29  * simpleUpdate, for example, corresponds to exactly (1 / fps) seconds

    30  * of game-time. This lets us record perfect video and audio even on

    31  * a slow computer.

    32  *

    33  * @author Robert McIntyre

    34  *

    35  */

    36 

    37 public class IsoTimer extends Timer {

    38 

    39 	private long framerate;

    40 	private int ticks;

    41 

    42 	public IsoTimer(float framerate){

    43 		this.framerate = (long) framerate;

    44 		this.ticks = 0;

    45 	}

    46 

    47 	public long getTime() {

    48 		return this.ticks;

    49 	}

    50 

    51 	public long getResolution() {

    52 		return framerate;

    53 	}

    54 

    55 	public float getFrameRate() {

    56 		return framerate;

    57 	}

    58 

    59 	public float getTimePerFrame() {

    60 		return (float) (1.0f / framerate);

    61 	}

    62 

    63 	public void update() {this.ticks++;}

    64 

    65 	public void reset() {this.ticks = 0;}

    66 

    67 }
author	Robert McIntyre <rlm@mit.edu>
date	Wed, 29 May 2013 17:15:41 -0400
parents	f5e52169f056
children	a67aef438383