add missing input file

Batch adjacent same-texture sprite draws in end_frame.
Replaces per-sprite DrawGPUPrimitives with texture runs so shared atlases issue one GPU draw.

Makefile

@@ -1,4 +1,4 @@
-.PHONY: shaders-vulkan shaders-d3d12 shaders-metal shaders-all bake toad check test help
+.PHONY: shaders-vulkan shaders-d3d12 shaders-metal shaders-all bake toad hello_sprite crowd camera_sandbox clips check test help
 
 help:
 	@echo "Targets:"
@@ -8,8 +8,12 @@ help:
 	@echo "  shaders-metal    Compile MSL into shaders/metal/ (needs shadercross)"
 	@echo "  shaders-all      Build all shader backends"
 	@echo "  test             Run engine unit tests"
-	@echo "  check           Typecheck examples/toad"
-	@echo "  toad            Run the toad example"
+	@echo "  check            Typecheck all examples"
+	@echo "  toad             Run the toad example (full demo)"
+	@echo "  hello_sprite     Minimal load + draw"
+	@echo "  crowd            Many sprites, one Character_Data"
+	@echo "  camera_sandbox   Pan camera / Space toggles follow"
+	@echo "  clips            Keys 1/2 switch idle/walk"
 
 bake:
 	./scripts/bake_all.sh
@@ -30,6 +34,22 @@ test:
 
 check:
 	odin check examples/toad -collection:pkg=.
+	odin check examples/hello_sprite -collection:pkg=.
+	odin check examples/crowd -collection:pkg=.
+	odin check examples/camera_sandbox -collection:pkg=.
+	odin check examples/clips -collection:pkg=.
 
 toad:
 	odin run examples/toad -collection:pkg=.
+
+hello_sprite:
+	odin run examples/hello_sprite -collection:pkg=.
+
+crowd:
+	odin run examples/crowd -collection:pkg=.
+
+camera_sandbox:
+	odin run examples/camera_sandbox -collection:pkg=.
+
+clips:
+	odin run examples/clips -collection:pkg=.

engine/app.odin

@@ -35,6 +35,7 @@ App :: struct {
 	transfer_buffer:   ^sdl.GPUTransferBuffer,
 	draw_list:         [dynamic]Queued_Sprite,
 	clear_color:       sdl.FColor,
+	camera:            Camera,
 }
 
 Shader_Backend :: enum {
@@ -124,6 +125,8 @@ init :: proc(app: ^App, title: cstring, width, height: i32) -> bool {
 
 	app.draw_list = make([dynamic]Queued_Sprite)
 
+	app.camera = camera_default()
+
 	return true
 }
 

engine/camera.odin

@@ -0,0 +1,17 @@
+package engine
+
+Camera :: struct {
+	position: Vec2,
+	anchor:   Vec2,
+}
+
+camera_default :: proc() -> Camera {
+	return Camera{position = {0, 0}, anchor = {0.5, 0.5}}
+}
+
+world_to_screen :: proc(cam: Camera, world: Vec2, viewport: Vec2) -> Vec2 {
+	return {
+		world.x - cam.position.x + viewport.x * cam.anchor[0],
+		world.y - cam.position.y + viewport.y * cam.anchor[1],
+	}
+}

engine/input.odin

@@ -7,6 +7,11 @@ Key :: enum {
 	D,
 	Left,
 	Right,
+	Up,
+	Down,
+	Space,
+	N1,
+	N2,
 }
 
 key_down :: proc(key: Key) -> bool {
@@ -23,6 +28,16 @@ key_down :: proc(key: Key) -> bool {
 		scan_code = .LEFT
 	case .Right:
 		scan_code = .RIGHT
+	case .Up:
+		scan_code = .UP
+	case .Down:
+		scan_code = .DOWN
+	case .Space:
+		scan_code = .SPACE
+	case .N1:
+		scan_code = ._1
+	case .N2:
+		scan_code = ._2
 	}
 	return keys[scan_code]
 }

engine/sprite.odin

@@ -109,14 +109,17 @@ draw_sprite :: proc(app: ^App, sprite: ^Sprite) {
 	trim_y := f32(frame.trim_offset[1])
 	pivot := sprite.data.def.pivot
 
-	canvas_top := sprite.position.y - src_h * pivot[1]
+	viewport := Vec2{f32(app.swapchain_w), f32(app.swapchain_h)}
+	feet := world_to_screen(app.camera, sprite.position, viewport)
+
+	canvas_top := feet.y - src_h * pivot[1]
 	x0_px, y0_px: f32
 	if sprite.flip_x {
-		canvas_left := sprite.position.x - (1.0 - pivot[0]) * src_w
+		canvas_left := feet.x - (1.0 - pivot[0]) * src_w
 		x0_px = canvas_left + (src_w - trim_x - fw)
 		y0_px = canvas_top + trim_y
 	} else {
-		canvas_left := sprite.position.x - src_w * pivot[0]
+		canvas_left := feet.x - src_w * pivot[0]
 		x0_px = canvas_left + trim_x
 		y0_px = canvas_top + trim_y
 	}
@@ -147,10 +150,7 @@ draw_sprite :: proc(app: ^App, sprite: ^Sprite) {
 		{pos = p3, uv = {u0, v1}},
 	}
 
-	append(
-		&app.draw_list,
-		Queued_Sprite{texture = sprite.data.texture, verts = verts},
-	)
+	append(&app.draw_list, Queued_Sprite{texture = sprite.data.texture, verts = verts})
 }
 
 set_sprite_clip :: proc(sprite: ^Sprite, clip: string) {

examples/camera_sandbox/main.odin

@@ -0,0 +1,58 @@
+package main
+
+import eng "pkg:engine"
+
+// Camera sandbox: toad stays put; arrows pan the camera. Space toggles follow mode.
+main :: proc() {
+	app: eng.App
+	if !eng.init(&app, "camera sandbox", 800, 600) do return
+	defer eng.shutdown(&app)
+
+	data, ok := eng.load_character_data(&app, "assets_baked/characters/toad/toad.char.json")
+	if !ok do return
+	defer eng.destroy_character_data(&app, &data)
+
+	toad := eng.spawn_sprite(&data, {0, 0}, "idle", 0)
+	app.camera.position = {0, -100}
+
+	follow := false
+	space_was_down := false
+	CAM_SPEED :: f32(300)
+
+	last := eng.now_seconds()
+
+	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+
+		space := eng.key_down(.Space)
+		if space && !space_was_down {
+			follow = !follow
+		}
+		space_was_down = space
+
+		if follow {
+			app.camera.position = toad.position - {0, 100}
+		} else {
+			if eng.key_down(.Left) || eng.key_down(.A) {
+				app.camera.position.x -= CAM_SPEED * dt
+			}
+			if eng.key_down(.Right) || eng.key_down(.D) {
+				app.camera.position.x += CAM_SPEED * dt
+			}
+			if eng.key_down(.Up) {
+				app.camera.position.y -= CAM_SPEED * dt
+			}
+			if eng.key_down(.Down) {
+				app.camera.position.y += CAM_SPEED * dt
+			}
+		}
+
+		eng.update_sprite(&toad, dt)
+
+		eng.begin_frame(&app)
+		eng.draw_sprite(&app, &toad)
+		eng.end_frame(&app)
+	}
+}

examples/clips/main.odin

@@ -0,0 +1,38 @@
+package main
+
+import eng "pkg:engine"
+
+// Clip switcher: 1 = idle, 2 = walk. No movement — animation policy only.
+main :: proc() {
+	app: eng.App
+	if !eng.init(&app, "clips", 800, 600) do return
+	defer eng.shutdown(&app)
+
+	data, ok := eng.load_character_data(&app, "assets_baked/characters/toad/toad.char.json")
+	if !ok do return
+	defer eng.destroy_character_data(&app, &data)
+
+	toad := eng.spawn_sprite(&data, {400, 500}, "idle", 0)
+	app.camera.position = toad.position - {0, 100}
+
+	last := eng.now_seconds()
+
+	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+
+		if eng.key_down(.N1) {
+			eng.set_sprite_clip(&toad, "idle")
+		}
+		if eng.key_down(.N2) {
+			eng.set_sprite_clip(&toad, "walk")
+		}
+
+		eng.update_sprite(&toad, dt)
+
+		eng.begin_frame(&app)
+		eng.draw_sprite(&app, &toad)
+		eng.end_frame(&app)
+	}
+}

