Revert "feat(platform): Centralize platform-specific WebGPU code and improve shader composition"

This reverts commit 16c2cdce6ad1d89d3c537f2c2cff743449925125.

9 files changed, 127 insertions, 456 deletions

diff --git a/src/3d/renderer.cc b/src/3d/renderer.cc
index 0bc8812..e08a0d0 100644
--- a/src/3d/renderer.cc
+++ b/src/3d/renderer.cc
@@ -5,7 +5,6 @@
 #include "generated/assets.h"
 #include "gpu/effects/shader_composer.h"
 #include "util/asset_manager.h"
-#include "util/mesh_utils.h"
 #include <algorithm>
 #include <cassert>
 #include <cstring>
@@ -125,254 +124,7 @@ void Renderer3D::create_default_resources() {
           WGPUBufferUsage_Storage | WGPUBufferUsage_CopyDst, nullptr)
           .buffer;
 }
-void Renderer3D::create_pipeline() {
-  // Shader Modules
-  std::string sdf_shader_source =
-      ShaderComposer::Get().Compose(std::vector<std::string>{}, AssetId::ASSET_SHADER_RENDER_SCENE_QUERY_BVH);
-  WGPUShaderModuleDescriptor sdf_shader_desc =
-      platform_create_shader_module_descriptor(sdf_shader_source.c_str());
-  WGPUShaderModule sdf_shader_module =
-      wgpuDeviceCreateShaderModule(device_, &sdf_shader_desc);
 
-  std::string sdf_no_bvh_shader_source =
-      ShaderComposer::Get().Compose(std::vector<std::string>{}, AssetId::ASSET_SHADER_RENDER_SCENE_QUERY_LINEAR);
-  WGPUShaderModuleDescriptor sdf_no_bvh_shader_desc =
-      platform_create_shader_module_descriptor(
-          sdf_no_bvh_shader_source.c_str());
-  WGPUShaderModule sdf_no_bvh_shader_module =
-      wgpuDeviceCreateShaderModule(device_, &sdf_no_bvh_shader_desc);
-
-  // Mesh Shader Module
-  std::string mesh_shader_source =
-      ShaderComposer::Get().Compose(std::vector<std::string>{}, AssetId::ASSET_SHADER_RENDER_SHADOWS); // Use SHADOWS shader
-  WGPUShaderModuleDescriptor mesh_shader_desc =
-      platform_create_shader_module_descriptor(mesh_shader_source.c_str());
-  WGPUShaderModule mesh_shader_module =
-      wgpuDeviceCreateShaderModule(device_, &mesh_shader_desc);
-
-  // Bind Group Layouts and Pipelines (SDF)
-  std::vector<WGPUBindGroupLayoutEntry> bgl_entries;
-  // Uniforms
-  bgl_entries.push_back({.binding = 0,
-                         .visibility = WGPUShaderStage_Vertex |
-                                       WGPUShaderStage_Fragment,
-                         .buffer = {.type = WGPUBufferBindingType_Uniform,
-                                    .hasDynamicOffset = false,
-                                    .minBindingSize = sizeof(GlobalUniforms)}});
-  // Object Storage
-  bgl_entries.push_back(
-      {.binding = 1,
-       .visibility = WGPUShaderStage_Vertex | WGPUShaderStage_Fragment,
-       .buffer = {.type = WGPUBufferBindingType_ReadOnlyStorage,
-                  .hasDynamicOffset = false,
-                  .minBindingSize = sizeof(ObjectData) * kMaxObjects}});
-
-  // BVH Storage (Conditional for BVH pipeline)
-  bgl_entries.push_back(
-      {.binding = 2,
-       .visibility = WGPUShaderStage_Vertex | WGPUShaderStage_Fragment,
-       .buffer = {.type = WGPUBufferBindingType_ReadOnlyStorage,
-                  .hasDynamicOffset = false,
-                  .minBindingSize = sizeof(BVHNode) * kMaxObjects * 2}});
-
-  // Noise Texture
-  bgl_entries.push_back({.binding = 3,
-                         .visibility = WGPUShaderStage_Fragment,
-                         .texture = {.sampleType = WGPUTextureSampleType_Float,
-                                     .viewDimension = WGPUTextureViewDimension_2D,
-                                     .multisampled = false}});
-  // Default Sampler
-  bgl_entries.push_back({.binding = 4,
-                         .visibility = WGPUShaderStage_Fragment,
-                         .sampler = {.type = WGPUSamplerBindingType_Filtering}});
-  // Skybox Texture
-  bgl_entries.push_back({.binding = 5,
-                         .visibility = WGPUShaderStage_Fragment,
-                         .texture = {.sampleType = WGPUTextureSampleType_Float,
-                                     .viewDimension = WGPUTextureViewDimension_2D,
-                                     .multisampled = false}});
-
-  WGPUBindGroupLayoutDescriptor bgl_desc = {};
-  bgl_desc.entryCount = (uint32_t)bgl_entries.size();
-  bgl_desc.entries = bgl_entries.data();
-
-  WGPUBindGroupLayout bind_group_layout =
-      wgpuDeviceCreateBindGroupLayout(device_, &bgl_desc);
-
-  WGPUPipelineLayoutDescriptor pl_desc = {};
-  pl_desc.bindGroupLayoutCount = 1;
-  pl_desc.bindGroupLayouts = &bind_group_layout;
-  WGPUPipelineLayout pipeline_layout =
-      wgpuDeviceCreatePipelineLayout(device_, &pl_desc);
-
-  // Depth Stencil State
-  WGPUDepthStencilState depth_stencil = {};
-  depth_stencil.format = WGPUTextureFormat_Depth24Plus;
-  depth_stencil.depthWriteEnabled = WGPUOptionalBool_True;
-  depth_stencil.depthCompare = WGPUCompareFunction_Less;
-
-  // Configure common color target state
-  WGPUColorTargetState color_target = {};
-  color_target.format = format_;
-  color_target.writeMask = WGPUColorWriteMask_All;
-  // Alpha blending for meshes/particles, but not SDFs
-  color_target.blend = nullptr; // Explicitly set to nullptr
-
-  WGPUFragmentState fragment_state = {};
-  fragment_state.module = sdf_shader_module;
-  fragment_state.entryPoint = str_view("fs_main");
-  fragment_state.targetCount = 1;
-  fragment_state.targets = &color_target;
-
-  // Create SDF pipeline (with BVH)
-  WGPURenderPipelineDescriptor pipeline_desc = {};
-  pipeline_desc.layout = pipeline_layout;
-  pipeline_desc.vertex.module = sdf_shader_module;
-  pipeline_desc.vertex.entryPoint = str_view("vs_main");
-  pipeline_desc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
-  pipeline_desc.multisample.count = 1;
-  pipeline_desc.multisample.mask = 0xFFFFFFFF;
-  pipeline_desc.fragment = &fragment_state;
-  PLATFORM_SET_PIPELINE_DEPTH_STENCIL(pipeline_desc, &depth_stencil);
-  pipeline_ = wgpuDeviceCreateRenderPipeline(device_, &pipeline_desc);
-
-  // Create SDF pipeline (without BVH)
-  fragment_state.module = sdf_no_bvh_shader_module; // Use linear shader
-  WGPURenderPipelineDescriptor pipeline_no_bvh_desc = pipeline_desc;
-  pipeline_no_bvh_desc.vertex.module = sdf_no_bvh_shader_module;
-  pipeline_no_bvh_desc.fragment = &fragment_state;
-  PLATFORM_SET_PIPELINE_DEPTH_STENCIL(pipeline_no_bvh_desc, &depth_stencil);
-  pipeline_no_bvh_ = wgpuDeviceCreateRenderPipeline(device_, &pipeline_no_bvh_desc);
-
-  // Configure blend state for mesh/particle pipeline
-  WGPUBlendState mesh_blend_state = {};
-  mesh_blend_state.color.srcFactor = WGPUBlendFactor_SrcAlpha;
-  mesh_blend_state.color.dstFactor = WGPUBlendFactor_OneMinusSrcAlpha;
-  mesh_blend_state.color.operation = WGPUBlendOperation_Add;
-  mesh_blend_state.alpha.srcFactor = WGPUBlendFactor_One;
-  mesh_blend_state.alpha.dstFactor = WGPUBlendFactor_OneMinusSrcAlpha;
-  mesh_blend_state.alpha.operation = WGPUBlendOperation_Add;
-  color_target.blend = &mesh_blend_state; // Enable blending for meshes
-
-  // Create Mesh pipeline
-  WGPURenderPipelineDescriptor mesh_pipeline_desc = {};
-  mesh_pipeline_desc.layout = pipeline_layout;
-  mesh_pipeline_desc.vertex.module = mesh_shader_module;
-  mesh_pipeline_desc.vertex.entryPoint = str_view("vs_main");
-  mesh_pipeline_desc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
-  mesh_pipeline_desc.multisample.count = 1;
-  mesh_pipeline_desc.multisample.mask = 0xFFFFFFFF;
-  mesh_pipeline_desc.fragment = &fragment_state; // Reuse fragment state
-  // Override fragment module to mesh_shader_module
-  fragment_state.module = mesh_shader_module;
-  mesh_pipeline_desc.fragment = &fragment_state;
-  PLATFORM_SET_PIPELINE_DEPTH_STENCIL(mesh_pipeline_desc, &depth_stencil);
-
-  // Vertex attributes for mesh
-  WGPUVertexAttribute vert_attrs[3] = {};
-  // Position
-  vert_attrs[0].shaderLocation = 0;
-  vert_attrs[0].offset = 0;
-  vert_attrs[0].format = WGPUVertexFormat_Float32x3;
-  // Normal
-  vert_attrs[1].shaderLocation = 1;
-  vert_attrs[1].offset = sizeof(vec3);
-  vert_attrs[1].format = WGPUVertexFormat_Float32x3;
-  // UV
-  vert_attrs[2].shaderLocation = 2;
-  vert_attrs[2].offset = sizeof(vec3) * 2;
-  vert_attrs[2].format = WGPUVertexFormat_Float32x2;
-
-  WGPUVertexBufferLayout vert_buffer_layout = {};
-  vert_buffer_layout.arrayStride = sizeof(MeshVertex);
-  vert_buffer_layout.stepMode = WGPUVertexStepMode_Vertex;
-  vert_buffer_layout.attributeCount = 3;
-  vert_buffer_layout.attributes = vert_attrs;
-
-  mesh_pipeline_desc.vertex.bufferCount = 1;
-  mesh_pipeline_desc.vertex.buffers = &vert_buffer_layout;
-
-  mesh_pipeline_ = wgpuDeviceCreateRenderPipeline(device_, &mesh_pipeline_desc);
-
-  // Release shader modules as they are now part of the pipelines
-  wgpuShaderModuleRelease(sdf_shader_module);
-  wgpuShaderModuleRelease(sdf_no_bvh_shader_module);
-  wgpuShaderModuleRelease(mesh_shader_module);
-  wgpuPipelineLayoutRelease(pipeline_layout);
-  wgpuBindGroupLayoutRelease(bind_group_layout);
-}
-
-void Renderer3D::create_skybox_pipeline() {
-  std::string skybox_shader_source =
-      ShaderComposer::Get().Compose(std::vector<std::string>{}, AssetId::ASSET_SHADER_RENDER_SHADOWS); // Use SHADOWS shader
-  WGPUShaderModuleDescriptor skybox_shader_desc =
-      platform_create_shader_module_descriptor(skybox_shader_source.c_str());
-  WGPUShaderModule skybox_shader_module =
-      wgpuDeviceCreateShaderModule(device_, &skybox_shader_desc);
-
-  WGPUBindGroupLayoutEntry bgl_entries[3] = {};
-  // Skybox Texture
-  bgl_entries[0].binding = 0;
-  bgl_entries[0].visibility = WGPUShaderStage_Fragment;
-  bgl_entries[0].texture = {.sampleType = WGPUTextureSampleType_Float,
-                            .viewDimension = WGPUTextureViewDimension_2D,
-                            .multisampled = false};
-  // Sampler
-  bgl_entries[1].binding = 1;
-  bgl_entries[1].visibility = WGPUShaderStage_Fragment;
-  bgl_entries[1].sampler = {.type = WGPUSamplerBindingType_Filtering};
-  // Global Uniforms
-  bgl_entries[2].binding = 2;
-  bgl_entries[2].visibility = WGPUShaderStage_Vertex;
-  bgl_entries[2].buffer = {.type = WGPUBufferBindingType_Uniform,
-                           .hasDynamicOffset = false,
-                           .minBindingSize = sizeof(GlobalUniforms)};
-
-  WGPUBindGroupLayoutDescriptor bgl_desc = {};
-  bgl_desc.entryCount = 3;
-  bgl_desc.entries = bgl_entries;
-  WGPUBindGroupLayout bind_group_layout =
-      wgpuDeviceCreateBindGroupLayout(device_, &bgl_desc);
-
-  WGPUPipelineLayoutDescriptor pl_desc = {};
-  pl_desc.bindGroupLayoutCount = 1;
-  pl_desc.bindGroupLayouts = &bind_group_layout;
-  WGPUPipelineLayout pipeline_layout =
-      wgpuDeviceCreatePipelineLayout(device_, &pl_desc);
-
-  WGPUColorTargetState color_target = {};
-  color_target.format = format_;
-  color_target.writeMask = WGPUColorWriteMask_All;
-  color_target.blend = nullptr; // No blending for skybox
-
-  WGPUFragmentState fragment_state = {};
-  fragment_state.module = skybox_shader_module;
-  fragment_state.entryPoint = str_view("fs_main");
-  fragment_state.targetCount = 1;
-  fragment_state.targets = &color_target;
-
-  WGPURenderPipelineDescriptor pipeline_desc = {};
-  pipeline_desc.layout = pipeline_layout;
-  pipeline_desc.vertex.module = skybox_shader_module;
-  pipeline_desc.vertex.entryPoint = str_view("vs_main");
-  pipeline_desc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
-  pipeline_desc.multisample.count = 1;
-  pipeline_desc.multisample.mask = 0xFFFFFFFF;
-  pipeline_desc.fragment = &fragment_state;
-
-  // Skybox depth state (clear and write depth for objects)
-  WGPUDepthStencilState depth_stencil = {};
-  depth_stencil.format = WGPUTextureFormat_Depth24Plus;
-  depth_stencil.depthWriteEnabled = WGPUOptionalBool_False;
-  depth_stencil.depthCompare = WGPUCompareFunction_Always;
-  PLATFORM_SET_PIPELINE_DEPTH_STENCIL(pipeline_desc, &depth_stencil);
-
-  skybox_pipeline_ = wgpuDeviceCreateRenderPipeline(device_, &pipeline_desc);
-
-  wgpuShaderModuleRelease(skybox_shader_module);
-  wgpuPipelineLayoutRelease(pipeline_layout);
-  wgpuBindGroupLayoutRelease(bind_group_layout);
-}
 void Renderer3D::set_noise_texture(WGPUTextureView noise_view) {
   noise_texture_view_ = noise_view;
 }
