add much-needed optimizations and enhance the snake example game

src/engine/engine.c

@@ -3,12 +3,144 @@
 engine_internal_state_t *internal_state = NULL;
 game_state_t *game_state = NULL;
 
+void
+mark_dirty_rect(int x, int y, int w, int h)
+{
+    if (w <= 0 || h <= 0) {
+        return;
+    }
+
+    // clip rectangle to the framebuffer
+    if (x < 0) {
+        w += x;
+        x = 0;
+    }
+
+    if (y < 0) {
+        h += y;
+        y = 0;
+    }
+
+    if (x + w > game_state->width) {
+        w = game_state->width - x;
+    }
+
+    if (y + h > game_state->height) {
+        h = game_state->height - y;
+    }
+
+    if (w <= 0 || h <= 0) {
+        return;
+    }
+
+    SDL_Rect rect = {
+        .x = x,
+        .y = y,
+        .w = w,
+        .h = h
+    };
+
+    if (!game_state->framebuffer_dirty) {
+        game_state->dirty_rect = rect;
+        game_state->framebuffer_dirty = true;
+        return;
+    }
+
+    int left = game_state->dirty_rect.x < rect.x
+        ? game_state->dirty_rect.x
+        : rect.x;
+
+    int top = game_state->dirty_rect.y < rect.y
+        ? game_state->dirty_rect.y
+        : rect.y;
+
+    int old_right =
+        game_state->dirty_rect.x + game_state->dirty_rect.w;
+
+    int new_right = rect.x + rect.w;
+
+    int old_bottom =
+        game_state->dirty_rect.y + game_state->dirty_rect.h;
+
+    int new_bottom = rect.y + rect.h;
+
+    int right = old_right > new_right
+        ? old_right
+        : new_right;
+
+    int bottom = old_bottom > new_bottom
+        ? old_bottom
+        : new_bottom;
+
+    game_state->dirty_rect = (SDL_Rect) {
+        .x = left,
+        .y = top,
+        .w = right - left,
+        .h = bottom - top
+    };
+}
+
+bool
+upload_dirty_texture(void)
+{
+    if (!game_state->framebuffer_dirty) {
+        return true;
+    }
+
+    SDL_Texture *texture =
+        internal_state->sdl_state->texture;
+
+    SDL_Rect rect = game_state->dirty_rect;
+
+    void *locked_pixels = NULL;
+    int locked_pitch = 0;
+
+    if (!SDL_LockTexture(
+            texture,
+            &rect,
+            &locked_pixels,
+            &locked_pitch
+        )) {
+        SDL_Log(
+            "SDL_LockTexture failed: %s",
+            SDL_GetError()
+        );
+        return false;
+    }
+
+    const size_t source_pitch =
+        (size_t)game_state->width * sizeof(uint32_t);
+
+    const size_t row_bytes =
+        (size_t)rect.w * sizeof(uint32_t);
+
+    const uint8_t *source =
+        (const uint8_t *)game_state->framebuffer +
+        (size_t)rect.y * source_pitch +
+        (size_t)rect.x * sizeof(uint32_t);
+
+    uint8_t *destination =
+        (uint8_t *)locked_pixels;
+
+    for (int y = 0; y < rect.h; ++y) {
+        memcpy(
+            destination + (size_t)y * locked_pitch,
+            source + (size_t)y * source_pitch,
+            row_bytes
+        );
+    }
+
+    SDL_UnlockTexture(texture);
+
+    game_state->framebuffer_dirty = false;
+
+    return true;
+}
+
 void
 engine_start() {
 	// main game loop
 	while(game_state->is_running) {
-		uint64_t start = SDL_GetPerformanceCounter();
-
 		// poll events
 		while (SDL_PollEvent(&game_state->event)) {
 			internal_state->engine_poll_events();
@@ -18,11 +150,7 @@ engine_start() {
 		internal_state->engine_update_framebuffer();
 
 		// update the texture with the modified framebuffer
-		SDL_UpdateTexture(
-			internal_state->sdl_state->texture, 
-			NULL, game_state->framebuffer, 
-			internal_state->sdl_state->width * sizeof(uint32_t)
-		);
+		upload_dirty_texture();
 
 		SDL_RenderClear(
 			internal_state->sdl_state->renderer
@@ -37,17 +165,6 @@ engine_start() {
 		SDL_RenderPresent(
 			internal_state->sdl_state->renderer
 		);
-
-		uint64_t end = SDL_GetPerformanceCounter();
-
-		double elapsed = 
-			(double)(end - start) / 
-			(double)SDL_GetPerformanceFrequency();
-
-		// cap the framerate at '1.0/TARGET_FRAME' fps
-		if (elapsed < TARGET_FRAME) {
-			SDL_Delay((TARGET_FRAME - elapsed) * 1000);
-		}
 	}
 }
 

src/engine/engine_init.c

@@ -65,6 +65,11 @@ engine_sdl_init_renderer(
 		return RCODE_FAILURE;
 	}
 
+	// enable VSync
+	if (!SDL_SetRenderVSync(state->renderer, 1)) {
+	    eprintf("SDL_SetRenderVSync failed: %s\n", SDL_GetError());
+	}
+
 	return RCODE_SUCCESS;
 }
 
@@ -127,9 +132,16 @@ engine_init(
 ) {
 	internal_state = (engine_internal_state_t *)
 		malloc(sizeof(engine_internal_state_t));
+	if (internal_state == NULL) {
+		return RCODE_FAILURE;
+	}
 
 	game_state = (game_state_t *)
 		malloc(sizeof(game_state_t));
+	if (game_state == NULL) {
+		free(internal_state);
+		return RCODE_FAILURE;
+	}
 
 	internal_state->engine_poll_events
 		= engine_poll_events;
@@ -138,11 +150,22 @@ engine_init(
 		= engine_update_framebuffer;
 
 	internal_state->sdl_state = engine_sdl_init();
+	if (internal_state->sdl_state == NULL) {
+		free(internal_state);
+		free(game_state);
+		return RCODE_FAILURE;
+	}
 
 	game_state->is_running = true;
+	game_state->framebuffer_dirty = true;
+	game_state->dirty_rect = (SDL_Rect) {
+	    .x = 0,
+	    .y = 0,
+	    .w = game_state->width,
+	    .h = game_state->height
+	};
 	game_state->width = internal_state->sdl_state->width;
 	game_state->height = internal_state->sdl_state->height;
 
-	return (game_state == NULL || internal_state == NULL) 
-		? RCODE_FAILURE : RCODE_SUCCESS;
+	return RCODE_SUCCESS;
 }

src/engine/render.c

@@ -20,6 +20,8 @@ put_pixel(
 	} else {
 		game_state->framebuffer[game_state->width * y + x]
 			= color;
+
+	    mark_dirty_rect(x, y, 1, 1);
 	}
 }
 
@@ -40,18 +42,43 @@ put_rect(
 			put_pixel(i, j, color);
 		}
 	}
+	mark_dirty_rect(x, y, w, h);
 }
 
 // fill the entire framebuffer with a given color
-void 
+void
 clear_framebuffer(
 	uint32_t color
 ) {
-	uint16_t w = game_state->width;
-	uint16_t h = game_state->height;
+    for (size_t i = 0;
+         i < (size_t)game_state->width * game_state->height;
+         ++i) {
+        game_state->framebuffer[i] = color;
+    }
 
-	for (int i = 0; i < w * h; i++) {
-		game_state->framebuffer[i] = color;
-	}
+    mark_dirty_rect(
+        0,
+        0,
+        game_state->width,
+        game_state->height
+    );
 }
 
+void
+clear_rect(int x, int y, int w, int h, uint32_t color)
+{
+    for (int py = y; py < y + h; ++py) {
+        for (int px = x; px < x + w; ++px) {
+            if (px >= 0 &&
+                px < game_state->width &&
+                py >= 0 &&
+                py < game_state->height) {
+                game_state->framebuffer[
+                    py * game_state->width + px
+                ] = color;
+            }
+        }
+    }
+
+    mark_dirty_rect(x, y, w, h);
+}

src/engine/text.c

@@ -112,6 +112,8 @@ put_char(
             );
         }
     }
+
+    mark_dirty_rect(x, y, size, size);
 }
 
 void