Make games run on watchOS (FFI stubs, string FFI, file reading, 2D camera) (#60)

* fix(watchos): generate the full FFI stub set so games link

gen_stubs.js threw on `string` params (rustType only knew f64/i64/void), so
it crashed before writing src/ffi_stubs.rs and the checked-in file went stale —
a game linking against the watchOS lib failed with undefined `_bloom_*`
(post-pass, ssao, wind, …). Map `string` -> i64 (Perry passes string pointers
in an integer register) for both params and returns, and add bloom_get_language
/ bloom_set_direct_2d_mode to OVERRIDES (real impls in lib.rs that regen would
otherwise duplicate). Regenerate.

Four functions (bloom_set_material_params, bloom_splat_impulse,
bloom_profiler_frame_history, bloom_profiler_overlay_text) are declared in the
engine's core/index.ts but absent from package.json's nativeLibrary.functions,
so gen_stubs can't see them — add hand-written no-op stubs in
src/ffi_stubs_manual.rs (perry validates the manifest cross-platform, so the
manifest gap is left for a separate change).

* fix(watchos): correct string FFI, implement file reading + 2D camera

Three runtime gaps that kept games from actually rendering on watchOS:

- StringHeader was 16 bytes (4×u32), but Perry 0.5.x's canonical header is 20
  bytes (5×u32 incl `flags`, data at +20). `perry_str` read every incoming
  string 4 bytes early — text rendered with a 4-null prefix + truncated tail
  ("BLOOM JUMP" -> "BLOOM") and file paths came back corrupted so levels
  never loaded. Add the missing `flags` field.

- bloom_read_file was a stub returning 0 (null); the game's inline `.length`
  then dereferenced null and crashed. Implement it: resolve the bundle-relative
  path, read the file, and return a real StringHeader via a new
  alloc_perry_string (empty string on a miss, never null).

- bloom_begin_mode_2d / bloom_end_mode_2d were no-ops, so world-space draws
  (tiles, sprites) rendered at raw coordinates off-screen while the screen-space
  HUD showed. Emit BEGIN_2D/END_2D marker commands carrying the camera; the
  SwiftUI Canvas applies the matching affine transform (world -> screen) to
  every command in between.

Also drop the watchOS `metal_sources` post-fx shader: SCNTechnique/SCNRenderer
is absent from the watchOS SDK so it can't run, and compiling it needs the
separately-downloadable Metal Toolchain. The app renders fine without the
metallib.

Author: proggeramlug

native/watchos/gen_stubs.js

@@ -11,7 +11,8 @@ const fns = pkg.perry.nativeLibrary.functions;
 
 const OVERRIDES = new Set([
   // Platform + input
-  'bloom_get_platform', 'bloom_get_crown_rotation',
+  'bloom_get_platform', 'bloom_get_crown_rotation', 'bloom_get_language',
+  'bloom_set_direct_2d_mode',
   'bloom_get_screen_width', 'bloom_get_screen_height',
   'bloom_get_touch_x', 'bloom_get_touch_y', 'bloom_get_touch_count',
   'bloom_get_delta_time', 'bloom_get_time', 'bloom_get_fps',
@@ -25,7 +26,8 @@ const OVERRIDES = new Set([
   'bloom_is_gamepad_available', 'bloom_get_gamepad_axis',
   'bloom_is_gamepad_button_pressed', 'bloom_is_gamepad_button_down', 'bloom_is_gamepad_button_released',
   'bloom_get_gamepad_axis_count',
-  // 2D shapes
+  // 2D camera + shapes
+  'bloom_begin_mode_2d', 'bloom_end_mode_2d',
   'bloom_draw_rect', 'bloom_draw_rect_lines',
   'bloom_draw_circle', 'bloom_draw_circle_lines',
   'bloom_draw_line', 'bloom_draw_triangle', 'bloom_draw_poly',
@@ -69,13 +71,17 @@ const OVERRIDES = new Set([
 const rustType = (p) => {
   if (p === 'f64') return 'f64';
   if (p === 'i64') return 'i64';
+  // Perry passes/returns heap strings as a pointer carried in an integer
+  // register; the stub ignores it, so i64 is the correct ABI-compatible type.
+  if (p === 'string') return 'i64';
   if (p === 'void') return '()';
   throw new Error(`Unknown param type: ${p}`);
 };
 
 const defaultForReturn = (r) => {
   if (r === 'f64') return '0.0';
   if (r === 'i64') return '0';
+  if (r === 'string') return '0';
   if (r === 'void') return '()';
   throw new Error(`Unknown return type: ${r}`);
 };

native/watchos/src/BloomWatchApp.swift

@@ -176,6 +176,8 @@ let K_TEXTURE: Int32 = 7
 let K_TEXTURE_REC: Int32 = 8
 let K_TEXTURE_PRO: Int32 = 9
 let K_TEXT: Int32 = 10
+let K_BEGIN_2D: Int32 = 11
+let K_END_2D: Int32 = 12
 
 // 3D primitives
 let K_CUBE: Int32 = 20
@@ -307,11 +309,30 @@ struct BloomRootView: View {
                     // Pull this frame's commands. 2D draws render here; 3D
                     // commands are filtered by BloomSceneView.
                     let n = Int(bloom_watchos_copy_draw_list(drawBuf.baseAddress!, 4096))
+                    // `active` is the context world-space draws use: between a
+                    // BEGIN_2D / END_2D pair it carries the camera's affine
+                    // transform (world → screen); otherwise it's the plain
+                    // screen-space context.
+                    var active = ctx
                     for i in 0..<n {
                         let ptr = drawBuf.baseAddress!.advanced(by: i)
                         let k = ptr.pointee.kind
                         if k >= 20 && k <= 29 { continue }  // 3D — handled by SceneView
-                        drawOne(ctx: ctx, cmdPtr: ptr)
+                        if k == K_BEGIN_2D {
+                            let zoom = ptr.pointee.size
+                            var t = CGAffineTransform(translationX: ptr.pointee.x, y: ptr.pointee.y)
+                            t = t.scaledBy(x: zoom, y: zoom)
+                            t = t.translatedBy(x: -ptr.pointee.w, y: -ptr.pointee.h)
+                            var w = ctx
+                            w.transform = t
+                            active = w
+                            continue
+                        }
+                        if k == K_END_2D {
+                            active = ctx
+                            continue
+                        }
+                        drawOne(ctx: active, cmdPtr: ptr)
                     }
                 }
             }

native/watchos/src/draw_list.rs

@@ -30,6 +30,12 @@ pub mod kind {
     pub const TEXTURE_PRO: i32 = 9;  // full: source, dest, origin, rotation
     pub const TEXT: i32 = 10;
 
+    // 2D camera mode markers. BEGIN carries the camera in reused fields:
+    // x,y = screen offset; w,h = world target; size = zoom. The Swift Canvas
+    // applies the matching affine transform to every command until END.
+    pub const BEGIN_2D: i32 = 11;
+    pub const END_2D: i32 = 12;
+
     // 3D immediate-mode primitives (pos = x,y,z; w,h = scale; src_x,y,z = secondary).
     pub const CUBE: i32 = 20;         // pos (x,y,z), size (w,h,size=depth)
     pub const CUBE_WIRES: i32 = 21;