@@ -698,4 +450,4 @@ void Renderer3D::render(const Scene& scene, const Camera& camera, float time,
   wgpuCommandBufferRelease(commands);
 
   wgpuCommandEncoderRelease(encoder);
-}
+}
\ No newline at end of file
diff --git a/src/gpu/effect.cc b/src/gpu/effect.cc
index 9e769eb..a1b45f1 100644
--- a/src/gpu/effect.cc
+++ b/src/gpu/effect.cc
@@ -260,7 +260,9 @@ void MainSequence::render_frame(float global_time, float beat, float peak,
   scene_attachment.loadOp = WGPULoadOp_Clear;
   scene_attachment.storeOp = WGPUStoreOp_Store;
   scene_attachment.clearValue = {0, 0, 0, 1};
+#if !defined(DEMO_CROSS_COMPILE_WIN32)
   scene_attachment.depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
+#endif /* !defined(DEMO_CROSS_COMPILE_WIN32) */
 
   WGPURenderPassDepthStencilAttachment depth_attachment = {};
   depth_attachment.view = depth_view_;
@@ -300,7 +302,9 @@ void MainSequence::render_frame(float global_time, float beat, float peak,
     final_attachment.resolveTarget = nullptr;
     final_attachment.loadOp = WGPULoadOp_Load;
     final_attachment.storeOp = WGPUStoreOp_Store;
+#if !defined(DEMO_CROSS_COMPILE_WIN32)
     final_attachment.depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
+#endif /* !defined(DEMO_CROSS_COMPILE_WIN32) */
     WGPURenderPassDescriptor final_desc = {
         .colorAttachmentCount = 1, .colorAttachments = &final_attachment};
     WGPURenderPassEncoder final_pass =
@@ -334,7 +338,9 @@ void MainSequence::render_frame(float global_time, float beat, float peak,
       pp_attachment.resolveTarget = nullptr;
       pp_attachment.loadOp = WGPULoadOp_Load;
       pp_attachment.storeOp = WGPUStoreOp_Store;
+#if !defined(DEMO_CROSS_COMPILE_WIN32)
       pp_attachment.depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
+#endif /* !defined(DEMO_CROSS_COMPILE_WIN32) */
       WGPURenderPassDescriptor pp_desc = {.colorAttachmentCount = 1,
                                           .colorAttachments = &pp_attachment};
       WGPURenderPassEncoder pp_pass =
diff --git a/src/gpu/effects/shader_composer.cc b/src/gpu/effects/shader_composer.cc
index 5cd8699..b746f8b 100644
--- a/src/gpu/effects/shader_composer.cc
+++ b/src/gpu/effects/shader_composer.cc
@@ -2,7 +2,6 @@
 // It implements the ShaderComposer class.
 
 #include "gpu/effects/shader_composer.h"
-#include "util/asset_manager.h"
 #include <set>
 #include <sstream>
 
@@ -87,12 +86,3 @@ ShaderComposer::Compose(const std::vector<std::string>& dependencies,
 
   return ss.str();
 }
-
-std::string
-ShaderComposer::Compose(const std::vector<std::string>& dependencies,
-                        AssetId main_code_asset_id,
-                        const CompositionMap& substitutions) {
-  size_t size;
-  const char* main_code = reinterpret_cast<const char*>(GetAsset(main_code_asset_id, &size));
-  return Compose(dependencies, std::string(main_code, size), substitutions);
-}
diff --git a/src/gpu/effects/shader_composer.h b/src/gpu/effects/shader_composer.h
index 961ffcb..9eb43f4 100644
--- a/src/gpu/effects/shader_composer.h
+++ b/src/gpu/effects/shader_composer.h
@@ -3,7 +3,6 @@
 
 #pragma once
 
-#include "generated/assets.h" // For AssetId
 #include <map>
 #include <set>
 #include <string>
@@ -24,10 +23,6 @@ class ShaderComposer {
   std::string Compose(const std::vector<std::string>& dependencies,
                       const std::string& main_code,
                       const CompositionMap& substitutions = {});
-  
-  std::string Compose(const std::vector<std::string>& dependencies,
-                      AssetId main_code_asset_id,
-                      const CompositionMap& substitutions = {});
 
  private:
   ShaderComposer() = default;
diff --git a/src/gpu/gpu.cc b/src/gpu/gpu.cc
index c61c605..9776eac 100644
--- a/src/gpu/gpu.cc
+++ b/src/gpu/gpu.cc
@@ -57,7 +57,11 @@ RenderPass gpu_create_render_pass(WGPUDevice device, WGPUTextureFormat format,
   RenderPass pass = {};
 
   // Create Shader Module
-  WGPUShaderModuleDescriptor shader_desc = platform_create_shader_module_descriptor(shader_code);
+  WGPUShaderSourceWGSL wgsl_src = {};
+  wgsl_src.chain.sType = WGPUSType_ShaderSourceWGSL;
+  wgsl_src.code = str_view(shader_code);
+  WGPUShaderModuleDescriptor shader_desc = {};
+  shader_desc.nextInChain = &wgsl_src.chain;
   WGPUShaderModule shader_module =
       wgpuDeviceCreateShaderModule(device, &shader_desc);
 
@@ -141,7 +145,7 @@ RenderPass gpu_create_render_pass(WGPUDevice device, WGPUTextureFormat format,
   depth_stencil.format = WGPUTextureFormat_Depth24Plus;
   depth_stencil.depthWriteEnabled = WGPUOptionalBool_False;
   depth_stencil.depthCompare = WGPUCompareFunction_Always;
-  PLATFORM_SET_PIPELINE_DEPTH_STENCIL(pipeline_desc, &depth_stencil);
+  pipeline_desc.depthStencil = &depth_stencil;
 
   pass.pipeline = wgpuDeviceCreateRenderPipeline(device, &pipeline_desc);
 
@@ -153,7 +157,11 @@ ComputePass gpu_create_compute_pass(WGPUDevice device, const char* shader_code,
                                     int num_bindings) {
   ComputePass pass = {};
 
-  WGPUShaderModuleDescriptor shader_desc = platform_create_shader_module_descriptor(shader_code);
+  WGPUShaderSourceWGSL wgsl_src = {};
+  wgsl_src.chain.sType = WGPUSType_ShaderSourceWGSL;
+  wgsl_src.code = str_view(shader_code);
+  WGPUShaderModuleDescriptor shader_desc = {};
+  shader_desc.nextInChain = &wgsl_src.chain;
   WGPUShaderModule shader_module =
       wgpuDeviceCreateShaderModule(device, &shader_desc);
 
@@ -206,11 +214,49 @@ ComputePass gpu_create_compute_pass(WGPUDevice device, const char* shader_code,
 
 #if !defined(STRIP_ALL)
 #if defined(DEMO_CROSS_COMPILE_WIN32)
+static void handle_request_adapter(WGPURequestAdapterStatus status,
+                                   WGPUAdapter adapter, const char* message,
+                                   void* userdata) {
+  if (status == WGPURequestAdapterStatus_Success) {
+    *((WGPUAdapter*)userdata) = adapter;
+  } else {
+    printf("Request adapter failed: %s\n", message ? message : "Unknown");
+  }
+}
+static void handle_request_device(WGPURequestDeviceStatus status,
+                                  WGPUDevice device, const char* message,
+                                  void* userdata) {
+  if (status == WGPURequestDeviceStatus_Success) {
+    *((WGPUDevice*)userdata) = device;
+  } else {
+    printf("Request device failed: %s\n", message ? message : "Unknown");
+  }
+}
 static void handle_device_error(WGPUErrorType type, const char* message,
                                 void* userdata) {
   printf("WebGPU Error: %s\n", message ? message : "Unknown");
 }
 #else
+static void handle_request_adapter(WGPURequestAdapterStatus status,
+                                   WGPUAdapter adapter, WGPUStringView message,
+                                   void* userdata, void* userdata2) {
+  (void)userdata2;
+  if (status == WGPURequestAdapterStatus_Success) {
+    *((WGPUAdapter*)userdata) = adapter;
+  } else {
+    printf("Request adapter failed: %.*s\n", (int)message.length, message.data);
+  }
+}
+static void handle_request_device(WGPURequestDeviceStatus status,
+                                  WGPUDevice device, WGPUStringView message,
+                                  void* userdata, void* userdata2) {
+  (void)userdata2;
+  if (status == WGPURequestDeviceStatus_Success) {
+    *((WGPUDevice*)userdata) = device;
+  } else {
+    printf("Request device failed: %.*s\n", (int)message.length, message.data);
+  }
+}
 static void handle_device_error(const WGPUDevice* device, WGPUErrorType type,
                                 WGPUStringView message, void* userdata,
                                 void* userdata2) {
@@ -220,6 +266,41 @@ static void handle_device_error(const WGPUDevice* device, WGPUErrorType type,
   printf("WebGPU Error: %.*s\n", (int)message.length, message.data);
 }
 #endif /* defined(DEMO_CROSS_COMPILE_WIN32) */
+#else
+// STRIP_ALL versions
+#if defined(DEMO_CROSS_COMPILE_WIN32)
+static void handle_request_adapter(WGPURequestAdapterStatus status,
+                                   WGPUAdapter adapter, const char* message,
+                                   void* userdata) {
+  if (status == WGPURequestAdapterStatus_Success) {
+    *((WGPUAdapter*)userdata) = adapter;
+  }
+}
+static void handle_request_device(WGPURequestDeviceStatus status,
+                                  WGPUDevice device, const char* message,
+                                  void* userdata) {
+  if (status == WGPURequestDeviceStatus_Success) {
+    *((WGPUDevice*)userdata) = device;
+  }
+}
+#else
+static void handle_request_adapter(WGPURequestAdapterStatus status,
+                                   WGPUAdapter adapter, WGPUStringView message,
+                                   void* userdata, void* userdata2) {
+  (void)userdata2;
+  if (status == WGPURequestAdapterStatus_Success) {
+    *((WGPUAdapter*)userdata) = adapter;
+  }
+}
+static void handle_request_device(WGPURequestDeviceStatus status,
+                                  WGPUDevice device, WGPUStringView message,
+                                  void* userdata, void* userdata2) {
+  (void)userdata2;
+  if (status == WGPURequestDeviceStatus_Success) {
+    *((WGPUDevice*)userdata) = device;
+  }
+}
+#endif /* defined(DEMO_CROSS_COMPILE_WIN32) */
 #endif /* !defined(STRIP_ALL) */
 
 void gpu_init(PlatformState* platform_state) {
@@ -230,8 +311,16 @@ void gpu_init(PlatformState* platform_state) {
   adapter_opts.compatibleSurface = g_surface;
   adapter_opts.powerPreference = WGPUPowerPreference_HighPerformance;
 
-  platform_wgpu_request_adapter(g_instance, &adapter_opts, &g_adapter);
-
+#if defined(DEMO_CROSS_COMPILE_WIN32)
+  wgpuInstanceRequestAdapter(g_instance, &adapter_opts, handle_request_adapter,
+                             &g_adapter);
+#else
+  WGPURequestAdapterCallbackInfo adapter_cb = {};
+  adapter_cb.mode = WGPUCallbackMode_WaitAnyOnly;
+  adapter_cb.callback = handle_request_adapter;
+  adapter_cb.userdata1 = &g_adapter;
+  wgpuInstanceRequestAdapter(g_instance, &adapter_opts, adapter_cb);
+#endif /* defined(DEMO_CROSS_COMPILE_WIN32) */
   while (!g_adapter)
     platform_wgpu_wait_any(g_instance);
 
@@ -242,8 +331,16 @@ void gpu_init(PlatformState* platform_state) {
 #endif /* !defined(DEMO_CROSS_COMPILE_WIN32) */
 #endif /* !defined(STRIP_ALL) */
 
-  platform_wgpu_request_device(g_adapter, &device_desc, &g_device);
-
+#if defined(DEMO_CROSS_COMPILE_WIN32)
+  wgpuAdapterRequestDevice(g_adapter, &device_desc, handle_request_device,
+                           &g_device);
+#else
+  WGPURequestDeviceCallbackInfo device_cb = {};
+  device_cb.mode = WGPUCallbackMode_WaitAnyOnly;
+  device_cb.callback = handle_request_device;
+  device_cb.userdata1 = &g_device;
+  wgpuAdapterRequestDevice(g_adapter, &device_desc, device_cb);
+#endif /* defined(DEMO_CROSS_COMPILE_WIN32) */
   while (!g_device)
     platform_wgpu_wait_any(g_instance);
 
diff --git a/src/gpu/texture_manager.cc b/src/gpu/texture_manager.cc
index e69425f..0c30c94 100644
--- a/src/gpu/texture_manager.cc
+++ b/src/gpu/texture_manager.cc
@@ -2,10 +2,19 @@
 // It implements the TextureManager.
 
 #include "gpu/texture_manager.h"
-#include "platform/platform.h" // Include for WGPU_TEX_COPY_INFO and WGPU_TEX_DATA_LAYOUT
 #include <cstdio>
 #include <vector>
 
+#if defined(DEMO_CROSS_COMPILE_WIN32)
+// Old API
+#define WGPU_TEX_COPY_INFO WGPUImageCopyTexture
+#define WGPU_TEX_DATA_LAYOUT WGPUTextureDataLayout
+#else
+// New API
+#define WGPU_TEX_COPY_INFO WGPUTexelCopyTextureInfo
+#define WGPU_TEX_DATA_LAYOUT WGPUTexelCopyBufferLayout
+#endif
+
 void TextureManager::init(WGPUDevice device, WGPUQueue queue) {
   device_ = device;
   queue_ = queue;
@@ -51,7 +60,11 @@ void TextureManager::create_texture(const std::string& name, int width,
   tex_desc.format = WGPUTextureFormat_RGBA8Unorm;
   tex_desc.mipLevelCount = 1;
   tex_desc.sampleCount = 1;
-  tex_desc.label = label_view(name.c_str());
+#if defined(DEMO_CROSS_COMPILE_WIN32)
+  tex_desc.label = nullptr;
+#else
+  tex_desc.label = {nullptr, 0};
+#endif
 
   WGPUTexture texture = wgpuDeviceCreateTexture(device_, &tex_desc);
 
diff --git a/src/platform/platform.cc b/src/platform/platform.cc
index 2b8529a..29b3af3 100644
--- a/src/platform/platform.cc
+++ b/src/platform/platform.cc
@@ -5,7 +5,6 @@
 #include "platform/platform.h"
 #include "glfw3webgpu.h"
 #include <GLFW/glfw3.h>
-#include <cstdio>
 
 // --- Callbacks ---
 
@@ -129,88 +128,4 @@ WGPUSurface platform_create_wgpu_surface(WGPUInstance instance,
 
 double platform_get_time() {
   return glfwGetTime();
-}
-
-// --- WebGPU Request Helpers ---
-
-#if defined(DEMO_CROSS_COMPILE_WIN32)
-static void _platform_adapter_cb_win32(WGPURequestAdapterStatus status,
-                                       WGPUAdapter adapter, const char* message,
-                                       void* userdata) {
-  if (status == WGPURequestAdapterStatus_Success) {
-    *((WGPUAdapter*)userdata) = adapter;
-  } else {
-    printf("Request adapter failed: %s\n", message ? message : "Unknown");
-  }
-}
-
-void platform_wgpu_request_adapter(WGPUInstance instance,
-                                   const WGPURequestAdapterOptions* options,
-                                   WGPUAdapter* out_adapter) {
-  wgpuInstanceRequestAdapter(instance, options, _platform_adapter_cb_win32,
-                             out_adapter);
-}
-
-static void _platform_device_cb_win32(WGPURequestDeviceStatus status,
-                                      WGPUDevice device, const char* message,
-                                      void* userdata) {
-  if (status == WGPURequestDeviceStatus_Success) {
-    *((WGPUDevice*)userdata) = device;
-  } else {
-    printf("Request device failed: %s\n", message ? message : "Unknown");
-  }
-}
-
-void platform_wgpu_request_device(WGPUAdapter adapter,
-                                  const WGPUDeviceDescriptor* descriptor,
-                                  WGPUDevice* out_device) {
-  wgpuAdapterRequestDevice(adapter, descriptor, _platform_device_cb_win32,
-                           out_device);
-}
-
-#else
-
-static void _platform_adapter_cb_native(WGPURequestAdapterStatus status,
-                                        WGPUAdapter adapter,
-                                        WGPUStringView message, void* userdata,
-                                        void* userdata2) {
-  (void)userdata2;
-  if (status == WGPURequestAdapterStatus_Success) {
-    *((WGPUAdapter*)userdata) = adapter;
-  } else {
-    printf("Request adapter failed: %.*s\n", (int)message.length, message.data);
-  }
-}
-
-void platform_wgpu_request_adapter(WGPUInstance instance,
-                                   const WGPURequestAdapterOptions* options,
-                                   WGPUAdapter* out_adapter) {
-  WGPURequestAdapterCallbackInfo cb = {};
-  cb.mode = WGPUCallbackMode_WaitAnyOnly;
-  cb.callback = _platform_adapter_cb_native;
-  cb.userdata1 = out_adapter;
-  wgpuInstanceRequestAdapter(instance, options, cb);
-}
-
-static void _platform_device_cb_native(WGPURequestDeviceStatus status,
-                                       WGPUDevice device,
-                                       WGPUStringView message, void* userdata,
-                                       void* userdata2) {
-  (void)userdata2;
-  if (status == WGPURequestDeviceStatus_Success) {
-    *((WGPUDevice*)userdata) = device;
-  } else {
-    printf("Request device failed: %.*s\n", (int)message.length, message.data);
-  }
-}
-
-void platform_wgpu_request_device(WGPUAdapter adapter,
-                                  const WGPUDeviceDescriptor* descriptor,
-                                  WGPUDevice* out_device) {
-  WGPURequestDeviceCallbackInfo cb = {};
-  cb.mode = WGPUCallbackMode_WaitAnyOnly;
-  cb.callback = _platform_device_cb_native;
-  cb.userdata1 = out_device;
-  wgpuAdapterRequestDevice(adapter, descriptor, cb);
-}
-#endif
+}
\ No newline at end of file
diff --git a/src/platform/platform.h b/src/platform/platform.h
index ddea7af..0a98850 100644
--- a/src/platform/platform.h
+++ b/src/platform/platform.h
@@ -22,9 +22,6 @@
 #define WGPUCallbackMode_WaitAnyOnly 0
 
 typedef WGPUShaderModuleWGSLDescriptor WGPUShaderSourceWGSL;
-// Texture compatibility typedefs
-typedef WGPUImageCopyTexture WGPU_TEX_COPY_INFO;
-typedef WGPUTextureDataLayout WGPU_TEX_DATA_LAYOUT;
 
 static inline const char* str_view(const char* str) {
   return str;
@@ -42,44 +39,10 @@ platform_wgpu_set_error_callback(WGPUDevice device,
   wgpuDeviceSetUncapturedErrorCallback(device, callback, nullptr);
 }
 
-// Helper to create a WGPUShaderModuleDescriptor with platform-specific chain
-static inline WGPUShaderModuleDescriptor platform_create_shader_module_descriptor(
-    const char* shader_code) {
-  WGPUShaderSourceWGSL* wgsl_src = new WGPUShaderSourceWGSL();
-  wgsl_src->chain.sType = WGPUSType_ShaderSourceWGSL;
-  wgsl_src->code = str_view(shader_code);
-
-  WGPUShaderModuleDescriptor shader_desc = {};
-  shader_desc.nextInChain = &wgsl_src->chain;
-  shader_desc.label = label_view(nullptr); // Use label_view for cross-platform compatibility
-
-  return shader_desc;
-}
-
-// Macro to set the depth stencil state for render pipelines
-#define PLATFORM_SET_PIPELINE_DEPTH_STENCIL(pipeline_desc, depth_stencil_state_ptr) \
-  _Pragma("clang diagnostic push") \
-  _Pragma("clang diagnostic ignored \"-Wuninitialized\"") \
-  _Pragma("clang diagnostic ignored \"-Wmissing-field-initializers\"") \
-  do { \
-    if (depth_stencil_state_ptr) { \
-      if (defined(DEMO_CROSS_COMPILE_WIN32)) { \
-        (pipeline_desc).depthStencilState = *(depth_stencil_state_ptr); \
-      } else { \
-        (pipeline_desc).depthStencil = (depth_stencil_state_ptr); \
-      } \
-    } \
-  } while (0) \
-  _Pragma("clang diagnostic pop")
-
 #else
 #include <webgpu.h>
 #include <wgpu.h>
 
-// Texture compatibility typedefs
-typedef WGPUTexelCopyTextureInfo WGPU_TEX_COPY_INFO;
-typedef WGPUTexelCopyBufferLayout WGPU_TEX_DATA_LAYOUT;
-
 static inline WGPUStringView str_view(const char* str) {
   if (!str)
     return {nullptr, 0};
@@ -106,55 +69,8 @@ platform_wgpu_set_error_callback(WGPUDevice device,
   // Handled in descriptor for new API, but provided for compatibility if needed
   // elsewhere
 }
-
-// Helper to create a WGPUShaderModuleDescriptor with platform-specific chain
-static inline WGPUShaderModuleDescriptor platform_create_shader_module_descriptor(
-    const char* shader_code) {
-  WGPUShaderModuleDescriptor shader_desc = {};
-  // Need to dynamically allocate wgsl_src, as it needs to persist for the lifetime of shader_desc.
-  WGPUShaderSourceWGSL* wgsl_src = new WGPUShaderSourceWGSL(); 
-  wgsl_src->chain.sType = WGPUSType_ShaderSourceWGSL;
-  wgsl_src->code = str_view(shader_code);
-
-  shader_desc.nextInChain = &wgsl_src->chain;
-  shader_desc.label = label_view(nullptr);
-  return shader_desc;
-}
-
-// Macro to set the depth stencil state for render pipelines
-#define PLATFORM_SET_PIPELINE_DEPTH_STENCIL(pipeline_desc, depth_stencil_state_ptr) \
-  do { \
-    (pipeline_desc).depthStencil = (depth_stencil_state_ptr); \
-  } while (0)
 #endif
 
-// Helper to extract error message from platform-specific string type
-static inline const char* platform_wgpu_get_error_message(
-#if defined(DEMO_CROSS_COMPILE_WIN32)
-    const char* message
-#else
-    WGPUStringView message
-#endif
-) {
-#if defined(DEMO_CROSS_COMPILE_WIN32)
-  return message ? message : "Unknown";
-#else
-  // Warning: Returns raw pointer to view data, typically not null-terminated!
-  // Use '%.*s' printf format with message.length if possible.
-  // This helper is best effort.
-  return message.data;
-#endif
-}
-
-// Platform-agnostic WebGPU request helpers
-void platform_wgpu_request_adapter(WGPUInstance instance,
-                                   const WGPURequestAdapterOptions* options,
-                                   WGPUAdapter* out_adapter);
-
-void platform_wgpu_request_device(WGPUAdapter adapter,
-                                  const WGPUDeviceDescriptor* descriptor,
-                                  WGPUDevice* out_device);
-
 // Forward declare GLFWwindow to avoid including the full header here.
 struct GLFWwindow;
 
diff --git a/src/util/mesh_utils.h b/src/util/mesh_utils.h
deleted file mode 100644
index df203ed..0000000
--- a/src/util/mesh_utils.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// This file is part of the 64k demo project.
-// It defines utility structures and functions for mesh processing.
-
-#pragma once
-
-#include "util/mini_math.h"
-
-// Vertex structure for meshes
-struct MeshVertex {
-  vec3 position;
-  vec3 normal;
-  vec2 uv;
-};