1 files changed, 79 insertions, 92 deletions

diff --git a/src/tests/gpu/test_effect_base.cc b/src/tests/gpu/test_effect_base.cc
index f049dff..cd6e2db 100644
--- a/src/tests/gpu/test_effect_base.cc
+++ b/src/tests/gpu/test_effect_base.cc
@@ -1,12 +1,13 @@
 // This file is part of the 64k demo project.
-// It tests the Effect/Sequence/MainSequence lifecycle using headless rendering.
-// Verifies effect initialization, activation, and basic rendering.
+// It tests the EffectV2/SequenceV2 lifecycle using headless rendering.
+// Verifies effect initialization and basic rendering.
 
 #include "../common/effect_test_helpers.h"
 #include "../common/offscreen_render_target.h"
 #include "../common/webgpu_test_fixture.h"
-#include "gpu/demo_effects.h"
-#include "gpu/effect.h"
+#include "effects/passthrough_effect_v2.h"
+#include "gpu/effect_v2.h"
+#include "gpu/sequence_v2.h"
 #include <cassert>
 #include <cstdio>
 #include <memory>
@@ -79,17 +80,19 @@ static void test_effect_construction() {
     return;
   }
 
-  // Create FlashEffect (simple post-process effect)
-  auto effect = std::make_shared<FlashEffect>(fixture.ctx());
+  // Create PassthroughEffectV2 (simple effect)
+  auto effect = std::make_shared<PassthroughEffectV2>(
+      fixture.ctx(), std::vector<std::string>{"source"},
+      std::vector<std::string>{"sink"});
 
-  assert(!effect->is_initialized && "Effect should not be initialized yet");
+  assert(effect != nullptr && "Effect should be constructed");
 
-  fprintf(stdout, "  ✓ FlashEffect constructed (not initialized)\n");
+  fprintf(stdout, "  ✓ PassthroughEffectV2 constructed\n");
 }
 
