style: apply clang-formatHEADmain

1 files changed, 116 insertions, 106 deletions

diff --git a/cnn_v3/src/gbuffer_effect.cc b/cnn_v3/src/gbuffer_effect.cc
index 82ad8b1..395c8bc 100644
--- a/cnn_v3/src/gbuffer_effect.cc
+++ b/cnn_v3/src/gbuffer_effect.cc
@@ -1,5 +1,6 @@
 // GBufferEffect implementation
-// Rasterizes proxy geometry to MRT G-buffer, then packs into CNN v3 feature textures.
+// Rasterizes proxy geometry to MRT G-buffer, then packs into CNN v3 feature
+// textures.
 
 #include "gbuffer_effect.h"
 #include "3d/object.h"
@@ -10,9 +11,10 @@
 #include <cstring>
 #include <vector>
 
-// Shader source (loaded from asset at runtime — declared extern by the build system)
-// For standalone use outside the asset system, the caller must ensure the WGSL
-// source strings are available.  They are declared here as weak-linkable externs.
+// Shader source (loaded from asset at runtime — declared extern by the build
+// system) For standalone use outside the asset system, the caller must ensure
+// the WGSL source strings are available.  They are declared here as
+// weak-linkable externs.
 extern const char* gbuf_raster_wgsl;
 extern const char* gbuf_shadow_wgsl;
 extern const char* gbuf_pack_wgsl;
@@ -20,7 +22,8 @@ extern const char* gbuf_pack_wgsl;
 // Maximum number of objects the G-buffer supports per frame.
 static const int kGBufMaxObjects = 256;
 