examples/crowd/main.odin

@@ -0,0 +1,49 @@
+package main
+
+import eng "pkg:engine"
+
+// Many sprites sharing one Character_Data (Flyweight) — good batching demo.
+COUNT :: 24
+
+main :: proc() {
+	app: eng.App
+	if !eng.init(&app, "crowd", 800, 600) do return
+	defer eng.shutdown(&app)
+
+	data, ok := eng.load_character_data(&app, "assets_baked/characters/toad/toad.char.json")
+	if !ok do return
+	defer eng.destroy_character_data(&app, &data)
+
+	sprites: [COUNT]eng.Sprite
+	for i in 0 ..< COUNT {
+		col := i % 8
+		row := i / 8
+		pos := eng.Vec2 {
+			f32(120 + col * 80),
+			f32(280 + row * 120),
+		}
+		clip := "idle" if (i % 2) == 0 else "walk"
+		sprites[i] = eng.spawn_sprite(&data, pos, clip, i % 5)
+	}
+
+	// Look at the middle of the grid
+	app.camera.position = {400, 400}
+
+	last := eng.now_seconds()
+
+	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+
+		for &s in sprites {
+			eng.update_sprite(&s, dt)
+		}
+
+		eng.begin_frame(&app)
+		for &s in sprites {
+			eng.draw_sprite(&app, &s)
+		}
+		eng.end_frame(&app)
+	}
+}

examples/hello_sprite/main.odin

@@ -0,0 +1,34 @@
+package main
+
+import eng "pkg:engine"
+
+// Minimal: load one baked character and draw idle. No input, no camera follow.
+main :: proc() {
+	app: eng.App
+	if !eng.init(&app, "hello sprite", 800, 600) do return
+	defer eng.shutdown(&app)
+
+	data, ok := eng.load_character_data(&app, "assets_baked/characters/toad/toad.char.json")
+	if !ok do return
+	defer eng.destroy_character_data(&app, &data)
+
+	sprite := eng.spawn_sprite(&data, {400, 500}, "idle", 0)
+
+	// Screen-centered framing without gameplay camera follow:
+	// treat spawn position as world; look slightly above feet.
+	app.camera.position = sprite.position - {0, 100}
+
+	last := eng.now_seconds()
+
+	for eng.events() {
+		now := eng.now_seconds()
+		dt := f32(now - last)
+		last = now
+
+		eng.update_sprite(&sprite, dt)
+
+		eng.begin_frame(&app)
+		eng.draw_sprite(&app, &sprite)
+		eng.end_frame(&app)
+	}
+}

examples/toad/main.odin

@@ -39,6 +39,8 @@ main :: proc() {
 		} else {
 			eng.set_sprite_clip(&toad, "idle")
 		}
+
+		app.camera.position = toad.position - {0, 100}
 		eng.update_sprite(&toad, dt)
 
 		eng.begin_frame(&app)