-// Test 4: Effect initialization via Sequence
-static void test_effect_initialization() {
-  fprintf(stdout, "Testing effect initialization...\n");
+// Test 4: Effect added to sequence DAG
+static void test_effect_in_sequence() {
+  fprintf(stdout, "Testing effect in SequenceV2 DAG...\n");
 
   WebGPUTestFixture fixture;
   if (!fixture.init()) {
@@ -97,31 +100,30 @@ static void test_effect_initialization() {
     return;
   }
 
-  // Create MainSequence (use init_test for test environment)
-  MainSequence main_seq;
-  main_seq.init_test(fixture.ctx());
+  // Create minimal sequence with one effect
+  class TestSequence : public SequenceV2 {
+  public:
+    TestSequence(const GpuContext& ctx, int w, int h) : SequenceV2(ctx, w, h) {
+      auto effect = std::make_shared<PassthroughEffectV2>(
+          ctx, std::vector<std::string>{"source"},
+          std::vector<std::string>{"sink"});
 
-  // Create FlashEffect
-  auto effect = std::make_shared<FlashEffect>(fixture.ctx());
+      effect_dag_.push_back({effect, {"source"}, {"sink"}, 0});
+      init_effect_nodes();
+    }
+  };
 
-  assert(!effect->is_initialized && "Effect should not be initialized yet");
+  auto seq = std::make_unique<TestSequence>(fixture.ctx(), 256, 256);
 
-  // Add effect to sequence
-  auto seq = std::make_shared<Sequence>();
-  seq->add_effect(effect, 0.0f, 10.0f, 0);
+  assert(seq->get_effect_dag().size() == 1 && "Should have one effect");
+  assert(seq->get_effect_dag()[0].effect != nullptr && "Effect should exist");
 
-  // Initialize sequence (this sets effect->is_initialized)
-  seq->init(&main_seq);
-
-  assert(effect->is_initialized &&
-         "Effect should be initialized after Sequence::init()");
-
-  fprintf(stdout, "  ✓ FlashEffect initialized via Sequence::init()\n");
+  fprintf(stdout, "  ✓ Effect added to DAG and initialized\n");
 }
 
-// Test 5: Sequence add_effect
-static void test_sequence_add_effect() {
-  fprintf(stdout, "Testing Sequence::add_effect...\n");
+// Test 5: Sequence rendering (smoke test)
+static void test_sequence_render() {
+  fprintf(stdout, "Testing sequence render...\n");
 
   WebGPUTestFixture fixture;
   if (!fixture.init()) {
@@ -129,35 +131,40 @@ static void test_sequence_add_effect() {
     return;
   }
 
-  MainSequence main_seq;
-  main_seq.init_test(fixture.ctx());
+  OffscreenRenderTarget target(fixture.instance(), fixture.device(), 256, 256);
 
-  // Create sequence
-  auto seq = std::make_shared<Sequence>();
+  class TestSequence : public SequenceV2 {
+  public:
+    TestSequence(const GpuContext& ctx, int w, int h) : SequenceV2(ctx, w, h) {
+      auto effect = std::make_shared<PassthroughEffectV2>(
+          ctx, std::vector<std::string>{"source"},
+          std::vector<std::string>{"sink"});
 
-  // Create effect
-  auto effect = std::make_shared<FlashEffect>(fixture.ctx());
+      effect_dag_.push_back({effect, {"source"}, {"sink"}, 0});
+      init_effect_nodes();
+    }
+  };
 
-  assert(!effect->is_initialized &&
-         "Effect should not be initialized before Sequence::init()");
+  auto seq = std::make_unique<TestSequence>(fixture.ctx(), 256, 256);
+  seq->set_sink_view(target.view());
+  seq->set_source_view(target.view());
 
-  // Add effect to sequence (time range: 0.0 - 10.0, priority 0)
-  seq->add_effect(effect, 0.0f, 10.0f, 0);
+  // Create encoder and attempt render
+  WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(
+      fixture.device(), nullptr);
 
-  // Initialize sequence (this should initialize the effect)
-  seq->init(&main_seq);
+  seq->render_effects(encoder);
 
-  assert(effect->is_initialized &&
-         "Effect should be initialized after Sequence::init()");
+  WGPUCommandBuffer commands = wgpuCommandEncoderFinish(encoder, nullptr);
+  wgpuQueueSubmit(fixture.queue(), 1, &commands);
+  wgpuCommandBufferRelease(commands);
 
-  fprintf(stdout,
-          "  ✓ Effect added to sequence and initialized (time=0.0-10.0, "
-          "priority=0)\n");
+  fprintf(stdout, "  ✓ Sequence rendered without error\n");
 }
 
-// Test 6: Sequence activation logic
-static void test_sequence_activation() {
-  fprintf(stdout, "Testing sequence activation logic...\n");
+// Test 6: Sequence time-based parameters
+static void test_sequence_time_params() {
+  fprintf(stdout, "Testing sequence time parameters...\n");
 
   WebGPUTestFixture fixture;
   if (!fixture.init()) {
@@ -165,51 +172,31 @@ static void test_sequence_activation() {
     return;
   }
 
-  MainSequence main_seq;
-  main_seq.init_test(fixture.ctx());
-
-  auto seq = std::make_shared<Sequence>();
-  auto effect = std::make_shared<FlashEffect>(fixture.ctx());
-
-  // Effect active from 5.0 to 10.0 seconds
-  seq->add_effect(effect, 5.0f, 10.0f, 0);
-  seq->init(&main_seq);
-
-  // Before start time: should not be active
-  seq->update_active_list(-1.0f);
-  std::vector<SequenceItem*> scene_before, post_before;
-  seq->collect_active_effects(scene_before, post_before);
-  assert(scene_before.empty() && post_before.empty() &&
-         "Effect should not be active before start time");
-
-  fprintf(stdout, "  ✓ Effect not active before start time (t=-1.0)\n");
+  class TestSequence : public SequenceV2 {
+  public:
+    TestSequence(const GpuContext& ctx, int w, int h) : SequenceV2(ctx, w, h) {
+      init_effect_nodes();
+    }
 
-  // At start time: should be active
-  seq->update_active_list(5.0f);
-  std::vector<SequenceItem*> scene_at_start, post_at_start;
-  seq->collect_active_effects(scene_at_start, post_at_start);
-  const size_t active_at_start = scene_at_start.size() + post_at_start.size();
-  assert(active_at_start == 1 && "Effect should be active at start time");
+    void preprocess(float seq_time, float beat_time, float beat_phase,
+                    float audio_intensity) override {
+      SequenceV2::preprocess(seq_time, beat_time, beat_phase, audio_intensity);
+      last_time = seq_time;
+    }
 
-  fprintf(stdout, "  ✓ Effect active at start time (t=5.0)\n");
+    float last_time = -1.0f;
+  };
 
-  // During active period: should remain active
-  seq->update_active_list(7.5f);
-  std::vector<SequenceItem*> scene_during, post_during;
-  seq->collect_active_effects(scene_during, post_during);
-  const size_t active_during = scene_during.size() + post_during.size();
-  assert(active_during == 1 && "Effect should be active during period");
+  auto seq = std::make_unique<TestSequence>(fixture.ctx(), 256, 256);
 
-  fprintf(stdout, "  ✓ Effect active during period (t=7.5)\n");
+  // Test different time values
+  seq->preprocess(0.0f, 0.0f, 0.0f, 0.0f);
+  assert(seq->last_time == 0.0f && "Time at t=0");
 
-  // After end time: should not be active
-  seq->update_active_list(11.0f);
-  std::vector<SequenceItem*> scene_after, post_after;
-  seq->collect_active_effects(scene_after, post_after);
-  assert(scene_after.empty() && post_after.empty() &&
-         "Effect should not be active after end time");
+  seq->preprocess(5.5f, 10.0f, 0.5f, 0.8f);
+  assert(seq->last_time == 5.5f && "Time at t=5.5");
 
-  fprintf(stdout, "  ✓ Effect not active after end time (t=11.0)\n");
+  fprintf(stdout, "  ✓ Sequence time parameters updated correctly\n");
 }
 
 // Test 7: Pixel validation helpers
@@ -255,9 +242,9 @@ int main() {
   test_webgpu_fixture();
   test_offscreen_render_target();
   test_effect_construction();
-  test_effect_initialization();
-  test_sequence_add_effect();
-  test_sequence_activation();
+  test_effect_in_sequence();
+  test_sequence_render();
+  test_sequence_time_params();
   test_pixel_helpers();
 
   fprintf(stdout, "=== All Effect Base Tests Passed ===\n");