fix: transpose matrices on GPU upload (row-major → column-major)

mini_math mat4 is row-major; WGSL mat4x4f is column-major. Matrices
uploaded without transposing were interpreted as their own transpose on
the GPU, causing RotatingCube and Renderer3D to render upside-down.

- Add gpu_upload_mat4() to post_process_helper for standalone uploads
- Add Uniforms::make() to RotatingCube::Uniforms (handles transpose)
- Add GlobalUniforms::make() and ObjectData::make() to renderer.h
- Update renderer_draw.cc and visual_debug.cc to use make()

handoff(Gemini): matrix layout bug fixed across all rasterized effects.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

3 files changed, 32 insertions, 45 deletions

diff --git a/src/3d/renderer.h b/src/3d/renderer.h
index bf3b497..4c31c97 100644
--- a/src/3d/renderer.h
+++ b/src/3d/renderer.h
@@ -23,6 +23,14 @@ struct GlobalUniforms {
   vec4 params;          // x = num_objects, yzw = padding
   vec2 resolution;
   vec2 padding;
+
+  // Transpose matrices: mini_math is row-major, WGSL expects column-major.
+  static GlobalUniforms make(const mat4& vp, const vec4& cam_pos_time,
+                             const vec4& p, const vec2& res) {
+    return {mat4::transpose(vp), mat4::transpose(vp.inverse()),
+            cam_pos_time,        p,
+            res,                 vec2(0.0f, 0.0f)};
+  }
 };
 
 // Matches the GPU struct layout
@@ -33,6 +41,11 @@ struct ObjectData {
   // params.x = object type (as float), params.y = plane_distance (if
   // applicable)
   vec4 params;
+
+  // Transpose matrices: mini_math is row-major, WGSL expects column-major.
+  static ObjectData make(const mat4& m, const vec4& col, const vec4& p) {
+    return {mat4::transpose(m), mat4::transpose(m.inverse()), col, p};
+  }
 };
 
 class Renderer3D {
diff --git a/src/3d/renderer_draw.cc b/src/3d/renderer_draw.cc
index 8a08998..d4a35a8 100644
--- a/src/3d/renderer_draw.cc
+++ b/src/3d/renderer_draw.cc
@@ -9,63 +9,38 @@
 
 void Renderer3D::update_uniforms(const Scene& scene, const Camera& camera,
                                  float time) {
-  GlobalUniforms globals;
-  globals.view_proj = camera.get_projection_matrix() * camera.get_view_matrix();
-  globals.inv_view_proj = globals.view_proj.inverse();
-  globals.camera_pos_time =
-      vec4(camera.position.x, camera.position.y, camera.position.z, time);
-  globals.params =
+  const mat4 vp = camera.get_projection_matrix() * camera.get_view_matrix();
+  const GlobalUniforms globals = GlobalUniforms::make(
+      vp,
+      vec4(camera.position.x, camera.position.y, camera.position.z, time),
       vec4((float)std::min((size_t)kMaxObjects, scene.objects.size()), 0.0f,
-           0.0f, 0.0f);
-  globals.resolution = vec2((float)width_, (float)height_);
-  globals.padding = vec2(0.0f, 0.0f);
+           0.0f, 0.0f),
+      vec2((float)width_, (float)height_));
 
   wgpuQueueWriteBuffer(queue_, global_uniform_buffer_, 0, &globals,
                        sizeof(GlobalUniforms));
 
   std::vector<ObjectData> obj_data;
   for (const auto& obj : scene.objects) {
-    ObjectData data;
-    data.model = obj.get_model_matrix();
-
-    // Calculate Inverse for point transformation
-    data.inv_model = data.model.inverse();
-
-    data.color = obj.color;
     float type_id = 0.0f;
     switch (obj.type) {
-    case ObjectType::SPHERE:
-      type_id = 1.0f;
-      break;
-    case ObjectType::BOX:
-      type_id = 2.0f;
-      break;
-    case ObjectType::CUBE:
-      type_id = 2.0f;
-      break; // CUBE is same as BOX for shader
-    case ObjectType::TORUS:
-      type_id = 3.0f;
-      break;
-    case ObjectType::PLANE:
-      type_id = 4.0f;
-      break;
-    case ObjectType::MESH:
-      type_id = 5.0f;
-      break;
-    default:
-      type_id = 0.0f;
-      break;
+    case ObjectType::SPHERE: type_id = 1.0f; break;
+    case ObjectType::BOX:    type_id = 2.0f; break;
+    case ObjectType::CUBE:   type_id = 2.0f; break; // CUBE is same as BOX
+    case ObjectType::TORUS:  type_id = 3.0f; break;
+    case ObjectType::PLANE:  type_id = 4.0f; break;
+    case ObjectType::MESH:   type_id = 5.0f; break;
+    default:                 type_id = 0.0f; break;
     }
 
     float plane_distance = 0.0f;
     if (obj.type == ObjectType::PLANE && obj.shared_user_data) {
-      // Safely cast shared_user_data to PlaneData* and get distance
       plane_distance = ((PlaneData*)(obj.shared_user_data.get()))->distance;
     }
 
-    data.params =
-        vec4(type_id, plane_distance, obj.local_extent.x, obj.local_extent.y);
-    obj_data.push_back(data);
+    obj_data.push_back(ObjectData::make(
+        obj.get_model_matrix(), obj.color,
+        vec4(type_id, plane_distance, obj.local_extent.x, obj.local_extent.y)));
     if (obj_data.size() >= kMaxObjects)
       break;
   }
diff --git a/src/3d/visual_debug.cc b/src/3d/visual_debug.cc
index cd4ccce..f6796d5 100644
--- a/src/3d/visual_debug.cc
+++ b/src/3d/visual_debug.cc
@@ -340,10 +340,9 @@ void VisualDebug::add_trajectory(const std::vector<vec3>& points,
 }
 
 void VisualDebug::update_buffers(const mat4& view_proj) {
-  // Update Uniforms - fill entire GlobalUniforms structure
-  GlobalUniforms uniforms = {};
-  uniforms.view_proj = view_proj;
-  // Other fields zeroed (not used by visual debug shader)
+  // Update Uniforms - only view_proj used by visual debug shader
+  const GlobalUniforms uniforms = GlobalUniforms::make(
+      view_proj, vec4(0, 0, 0, 0), vec4(0, 0, 0, 0), vec2(0, 0));
   wgpuQueueWriteBuffer(wgpuDeviceGetQueue(device_), uniform_buffer_, 0,
                        &uniforms, sizeof(GlobalUniforms));