14 files changed, 733 insertions, 162 deletions

diff --git a/src/gpu/demo_effects.cc b/src/gpu/demo_effects.cc
index 36fd16e..069d36c 100644
--- a/src/gpu/demo_effects.cc
+++ b/src/gpu/demo_effects.cc
@@ -3,6 +3,8 @@
 // Its content has been split into individual effect files and helper files.
 
 #include "gpu/demo_effects.h"
+#include "gpu/effects/circle_mask_effect.h"
+#include "gpu/effects/rotating_cube_effect.h"
 
 // Auto-generated function to populate the timeline
 void LoadTimeline(MainSequence& main_seq, WGPUDevice device, WGPUQueue queue,
diff --git a/src/gpu/demo_effects.h b/src/gpu/demo_effects.h
index 6c8729d..fabfbd2 100644
--- a/src/gpu/demo_effects.h
+++ b/src/gpu/demo_effects.h
@@ -9,6 +9,8 @@
 #include "gpu/effects/flash_effect.h" // FlashEffect with params support
 #include "gpu/effects/post_process_helper.h"
 #include "gpu/effects/shaders.h"
+#include "gpu/effects/circle_mask_effect.h"
+#include "gpu/effects/rotating_cube_effect.h"
 #include "gpu/gpu.h"
 #include "gpu/texture_manager.h"
 #include "gpu/uniform_helper.h"
@@ -119,12 +121,37 @@ class SolarizeEffect : public PostProcessEffect {
   void update_bind_group(WGPUTextureView input_view) override;
 };
 
-class DistortEffect : public PostProcessEffect {
+// Parameters for VignetteEffect
+struct VignetteParams {
+  float radius = 0.5f;   // Radius of the clear center
+  float softness = 0.5f; // Softness of the vignette edge
+};
+
+// Uniform data for VignetteEffect
+struct VignetteUniforms {
+  float time;         // offset 0
+  float beat;         // offset 4
+  float intensity;    // offset 8
+  float aspect_ratio; // offset 12
+  float width;        // offset 16
+  float height;       // offset 20
+  float radius;       // offset 24
+  float softness;     // offset 28
+};
+static_assert(sizeof(VignetteUniforms) == 32,
+              "VignetteUniforms must be 32 bytes for WGSL alignment");
+
+class VignetteEffect : public PostProcessEffect {
  public:
-  DistortEffect(const GpuContext& ctx);
+  VignetteEffect(const GpuContext& ctx);
+  VignetteEffect(const GpuContext& ctx, const VignetteParams& params);
   void render(WGPURenderPassEncoder pass, float time, float beat,
               float intensity, float aspect_ratio) override;
   void update_bind_group(WGPUTextureView input_view) override;
+
+ private:
+  VignetteParams params_;
+  UniformBuffer<VignetteUniforms> uniforms_;
 };
 
 // Parameters for ChromaAberrationEffect (set at construction time)
diff --git a/src/gpu/effect.cc b/src/gpu/effect.cc
index df8ef2d..c2c36b4 100644
--- a/src/gpu/effect.cc
+++ b/src/gpu/effect.cc
@@ -5,6 +5,7 @@
 #include "audio/tracker.h"
 #include "gpu/demo_effects.h"
 #include "gpu/gpu.h"
+#include "util/fatal_error.h"
 #include <algorithm>
 #include <cstdio>
 #include <typeinfo>
@@ -378,11 +379,76 @@ void MainSequence::shutdown() {
     wgpuTextureViewRelease(depth_view_);
   if (depth_texture_)
     wgpuTextureRelease(depth_texture_);
+  for (auto& [name, aux] : auxiliary_textures_) {
+    if (aux.view)
+      wgpuTextureViewRelease(aux.view);
+    if (aux.texture)
+      wgpuTextureRelease(aux.texture);
+  }
+  auxiliary_textures_.clear();
   for (ActiveSequence& entry : sequences_) {
     entry.seq->reset();
   }
 }
 
+// Register a named auxiliary texture for inter-effect sharing
+void MainSequence::register_auxiliary_texture(const char* name, int width,
+                                              int height) {
+  const std::string key(name);
+
+  // Check if already exists
+  auto it = auxiliary_textures_.find(key);
+  if (it != auxiliary_textures_.end()) {
+#if !defined(STRIP_ALL)
+    fprintf(stderr, "Warning: Auxiliary texture '%s' already registered\n",
+            name);
+#endif /* !defined(STRIP_ALL) */
+    return;
+  }
+
+  // Create texture
+  const WGPUTextureDescriptor desc = {
+      .usage =
+          WGPUTextureUsage_RenderAttachment | WGPUTextureUsage_TextureBinding,
+      .dimension = WGPUTextureDimension_2D,
+      .size = {(uint32_t)width, (uint32_t)height, 1},
+      .format = gpu_ctx.format,
+      .mipLevelCount = 1,
+      .sampleCount = 1,
+  };
+
+  WGPUTexture texture = wgpuDeviceCreateTexture(gpu_ctx.device, &desc);
+  FATAL_CHECK(!texture, "Failed to create auxiliary texture: %s\n", name);
+
+  // Create view
+  const WGPUTextureViewDescriptor view_desc = {
+      .format = gpu_ctx.format,
+      .dimension = WGPUTextureViewDimension_2D,
+      .mipLevelCount = 1,
+      .arrayLayerCount = 1,
+  };
+
+  WGPUTextureView view = wgpuTextureCreateView(texture, &view_desc);
+  FATAL_CHECK(!view, "Failed to create auxiliary texture view: %s\n", name);
+
+  // Store in registry
+  auxiliary_textures_[key] = {texture, view, width, height};
+
+#if !defined(STRIP_ALL)
+  printf("[MainSequence] Registered auxiliary texture '%s' (%dx%d)\n", name,
+         width, height);
+#endif /* !defined(STRIP_ALL) */
+}
+
+// Retrieve auxiliary texture view by name
+WGPUTextureView MainSequence::get_auxiliary_view(const char* name) {
+  const std::string key(name);
+  auto it = auxiliary_textures_.find(key);
+  FATAL_CHECK(it == auxiliary_textures_.end(),
+              "Auxiliary texture not found: %s\n", name);
+  return it->second.view;
+}
+
 #if !defined(STRIP_ALL)
 void MainSequence::simulate_until(float target_time, float step_rate,
                                   float bpm) {
diff --git a/src/gpu/effect.h b/src/gpu/effect.h
index 6ed2c55..6fdb0f4 100644
--- a/src/gpu/effect.h
+++ b/src/gpu/effect.h
@@ -1,7 +1,9 @@
 #pragma once
 #include "gpu/gpu.h"
 #include <algorithm>
+#include <map>
 #include <memory>
+#include <string>
 #include <vector>
 
 class MainSequence;
@@ -112,6 +114,10 @@ class MainSequence {
   void resize(int width, int height);
   void shutdown();
 
+  // Auxiliary texture registry for inter-effect texture sharing
+  void register_auxiliary_texture(const char* name, int width, int height);
+  WGPUTextureView get_auxiliary_view(const char* name);
+
 #if !defined(STRIP_ALL)
   void simulate_until(float target_time, float step_rate, float bpm = 120.0f);
 #endif /* !defined(STRIP_ALL) */
@@ -139,5 +145,13 @@ class MainSequence {
 
   std::unique_ptr<Effect> passthrough_effect_;
 
+  struct AuxiliaryTexture {
+    WGPUTexture texture;
+    WGPUTextureView view;
+    int width;
+    int height;
+  };
+  std::map<std::string, AuxiliaryTexture> auxiliary_textures_;
+
   void create_framebuffers(int width, int height);
 };
diff --git a/src/gpu/effects/circle_mask_effect.cc b/src/gpu/effects/circle_mask_effect.cc
new file mode 100644
index 0000000..226b603
--- /dev/null
+++ b/src/gpu/effects/circle_mask_effect.cc
@@ -0,0 +1,189 @@
+// This file is part of the 64k demo project.
+// It implements CircleMaskEffect for auxiliary texture masking demonstration.
+// Generates circular mask and renders green background outside circle.
+
+#include "gpu/effects/circle_mask_effect.h"
+#include "generated/assets.h"
+
+CircleMaskEffect::CircleMaskEffect(const GpuContext& ctx, float radius)
+  : Effect(ctx), radius_(radius) {}
+
+CircleMaskEffect::~CircleMaskEffect() {
+  if (mask_sampler_) wgpuSamplerRelease(mask_sampler_);
+  if (render_bind_group_) wgpuBindGroupRelease(render_bind_group_);
+  if (render_pipeline_) wgpuRenderPipelineRelease(render_pipeline_);
+  if (compute_bind_group_) wgpuBindGroupRelease(compute_bind_group_);
+  if (compute_pipeline_) wgpuRenderPipelineRelease(compute_pipeline_);
+}
+
+void CircleMaskEffect::init(MainSequence* demo) {
+  demo_ = demo;
+
+  const uint32_t width = width_;
+  const uint32_t height = height_;
+
+  demo_->register_auxiliary_texture("circle_mask", width, height);
+
+  compute_uniforms_.init(ctx_.device);
+  render_uniforms_.init(ctx_.device);
+
+  WGPUSamplerDescriptor sampler_desc = {};
+  sampler_desc.addressModeU = WGPUAddressMode_ClampToEdge;
+  sampler_desc.addressModeV = WGPUAddressMode_ClampToEdge;
+  sampler_desc.magFilter = WGPUFilterMode_Linear;
+  sampler_desc.minFilter = WGPUFilterMode_Linear;
+  sampler_desc.mipmapFilter = WGPUMipmapFilterMode_Linear;
+  sampler_desc.maxAnisotropy = 1;
+  mask_sampler_ = wgpuDeviceCreateSampler(ctx_.device, &sampler_desc);
+
+  size_t compute_size, render_size;
+  const char* compute_shader = (const char*)GetAsset(
+      AssetId::ASSET_CIRCLE_MASK_COMPUTE_SHADER, &compute_size);
+  const char* render_shader = (const char*)GetAsset(
+      AssetId::ASSET_CIRCLE_MASK_RENDER_SHADER, &render_size);
+
+  WGPUShaderSourceWGSL compute_wgsl = {};
+  compute_wgsl.chain.sType = WGPUSType_ShaderSourceWGSL;
+  compute_wgsl.code = str_view(compute_shader);
+
+  WGPUShaderModuleDescriptor compute_desc = {};
+  compute_desc.nextInChain = &compute_wgsl.chain;
+  WGPUShaderModule compute_module = wgpuDeviceCreateShaderModule(ctx_.device, &compute_desc);
+
+  const WGPUColorTargetState compute_target = {
+    .format = ctx_.format,  // Match auxiliary texture format
+    .writeMask = WGPUColorWriteMask_All,
+  };
+  WGPUFragmentState compute_frag = {};
+  compute_frag.module = compute_module;
+  compute_frag.entryPoint = str_view("fs_main");
+  compute_frag.targetCount = 1;
+  compute_frag.targets = &compute_target;
+  WGPURenderPipelineDescriptor compute_pipeline_desc = {};
+  compute_pipeline_desc.label = label_view("CircleMaskEffect_compute");
+  compute_pipeline_desc.vertex.module = compute_module;
+  compute_pipeline_desc.vertex.entryPoint = str_view("vs_main");
+  compute_pipeline_desc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
+  compute_pipeline_desc.primitive.cullMode = WGPUCullMode_None;
+  compute_pipeline_desc.multisample.count = 1;
+  compute_pipeline_desc.multisample.mask = 0xFFFFFFFF;
+  compute_pipeline_desc.fragment = &compute_frag;
+  compute_pipeline_ = wgpuDeviceCreateRenderPipeline(ctx_.device, &compute_pipeline_desc);
+  wgpuShaderModuleRelease(compute_module);
+
+  const WGPUBindGroupEntry compute_entries[] = {
+    {.binding = 0, .buffer = compute_uniforms_.get().buffer,
+     .size = sizeof(ComputeUniforms)},
+  };
+  const WGPUBindGroupDescriptor compute_bg_desc = {
+    .layout = wgpuRenderPipelineGetBindGroupLayout(compute_pipeline_, 0),
+    .entryCount = 1,
+    .entries = compute_entries,
+  };
+  compute_bind_group_ = wgpuDeviceCreateBindGroup(ctx_.device, &compute_bg_desc);
+
+  WGPUShaderSourceWGSL render_wgsl = {};
+  render_wgsl.chain.sType = WGPUSType_ShaderSourceWGSL;
+  render_wgsl.code = str_view(render_shader);
+
+  WGPUShaderModuleDescriptor render_desc = {};
+  render_desc.nextInChain = &render_wgsl.chain;
+  WGPUShaderModule render_module = wgpuDeviceCreateShaderModule(ctx_.device, &render_desc);
+
+  const WGPUColorTargetState render_target = {
+    .format = ctx_.format,
+    .writeMask = WGPUColorWriteMask_All,
+  };
+  WGPUFragmentState render_frag = {};
+  render_frag.module = render_module;
+  render_frag.entryPoint = str_view("fs_main");
+  render_frag.targetCount = 1;
+  render_frag.targets = &render_target;
+  const WGPUDepthStencilState depth_stencil = {
+    .format = WGPUTextureFormat_Depth24Plus,
+    .depthWriteEnabled = WGPUOptionalBool_False,  // Don't write depth
+    .depthCompare = WGPUCompareFunction_Always,   // Always pass
+  };
+
+  WGPURenderPipelineDescriptor render_pipeline_desc = {};
+  render_pipeline_desc.label = label_view("CircleMaskEffect_render");
+  render_pipeline_desc.vertex.module = render_module;
+  render_pipeline_desc.vertex.entryPoint = str_view("vs_main");
+  render_pipeline_desc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
+  render_pipeline_desc.primitive.cullMode = WGPUCullMode_None;
+  render_pipeline_desc.depthStencil = &depth_stencil;
+  render_pipeline_desc.multisample.count = 1;
+  render_pipeline_desc.multisample.mask = 0xFFFFFFFF;
+  render_pipeline_desc.fragment = &render_frag;
+  render_pipeline_ = wgpuDeviceCreateRenderPipeline(ctx_.device, &render_pipeline_desc);
+  wgpuShaderModuleRelease(render_module);
+
+  WGPUTextureView mask_view = demo_->get_auxiliary_view("circle_mask");
+  const WGPUBindGroupEntry render_entries[] = {
+    {.binding = 0, .textureView = mask_view},
+    {.binding = 1, .sampler = mask_sampler_},
+    {.binding = 2, .buffer = render_uniforms_.get().buffer,
+     .size = sizeof(RenderUniforms)},
+  };
+  const WGPUBindGroupDescriptor render_bg_desc = {
+    .layout = wgpuRenderPipelineGetBindGroupLayout(render_pipeline_, 0),
+    .entryCount = 3,
+    .entries = render_entries,
+  };
+  render_bind_group_ = wgpuDeviceCreateBindGroup(ctx_.device, &render_bg_desc);
+}
+
+void CircleMaskEffect::compute(WGPUCommandEncoder encoder, float time,
+                                float beat, float intensity,
+                                float aspect_ratio) {
+  const uint32_t width = width_;
+  const uint32_t height = height_;
+
+  const ComputeUniforms uniforms = {
+    .radius = radius_,
+    .aspect_ratio = aspect_ratio,
+    .width = static_cast<float>(width),
+    .height = static_cast<float>(height),
+  };
+  compute_uniforms_.update(ctx_.queue, uniforms);
+
+  WGPUTextureView mask_view = demo_->get_auxiliary_view("circle_mask");
+  WGPURenderPassColorAttachment color_attachment = {};
+  color_attachment.view = mask_view;
+  color_attachment.loadOp = WGPULoadOp_Clear;
+  color_attachment.storeOp = WGPUStoreOp_Store;
+  color_attachment.clearValue = {0.0, 0.0, 0.0, 1.0};
+#if !defined(DEMO_CROSS_COMPILE_WIN32)
+  color_attachment.depthSlice = WGPU_DEPTH_SLICE_UNDEFINED;
+#endif
+
+  WGPURenderPassDescriptor pass_desc = {};
+  pass_desc.colorAttachmentCount = 1;
+  pass_desc.colorAttachments = &color_attachment;
+
+  WGPURenderPassEncoder pass = wgpuCommandEncoderBeginRenderPass(encoder, &pass_desc);
+  wgpuRenderPassEncoderSetPipeline(pass, compute_pipeline_);
+  wgpuRenderPassEncoderSetBindGroup(pass, 0, compute_bind_group_, 0, nullptr);
+  wgpuRenderPassEncoderDraw(pass, 3, 1, 0, 0);
+  wgpuRenderPassEncoderEnd(pass);
+  wgpuRenderPassEncoderRelease(pass);
+}
+
+void CircleMaskEffect::render(WGPURenderPassEncoder pass, float time,
+                               float beat, float intensity,
+                               float aspect_ratio) {
+  const uint32_t width = width_;
+  const uint32_t height = height_;
+
+  const RenderUniforms uniforms = {
+    .width = static_cast<float>(width),
+    .height = static_cast<float>(height),
+    ._pad1 = 0.0f,
+    ._pad2 = 0.0f,
+  };
+  render_uniforms_.update(ctx_.queue, uniforms);
+
+  wgpuRenderPassEncoderSetPipeline(pass, render_pipeline_);
+  wgpuRenderPassEncoderSetBindGroup(pass, 0, render_bind_group_, 0, nullptr);
+  wgpuRenderPassEncoderDraw(pass, 3, 1, 0, 0);
+}
diff --git a/src/gpu/effects/circle_mask_effect.h b/src/gpu/effects/circle_mask_effect.h
new file mode 100644
index 0000000..57f2389
--- /dev/null
+++ b/src/gpu/effects/circle_mask_effect.h
@@ -0,0 +1,50 @@
+// This file is part of the 64k demo project.
+// It defines the CircleMaskEffect class for masking system demonstration.
+// Creates a circular mask and renders green outside the circle.
+
+#ifndef CIRCLE_MASK_EFFECT_H_
+#define CIRCLE_MASK_EFFECT_H_
+
+#include "gpu/effect.h"
+#include "gpu/uniform_helper.h"
+
+class CircleMaskEffect : public Effect {
+ public:
+  CircleMaskEffect(const GpuContext& ctx, float radius = 0.4f);
+  ~CircleMaskEffect() override;
+
+  void init(MainSequence* demo) override;
+  void compute(WGPUCommandEncoder encoder, float time, float beat,
+               float intensity, float aspect_ratio) override;
+  void render(WGPURenderPassEncoder pass, float time, float beat,
+              float intensity, float aspect_ratio) override;
+
+ private:
+  struct ComputeUniforms {
+    float radius;
+    float aspect_ratio;
+    float width;
+    float height;
+  };
+
+  struct RenderUniforms {
+    float width;
+    float height;
+    float _pad1;
+    float _pad2;
+  };
+
+  MainSequence* demo_ = nullptr;
+  float radius_;
+
+  WGPURenderPipeline compute_pipeline_ = nullptr;
+  WGPUBindGroup compute_bind_group_ = nullptr;
+  UniformBuffer<ComputeUniforms> compute_uniforms_;
+
+  WGPURenderPipeline render_pipeline_ = nullptr;
+  WGPUBindGroup render_bind_group_ = nullptr;
+  WGPUSampler mask_sampler_ = nullptr;
+  UniformBuffer<RenderUniforms> render_uniforms_;
+};
+
+#endif /* CIRCLE_MASK_EFFECT_H_ */
diff --git a/src/gpu/effects/distort_effect.cc b/src/gpu/effects/distort_effect.cc
index b7e27a7..589cdff 100644
--- a/src/gpu/effects/distort_effect.cc
+++ b/src/gpu/effects/distort_effect.cc
@@ -5,21 +5,33 @@
 #include "gpu/gpu.h"
 
 // --- DistortEffect ---
-DistortEffect::DistortEffect(const GpuContext& ctx) : PostProcessEffect(ctx) {
-  uniforms_ =
-      gpu_create_buffer(ctx_.device, sizeof(float) * 6,
-                        WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
+DistortEffect::DistortEffect(const GpuContext& ctx)
+    : DistortEffect(ctx, DistortParams()) {}
+
+DistortEffect::DistEffect(const GpuContext& ctx, const DistortParams& params)
+    : PostProcessEffect(ctx), params_(params) {
+  uniforms_ = gpu_create_buffer(ctx_.device, sizeof(DistortUniforms),
+                                WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
   pipeline_ = create_post_process_pipeline(ctx_.device, ctx_.format,
                                            distort_shader_wgsl);
 }
+
 void DistortEffect::render(WGPURenderPassEncoder pass, float t, float b,
                            float i, float a) {
-  struct {
-    float t, b, i, a, w, h;
-  } u = {t, b, i, a, (float)width_, (float)height_};
+  DistortUniforms u = {
+      .time = t,
+      .beat = b,
+      .intensity = i,
+      .aspect_ratio = a,
+      .width = (float)width_,
+      .height = (float)height_,
+      .strength = params_.strength,
+      .speed = params_.speed,
+  };
   wgpuQueueWriteBuffer(ctx_.queue, uniforms_.buffer, 0, &u, sizeof(u));
   PostProcessEffect::render(pass, t, b, i, a);
 }
+
 void DistortEffect::update_bind_group(WGPUTextureView v) {
   pp_update_bind_group(ctx_.device, pipeline_, &bind_group_, v, uniforms_);
-}
+}
\ No newline at end of file
diff --git a/src/gpu/effects/rotating_cube_effect.cc b/src/gpu/effects/rotating_cube_effect.cc
new file mode 100644
index 0000000..7f590c5
--- /dev/null
+++ b/src/gpu/effects/rotating_cube_effect.cc
@@ -0,0 +1,181 @@
+// This file is part of the 64k demo project.
+// It implements RotatingCubeEffect for bump-mapped rotating cube rendering.
+// Uses auxiliary texture masking to render only inside a circular region.
+
+#include "gpu/effects/rotating_cube_effect.h"
+#include "gpu/effects/shader_composer.h"
+#include "generated/assets.h"
+#include "util/asset_manager_utils.h"
+
+
+RotatingCubeEffect::RotatingCubeEffect(const GpuContext& ctx) : Effect(ctx) {}
+
+RotatingCubeEffect::~RotatingCubeEffect() {
+  if (mask_sampler_) wgpuSamplerRelease(mask_sampler_);
+  if (noise_sampler_) wgpuSamplerRelease(noise_sampler_);
+  if (noise_view_) wgpuTextureViewRelease(noise_view_);
+  if (noise_texture_) wgpuTextureRelease(noise_texture_);
+  if (bind_group_1_) wgpuBindGroupRelease(bind_group_1_);
+  if (bind_group_0_) wgpuBindGroupRelease(bind_group_0_);
+  if (pipeline_) wgpuRenderPipelineRelease(pipeline_);
+}
+
+void RotatingCubeEffect::init(MainSequence* demo) {
+  demo_ = demo;
+
+  uniform_buffer_ =
+      gpu_create_buffer(ctx_.device, sizeof(Uniforms),
+                        WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst);
+  object_buffer_ =
+      gpu_create_buffer(ctx_.device, sizeof(ObjectData),
+                        WGPUBufferUsage_Storage | WGPUBufferUsage_CopyDst);
+
+  const WGPUTextureDescriptor tex_desc = {
+      .usage = WGPUTextureUsage_TextureBinding | WGPUTextureUsage_RenderAttachment,
+      .dimension = WGPUTextureDimension_2D,
+      .size = {1, 1, 1},
+      .format = WGPUTextureFormat_RGBA8Unorm,
+      .mipLevelCount = 1,
+      .sampleCount = 1,
+  };
+  noise_texture_ = wgpuDeviceCreateTexture(ctx_.device, &tex_desc);
+  noise_view_ = wgpuTextureCreateView(noise_texture_, nullptr);
+
+  WGPUSamplerDescriptor sampler_desc = {};
+  sampler_desc.addressModeU = WGPUAddressMode_Repeat;
+  sampler_desc.addressModeV = WGPUAddressMode_Repeat;
+  sampler_desc.magFilter = WGPUFilterMode_Linear;
+  sampler_desc.minFilter = WGPUFilterMode_Linear;
+  sampler_desc.maxAnisotropy = 1;
+  noise_sampler_ = wgpuDeviceCreateSampler(ctx_.device, &sampler_desc);
+
+  WGPUSamplerDescriptor mask_sampler_desc = {};
+  mask_sampler_desc.addressModeU = WGPUAddressMode_ClampToEdge;
+  mask_sampler_desc.addressModeV = WGPUAddressMode_ClampToEdge;
+  mask_sampler_desc.magFilter = WGPUFilterMode_Linear;
+  mask_sampler_desc.minFilter = WGPUFilterMode_Linear;
+  mask_sampler_desc.maxAnisotropy = 1;
+  mask_sampler_ = wgpuDeviceCreateSampler(ctx_.device, &mask_sampler_desc);
+
+  size_t shader_size;
+  const char* shader_code =
+      (const char*)GetAsset(AssetId::ASSET_MASKED_CUBE_SHADER, &shader_size);
+
+  ShaderComposer::CompositionMap composition_map;
+  composition_map["render/scene_query_mode"] = "render/scene_query_linear";
+  composed_shader_ = ShaderComposer::Get().Compose(
+      {}, std::string(shader_code, shader_size), composition_map);
+
+  WGPUShaderSourceWGSL wgsl_src = {};
+  wgsl_src.chain.sType = WGPUSType_ShaderSourceWGSL;
+  wgsl_src.code = str_view(composed_shader_.c_str());
+
+  WGPUShaderModuleDescriptor shader_desc = {};
+  shader_desc.nextInChain = &wgsl_src.chain;
+  WGPUShaderModule shader_module =
+      wgpuDeviceCreateShaderModule(ctx_.device, &shader_desc);
+
+  const WGPUColorTargetState color_target = {
+      .format = ctx_.format,
+      .writeMask = WGPUColorWriteMask_All,
+  };
+
+  const WGPUDepthStencilState depth_stencil = {
+      .format = WGPUTextureFormat_Depth24Plus,
+      .depthWriteEnabled = WGPUOptionalBool_True,
+      .depthCompare = WGPUCompareFunction_Less,
+  };
+
+  WGPUFragmentState fragment = {};
+  fragment.module = shader_module;
+  fragment.entryPoint = str_view("fs_main");
+  fragment.targetCount = 1;
+  fragment.targets = &color_target;
+
+  WGPURenderPipelineDescriptor pipeline_desc = {};
+  pipeline_desc.vertex.module = shader_module;
+  pipeline_desc.vertex.entryPoint = str_view("vs_main");
+  pipeline_desc.primitive.topology = WGPUPrimitiveTopology_TriangleList;
+  pipeline_desc.primitive.cullMode = WGPUCullMode_None;
+  pipeline_desc.depthStencil = &depth_stencil;
+  pipeline_desc.multisample.count = 1;
+  pipeline_desc.multisample.mask = 0xFFFFFFFF;
+  pipeline_desc.fragment = &fragment;
+
+  pipeline_ = wgpuDeviceCreateRenderPipeline(ctx_.device, &pipeline_desc);
+  wgpuShaderModuleRelease(shader_module);
+
+  const WGPUBindGroupEntry entries_0[] = {
+      {.binding = 0, .buffer = uniform_buffer_.buffer, .size = sizeof(Uniforms)},
+      {.binding = 1, .buffer = object_buffer_.buffer, .size = sizeof(ObjectData)},
+      {.binding = 3, .textureView = noise_view_},
+      {.binding = 4, .sampler = noise_sampler_},
+  };
+
+  const WGPUBindGroupDescriptor bg_desc_0 = {
+      .layout = wgpuRenderPipelineGetBindGroupLayout(pipeline_, 0),
+      .entryCount = 4,
+      .entries = entries_0,
+  };
+  bind_group_0_ = wgpuDeviceCreateBindGroup(ctx_.device, &bg_desc_0);
+
+  WGPUTextureView mask_view = demo_->get_auxiliary_view("circle_mask");
+  const WGPUBindGroupEntry entries_1[] = {
+      {.binding = 0, .textureView = mask_view},
+      {.binding = 1, .sampler = mask_sampler_},
+  };
+
+  const WGPUBindGroupDescriptor bg_desc_1 = {
+      .layout = wgpuRenderPipelineGetBindGroupLayout(pipeline_, 1),
+      .entryCount = 2,
+      .entries = entries_1,
+  };
+  bind_group_1_ = wgpuDeviceCreateBindGroup(ctx_.device, &bg_desc_1);
+}
+
+void RotatingCubeEffect::render(WGPURenderPassEncoder pass, float time,
+                                 float beat, float intensity,
+                                 float aspect_ratio) {
+  rotation_ += 0.016f * 1.5f;
+
+  const vec3 camera_pos = vec3(0, 0, 5);
+  const vec3 target = vec3(0, 0, 0);
+  const vec3 up = vec3(0, 1, 0);
+
+  const mat4 view = mat4::look_at(camera_pos, target, up);
+  const float fov = 60.0f * 3.14159f / 180.0f;
+  const mat4 proj = mat4::perspective(fov, aspect_ratio, 0.1f, 100.0f);
+  const mat4 view_proj = proj * view;
+
+  const quat rot = quat::from_axis(vec3(0.3f, 1.0f, 0.2f), rotation_);
+  const mat4 T = mat4::translate(vec3(0, 0, 0));
+  const mat4 R = rot.to_mat();
+  const mat4 S = mat4::scale(vec3(1.5f, 1.5f, 1.5f));
+  const mat4 model = T * R * S;
+  const mat4 inv_model = model.inverse();
+
+  const Uniforms uniforms = {
+      .view_proj = view_proj,
+      .inv_view_proj = view_proj.inverse(),
+      .camera_pos_time = vec4(camera_pos.x, camera_pos.y, camera_pos.z, time),
+      .params = vec4(1.0f, 0.0f, 0.0f, 0.0f),
+      .resolution = vec2(1280.0f, 720.0f),
+  };
+
+  const ObjectData obj_data = {
+      .model = model,
+      .inv_model = inv_model,
+      .color = vec4(0.8f, 0.4f, 0.2f, 1.0f),
+      .params = vec4(1.0f, 0.0f, 0.0f, 0.0f),
+  };
+
+  wgpuQueueWriteBuffer(ctx_.queue, uniform_buffer_.buffer, 0, &uniforms,
+                       sizeof(Uniforms));
+  wgpuQueueWriteBuffer(ctx_.queue, object_buffer_.buffer, 0, &obj_data,
+                       sizeof(ObjectData));
+
+  wgpuRenderPassEncoderSetPipeline(pass, pipeline_);
+  wgpuRenderPassEncoderSetBindGroup(pass, 0, bind_group_0_, 0, nullptr);
+  wgpuRenderPassEncoderSetBindGroup(pass, 1, bind_group_1_, 0, nullptr);
+  wgpuRenderPassEncoderDraw(pass, 36, 1, 0, 0);
+}
diff --git a/src/gpu/effects/rotating_cube_effect.h b/src/gpu/effects/rotating_cube_effect.h
new file mode 100644
index 0000000..89b3fa6
--- /dev/null
+++ b/src/gpu/effects/rotating_cube_effect.h
@@ -0,0 +1,55 @@
+// This file is part of the 64k demo project.
+// It defines RotatingCubeEffect for rendering a bump-mapped rotating cube.
+// Uses auxiliary texture masking to render only inside a circular region.
+
+#ifndef ROTATING_CUBE_EFFECT_H_
+#define ROTATING_CUBE_EFFECT_H_
+
+#include "gpu/effect.h"
+#include "gpu/gpu.h"
+#include "util/mini_math.h"
+#include <string>
+
+class RotatingCubeEffect : public Effect {
+ public:
+  RotatingCubeEffect(const GpuContext& ctx);
+  ~RotatingCubeEffect() override;
+
+  void init(MainSequence* demo) override;
+  void render(WGPURenderPassEncoder pass, float time, float beat,
+              float intensity, float aspect_ratio) override;
+
+ private:
+  struct Uniforms {
+    mat4 view_proj;
+    mat4 inv_view_proj;
+    vec4 camera_pos_time;
+    vec4 params;
+    vec2 resolution;
+    vec2 padding;
+  };
+
+  struct ObjectData {
+    mat4 model;
+    mat4 inv_model;
+    vec4 color;
+    vec4 params;
+  };
+
+  MainSequence* demo_ = nullptr;
+  WGPURenderPipeline pipeline_ = nullptr;
+  WGPUBindGroup bind_group_0_ = nullptr;
+  WGPUBindGroup bind_group_1_ = nullptr;
+  GpuBuffer uniform_buffer_;
+  GpuBuffer object_buffer_;
+  WGPUTexture noise_texture_ = nullptr;
+  WGPUTextureView noise_view_ = nullptr;
+  WGPUSampler noise_sampler_ = nullptr;
+  WGPUSampler mask_sampler_ = nullptr;
+  float rotation_ = 0.0f;
+
+  // Store composed shader to keep it alive for WebGPU
+  std::string composed_shader_;
+};
+
+#endif /* ROTATING_CUBE_EFFECT_H_ */
diff --git a/src/gpu/effects/shaders.cc b/src/gpu/effects/shaders.cc
index ce60a74..2e1cfe5 100644
--- a/src/gpu/effects/shaders.cc
+++ b/src/gpu/effects/shaders.cc
@@ -98,3 +98,7 @@ const char* distort_shader_wgsl =
 const char* chroma_aberration_shader_wgsl =
 
     SafeGetAsset(AssetId::ASSET_SHADER_CHROMA_ABERRATION);
+
+const char* vignette_shader_wgsl =
+
+    SafeGetAsset(AssetId::ASSET_SHADER_VIGNETTE);
diff --git a/src/gpu/effects/shaders.h b/src/gpu/effects/shaders.h
index f8e45ba..50b4f32 100644
--- a/src/gpu/effects/shaders.h
+++ b/src/gpu/effects/shaders.h
@@ -17,3 +17,4 @@ extern const char* gaussian_blur_shader_wgsl;
 extern const char* solarize_shader_wgsl;
 extern const char* distort_shader_wgsl;
 extern const char* chroma_aberration_shader_wgsl;
+extern const char* vignette_shader_wgsl;
diff --git a/src/gpu/effects/vignette_effect.cc b/src/gpu/effects/vignette_effect.cc
new file mode 100644
index 0000000..d3572a3
--- /dev/null
+++ b/src/gpu/effects/vignette_effect.cc
@@ -0,0 +1,36 @@
+// This file is part of the 64k demo project.
+// It implements the VignetteEffect.
+
+#include "gpu/demo_effects.h"
+#include "gpu/gpu.h"
+
+VignetteEffect::VignetteEffect(const GpuContext& ctx)
+    : VignetteEffect(ctx, VignetteParams()) {}
+
+VignetteEffect::VignetteEffect(const GpuContext& ctx,
+                               const VignetteParams& params)
+    : PostProcessEffect(ctx), params_(params) {
+  uniforms_.init(ctx_.device);
+  pipeline_ = create_post_process_pipeline(ctx_.device, ctx_.format,
+                                           vignette_shader_wgsl);
+}
+
+void VignetteEffect::render(WGPURenderPassEncoder pass, float t, float b,
+                            float i, float a) {
+  VignetteUniforms u = {
+      .time = t,
+      .beat = b,
+      .intensity = i,
+      .aspect_ratio = a,
+      .width = (float)width_,
+      .height = (float)height_,
+      .radius = params_.radius,
+      .softness = params_.softness,
+  };
+  uniforms_.update(ctx_.queue, u);
+  PostProcessEffect::render(pass, t, b, i, a);
+}
+
+void VignetteEffect::update_bind_group(WGPUTextureView v) {
+  pp_update_bind_group(ctx_.device, pipeline_, &bind_group_, v, uniforms_.get());
+}
diff --git a/src/procedural/generator.cc b/src/procedural/generator.cc
index 41ee661..18ad133 100644
--- a/src/procedural/generator.cc
+++ b/src/procedural/generator.cc
@@ -15,180 +15,105 @@ constexpr float mix(float a, float b, float t) {
   return (a * (1.0f - t) + b * t);
 }
 
+// Fractional part
+static inline float fract(float x) {
+  return x - floorf(x);
+}
+
+// Hash function: vec2 -> float (deterministic, no rand())
+// Matches WGSL hash_2f() behavior
+static float hash_2f(float x, float y) {
+  const float h = x * 127.1f + y * 311.7f;
+  return fract(sinf(h) * 43758.5453123f);
+}
+
+// Value noise: 2D (matches WGSL noise_2d)
+static float noise_2d(float x, float y) {
+  const float ix = floorf(x);
+  const float iy = floorf(y);
+  const float fx = fract(x);
+  const float fy = fract(y);
+  const float u = smooth(fx);
+  const float v = smooth(fy);
+
+  const float n00 = hash_2f(ix + 0.0f, iy + 0.0f);
+  const float n10 = hash_2f(ix + 1.0f, iy + 0.0f);
+  const float n01 = hash_2f(ix + 0.0f, iy + 1.0f);
+  const float n11 = hash_2f(ix + 1.0f, iy + 1.0f);
+
+  const float ix0 = mix(n00, n10, u);
+  const float ix1 = mix(n01, n11, u);
+  return mix(ix0, ix1, v);
+}
+
 // Perlin noise generator (Fractional Brownian Motion using value noise)
-// Params[0]: Seed
+// Params[0]: Seed (offset for hash function)
 // Params[1]: Frequency (Scale)
 // Params[2]: Amplitude
 // Params[3]: Amplitude decay
 // Params[4]: Number of octaves
 bool gen_perlin(uint8_t* buffer, int w, int h, const float* params,
                 int num_params) {
-  float base_freq = (num_params > 1) ? params[1] : 4.0f;
-  float base_amp = (num_params > 2) ? params[2] : 1.0f;
-  float amp_decay = (num_params > 3) ? params[3] : 0.5f;
-  int octaves = (num_params > 4) ? (int)params[4] : 4;
-  if (num_params > 0 && params[0] != 0) {
-    srand((unsigned int)params[0]);
-  }
-
-  // Pre-allocate temporary float buffer for accumulating noise
-  float* accum = (float*)calloc((size_t)w * h, sizeof(float));
-  if (!accum)
-    return false;
-
-  float current_freq = base_freq;
-  float current_amp = base_amp;
-  float total_amp = 0.0f;
-
-  for (int o = 0; o < octaves; ++o) {
-    const int lattice_w = (int)ceil(current_freq) + 1;
-    const int lattice_h = (int)ceil(current_freq) + 1;
-    float* lattice =
-        (float*)malloc((size_t)lattice_w * lattice_h * sizeof(float));
-    if (!lattice) {
-      free(accum);
-      return false;
-    }
-
-    for (int i = 0; i < lattice_w * lattice_h; ++i) {
-      lattice[i] = (float)rand() / RAND_MAX;
-    }
-
-    const float scale_u = current_freq / w;
-    const float scale_v = current_freq / h;
+  const float seed = (num_params > 0) ? params[0] : 0.0f;
+  const float base_freq = (num_params > 1) ? params[1] : 4.0f;
+  const float base_amp = (num_params > 2) ? params[2] : 1.0f;
+  const float amp_decay = (num_params > 3) ? params[3] : 0.5f;
+  const int octaves = (num_params > 4) ? (int)params[4] : 4;
 
-    for (int y = 0; y < h; ++y) {
-      const float v = scale_v * y;
-      const int ly = (int)floor(v);
-      const int ly_next = (ly + 1); // No wrap here for better octaves
-      float fv = smooth(v - ly);
-      for (int x = 0; x < w; ++x) {
-        float u = scale_u * x;
-        const int lx = (int)floor(u);
-        const int lx_next = (lx + 1);
-        float fu = smooth(u - lx);
-
-        // Simple tiling for lattice access
-        auto get_lat = [&](int ix, int iy) {
-          return lattice[(iy % lattice_h) * lattice_w + (ix % lattice_w)];
-        };
-
-        float n00 = get_lat(lx, ly);
-        float n10 = get_lat(lx_next, ly);
-        float n01 = get_lat(lx, ly_next);
-        float n11 = get_lat(lx_next, ly_next);
+  for (int y = 0; y < h; ++y) {
+    for (int x = 0; x < w; ++x) {
+      float value = 0.0f;
+      float amplitude = base_amp;
+      float frequency = base_freq;
+      float total_amp = 0.0f;
 
-        const float noise = mix(mix(n00, n10, fu), mix(n01, n11, fu), fv);
-        accum[y * w + x] += noise * current_amp;
+      for (int o = 0; o < octaves; ++o) {
+        const float nx = (float)x / (float)w * frequency + seed;
+        const float ny = (float)y / (float)h * frequency + seed;
+        value += noise_2d(nx, ny) * amplitude;
+        total_amp += amplitude;
+        frequency *= 2.0f;
+        amplitude *= amp_decay;
       }
-    }
 
-    total_amp += current_amp;
-    current_freq *= 2.0f;
-    current_amp *= amp_decay;
-    free(lattice);
-  }
-
-  // Normalize and write to RGBA buffer
-  for (int i = 0; i < w * h; ++i) {
-    float val = accum[i] / total_amp;
-    uint8_t uval = (uint8_t)(fminf(fmaxf(val, 0.0f), 1.0f) * 255.0f);
-    buffer[4 * i + 0] = uval;
-    buffer[4 * i + 1] = uval;
-    buffer[4 * i + 2] = uval;
-    buffer[4 * i + 3] = 255;
+      value /= total_amp;
+      const uint8_t uval = (uint8_t)(fminf(fmaxf(value, 0.0f), 1.0f) * 255.0f);
+      const int idx = (y * w + x) * 4;
+      buffer[idx + 0] = uval;
+      buffer[idx + 1] = uval;
+      buffer[idx + 2] = uval;
+      buffer[idx + 3] = 255;
+    }
   }
 
-  free(accum);
   return true;
 }
 
-// Simple smooth noise generator (Value Noise-ish)
-
-// Params[0]: Seed
-
+// Simple smooth noise generator (Value Noise)
+// Params[0]: Seed (offset for hash function)
 // Params[1]: Frequency (Scale)
-
 bool gen_noise(uint8_t* buffer, int w, int h, const float* params,
-
                int num_params) {
   if (num_params > 0 && params[0] == -1337.0f)
     return false;
 
-  float freq = (num_params > 1) ? params[1] : 4.0f;
-
-  if (num_params > 0 && params[0] != 0) {
-    srand((unsigned int)params[0]);
-  }
-
-  // Create a small lattice of random values
-
-  const int lattice_w = (int)ceil(freq);
-
-  const int lattice_h = (int)ceil(freq);
-
-  float* lattice =
-      (float*)malloc((size_t)lattice_w * lattice_h * sizeof(float));
-
-  if (!lattice)
-    return false;
-
-  for (int i = 0; i < lattice_w * lattice_h; ++i) {
-    lattice[i] = (float)rand() / RAND_MAX;
-  }
-
-  const float scale_u = 1.f * (lattice_w - 1) / w;
-
-  const float scale_v = 1.f * (lattice_h - 1) / h;
+  const float seed = (num_params > 0) ? params[0] : 0.0f;
+  const float freq = (num_params > 1) ? params[1] : 4.0f;
 
   for (int y = 0; y < h; ++y) {
-    const float v = scale_v * y;
-
-    const int ly = (int)floor(v);
-
-    const int ly_next = (ly + 1) % lattice_h; // Wrap
-
-    const float* const n0 = &lattice[ly * lattice_w];
-
-    const float* const n1 = &lattice[ly_next * lattice_w];
-
-    float fv = smooth(v - ly);
-
-    uint8_t* const dst = &buffer[y * w * 4];
-
     for (int x = 0; x < w; ++x) {
-      float u = scale_u * x;
-
-      const int lx = (int)floor(u);
-
-      const int lx_next = (lx + 1) % lattice_w;
-
-      float fu = smooth(u - lx);
-
-      float n00 = n0[lx];
-
-      float n10 = n0[lx_next];
-
-      float n01 = n1[lx];
-
-      float n11 = n1[lx_next];
-
-      const float noise = mix(mix(n00, n10, fu), mix(n01, n11, fu), fv);
-
+      const float nx = (float)x / (float)w * freq + seed;
+      const float ny = (float)y / (float)h * freq + seed;
+      const float noise = noise_2d(nx, ny);
       const uint8_t val = (uint8_t)(noise * 255.0f);
-
-      dst[4 * x + 0] = val; // R
-
-      dst[4 * x + 1] = val; // G
-
-      dst[4 * x + 2] = val; // B
-
-      dst[4 * x + 3] = 255; // A
+      const int idx = (y * w + x) * 4;
+      buffer[idx + 0] = val;
+      buffer[idx + 1] = val;
+      buffer[idx + 2] = val;
+      buffer[idx + 3] = 255;
     }
   }
 
-  free(lattice);
-
   return true;
 }
 
diff --git a/src/tests/test_demo_effects.cc b/src/tests/test_demo_effects.cc
index a5500a8..25ada59 100644
--- a/src/tests/test_demo_effects.cc
+++ b/src/tests/test_demo_effects.cc
@@ -14,11 +14,12 @@
 // Expected effect counts - UPDATE THESE when adding new effects!
 static constexpr int EXPECTED_POST_PROCESS_COUNT =
     8; // FlashEffect, PassthroughEffect, GaussianBlurEffect,
-       // ChromaAberrationEffect, DistortEffect, SolarizeEffect, FadeEffect,
-       // ThemeModulationEffect
+       // ChromaAberrationEffect, SolarizeEffect, FadeEffect,
+       // ThemeModulationEffect, VignetteEffect
 static constexpr int EXPECTED_SCENE_COUNT =
-    6; // HeptagonEffect, ParticlesEffect, ParticleSprayEffect,
-       // MovingEllipseEffect, FlashCubeEffect, Hybrid3DEffect
+    8; // HeptagonEffect, ParticlesEffect, ParticleSprayEffect,
+       // MovingEllipseEffect, FlashCubeEffect, Hybrid3DEffect,
+       // CircleMaskEffect, RotatingCubeEffect
 
 #include "effect_test_helpers.h"
 #include "gpu/demo_effects.h"
@@ -93,11 +94,11 @@ static void test_post_process_effects() {
        std::make_shared<GaussianBlurEffect>(fixture.ctx())},
       {"ChromaAberrationEffect",
        std::make_shared<ChromaAberrationEffect>(fixture.ctx())},
-      {"DistortEffect", std::make_shared<DistortEffect>(fixture.ctx())},
       {"SolarizeEffect", std::make_shared<SolarizeEffect>(fixture.ctx())},
       {"FadeEffect", std::make_shared<FadeEffect>(fixture.ctx())},
       {"ThemeModulationEffect",
        std::make_shared<ThemeModulationEffect>(fixture.ctx())},
+      {"VignetteEffect", std::make_shared<VignetteEffect>(fixture.ctx())},
   };
 
   int passed = 0;
@@ -154,6 +155,8 @@ static void test_scene_effects() {
        std::make_shared<MovingEllipseEffect>(fixture.ctx())},
       {"FlashCubeEffect", std::make_shared<FlashCubeEffect>(fixture.ctx())},
       {"Hybrid3DEffect", std::make_shared<Hybrid3DEffect>(fixture.ctx())},
+      {"CircleMaskEffect", std::make_shared<CircleMaskEffect>(fixture.ctx())},
+      {"RotatingCubeEffect", std::make_shared<RotatingCubeEffect>(fixture.ctx())},
   };
 
   int passed = 0;
@@ -163,9 +166,11 @@ static void test_scene_effects() {
     assert(!effect->is_post_process() &&
            "Scene effect should return false for is_post_process()");
 
-    // FlashCubeEffect and Hybrid3DEffect require full 3D pipeline (Renderer3D)
+    // FlashCubeEffect, Hybrid3DEffect, RotatingCubeEffect, and CircleMaskEffect require full 3D pipeline (Renderer3D) or auxiliary textures
     const bool requires_3d = (strcmp(name, "FlashCubeEffect") == 0 ||
-                              strcmp(name, "Hybrid3DEffect") == 0);
+                              strcmp(name, "Hybrid3DEffect") == 0 ||
+                              strcmp(name, "RotatingCubeEffect") == 0 ||
+                              strcmp(name, "CircleMaskEffect") == 0);
 
     const int result = test_effect_smoke(name, effect, &main_seq, requires_3d);
     if (result == 1) {
@@ -211,6 +216,10 @@ static void test_effect_type_classification() {
   assert(blur->is_post_process() &&
          "GaussianBlurEffect should be post-process");
 
+  auto vignette = std::make_shared<VignetteEffect>(fixture.ctx());
+  assert(vignette->is_post_process() &&
+         "VignetteEffect should be post-process");
+
   // Scene effects should return false
   auto heptagon = std::make_shared<HeptagonEffect>(fixture.ctx());
   assert(!heptagon->is_post_process() &&