fix(sokol): scale camera offset to physical pixels for HiDPI (mobile) NDC

On desktop, design dimensions == physical dimensions so the camera offset
(stored in design coordinates, e.g. 512,384) maps correctly to NDC. On
HiDPI mobile (e.g. 2400×1080 physical vs 1024×768 design), the offset
must be scaled by screen/design ratio before the NDC divide, otherwise the
world centre lands at NDC (-0.57, 0.29) instead of (0, 0) — a white screen.

Fix: multiply cam.offset by (screen_w/design_w, screen_h/design_h) in
toNdcX/Y, worldToScreen, and screenToWorld.

Author: apotema

backends/sokol/src/gfx.zig

@@ -88,15 +88,24 @@ var camera_active: bool = false;
 
 /// Convert screen-space pixel coordinates to NDC (-1..1) for sokol_gl.
 /// When a camera is active, applies forward transform: (world - target) * zoom + offset.
+///
+/// The camera offset is stored in design coordinates (e.g. design_w/2, design_h/2)
+/// so that the engine code is portable between backends.  When physical screen
+/// dimensions differ from design dimensions (HiDPI / mobile), scale the offset to
+/// physical pixels before dividing by the physical screen extent.
 fn toNdcX(px: f32) f32 {
     if (!camera_active) {
         // Screen-space: map design coords directly to NDC so a design-width
         // quad fills exactly NDC -1..1 regardless of physical screen width.
         return (px / @as(f32, @floatFromInt(design_w))) * 2.0 - 1.0;
     }
     const cam = active_camera;
-    const screen_x = (px - cam.target.x) * cam.zoom + cam.offset.x;
-    return (screen_x / @as(f32, @floatFromInt(screen_w))) * 2.0 - 1.0;
+    const fw = @as(f32, @floatFromInt(screen_w));
+    const fdw = @as(f32, @floatFromInt(design_w));
+    // Scale offset from design-space to physical-space so the camera center
+    // lands at the correct NDC position even when design != physical (HiDPI).
+    const screen_x = (px - cam.target.x) * cam.zoom + cam.offset.x * (fw / fdw);
+    return (screen_x / fw) * 2.0 - 1.0;
 }
 
 fn toNdcY(py: f32) f32 {
@@ -107,10 +116,10 @@ fn toNdcY(py: f32) f32 {
     }
     const cam = active_camera;
     const fh = @as(f32, @floatFromInt(screen_h));
+    const fdh = @as(f32, @floatFromInt(design_h));
     // Positions arrive in screen-space Y-down (Y-flipped by renderer.toScreenY).
-    // Apply the camera in the same screen-Y-down convention as the raylib backend:
-    // screen_final = (py - target.y) * zoom + offset.y
-    const screen_y = (py - cam.target.y) * cam.zoom + cam.offset.y;
+    // Scale offset from design-space to physical-space (same HiDPI correction as X).
+    const screen_y = (py - cam.target.y) * cam.zoom + cam.offset.y * (fh / fdh);
     return 1.0 - (screen_y / fh) * 2.0;
 }
 
@@ -371,18 +380,24 @@ pub fn getScreenHeight() i32 {
 }
 
 pub fn screenToWorld(pos: Vector2, camera: Camera2D) Vector2 {
+    // Scale camera offset from design-space to physical-space (HiDPI correction).
+    const off_x = camera.offset.x * @as(f32, @floatFromInt(screen_w)) / @as(f32, @floatFromInt(design_w));
+    const off_y = camera.offset.y * @as(f32, @floatFromInt(screen_h)) / @as(f32, @floatFromInt(design_h));
     return .{
-        .x = (pos.x - camera.offset.x) / camera.zoom + camera.target.x,
+        .x = (pos.x - off_x) / camera.zoom + camera.target.x,
         // Screen Y-down convention, same as raylib backend
-        .y = (pos.y - camera.offset.y) / camera.zoom + camera.target.y,
+        .y = (pos.y - off_y) / camera.zoom + camera.target.y,
     };
 }
 
 pub fn worldToScreen(pos: Vector2, camera: Camera2D) Vector2 {
+    // Scale camera offset from design-space to physical-space (HiDPI correction).
+    const off_x = camera.offset.x * @as(f32, @floatFromInt(screen_w)) / @as(f32, @floatFromInt(design_w));
+    const off_y = camera.offset.y * @as(f32, @floatFromInt(screen_h)) / @as(f32, @floatFromInt(design_h));
     return .{
-        .x = (pos.x - camera.target.x) * camera.zoom + camera.offset.x,
+        .x = (pos.x - camera.target.x) * camera.zoom + off_x,
         // Screen Y-down convention, same as raylib backend
-        .y = (pos.y - camera.target.y) * camera.zoom + camera.offset.y,
+        .y = (pos.y - camera.target.y) * camera.zoom + off_y,
     };
 }