Use vsync instead of delay-based synchronization

Also changed the game_update() interface to take dt in seconds as a
double (rather than milliseconds as an unsigned integer) as we're now
computing the refresh interval as a double anyway (by querying the
display mode).  To my eye (and on my machine), all chunkiness is now
gone; the game feels very smooth.

engine/engine.c

@@ -10,9 +10,6 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
-#define FRAMERATE 60
-#define INTERVAL (1000 / FRAMERATE)
-
 #define VT100_CURSORTOPLEFT "\33[H"
 #define VT100_CLEAR "\33[2J"
 
@@ -31,18 +28,21 @@ int main(int argc, char *argv[])
 	    SDL_WINDOWPOS_UNDEFINED, game_conf.win.w, game_conf.win.h, 0);
 	assert(NULL != window);
 
-	SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);
+	SDL_Renderer *renderer = SDL_CreateRenderer(
+	    window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
 	assert(NULL != renderer);
 
+	SDL_DisplayMode mode;
+	assert(SDL_GetWindowDisplayMode(window, &mode) == 0);
+	const double interval = 1.0 / mode.refresh_rate;
+
 	void *gamemem = calloc(1, game_conf.memsize);
 	game_init(argc, argv, gamemem, renderer);
 
 	SDL_SetRenderDrawColor(renderer, 0xf0, 0x10, 0x10, 0xff);
 	SDL_Rect blinker = { .x = 10, .y = 10, .w = 20, .h = 20 };
 
-	const uint64_t perfhz = SDL_GetPerformanceFrequency();
-	const uint64_t intervalperf = (INTERVAL * perfhz) / 1000;
-	perf_t perf = { .freq = perfhz / 1000000.0 };
+	perf_t perf = { .freq = SDL_GetPerformanceFrequency() / 1000000.0 };
 	uint64_t frame = 0;
 	while (1) {
 		perf.start = SDL_GetPerformanceCounter();
@@ -56,7 +56,7 @@ int main(int argc, char *argv[])
 		perf.evt = SDL_GetPerformanceCounter();
 
 		// Update game state
-		if (game_update(gamemem, INTERVAL) != GAMESTATUS_OK)
+		if (game_update(gamemem, interval) != GAMESTATUS_OK)
 			goto quit;
 		perf.update = SDL_GetPerformanceCounter();
 
@@ -65,7 +65,6 @@ int main(int argc, char *argv[])
 		game_render(gamemem, renderer, SDL_GetTicks64());
 		if ((frame & 1) == 0)
 			SDL_RenderFillRect(renderer, &blinker);
-		SDL_RenderPresent(renderer);
 		perf.render = SDL_GetPerformanceCounter();
 
 		// Print performance analysis every 16 frames
@@ -74,7 +73,7 @@ int main(int argc, char *argv[])
 			const double update = (perf.update - perf.evt) / perf.freq;
 			const double render = (perf.render - perf.update) / perf.freq;
 			const double total = (perf.render - perf.start) / perf.freq;
-			const double total_pc = (100 * total / (1000 * INTERVAL));
+			const double total_pc = 100 * total / (1000000 * interval);
 			printf(
 			    VT100_CLEAR VT100_CURSORTOPLEFT
 			    "evt\t%10.3f μs\nupdate\t%10.3f μs\nrender\t"
@@ -82,11 +81,9 @@ int main(int argc, char *argv[])
 			    evt, update, render, total, total_pc);
 		}
 
-		// Increment frame counter and wait until next interval
+		// Increment frame counter and present frame
 		++frame;
-		const uint64_t elapsed = SDL_GetPerformanceCounter() - perf.start;
-		assert(elapsed < intervalperf);
-		SDL_Delay((1000 * (intervalperf - elapsed)) / perfhz);
+		SDL_RenderPresent(renderer);
 	}
 
 quit:

engine/include/engine_hooks.h

@@ -27,7 +27,7 @@ void game_init(int argc, char *argv[], void *mem, SDL_Renderer *renderer);
 void game_teardown(void *mem);
 
 gamestatus_t game_evthandle(void *mem, const SDL_Event *evt);
-gamestatus_t game_update(void *mem, unsigned dt);
+gamestatus_t game_update(void *mem, double dt);
 
 void game_render(const void *mem, SDL_Renderer *renderer, long unsigned t);
 

game/main.c

@@ -576,7 +576,7 @@ gamestatus_t game_evthandle(void *mem, const SDL_Event *evt)
 	return GAMESTATUS_OK;
 }
 
-gamestatus_t game_update(void *mem, unsigned dt)
+gamestatus_t game_update(void *mem, double dt)
 {
 	gamestate_t *state = (gamestate_t *)mem;
 
@@ -590,7 +590,7 @@ gamestatus_t game_update(void *mem, unsigned dt)
 		state->p.dir.x /= dmag;
 		state->p.dir.y /= dmag;
 		state->p.tex = state->pwalk;
-		state->p.speed = WALKSPEED / 1000.0;
+		state->p.speed = WALKSPEED;
 	} else {
 		state->p.tex = state->pidle;
 		state->p.speed = 0;