Measuring time inside render loop.

Newbie & Debugging Questions
#1

I have different sprites that I want to render at different speeds by changing to the next frame in the spritesheet if a delta time has passed. The problem is I have no idea how to get this delta, I cannot measure it inside the frameUpdate method of the sprite because it is called all the time inside my gameloop. I cannot measure it inside the gameloop because the game loops condition is while(game.isRunning()).

Essentially:


1) Somewhere in code, create animatedsprite with framedelay 250ms.
In gameloop:
2) Measure time after updating
3) Pass delta to animatedsprite
4) In animatedSprite, check if 250 ms has passed 
5) Has 250 ms passed? Then draw next frame

Stuck on 3). I am currently solving this by clever use of math, if a multiple of the framedelay has passed then I curentFrame++ but since the Thread.sleep in the gameloop is not continious (1 ms resolution but usually determined by fps, eg if 100 fps then 10 ms resolution) this will not work if I do not provide a margin, my current margin is 10 ms. This assumes that the game MUST run under 100 fps and that there is no sprite that is rendered above 100 fps (framedelay < 10 ms).

Any solutions? Current SCCE:
Sprite

public class Animated implements Renderable {
	private ArrayList<BufferedImage> sheet;
	private int cols;
	private int rows;
	private int x;
	private int y;
	private int frameDelay;
	private int currentFrame;
	private int lastFrame;
	private BufferedImage currentImage;

	public Animated(ArrayList<BufferedImage> spritesheet, int cols,
			int rows, int frameDelay) {

		this.sheet = spritesheet;
		this.cols = cols;
		this.rows = rows;
		this.frameDelay = frameDelay;
		this.lastFrame = sheet.size() - 1;
		this.currentImage = sheet.get(0);
	}

	private void frameUpdate(int deltaTime) {
		System.out.println(deltaTime % frameDelay);
		if ((deltaTime % frameDelay) < 10) {
			if (currentFrame == lastFrame) {
				currentFrame = 0;
			}
			else {
				currentFrame++;
			}
			currentImage = sheet.get(currentFrame);

		}
	}

	@Override
	public void render(Graphics2D g) {

	}

	@Override
	public void setPosition(int x, int y) {
		this.x = x;
		this.y = y;
	}

	@Override
	public void render(Graphics2D g, int deltaTime) {
		frameUpdate(deltaTime);
		g.drawImage(currentImage, x, y, null);

	}

}

Render in loop:

public void render() {
		Renderable bahamut = new Animated(images.get("bahamutANIMATED"), 4, 4,
				250);
		bahamut.setPosition(0, 500);
		Renderable bahamut2 = new Animated(images.get("bahamutANIMATED"), 4, 4,
				5000);
		bahamut2.setPosition(0, 0);
		long t0 = System.currentTimeMillis();

		while (true) {
			clearScreen();

			long t1 = System.currentTimeMillis();
			int delta = (int) (t1 - t0);
			bahamut.render(g, delta);
			bahamut2.render(g, delta);

			showBuffer();
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
	}
#2

After extensive testing it seems I can keep complete control over the margin (eg this works completely), using the code above but keeping control over the margin by setting a limit on how fast the sprites can render, I wanted to avoid doing this but it works and the % operator is very cheap.

margin = fpsDelay;
if (frameDelay<fpsDelay) {
 frameDelay = fpsDelay; }
#3

I told myself I would stop trolling here so much but I give in.

Normally, you do not do any sort of logic in the rendering thread. That is to say, you do not care about delta or anything like that. For animation rendering, you would set which frame is to be render in your logic (update). Then when rendering comes, you render is. If this code is working fine for you, use it but do not try measuring delta time stuff in renderloop.

Here is how I do animations or any form of timing. (no interpolation)


int currentUpdate = 0;
int frameRate = 60; //(1 frame every second)

updateMethod(delta)
{
    currentUpdate++;
    currentUpdate *= delta; //
    if(currentUpdate >= frameRate)
    {
         currentUpdate = 0;
         nextFrame();
         //check to see if you need to loop back to start when updating frame
    }
}

This is just some psudo code. It will not take into account huge deltas but the key is to keep logic away from rendering.

#4

That was in the SCCE, the actual game has no logic in the rendering, in the gameloop after updating the entities renderer.render(delta) is called where the renderer keeps an arraylist with references to all the objects in the game that implement the Renderable interface. AnimatedSprite is only one type that implements the interface, I have stuff like “GameString” which draws a spritelike string and questpanels etc. The idea was to remove intercoupling of objects ( or reduce it to a minimum level) letting me expand and implement new futures without breaking stuff all the time. This is why most objects take care of themselves in my code, like how the animatedsprite only needs a delta and a reference to the Graphics2D.

#5

Cool then. If it works then don’t do anything. If it is slow, ask yourself “is it REALLY slow?”

Keep up the work.

#6

One thing that confuses me is that you appear to use the time since the start of the game as your time delta. Normally you would use the time between the previous update and the current update as your time delta for calculations. For example, in your code you could simply add t0 = t1:

#7

You are of course right that it would be better, especially if the rendering takes any measurable time as in my current loop I don’t take that into consideration.