-// ObjectData struct that mirrors the WGSL layout in gbuf_raster.wgsl and renderer.h
+// ObjectData struct that mirrors the WGSL layout in gbuf_raster.wgsl and
+// renderer.h
 struct GBufObjectData {
   mat4 model;
   mat4 inv_model;
@@ -38,7 +41,7 @@ struct GBufGlobalUniforms {
   mat4 view_proj;
   mat4 inv_view_proj;
   vec4 camera_pos_time;
-  vec4 params;        // x = num_objects
+  vec4 params; // x = num_objects
   vec2 resolution;
   vec2 padding;
 };
@@ -56,12 +59,12 @@ GBufferEffect::GBufferEffect(const GpuContext& ctx,
 
   // Derive internal node name prefix from the first output name.
   const std::string& prefix = outputs.empty() ? "gbuf" : outputs[0];
-  node_albedo_     = prefix + "_albedo";
+  node_albedo_ = prefix + "_albedo";
   node_normal_mat_ = prefix + "_normal_mat";
-  node_depth_      = prefix + "_depth";
-  node_shadow_     = prefix + "_shadow";
-  node_transp_     = prefix + "_transp";
-  node_prev_tex_   = prefix + "_prev";
+  node_depth_ = prefix + "_depth";
+  node_shadow_ = prefix + "_shadow";
+  node_transp_ = prefix + "_transp";
+  node_prev_tex_ = prefix + "_prev";
   // Allocate GPU buffers for scene data.
   global_uniforms_buf_ =
       gpu_create_buffer(ctx_.device, sizeof(GBufGlobalUniforms),
@@ -83,11 +86,11 @@ GBufferEffect::GBufferEffect(const GpuContext& ctx,
 }
 
 void GBufferEffect::declare_nodes(NodeRegistry& registry) {
-  registry.declare_node(node_albedo_,     NodeType::GBUF_ALBEDO,    -1, -1);
-  registry.declare_node(node_normal_mat_, NodeType::GBUF_ALBEDO,    -1, -1);
-  registry.declare_node(node_depth_,      NodeType::GBUF_DEPTH32,   -1, -1);
-  registry.declare_node(node_shadow_,     NodeType::GBUF_R8,        -1, -1);
-  registry.declare_node(node_transp_,     NodeType::GBUF_R8,        -1, -1);
+  registry.declare_node(node_albedo_, NodeType::GBUF_ALBEDO, -1, -1);
+  registry.declare_node(node_normal_mat_, NodeType::GBUF_ALBEDO, -1, -1);
+  registry.declare_node(node_depth_, NodeType::GBUF_DEPTH32, -1, -1);
+  registry.declare_node(node_shadow_, NodeType::GBUF_R8, -1, -1);
+  registry.declare_node(node_transp_, NodeType::GBUF_R8, -1, -1);
   // feat_tex0 / feat_tex1 are the declared output_nodes_ — they get registered
   // by the sequence infrastructure; declare them here as well if not already.
   if (!registry.has_node(output_nodes_[0])) {
@@ -96,7 +99,8 @@ void GBufferEffect::declare_nodes(NodeRegistry& registry) {
   if (!registry.has_node(output_nodes_[1])) {
     registry.declare_node(output_nodes_[1], NodeType::GBUF_RGBA32UINT, -1, -1);
   }
-  // F16X8 = Rgba16Float with CopySrc|CopyDst — matches CNNv3Effect output format.
+  // F16X8 = Rgba16Float with CopySrc|CopyDst — matches CNNv3Effect output
+  // format.
   registry.declare_node(node_prev_tex_, NodeType::F16X8, -1, -1);
 }
 
@@ -111,7 +115,7 @@ void GBufferEffect::set_scene() {
     seed ^= seed << 13;
     seed ^= seed >> 17;
     seed ^= seed << 5;
-    return (float)(seed >> 8) / 16777216.0f;  // [0, 1)
+    return (float)(seed >> 8) / 16777216.0f; // [0, 1)
   };
   auto rrange = [&](float lo, float hi) { return lo + rnd() * (hi - lo); };
 
@@ -120,8 +124,8 @@ void GBufferEffect::set_scene() {
   {
     Object3D obj(ObjectType::BOX);
     obj.position = vec3(1.0f, 0.0f, 0.0f);
-    obj.scale    = vec3(0.6f, 0.6f, 0.6f);
-    obj.color    = vec4(0.9f, 0.5f, 0.3f, 1.0f);
+    obj.scale = vec3(0.6f, 0.6f, 0.6f);
+    obj.color = vec4(0.9f, 0.5f, 0.3f, 1.0f);
     scene_.add_object(obj);
     cube_anims_.push_back({{0.0f, 1.0f, 0.0f}, 0.0f});
   }
@@ -129,8 +133,8 @@ void GBufferEffect::set_scene() {
     Object3D obj(ObjectType::SPHERE);
     obj.position = vec3(-1.0f, 0.0f, 0.0f);
     const float r = 0.9f;
-    obj.scale    = vec3(r, r, r);
-    obj.color    = vec4(0.3f, 0.6f, 0.9f, 1.0f);
+    obj.scale = vec3(r, r, r);
+    obj.color = vec4(0.3f, 0.6f, 0.9f, 1.0f);
     const int idx = (int)scene_.objects.size();
     scene_.add_object(obj);
     sphere_anims_.push_back({idx, r});
@@ -141,36 +145,35 @@ void GBufferEffect::set_scene() {
     Object3D obj(ObjectType::SPHERE);
     obj.position = vec3(0.0f, 2.2f, 0.0f);
     const float r = 0.6f;
-    obj.scale    = vec3(r, r, r);
-    obj.color    = vec4(0.9f, 0.8f, 0.2f, 1.0f);
+    obj.scale = vec3(r, r, r);
+    obj.color = vec4(0.9f, 0.8f, 0.2f, 1.0f);
     const int idx = (int)scene_.objects.size();
     scene_.add_object(obj);
     sphere_anims_.push_back({idx, r});
   }
 
   // Camera: above and in front of the scene, looking at origin.
-  camera_.set_look_at(vec3(0.0f, 2.5f, 6.0f),
-                      vec3(0.0f, 0.0f, 0.0f),
+  camera_.set_look_at(vec3(0.0f, 2.5f, 6.0f), vec3(0.0f, 0.0f, 0.0f),
                       vec3(0.0f, 1.0f, 0.0f));
-  camera_.fov_y_rad  = 0.7854f;  // 45°
+  camera_.fov_y_rad = 0.7854f; // 45°
   camera_.near_plane = 0.1f;
-  camera_.far_plane  = 20.0f;
+  camera_.far_plane = 20.0f;
   // aspect_ratio is updated each frame from params.resolution.
 
   scene_ready_ = true;
 }
 
 static void clear_r8_node(WGPUCommandEncoder encoder, WGPUTextureView view,
-                           float value) {
+                          float value) {
   WGPURenderPassColorAttachment att = {};
-  att.view       = view;
-  att.loadOp     = WGPULoadOp_Clear;
-  att.storeOp    = WGPUStoreOp_Store;
+  att.view = view;
+  att.loadOp = WGPULoadOp_Clear;
+  att.storeOp = WGPUStoreOp_Store;
   att.clearValue = {value, value, value, value};
   att.depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
   WGPURenderPassDescriptor pd = {};
   pd.colorAttachmentCount = 1;
-  pd.colorAttachments     = &att;
+  pd.colorAttachments = &att;
   WGPURenderPassEncoder p = wgpuCommandEncoderBeginRenderPass(encoder, &pd);
   wgpuRenderPassEncoderEnd(p);
   wgpuRenderPassEncoderRelease(p);
@@ -190,8 +193,7 @@ void GBufferEffect::render(WGPUCommandEncoder encoder,
   const float angle = params.time * 0.3f;
   const float R = 6.0f;
   camera_.set_look_at(vec3(R * sinf(angle), 2.5f, R * cosf(angle)),
-                      vec3(0.0f, 0.0f, 0.0f),
-                      vec3(0.0f, 1.0f, 0.0f));
+                      vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f));
 
   // Animate cubes: axis-angle rotation driven by physical time.
   for (int i = 0; i < (int)cube_anims_.size(); ++i) {
@@ -210,8 +212,8 @@ void GBufferEffect::render(WGPUCommandEncoder encoder,
     GBufLightsUniforms lu = {};
     lu.params = vec4(1.0f, 0.0f, 0.0f, 0.0f);
     // Key: warm sun, upper-right-front.
-    lu.lights[0].direction = vec4(0.408f, 0.816f, 0.408f, 0.0f);  // norm(1,2,1)
-    lu.lights[0].color     = vec4(1.00f, 0.92f, 0.78f, 1.0f);
+    lu.lights[0].direction = vec4(0.408f, 0.816f, 0.408f, 0.0f); // norm(1,2,1)
+    lu.lights[0].color = vec4(1.00f, 0.92f, 0.78f, 1.0f);
     // Fill: cool sky, upper-left-back. (disabled for debugging)
     // lu.lights[1].direction = vec4(-0.577f, 0.577f, -0.577f, 0.0f);
     // lu.lights[1].color     = vec4(0.40f, 0.45f, 0.80f, 0.4f);
@@ -227,11 +229,11 @@ void GBufferEffect::render(WGPUCommandEncoder encoder,
   res_uni._pad1 = 0.0f;
   pack_res_uniform_.update(ctx_.queue, res_uni);
 
-  WGPUTextureView albedo_view     = nodes.get_view(node_albedo_);
+  WGPUTextureView albedo_view = nodes.get_view(node_albedo_);
   WGPUTextureView normal_mat_view = nodes.get_view(node_normal_mat_);
-  WGPUTextureView depth_view      = nodes.get_view(node_depth_);
-  WGPUTextureView feat0_view      = nodes.get_view(output_nodes_[0]);
-  WGPUTextureView feat1_view      = nodes.get_view(output_nodes_[1]);
+  WGPUTextureView depth_view = nodes.get_view(node_depth_);
+  WGPUTextureView feat0_view = nodes.get_view(output_nodes_[0]);
+  WGPUTextureView feat1_view = nodes.get_view(output_nodes_[1]);
 
   // node_prev_tex_ is updated by post_render() at the end of each frame.
   // On frame 0 it is zero (NodeRegistry zeroes new textures) — correct default.
@@ -266,17 +268,16 @@ void GBufferEffect::render(WGPUCommandEncoder encoder,
   raster_pass_desc.colorAttachments = color_attachments;
   raster_pass_desc.depthStencilAttachment = &depth_attachment;
 
-  const int num_objects =
-      (int)(scene_.objects.size() < (size_t)kGBufMaxObjects
-                ? scene_.objects.size()
-                : (size_t)kGBufMaxObjects);
+  const int num_objects = (int)(scene_.objects.size() < (size_t)kGBufMaxObjects
+                                    ? scene_.objects.size()
+                                    : (size_t)kGBufMaxObjects);
 
   if (num_objects > 0 && raster_pipeline_.get() != nullptr) {
     WGPURenderPassEncoder raster_pass =
         wgpuCommandEncoderBeginRenderPass(encoder, &raster_pass_desc);
     wgpuRenderPassEncoderSetPipeline(raster_pass, raster_pipeline_.get());
-    wgpuRenderPassEncoderSetBindGroup(raster_pass, 0,
-                                     raster_bind_group_.get(), 0, nullptr);
+    wgpuRenderPassEncoderSetBindGroup(raster_pass, 0, raster_bind_group_.get(),
+                                      0, nullptr);
     // Draw 36 vertices (proxy box) × num_objects instances.
     wgpuRenderPassEncoderDraw(raster_pass, 36, (uint32_t)num_objects, 0, 0);
     wgpuRenderPassEncoderEnd(raster_pass);
@@ -293,45 +294,46 @@ void GBufferEffect::render(WGPUCommandEncoder encoder,
   if (shadow_pipeline_.get() != nullptr) {
     WGPUBindGroupEntry shadow_entries[5] = {};
     shadow_entries[0].binding = 0;
-    shadow_entries[0].buffer  = global_uniforms_buf_.buffer;
-    shadow_entries[0].size    = sizeof(GBufGlobalUniforms);
+    shadow_entries[0].buffer = global_uniforms_buf_.buffer;
+    shadow_entries[0].size = sizeof(GBufGlobalUniforms);
 
     shadow_entries[1].binding = 1;
-    shadow_entries[1].buffer  = objects_buf_.buffer;
-    shadow_entries[1].size    = (size_t)objects_buf_capacity_ * sizeof(GBufObjectData);
+    shadow_entries[1].buffer = objects_buf_.buffer;
+    shadow_entries[1].size =
+        (size_t)objects_buf_capacity_ * sizeof(GBufObjectData);
 
-    shadow_entries[2].binding     = 2;
+    shadow_entries[2].binding = 2;
     shadow_entries[2].textureView = depth_view;
 
     shadow_entries[3].binding = 3;
-    shadow_entries[3].buffer  = lights_uniform_.get().buffer;
-    shadow_entries[3].size    = sizeof(GBufLightsUniforms);
+    shadow_entries[3].buffer = lights_uniform_.get().buffer;
+    shadow_entries[3].size = sizeof(GBufLightsUniforms);
 
-    shadow_entries[4].binding     = 4;
+    shadow_entries[4].binding = 4;
     shadow_entries[4].textureView = normal_mat_view;
 
     WGPUBindGroupLayout shadow_bgl =
         wgpuRenderPipelineGetBindGroupLayout(shadow_pipeline_.get(), 0);
 
     WGPUBindGroupDescriptor shadow_bg_desc = {};
-    shadow_bg_desc.layout     = shadow_bgl;
+    shadow_bg_desc.layout = shadow_bgl;
     shadow_bg_desc.entryCount = 5;
-    shadow_bg_desc.entries    = shadow_entries;
+    shadow_bg_desc.entries = shadow_entries;
 
     WGPUBindGroup shadow_bg =
         wgpuDeviceCreateBindGroup(ctx_.device, &shadow_bg_desc);
     wgpuBindGroupLayoutRelease(shadow_bgl);
 
     WGPURenderPassColorAttachment shadow_att = {};
-    shadow_att.view       = nodes.get_view(node_shadow_);
-    shadow_att.loadOp     = WGPULoadOp_Clear;
-    shadow_att.storeOp    = WGPUStoreOp_Store;
+    shadow_att.view = nodes.get_view(node_shadow_);
+    shadow_att.loadOp = WGPULoadOp_Clear;
+    shadow_att.storeOp = WGPUStoreOp_Store;
     shadow_att.clearValue = {1.0f, 1.0f, 1.0f, 1.0f};
     shadow_att.depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
 
     WGPURenderPassDescriptor shadow_pass_desc = {};
     shadow_pass_desc.colorAttachmentCount = 1;
-    shadow_pass_desc.colorAttachments     = &shadow_att;
+    shadow_pass_desc.colorAttachments = &shadow_att;
 
     WGPURenderPassEncoder shadow_pass =
         wgpuCommandEncoderBeginRenderPass(encoder, &shadow_pass_desc);
@@ -408,7 +410,7 @@ void GBufferEffect::render(WGPUCommandEncoder encoder,
   wgpuComputePassEncoderSetPipeline(compute_pass, pack_pipeline_.get());
   wgpuComputePassEncoderSetBindGroup(compute_pass, 0, pack_bg, 0, nullptr);
 
-  const uint32_t wg_x = ((uint32_t)width_  + 7u) / 8u;
+  const uint32_t wg_x = ((uint32_t)width_ + 7u) / 8u;
   const uint32_t wg_y = ((uint32_t)height_ + 7u) / 8u;
   wgpuComputePassEncoderDispatchWorkgroups(compute_pass, wg_x, wg_y, 1);
   wgpuComputePassEncoderEnd(compute_pass);
@@ -433,29 +435,29 @@ void GBufferEffect::ensure_objects_buffer(int num_objects) {
   objects_buf_capacity_ = num_objects;
 }
 
-void GBufferEffect::upload_scene_data(const Scene& scene,
-                                      const Camera& camera, float time) {
-  const int num_objects =
-      (int)(scene.objects.size() < (size_t)kGBufMaxObjects
-                ? scene.objects.size()
-                : (size_t)kGBufMaxObjects);
+void GBufferEffect::upload_scene_data(const Scene& scene, const Camera& camera,
+                                      float time) {
+  const int num_objects = (int)(scene.objects.size() < (size_t)kGBufMaxObjects
+                                    ? scene.objects.size()
+                                    : (size_t)kGBufMaxObjects);
 
   const mat4 view = camera.get_view_matrix();
   mat4 proj = camera.get_projection_matrix();
-  proj.m[5] = -proj.m[5];  // undo post-process Y flip: G-buffer uses integer reads
-  const mat4 vp   = proj * view;
+  proj.m[5] =
+      -proj.m[5]; // undo post-process Y flip: G-buffer uses integer reads
+  const mat4 vp = proj * view;
 
   GBufGlobalUniforms gu = {};
-  gu.view_proj       = vp;
-  gu.inv_view_proj   = vp.inverse();
-  gu.camera_pos_time = vec4(camera.position.x, camera.position.y,
-                            camera.position.z, time);
-  gu.params    = vec4((float)num_objects, 0.0f, 0.0f, 0.0f);
+  gu.view_proj = vp;
+  gu.inv_view_proj = vp.inverse();
+  gu.camera_pos_time =
+      vec4(camera.position.x, camera.position.y, camera.position.z, time);
+  gu.params = vec4((float)num_objects, 0.0f, 0.0f, 0.0f);
   gu.resolution = vec2((float)width_, (float)height_);
-  gu.padding   = vec2(0.0f, 0.0f);
+  gu.padding = vec2(0.0f, 0.0f);
 
-  wgpuQueueWriteBuffer(ctx_.queue, global_uniforms_buf_.buffer, 0,
-                       &gu, sizeof(GBufGlobalUniforms));
+  wgpuQueueWriteBuffer(ctx_.queue, global_uniforms_buf_.buffer, 0, &gu,
+                       sizeof(GBufGlobalUniforms));
 
   // Upload object data (no per-frame heap alloc — reuse s_obj_staging).
   if (num_objects > 0) {
@@ -463,13 +465,12 @@ void GBufferEffect::upload_scene_data(const Scene& scene,
     for (int i = 0; i < num_objects; ++i) {
       const Object3D& obj = scene.objects[(size_t)i];
       const mat4 m = obj.get_model_matrix();
-      s_obj_staging[i].model     = m;
+      s_obj_staging[i].model = m;
       s_obj_staging[i].inv_model = m.inverse();
-      s_obj_staging[i].color     = obj.color;
-      s_obj_staging[i].params    = vec4((float)(int)obj.type, 0.0f, 0.0f, 0.0f);
+      s_obj_staging[i].color = obj.color;
+      s_obj_staging[i].params = vec4((float)(int)obj.type, 0.0f, 0.0f, 0.0f);
     }
-    wgpuQueueWriteBuffer(ctx_.queue, objects_buf_.buffer, 0,
-                         s_obj_staging,
+    wgpuQueueWriteBuffer(ctx_.queue, objects_buf_.buffer, 0, s_obj_staging,
                          (size_t)num_objects * sizeof(GBufObjectData));
   }
 }
@@ -483,8 +484,7 @@ void GBufferEffect::create_raster_pipeline() {
     return; // Asset not loaded yet; pipeline creation deferred.
   }
 
-  const std::string composed =
-      ShaderComposer::Get().Compose({}, src);
+  const std::string composed = ShaderComposer::Get().Compose({}, src);
 
   WGPUShaderSourceWGSL wgsl_src = {};
   wgsl_src.chain.sType = WGPUSType_ShaderSourceWGSL;
@@ -492,7 +492,8 @@ void GBufferEffect::create_raster_pipeline() {
 
   WGPUShaderModuleDescriptor shader_desc = {};
   shader_desc.nextInChain = &wgsl_src.chain;
-  WGPUShaderModule shader = wgpuDeviceCreateShaderModule(ctx_.device, &shader_desc);
+  WGPUShaderModule shader =
+      wgpuDeviceCreateShaderModule(ctx_.device, &shader_desc);
 
   // Bind group layout: B0 = GlobalUniforms, B1 = ObjectsBuffer (storage read)
   WGPUBindGroupLayoutEntry bgl_entries[2] = {};
@@ -511,7 +512,8 @@ void GBufferEffect::create_raster_pipeline() {
   WGPUBindGroupLayoutDescriptor bgl_desc = {};
   bgl_desc.entryCount = 2;
   bgl_desc.entries = bgl_entries;
-  WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(ctx_.device, &bgl_desc);
+  WGPUBindGroupLayout bgl =
+      wgpuDeviceCreateBindGroupLayout(ctx_.device, &bgl_desc);
 
   WGPUPipelineLayoutDescriptor pl_desc = {};
   pl_desc.bindGroupLayoutCount = 1;
@@ -542,9 +544,9 @@ void GBufferEffect::create_raster_pipeline() {
   pipe_desc.vertex.entryPoint = str_view("vs_main");
   pipe_desc.fragment = &frag;
   pipe_desc.depthStencil = &ds;
-  pipe_desc.primitive.topology  = WGPUPrimitiveTopology_TriangleList;
-  pipe_desc.primitive.cullMode  = WGPUCullMode_Back;
-  pipe_desc.primitive.frontFace = WGPUFrontFace_CCW;  // standard (no Y flip)
+  pipe_desc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
+  pipe_desc.primitive.cullMode = WGPUCullMode_Back;
+  pipe_desc.primitive.frontFace = WGPUFrontFace_CCW; // standard (no Y flip)
   pipe_desc.multisample.count = 1;
   pipe_desc.multisample.mask = 0xFFFFFFFF;
 
@@ -571,9 +573,11 @@ void GBufferEffect::create_shadow_pipeline() {
 
   WGPUShaderModuleDescriptor shader_desc = {};
   shader_desc.nextInChain = &wgsl_src.chain;
-  WGPUShaderModule shader = wgpuDeviceCreateShaderModule(ctx_.device, &shader_desc);
+  WGPUShaderModule shader =
+      wgpuDeviceCreateShaderModule(ctx_.device, &shader_desc);
 
-  // BGL: B0=GlobalUniforms, B1=ObjectsBuffer, B2=texture_depth_2d, B3=GBufLightsUniforms
+  // BGL: B0=GlobalUniforms, B1=ObjectsBuffer, B2=texture_depth_2d,
+  // B3=GBufLightsUniforms
   WGPUBindGroupLayoutEntry bgl_entries[5] = {};
 
   bgl_entries[0].binding = 0;
@@ -605,7 +609,8 @@ void GBufferEffect::create_shadow_pipeline() {
   WGPUBindGroupLayoutDescriptor bgl_desc = {};
   bgl_desc.entryCount = 5;
   bgl_desc.entries = bgl_entries;
-  WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(ctx_.device, &bgl_desc);
+  WGPUBindGroupLayout bgl =
+      wgpuDeviceCreateBindGroupLayout(ctx_.device, &bgl_desc);
 
   WGPUPipelineLayoutDescriptor pl_desc = {};
   pl_desc.bindGroupLayoutCount = 1;
@@ -656,7 +661,8 @@ void GBufferEffect::create_pack_pipeline() {
 
   WGPUShaderModuleDescriptor shader_desc = {};
   shader_desc.nextInChain = &wgsl_src.chain;
-  WGPUShaderModule shader = wgpuDeviceCreateShaderModule(ctx_.device, &shader_desc);
+  WGPUShaderModule shader =
+      wgpuDeviceCreateShaderModule(ctx_.device, &shader_desc);
 
   // Build explicit bind group layout for bindings 0-9.
   WGPUBindGroupLayoutEntry bgl_entries[10] = {};
@@ -725,7 +731,8 @@ void GBufferEffect::create_pack_pipeline() {
   WGPUBindGroupLayoutDescriptor bgl_desc = {};
   bgl_desc.entryCount = 10;
   bgl_desc.entries = bgl_entries;
-  WGPUBindGroupLayout bgl = wgpuDeviceCreateBindGroupLayout(ctx_.device, &bgl_desc);
+  WGPUBindGroupLayout bgl =
+      wgpuDeviceCreateBindGroupLayout(ctx_.device, &bgl_desc);
 
   WGPUPipelineLayoutDescriptor pl_desc = {};
   pl_desc.bindGroupLayoutCount = 1;
@@ -755,12 +762,12 @@ void GBufferEffect::update_raster_bind_group(NodeRegistry& nodes) {
 
   WGPUBindGroupEntry entries[2] = {};
   entries[0].binding = 0;
-  entries[0].buffer  = global_uniforms_buf_.buffer;
-  entries[0].size    = sizeof(GBufGlobalUniforms);
+  entries[0].buffer = global_uniforms_buf_.buffer;
+  entries[0].size = sizeof(GBufGlobalUniforms);
 
   entries[1].binding = 1;
-  entries[1].buffer  = objects_buf_.buffer;
-  entries[1].size    = (size_t)objects_buf_capacity_ * sizeof(GBufObjectData);
+  entries[1].buffer = objects_buf_.buffer;
+  entries[1].size = (size_t)objects_buf_capacity_ * sizeof(GBufObjectData);
 
   WGPUBindGroupLayout bgl =
       wgpuRenderPipelineGetBindGroupLayout(raster_pipeline_.get(), 0);
@@ -777,20 +784,23 @@ void GBufferEffect::update_raster_bind_group(NodeRegistry& nodes) {
 void GBufferEffect::wire_dag(const std::vector<EffectDAGNode>& dag) {
   const std::string out = find_downstream_output(dag);
   // "sink" is an external view (no owned texture) — not a valid copy source.
-  if (out != "sink") cnn_output_node_ = out;
+  if (out != "sink")
+    cnn_output_node_ = out;
 }
 
-void GBufferEffect::post_render(WGPUCommandEncoder encoder, NodeRegistry& nodes) {
-  if (cnn_output_node_.empty() || !nodes.has_node(cnn_output_node_)) return;
+void GBufferEffect::post_render(WGPUCommandEncoder encoder,
+                                NodeRegistry& nodes) {
+  if (cnn_output_node_.empty() || !nodes.has_node(cnn_output_node_))
+    return;
   WGPUTexture src_tex = nodes.get_texture(cnn_output_node_);
-  if (!src_tex) return;  // external view (e.g. sink) — no owned texture to copy
+  if (!src_tex)
+    return; // external view (e.g. sink) — no owned texture to copy
   WGPUTexelCopyTextureInfo src = {};
-  src.texture  = src_tex;
+  src.texture = src_tex;
   src.mipLevel = 0;
   WGPUTexelCopyTextureInfo dst = {};
-  dst.texture  = nodes.get_texture(node_prev_tex_);
+  dst.texture = nodes.get_texture(node_prev_tex_);
   dst.mipLevel = 0;
   WGPUExtent3D extent = {(uint32_t)width_, (uint32_t)height_, 1};
   wgpuCommandEncoderCopyTextureToTexture(encoder, &src, &dst, &extent);
 }
-