diff options
Diffstat (limited to 'src')
31 files changed, 220 insertions, 248 deletions
diff --git a/src/generated/test_demo_timeline.cc b/src/generated/test_demo_timeline.cc index 75c5fe6..8b80d15 100644 --- a/src/generated/test_demo_timeline.cc +++ b/src/generated/test_demo_timeline.cc @@ -6,10 +6,10 @@ float GetDemoDuration() { return 16.000000f; } -void LoadTimeline(MainSequence& main_seq, WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format) { +void LoadTimeline(MainSequence& main_seq, const GpuContext& ctx) { { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.0f, 16.0f, 0); + seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.0f, 16.0f, 0); main_seq.add_sequence(seq, 0.0f, 0); } } diff --git a/src/generated/timeline.cc b/src/generated/timeline.cc index cd03b77..1facf8f 100644 --- a/src/generated/timeline.cc +++ b/src/generated/timeline.cc @@ -6,118 +6,118 @@ float GetDemoDuration() { return 32.500000f; } -void LoadTimeline(MainSequence& main_seq, WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format) { +void LoadTimeline(MainSequence& main_seq, const GpuContext& ctx) { { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<FlashCubeEffect>(device, queue, format), .2f, 1.500000f, -1); - seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.0f, 1.f, 0); - seq->add_effect(std::make_shared<FadeEffect>(device, queue, format), 0.1f, 1.f, 1); - seq->add_effect(std::make_shared<SolarizeEffect>(device, queue, format), 0.000000f, 2.000000f, 2); + seq->add_effect(std::make_shared<FlashCubeEffect>(ctx), .2f, 1.500000f, -1); + seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.0f, 1.f, 0); + seq->add_effect(std::make_shared<FadeEffect>(ctx), 0.1f, 1.f, 1); + seq->add_effect(std::make_shared<SolarizeEffect>(ctx), 0.000000f, 2.000000f, 2); main_seq.add_sequence(seq, 0.000000f, 0); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<FlashCubeEffect>(device, queue, format), 0.1f, 3.f, -1); - seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.0f, 0.2f, 0); + seq->add_effect(std::make_shared<FlashCubeEffect>(ctx), 0.1f, 3.f, -1); + seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.0f, 0.2f, 0); main_seq.add_sequence(seq, 2.000000f, 0); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.0f, .2f, 0); - seq->add_effect(std::make_shared<FadeEffect>(device, queue, format), 0.1f, 1.0f, 1); + seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.0f, .2f, 0); + seq->add_effect(std::make_shared<FadeEffect>(ctx), 0.1f, 1.0f, 1); main_seq.add_sequence(seq, 3.500000f, 0); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 2.000000f, 0); - seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.000000f, 8.000000f, 1); - seq->add_effect(std::make_shared<ChromaAberrationEffect>(device, queue, format), 0.000000f, 8.000000f, 2); - seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 3); + seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 2.000000f, 0); + seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.000000f, 8.000000f, 1); + seq->add_effect(std::make_shared<ChromaAberrationEffect>(ctx), 0.000000f, 8.000000f, 2); + seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 3); main_seq.add_sequence(seq, 16.000000f, 0); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 2.000000f, 0); - seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.2f, 2.0f, 1); - seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 2); - seq->add_effect(std::make_shared<SolarizeEffect>(device, queue, format), 0.000000f, 1.000000f, 3); + seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 2.000000f, 0); + seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.2f, 2.0f, 1); + seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 2); + seq->add_effect(std::make_shared<SolarizeEffect>(ctx), 0.000000f, 1.000000f, 3); main_seq.add_sequence(seq, 24.000000f, 0); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 4.000000f, 0); - seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.2f, 2.0f, 0); - seq->add_effect(std::make_shared<Hybrid3DEffect>(device, queue, format), 0.000000f, 2.000000f, 1); - seq->add_effect(std::make_shared<ParticleSprayEffect>(device, queue, format), 0.000000f, 4.000000f, 2); - seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.000000f, 8.000000f, 3); - seq->add_effect(std::make_shared<ChromaAberrationEffect>(device, queue, format), 0.000000f, 8.000000f, 4); - seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 5); + seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 4.000000f, 0); + seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.2f, 2.0f, 0); + seq->add_effect(std::make_shared<Hybrid3DEffect>(ctx), 0.000000f, 2.000000f, 1); + seq->add_effect(std::make_shared<ParticleSprayEffect>(ctx), 0.000000f, 4.000000f, 2); + seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.000000f, 8.000000f, 3); + seq->add_effect(std::make_shared<ChromaAberrationEffect>(ctx), 0.000000f, 8.000000f, 4); + seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 5); main_seq.add_sequence(seq, 28.000000f, 0); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 1.500000f, 0); - seq->add_effect(std::make_shared<SolarizeEffect>(device, queue, format), 0.000000f, 1.500000f, 1); + seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 1.500000f, 0); + seq->add_effect(std::make_shared<SolarizeEffect>(ctx), 0.000000f, 1.500000f, 1); main_seq.add_sequence(seq, 31.000000f, 0); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<ParticleSprayEffect>(device, queue, format), 0.000000f, 2.000000f, 0); - seq->add_effect(std::make_shared<ParticlesEffect>(device, queue, format), 0.000000f, 2.000000f, 1); - seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 1); + seq->add_effect(std::make_shared<ParticleSprayEffect>(ctx), 0.000000f, 2.000000f, 0); + seq->add_effect(std::make_shared<ParticlesEffect>(ctx), 0.000000f, 2.000000f, 1); + seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 1); main_seq.add_sequence(seq, 3.000000f, 1); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 4.000000f, 0); - seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.2f, 2.0f, 1); - seq->add_effect(std::make_shared<ParticleSprayEffect>(device, queue, format), 0.000000f, 4.000000f, 2); - seq->add_effect(std::make_shared<Hybrid3DEffect>(device, queue, format), 0.000000f, 10.000000f, 3); - seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 4); - seq->add_effect(std::make_shared<ChromaAberrationEffect>(device, queue, format), 0.000000f, 5.000000f, 5); - seq->add_effect(std::make_shared<SolarizeEffect>(device, queue, format), 0.000000f, 5.000000f, 6); + seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 4.000000f, 0); + seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.2f, 2.0f, 1); + seq->add_effect(std::make_shared<ParticleSprayEffect>(ctx), 0.000000f, 4.000000f, 2); + seq->add_effect(std::make_shared<Hybrid3DEffect>(ctx), 0.000000f, 10.000000f, 3); + seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 4); + seq->add_effect(std::make_shared<ChromaAberrationEffect>(ctx), 0.000000f, 5.000000f, 5); + seq->add_effect(std::make_shared<SolarizeEffect>(ctx), 0.000000f, 5.000000f, 6); main_seq.add_sequence(seq, 12.000000f, 1); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<FlashCubeEffect>(device, queue, format), .2f, 1.500000f, -1); - seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.000000f, 2.000000f, 0); - seq->add_effect(std::make_shared<ParticleSprayEffect>(device, queue, format), 0.000000f, 2.000000f, 1); - seq->add_effect(std::make_shared<ParticlesEffect>(device, queue, format), 0.000000f, 2.000000f, 2); + seq->add_effect(std::make_shared<FlashCubeEffect>(ctx), .2f, 1.500000f, -1); + seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.000000f, 2.000000f, 0); + seq->add_effect(std::make_shared<ParticleSprayEffect>(ctx), 0.000000f, 2.000000f, 1); + seq->add_effect(std::make_shared<ParticlesEffect>(ctx), 0.000000f, 2.000000f, 2); main_seq.add_sequence(seq, 6.000000f, 2); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<FlashCubeEffect>(device, queue, format), .2f, 1.500000f, -1); - seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.0f, 0.500000f, 0); + seq->add_effect(std::make_shared<FlashCubeEffect>(ctx), .2f, 1.500000f, -1); + seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.0f, 0.500000f, 0); main_seq.add_sequence(seq, 7.500000f, 2); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 2.000000f, 0); - seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.2f, 2.0f, 1); - seq->add_effect(std::make_shared<ParticleSprayEffect>(device, queue, format), 0.000000f, 2.000000f, 2); - seq->add_effect(std::make_shared<ParticlesEffect>(device, queue, format), 0.000000f, 2.000000f, 2); - seq->add_effect(std::make_shared<Hybrid3DEffect>(device, queue, format), 0.000000f, 2.000000f, 3); - seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 4); - seq->add_effect(std::make_shared<ChromaAberrationEffect>(device, queue, format), 0.000000f, 3.000000f, 5); + seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 2.000000f, 0); + seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.2f, 2.0f, 1); + seq->add_effect(std::make_shared<ParticleSprayEffect>(ctx), 0.000000f, 2.000000f, 2); + seq->add_effect(std::make_shared<ParticlesEffect>(ctx), 0.000000f, 2.000000f, 2); + seq->add_effect(std::make_shared<Hybrid3DEffect>(ctx), 0.000000f, 2.000000f, 3); + seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 4); + seq->add_effect(std::make_shared<ChromaAberrationEffect>(ctx), 0.000000f, 3.000000f, 5); main_seq.add_sequence(seq, 8.500000f, 2); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<ThemeModulationEffect>(device, queue, format), 0.000000f, 2.000000f, 0); - seq->add_effect(std::make_shared<HeptagonEffect>(device, queue, format), 0.0f, 4.0f, 0); - seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 1); - seq->add_effect(std::make_shared<ChromaAberrationEffect>(device, queue, format), 0.000000f, 3.000000f, 2); - seq->add_effect(std::make_shared<SolarizeEffect>(device, queue, format), 0.000000f, 5.000000f, 3); + seq->add_effect(std::make_shared<ThemeModulationEffect>(ctx), 0.000000f, 2.000000f, 0); + seq->add_effect(std::make_shared<HeptagonEffect>(ctx), 0.0f, 4.0f, 0); + seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 1); + seq->add_effect(std::make_shared<ChromaAberrationEffect>(ctx), 0.000000f, 3.000000f, 2); + seq->add_effect(std::make_shared<SolarizeEffect>(ctx), 0.000000f, 5.000000f, 3); main_seq.add_sequence(seq, 4.000000f, 3); } { auto seq = std::make_shared<Sequence>(); - seq->add_effect(std::make_shared<FlashCubeEffect>(device, queue, format), .2f, 1.500000f, -1); - seq->add_effect(std::make_shared<GaussianBlurEffect>(device, queue, format), 0.000000f, 4.000000f, 0); - seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.0f, 0.2f, 1); - seq->add_effect(std::make_shared<FlashEffect>(device, queue, format), 0.500000f, 0.2f, 1); + seq->add_effect(std::make_shared<FlashCubeEffect>(ctx), .2f, 1.500000f, -1); + seq->add_effect(std::make_shared<GaussianBlurEffect>(ctx), 0.000000f, 4.000000f, 0); + seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.0f, 0.2f, 1); + seq->add_effect(std::make_shared<FlashEffect>(ctx), 0.500000f, 0.2f, 1); main_seq.add_sequence(seq, 8.000000f, 10); } } diff --git a/src/gpu/demo_effects.h b/src/gpu/demo_effects.h index 4b96ba7..cddd04b 100644 --- a/src/gpu/demo_effects.h +++ b/src/gpu/demo_effects.h @@ -23,7 +23,7 @@ struct Particle { class HeptagonEffect : public Effect { public: - HeptagonEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + HeptagonEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; @@ -33,7 +33,7 @@ class HeptagonEffect : public Effect { class ParticlesEffect : public Effect { public: - ParticlesEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + ParticlesEffect(const GpuContext& ctx); void compute(WGPUCommandEncoder encoder, float time, float beat, float intensity, float aspect_ratio) override; void render(WGPURenderPassEncoder pass, float time, float beat, @@ -47,15 +47,13 @@ class ParticlesEffect : public Effect { class PassthroughEffect : public PostProcessEffect { public: - PassthroughEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format); + PassthroughEffect(const GpuContext& ctx); void update_bind_group(WGPUTextureView input_view) override; }; class MovingEllipseEffect : public Effect { public: - MovingEllipseEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format); + MovingEllipseEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; @@ -65,8 +63,7 @@ class MovingEllipseEffect : public Effect { class ParticleSprayEffect : public Effect { public: - ParticleSprayEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format); + ParticleSprayEffect(const GpuContext& ctx); void compute(WGPUCommandEncoder encoder, float time, float beat, float intensity, float aspect_ratio) override; void render(WGPURenderPassEncoder pass, float time, float beat, @@ -80,8 +77,7 @@ class ParticleSprayEffect : public Effect { class GaussianBlurEffect : public PostProcessEffect { public: - GaussianBlurEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format); + GaussianBlurEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; void update_bind_group(WGPUTextureView input_view) override; @@ -89,7 +85,7 @@ class GaussianBlurEffect : public PostProcessEffect { class SolarizeEffect : public PostProcessEffect { public: - SolarizeEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + SolarizeEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; void update_bind_group(WGPUTextureView input_view) override; @@ -97,7 +93,7 @@ class SolarizeEffect : public PostProcessEffect { class DistortEffect : public PostProcessEffect { public: - DistortEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + DistortEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; void update_bind_group(WGPUTextureView input_view) override; @@ -105,8 +101,7 @@ class DistortEffect : public PostProcessEffect { class ChromaAberrationEffect : public PostProcessEffect { public: - ChromaAberrationEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format); + ChromaAberrationEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; void update_bind_group(WGPUTextureView input_view) override; @@ -114,7 +109,7 @@ class ChromaAberrationEffect : public PostProcessEffect { class Hybrid3DEffect : public Effect { public: - Hybrid3DEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + Hybrid3DEffect(const GpuContext& ctx); void init(MainSequence* demo) override; void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; @@ -130,7 +125,7 @@ class Hybrid3DEffect : public Effect { class FlashCubeEffect : public Effect { public: - FlashCubeEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + FlashCubeEffect(const GpuContext& ctx); void init(MainSequence* demo) override; void resize(int width, int height) override; void render(WGPURenderPassEncoder pass, float time, float beat, @@ -149,8 +144,7 @@ class FlashCubeEffect : public Effect { class ThemeModulationEffect : public PostProcessEffect { public: - ThemeModulationEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format); + ThemeModulationEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; void update_bind_group(WGPUTextureView input_view) override; @@ -158,7 +152,7 @@ class ThemeModulationEffect : public PostProcessEffect { class FadeEffect : public PostProcessEffect { public: - FadeEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + FadeEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; void update_bind_group(WGPUTextureView input_view) override; @@ -166,7 +160,7 @@ class FadeEffect : public PostProcessEffect { class FlashEffect : public PostProcessEffect { public: - FlashEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + FlashEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; void update_bind_group(WGPUTextureView input_view) override; @@ -176,7 +170,6 @@ class FlashEffect : public PostProcessEffect { }; // Auto-generated functions -void LoadTimeline(MainSequence& main_seq, WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format); +void LoadTimeline(MainSequence& main_seq, const GpuContext& ctx); float GetDemoDuration(); // Returns demo end time in seconds, or -1 if not // specified
\ No newline at end of file diff --git a/src/gpu/effect.cc b/src/gpu/effect.cc index b95c4ce..ea5230d 100644 --- a/src/gpu/effect.cc +++ b/src/gpu/effect.cc @@ -117,16 +117,16 @@ void MainSequence::create_framebuffers(int width, int height) { WGPUTextureUsage_RenderAttachment | WGPUTextureUsage_TextureBinding; desc.dimension = WGPUTextureDimension_2D; desc.size = {(uint32_t)width, (uint32_t)height, 1}; - desc.format = format; + desc.format = gpu_ctx.format; desc.mipLevelCount = 1; desc.sampleCount = 1; - framebuffer_a_ = wgpuDeviceCreateTexture(device, &desc); - framebuffer_b_ = wgpuDeviceCreateTexture(device, &desc); + framebuffer_a_ = wgpuDeviceCreateTexture(gpu_ctx.device, &desc); + framebuffer_b_ = wgpuDeviceCreateTexture(gpu_ctx.device, &desc); WGPUTextureViewDescriptor view_desc = {}; view_desc.dimension = WGPUTextureViewDimension_2D; - view_desc.format = format; + view_desc.format = gpu_ctx.format; view_desc.mipLevelCount = 1; view_desc.arrayLayerCount = 1; @@ -141,7 +141,7 @@ void MainSequence::create_framebuffers(int width, int height) { depth_desc.format = WGPUTextureFormat_Depth24Plus; depth_desc.mipLevelCount = 1; depth_desc.sampleCount = 1; - depth_texture_ = wgpuDeviceCreateTexture(device, &depth_desc); + depth_texture_ = wgpuDeviceCreateTexture(gpu_ctx.device, &depth_desc); WGPUTextureViewDescriptor depth_view_desc = {}; depth_view_desc.format = WGPUTextureFormat_Depth24Plus; @@ -152,25 +152,20 @@ void MainSequence::create_framebuffers(int width, int height) { depth_view_ = wgpuTextureCreateView(depth_texture_, &depth_view_desc); } -void MainSequence::init_test(WGPUDevice d, WGPUQueue q, WGPUTextureFormat f) { - device = d; - queue = q; - format = f; +void MainSequence::init_test(const GpuContext& ctx) { + gpu_ctx = ctx; // No framebuffers or passthrough effect created in test mode. // Test effects should not rely on these being real. } -void MainSequence::init(WGPUDevice d, WGPUQueue q, WGPUTextureFormat f, - int width, int height) { - device = d; - queue = q; - format = f; +void MainSequence::init(const GpuContext& ctx, int width, int height) { + gpu_ctx = ctx; width_ = width; height_ = height; create_framebuffers(width, height); passthrough_effect_ = - std::make_unique<PassthroughEffect>(device, queue, format); + std::make_unique<PassthroughEffect>(gpu_ctx); passthrough_effect_->resize(width, height); for (ActiveSequence& entry : sequences_) { @@ -183,7 +178,7 @@ void MainSequence::add_sequence(std::shared_ptr<Sequence> seq, float start_time, int priority) { sequences_.push_back({seq, start_time, priority}); // If MainSequence is already initialized, init the new sequence immediately - if (device) { + if (gpu_ctx.device) { seq->init(this); seq->resize(width_, height_); } @@ -225,7 +220,7 @@ void MainSequence::resize(int width, int height) { void MainSequence::render_frame(float global_time, float beat, float peak, float aspect_ratio, WGPUSurface surface) { - WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(device, nullptr); + WGPUCommandEncoder encoder = wgpuDeviceCreateCommandEncoder(gpu_ctx.device, nullptr); std::vector<SequenceItem*> scene_effects; std::vector<SequenceItem*> post_effects; @@ -360,7 +355,7 @@ void MainSequence::render_frame(float global_time, float beat, float peak, } WGPUCommandBuffer commands = wgpuCommandEncoderFinish(encoder, nullptr); - wgpuQueueSubmit(queue, 1, &commands); + wgpuQueueSubmit(gpu_ctx.queue, 1, &commands); if (st.texture) { wgpuTextureViewRelease(final_view); @@ -393,7 +388,7 @@ void MainSequence::simulate_until(float target_time, float step_rate) { const float aspect_ratio = 16.0f / 9.0f; for (float t = 0.0f; t < target_time; t += step_rate) { WGPUCommandEncoder encoder = - wgpuDeviceCreateCommandEncoder(device, nullptr); + wgpuDeviceCreateCommandEncoder(gpu_ctx.device, nullptr); float beat = fmodf(t * bpm / 60.0f, 1.0f); std::vector<SequenceItem*> scene_effects, post_effects; for (ActiveSequence& entry : sequences_) { @@ -407,7 +402,7 @@ void MainSequence::simulate_until(float target_time, float step_rate) { aspect_ratio); } WGPUCommandBuffer commands = wgpuCommandEncoderFinish(encoder, nullptr); - wgpuQueueSubmit(queue, 1, &commands); + wgpuQueueSubmit(gpu_ctx.queue, 1, &commands); } } #endif /* !defined(STRIP_ALL) */ diff --git a/src/gpu/effect.h b/src/gpu/effect.h index 0cc9de5..006ee6f 100644 --- a/src/gpu/effect.h +++ b/src/gpu/effect.h @@ -9,7 +9,7 @@ class PostProcessEffect; class Effect { public: - Effect(WGPUDevice device, WGPUQueue queue) : device_(device), queue_(queue) { + Effect(const GpuContext& ctx) : device_(ctx.device), queue_(ctx.queue), format_(ctx.format) { } virtual ~Effect() = default; virtual void init(MainSequence* demo) { @@ -42,6 +42,7 @@ class Effect { protected: WGPUDevice device_; WGPUQueue queue_; + WGPUTextureFormat format_; GpuBuffer uniforms_; int width_ = 1280; int height_ = 720; @@ -49,8 +50,8 @@ class Effect { class PostProcessEffect : public Effect { public: - PostProcessEffect(WGPUDevice device, WGPUQueue queue) - : Effect(device, queue) { + PostProcessEffect(const GpuContext& ctx) + : Effect(ctx) { } bool is_post_process() const override { return true; @@ -103,13 +104,10 @@ class MainSequence { public: MainSequence(); ~MainSequence(); - WGPUDevice device; - WGPUQueue queue; - WGPUTextureFormat format; + GpuContext gpu_ctx; - void init(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format, - int width, int height); - void init_test(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + void init(const GpuContext& ctx, int width, int height); + void init_test(const GpuContext& ctx); void add_sequence(std::shared_ptr<Sequence> seq, float start_time, int priority = 0); void render_frame(float global_time, float beat, float peak, diff --git a/src/gpu/effects/chroma_aberration_effect.cc b/src/gpu/effects/chroma_aberration_effect.cc index 6e64988..83c5f2a 100644 --- a/src/gpu/effects/chroma_aberration_effect.cc +++ b/src/gpu/effects/chroma_aberration_effect.cc @@ -5,14 +5,12 @@ #include "gpu/gpu.h" // --- ChromaAberrationEffect --- -ChromaAberrationEffect::ChromaAberrationEffect(WGPUDevice device, - WGPUQueue queue, - WGPUTextureFormat format) - : PostProcessEffect(device, queue) { +ChromaAberrationEffect::ChromaAberrationEffect(const GpuContext& ctx) + : PostProcessEffect(ctx) { uniforms_ = gpu_create_buffer(device_, sizeof(float) * 6, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); - pipeline_ = create_post_process_pipeline(device_, format, + pipeline_ = create_post_process_pipeline(device_, format_, chroma_aberration_shader_wgsl); } void ChromaAberrationEffect::render(WGPURenderPassEncoder pass, float t, diff --git a/src/gpu/effects/distort_effect.cc b/src/gpu/effects/distort_effect.cc index 0d4bb36..abaa2e7 100644 --- a/src/gpu/effects/distort_effect.cc +++ b/src/gpu/effects/distort_effect.cc @@ -5,14 +5,13 @@ #include "gpu/gpu.h" // --- DistortEffect --- -DistortEffect::DistortEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : PostProcessEffect(device, queue) { +DistortEffect::DistortEffect(const GpuContext& ctx) + : PostProcessEffect(ctx) { uniforms_ = gpu_create_buffer(device_, sizeof(float) * 6, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); pipeline_ = - create_post_process_pipeline(device_, format, distort_shader_wgsl); + create_post_process_pipeline(device_, format_, distort_shader_wgsl); } void DistortEffect::render(WGPURenderPassEncoder pass, float t, float b, float i, float a) { diff --git a/src/gpu/effects/fade_effect.cc b/src/gpu/effects/fade_effect.cc index 4d7633c..dce2360 100644 --- a/src/gpu/effects/fade_effect.cc +++ b/src/gpu/effects/fade_effect.cc @@ -5,9 +5,8 @@ #include "gpu/effects/post_process_helper.h" #include <cmath> -FadeEffect::FadeEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : PostProcessEffect(device, queue) { +FadeEffect::FadeEffect(const GpuContext& ctx) + : PostProcessEffect(ctx) { const char* shader_code = R"( struct VertexOutput { @builtin(position) position: vec4<f32>, @@ -46,9 +45,9 @@ FadeEffect::FadeEffect(WGPUDevice device, WGPUQueue queue, } )"; - pipeline_ = create_post_process_pipeline(device, format, shader_code); + pipeline_ = create_post_process_pipeline(device_, format_, shader_code); uniforms_ = gpu_create_buffer( - device, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); + device_, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); } void FadeEffect::update_bind_group(WGPUTextureView input_view) { diff --git a/src/gpu/effects/fade_effect.h b/src/gpu/effects/fade_effect.h index fc91646..2048c2a 100644 --- a/src/gpu/effects/fade_effect.h +++ b/src/gpu/effects/fade_effect.h @@ -8,7 +8,7 @@ class FadeEffect : public PostProcessEffect { public: - FadeEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + FadeEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; void update_bind_group(WGPUTextureView input_view) override; diff --git a/src/gpu/effects/flash_cube_effect.cc b/src/gpu/effects/flash_cube_effect.cc index 75c71e1..4f58562 100644 --- a/src/gpu/effects/flash_cube_effect.cc +++ b/src/gpu/effects/flash_cube_effect.cc @@ -8,10 +8,8 @@ #include <cmath> #include <iostream> -FlashCubeEffect::FlashCubeEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : Effect(device, queue) { - (void)format; +FlashCubeEffect::FlashCubeEffect(const GpuContext& ctx) + : Effect(ctx) { } void FlashCubeEffect::resize(int width, int height) { @@ -22,9 +20,9 @@ void FlashCubeEffect::resize(int width, int height) { void FlashCubeEffect::init(MainSequence* demo) { (void)demo; - WGPUTextureFormat format = demo->format; + WGPUTextureFormat format = demo->gpu_ctx.format; - renderer_.init(device_, queue_, format); + renderer_.init(device_, queue_, format_); renderer_.resize(width_, height_); // Texture Manager diff --git a/src/gpu/effects/flash_cube_effect.h b/src/gpu/effects/flash_cube_effect.h index 3af13eb..7089af2 100644 --- a/src/gpu/effects/flash_cube_effect.h +++ b/src/gpu/effects/flash_cube_effect.h @@ -11,7 +11,7 @@ class FlashCubeEffect : public Effect { public: - FlashCubeEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + FlashCubeEffect(const GpuContext& ctx); void init(MainSequence* demo) override; void resize(int width, int height) override; void render(WGPURenderPassEncoder pass, float time, float beat, diff --git a/src/gpu/effects/flash_effect.cc b/src/gpu/effects/flash_effect.cc index 176c60c..3dcb48a 100644 --- a/src/gpu/effects/flash_effect.cc +++ b/src/gpu/effects/flash_effect.cc @@ -5,9 +5,8 @@ #include "gpu/effects/post_process_helper.h" #include <cmath> -FlashEffect::FlashEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : PostProcessEffect(device, queue) { +FlashEffect::FlashEffect(const GpuContext& ctx) + : PostProcessEffect(ctx) { const char* shader_code = R"( struct VertexOutput { @builtin(position) position: vec4<f32>, @@ -48,9 +47,9 @@ FlashEffect::FlashEffect(WGPUDevice device, WGPUQueue queue, } )"; - pipeline_ = create_post_process_pipeline(device, format, shader_code); + pipeline_ = create_post_process_pipeline(device_, format_, shader_code); uniforms_ = gpu_create_buffer( - device, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); + device_, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); } void FlashEffect::update_bind_group(WGPUTextureView input_view) { diff --git a/src/gpu/effects/flash_effect.h b/src/gpu/effects/flash_effect.h index 9aa2c67..6be375d 100644 --- a/src/gpu/effects/flash_effect.h +++ b/src/gpu/effects/flash_effect.h @@ -8,7 +8,7 @@ class FlashEffect : public PostProcessEffect { public: - FlashEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + FlashEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; void update_bind_group(WGPUTextureView input_view) override; diff --git a/src/gpu/effects/gaussian_blur_effect.cc b/src/gpu/effects/gaussian_blur_effect.cc index ad9bf4b..72a93b8 100644 --- a/src/gpu/effects/gaussian_blur_effect.cc +++ b/src/gpu/effects/gaussian_blur_effect.cc @@ -5,14 +5,13 @@ #include "gpu/gpu.h" // --- GaussianBlurEffect --- -GaussianBlurEffect::GaussianBlurEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : PostProcessEffect(device, queue) { +GaussianBlurEffect::GaussianBlurEffect(const GpuContext& ctx) + : PostProcessEffect(ctx) { uniforms_ = gpu_create_buffer(device_, sizeof(float) * 6, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); pipeline_ = - create_post_process_pipeline(device_, format, gaussian_blur_shader_wgsl); + create_post_process_pipeline(device_, format_, gaussian_blur_shader_wgsl); } void GaussianBlurEffect::render(WGPURenderPassEncoder pass, float t, float b, float i, float a) { diff --git a/src/gpu/effects/heptagon_effect.cc b/src/gpu/effects/heptagon_effect.cc index c982912..024f076 100644 --- a/src/gpu/effects/heptagon_effect.cc +++ b/src/gpu/effects/heptagon_effect.cc @@ -5,15 +5,14 @@ #include "gpu/gpu.h" // --- HeptagonEffect --- -HeptagonEffect::HeptagonEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : Effect(device, queue) { +HeptagonEffect::HeptagonEffect(const GpuContext& ctx) + : Effect(ctx) { uniforms_ = gpu_create_buffer(device_, sizeof(float) * 4, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); ResourceBinding bindings[] = {{uniforms_, WGPUBufferBindingType_Uniform}}; pass_ = - gpu_create_render_pass(device_, format, main_shader_wgsl, bindings, 1); + gpu_create_render_pass(device_, format_, main_shader_wgsl, bindings, 1); pass_.vertex_count = 21; } void HeptagonEffect::render(WGPURenderPassEncoder pass, float t, float b, diff --git a/src/gpu/effects/hybrid_3d_effect.cc b/src/gpu/effects/hybrid_3d_effect.cc index 8c70c07..6f89bf3 100644 --- a/src/gpu/effects/hybrid_3d_effect.cc +++ b/src/gpu/effects/hybrid_3d_effect.cc @@ -8,10 +8,8 @@ #include <cmath> #include <iostream> -Hybrid3DEffect::Hybrid3DEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : Effect(device, queue) { - (void)format; // Passed to base, not directly used here. +Hybrid3DEffect::Hybrid3DEffect(const GpuContext& ctx) + : Effect(ctx) { } void Hybrid3DEffect::resize(int width, int height) { @@ -23,10 +21,10 @@ void Hybrid3DEffect::resize(int width, int height) { void Hybrid3DEffect::init(MainSequence* demo) { (void)demo; WGPUTextureFormat format = - demo->format; // Get current format from MainSequence (might be different - // than constructor if resized) + demo->gpu_ctx.format; // Get current format from MainSequence (might be different + // than constructor if resized) - renderer_.init(device_, queue_, format); + renderer_.init(device_, queue_, format_); renderer_.resize(width_, height_); // Texture Manager diff --git a/src/gpu/effects/hybrid_3d_effect.h b/src/gpu/effects/hybrid_3d_effect.h index 8e2fef9..3a4e87c 100644 --- a/src/gpu/effects/hybrid_3d_effect.h +++ b/src/gpu/effects/hybrid_3d_effect.h @@ -12,7 +12,7 @@ class Hybrid3DEffect : public Effect { public: - Hybrid3DEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); + Hybrid3DEffect(const GpuContext& ctx); virtual ~Hybrid3DEffect() override = default; void init(MainSequence* demo) override; diff --git a/src/gpu/effects/moving_ellipse_effect.cc b/src/gpu/effects/moving_ellipse_effect.cc index 3b73697..1163215 100644 --- a/src/gpu/effects/moving_ellipse_effect.cc +++ b/src/gpu/effects/moving_ellipse_effect.cc @@ -5,15 +5,14 @@ #include "gpu/gpu.h" // --- MovingEllipseEffect --- -MovingEllipseEffect::MovingEllipseEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : Effect(device, queue) { +MovingEllipseEffect::MovingEllipseEffect(const GpuContext& ctx) + : Effect(ctx) { uniforms_ = gpu_create_buffer(device_, sizeof(float) * 6, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); ResourceBinding bindings[] = {{uniforms_, WGPUBufferBindingType_Uniform}}; pass_ = - gpu_create_render_pass(device_, format, ellipse_shader_wgsl, bindings, 1); + gpu_create_render_pass(device_, format_, ellipse_shader_wgsl, bindings, 1); pass_.vertex_count = 3; } void MovingEllipseEffect::render(WGPURenderPassEncoder pass, float t, float b, diff --git a/src/gpu/effects/particle_spray_effect.cc b/src/gpu/effects/particle_spray_effect.cc index e8ead0a..452017e 100644 --- a/src/gpu/effects/particle_spray_effect.cc +++ b/src/gpu/effects/particle_spray_effect.cc @@ -6,9 +6,8 @@ #include <vector> // --- ParticleSprayEffect --- -ParticleSprayEffect::ParticleSprayEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : Effect(device, queue) { +ParticleSprayEffect::ParticleSprayEffect(const GpuContext& ctx) + : Effect(ctx) { uniforms_ = gpu_create_buffer(device_, sizeof(float) * 6, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); @@ -27,7 +26,7 @@ ParticleSprayEffect::ParticleSprayEffect(WGPUDevice device, WGPUQueue queue, {particles_buffer_, WGPUBufferBindingType_ReadOnlyStorage}, {uniforms_, WGPUBufferBindingType_Uniform}}; render_pass_ = - gpu_create_render_pass(device_, format, particle_render_wgsl, rb, 2); + gpu_create_render_pass(device_, format_, particle_render_wgsl, rb, 2); render_pass_.vertex_count = 6; render_pass_.instance_count = NUM_PARTICLES; } diff --git a/src/gpu/effects/particles_effect.cc b/src/gpu/effects/particles_effect.cc index 6218af9..137150a 100644 --- a/src/gpu/effects/particles_effect.cc +++ b/src/gpu/effects/particles_effect.cc @@ -6,9 +6,8 @@ #include <vector> // --- ParticlesEffect --- -ParticlesEffect::ParticlesEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : Effect(device, queue) { +ParticlesEffect::ParticlesEffect(const GpuContext& ctx) + : Effect(ctx) { uniforms_ = gpu_create_buffer(device_, sizeof(float) * 4, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); @@ -25,7 +24,7 @@ ParticlesEffect::ParticlesEffect(WGPUDevice device, WGPUQueue queue, {particles_buffer_, WGPUBufferBindingType_ReadOnlyStorage}, {uniforms_, WGPUBufferBindingType_Uniform}}; render_pass_ = - gpu_create_render_pass(device_, format, particle_render_wgsl, rb, 2); + gpu_create_render_pass(device_, format_, particle_render_wgsl, rb, 2); render_pass_.vertex_count = 6; render_pass_.instance_count = NUM_PARTICLES; } diff --git a/src/gpu/effects/passthrough_effect.cc b/src/gpu/effects/passthrough_effect.cc index 7825c0a..203f912 100644 --- a/src/gpu/effects/passthrough_effect.cc +++ b/src/gpu/effects/passthrough_effect.cc @@ -5,14 +5,13 @@ #include "gpu/gpu.h" // --- PassthroughEffect --- -PassthroughEffect::PassthroughEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : PostProcessEffect(device, queue) { +PassthroughEffect::PassthroughEffect(const GpuContext& ctx) + : PostProcessEffect(ctx) { uniforms_ = gpu_create_buffer(device_, sizeof(float) * 6, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); pipeline_ = - create_post_process_pipeline(device_, format, passthrough_shader_wgsl); + create_post_process_pipeline(device_, format_, passthrough_shader_wgsl); } void PassthroughEffect::update_bind_group(WGPUTextureView input_view) { struct { diff --git a/src/gpu/effects/solarize_effect.cc b/src/gpu/effects/solarize_effect.cc index a0bc971..b6cf6f9 100644 --- a/src/gpu/effects/solarize_effect.cc +++ b/src/gpu/effects/solarize_effect.cc @@ -5,14 +5,13 @@ #include "gpu/gpu.h" // --- SolarizeEffect --- -SolarizeEffect::SolarizeEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : PostProcessEffect(device, queue) { +SolarizeEffect::SolarizeEffect(const GpuContext& ctx) + : PostProcessEffect(ctx) { uniforms_ = gpu_create_buffer(device_, sizeof(float) * 6, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); pipeline_ = - create_post_process_pipeline(device_, format, solarize_shader_wgsl); + create_post_process_pipeline(device_, format_, solarize_shader_wgsl); } void SolarizeEffect::render(WGPURenderPassEncoder pass, float t, float b, float i, float a) { diff --git a/src/gpu/effects/theme_modulation_effect.cc b/src/gpu/effects/theme_modulation_effect.cc index d2705d5..d0d71cb 100644 --- a/src/gpu/effects/theme_modulation_effect.cc +++ b/src/gpu/effects/theme_modulation_effect.cc @@ -6,9 +6,8 @@ #include "gpu/effects/shaders.h" #include <cmath> -ThemeModulationEffect::ThemeModulationEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : PostProcessEffect(device, queue) { +ThemeModulationEffect::ThemeModulationEffect(const GpuContext& ctx) + : PostProcessEffect(ctx) { const char* shader_code = R"( struct VertexOutput { @builtin(position) position: vec4<f32>, @@ -48,11 +47,11 @@ ThemeModulationEffect::ThemeModulationEffect(WGPUDevice device, WGPUQueue queue, } )"; - pipeline_ = create_post_process_pipeline(device, format, shader_code); + pipeline_ = create_post_process_pipeline(device_, format_, shader_code); // Create uniform buffer (4 floats: brightness + padding) uniforms_ = gpu_create_buffer( - device, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); + device_, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); } void ThemeModulationEffect::update_bind_group(WGPUTextureView input_view) { diff --git a/src/gpu/effects/theme_modulation_effect.h b/src/gpu/effects/theme_modulation_effect.h index ac584e2..ad7322e 100644 --- a/src/gpu/effects/theme_modulation_effect.h +++ b/src/gpu/effects/theme_modulation_effect.h @@ -8,8 +8,7 @@ class ThemeModulationEffect : public PostProcessEffect { public: - ThemeModulationEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format); + ThemeModulationEffect(const GpuContext& ctx); void render(WGPURenderPassEncoder pass, float time, float beat, float intensity, float aspect_ratio) override; void update_bind_group(WGPUTextureView input_view) override; diff --git a/src/gpu/gpu.cc b/src/gpu/gpu.cc index 63a30ff..fe71d3e 100644 --- a/src/gpu/gpu.cc +++ b/src/gpu/gpu.cc @@ -21,12 +21,13 @@ static WGPUInstance g_instance = nullptr; static WGPUAdapter g_adapter = nullptr; -WGPUDevice g_device = nullptr; // Non-static for external access (debug builds) -WGPUQueue g_queue = nullptr; // Non-static for external access (debug builds) +static WGPUDevice g_device = nullptr; +static WGPUQueue g_queue = nullptr; static WGPUSurface g_surface = nullptr; static WGPUSurfaceConfiguration g_config = {}; -WGPUTextureFormat g_format = WGPUTextureFormat_BGRA8Unorm; // Exposed for custom effects +static WGPUTextureFormat g_format = WGPUTextureFormat_BGRA8Unorm; +static GpuContext g_gpu_context = {}; static MainSequence g_main_sequence; // --- Helper Functions --- @@ -355,7 +356,12 @@ void gpu_init(PlatformState* platform_state) { g_config.device = g_device; g_config.format = swap_chain_format; - g_format = swap_chain_format; // Update global format for external access + g_format = swap_chain_format; + + // Update GPU context for accessor + g_gpu_context.device = g_device; + g_gpu_context.queue = g_queue; + g_gpu_context.format = g_format; g_config.usage = WGPUTextureUsage_RenderAttachment; g_config.width = platform_state->width; g_config.height = platform_state->height; @@ -365,10 +371,9 @@ void gpu_init(PlatformState* platform_state) { InitShaderComposer(); - g_main_sequence.init(g_device, g_queue, g_config.format, - platform_state->width, platform_state->height); + g_main_sequence.init(g_gpu_context, platform_state->width, platform_state->height); - LoadTimeline(g_main_sequence, g_device, g_queue, g_config.format); + LoadTimeline(g_main_sequence, g_gpu_context); } void gpu_draw(float audio_peak, float aspect_ratio, float time, float beat) { @@ -395,6 +400,10 @@ void gpu_add_custom_effect(Effect* effect, float start_time, float end_time, int seq->init(&g_main_sequence); g_main_sequence.add_sequence(seq, 0.0f, priority); } + +const GpuContext* gpu_get_context() { + return &g_gpu_context; +} #endif /* !defined(STRIP_ALL) */ void gpu_shutdown() { diff --git a/src/gpu/gpu.h b/src/gpu/gpu.h index b8f58b2..c4d1993 100644 --- a/src/gpu/gpu.h +++ b/src/gpu/gpu.h @@ -9,6 +9,13 @@ struct PlatformState; // Forward declaration class Effect; // Forward declaration +// GPU context bundling device, queue, and surface format +struct GpuContext { + WGPUDevice device; + WGPUQueue queue; + WGPUTextureFormat format; +}; + // Basic wrapper for WebGPU buffers struct GpuBuffer { WGPUBuffer buffer; @@ -39,10 +46,8 @@ void gpu_resize(int width, int height); void gpu_simulate_until(float time); void gpu_add_custom_effect(Effect* effect, float start_time, float end_time, int priority); -// Expose WebGPU globals for custom effects (debug builds only) -extern WGPUDevice g_device; -extern WGPUQueue g_queue; -extern WGPUTextureFormat g_format; +// Get GPU context for custom effects (debug builds only) +const GpuContext* gpu_get_context(); #endif void gpu_shutdown(); diff --git a/src/test_demo.cc b/src/test_demo.cc index 9ae0e3a..69b18cc 100644 --- a/src/test_demo.cc +++ b/src/test_demo.cc @@ -15,14 +15,14 @@ // External declarations from generated files extern float GetDemoDuration(); -extern void LoadTimeline(MainSequence& main_seq, WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format); +extern void LoadTimeline(MainSequence& main_seq, const GpuContext& ctx); // Inline peak meter effect for debugging audio-visual sync #include "gpu/effects/post_process_helper.h" class PeakMeterEffect : public PostProcessEffect { public: - PeakMeterEffect(WGPUDevice device, WGPUQueue queue, WGPUTextureFormat format) - : PostProcessEffect(device, queue) { + PeakMeterEffect(const GpuContext& ctx) + : PostProcessEffect(ctx) { const char* shader_code = R"( struct VertexOutput { @builtin(position) position: vec4<f32>, @@ -82,9 +82,9 @@ class PeakMeterEffect : public PostProcessEffect { } )"; - pipeline_ = create_post_process_pipeline(device, format, shader_code); + pipeline_ = create_post_process_pipeline(device_, format_, shader_code); uniforms_ = gpu_create_buffer( - device, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); + device_, 16, WGPUBufferUsage_Uniform | WGPUBufferUsage_CopyDst); } void update_bind_group(WGPUTextureView input_view) { @@ -196,7 +196,8 @@ int main(int argc, char** argv) { // Add peak meter visualization effect (renders as final post-process) #if !defined(STRIP_ALL) - auto* peak_meter = new PeakMeterEffect(g_device, g_queue, g_format); + const GpuContext* gpu_ctx = gpu_get_context(); + auto* peak_meter = new PeakMeterEffect(*gpu_ctx); gpu_add_custom_effect(peak_meter, 0.0f, 99999.0f, 999); // High priority = renders last #endif diff --git a/src/tests/test_demo_effects.cc b/src/tests/test_demo_effects.cc index 3292c9c..ec1d68c 100644 --- a/src/tests/test_demo_effects.cc +++ b/src/tests/test_demo_effects.cc @@ -79,34 +79,28 @@ static void test_post_process_effects() { } MainSequence main_seq; - main_seq.init_test(fixture.device(), fixture.queue(), fixture.format()); + main_seq.init_test(fixture.ctx()); // Test each post-process effect std::vector<std::pair<const char*, std::shared_ptr<Effect>>> effects = { {"FlashEffect", - std::make_shared<FlashEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<FlashEffect>(fixture.ctx())}, {"PassthroughEffect", - std::make_shared<PassthroughEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<PassthroughEffect>(fixture.ctx())}, {"GaussianBlurEffect", - std::make_shared<GaussianBlurEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<GaussianBlurEffect>(fixture.ctx())}, {"ChromaAberrationEffect", std::make_shared<ChromaAberrationEffect>( - fixture.device(), fixture.queue(), fixture.format())}, + fixture.ctx())}, {"DistortEffect", - std::make_shared<DistortEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<DistortEffect>(fixture.ctx())}, {"SolarizeEffect", - std::make_shared<SolarizeEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<SolarizeEffect>(fixture.ctx())}, {"FadeEffect", - std::make_shared<FadeEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<FadeEffect>(fixture.ctx())}, {"ThemeModulationEffect", std::make_shared<ThemeModulationEffect>( - fixture.device(), fixture.queue(), fixture.format())}, + fixture.ctx())}, }; int passed = 0; @@ -146,28 +140,22 @@ static void test_scene_effects() { } MainSequence main_seq; - main_seq.init_test(fixture.device(), fixture.queue(), fixture.format()); + main_seq.init_test(fixture.ctx()); // Test each scene effect std::vector<std::pair<const char*, std::shared_ptr<Effect>>> effects = { {"HeptagonEffect", - std::make_shared<HeptagonEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<HeptagonEffect>(fixture.ctx())}, {"ParticlesEffect", - std::make_shared<ParticlesEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<ParticlesEffect>(fixture.ctx())}, {"ParticleSprayEffect", - std::make_shared<ParticleSprayEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<ParticleSprayEffect>(fixture.ctx())}, {"MovingEllipseEffect", - std::make_shared<MovingEllipseEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<MovingEllipseEffect>(fixture.ctx())}, {"FlashCubeEffect", - std::make_shared<FlashCubeEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<FlashCubeEffect>(fixture.ctx())}, {"Hybrid3DEffect", - std::make_shared<Hybrid3DEffect>(fixture.device(), fixture.queue(), - fixture.format())}, + std::make_shared<Hybrid3DEffect>(fixture.ctx())}, }; int passed = 0; @@ -215,20 +203,20 @@ static void test_effect_type_classification() { // Post-process effects should return true auto flash = std::make_shared<FlashEffect>( - fixture.device(), fixture.queue(), fixture.format()); + fixture.ctx()); assert(flash->is_post_process() && "FlashEffect should be post-process"); auto blur = std::make_shared<GaussianBlurEffect>( - fixture.device(), fixture.queue(), fixture.format()); + fixture.ctx()); assert(blur->is_post_process() && "GaussianBlurEffect should be post-process"); // Scene effects should return false auto heptagon = std::make_shared<HeptagonEffect>( - fixture.device(), fixture.queue(), fixture.format()); + fixture.ctx()); assert(!heptagon->is_post_process() && "HeptagonEffect should NOT be post-process"); auto particles = std::make_shared<ParticlesEffect>( - fixture.device(), fixture.queue(), fixture.format()); + fixture.ctx()); assert(!particles->is_post_process() && "ParticlesEffect should NOT be post-process"); diff --git a/src/tests/test_effect_base.cc b/src/tests/test_effect_base.cc index bc837be..8180535 100644 --- a/src/tests/test_effect_base.cc +++ b/src/tests/test_effect_base.cc @@ -73,7 +73,7 @@ static void test_effect_construction() { // Create FlashEffect (simple post-process effect) auto effect = std::make_shared<FlashEffect>( - fixture.device(), fixture.queue(), fixture.format()); + fixture.ctx()); assert(!effect->is_initialized && "Effect should not be initialized yet"); @@ -92,11 +92,11 @@ static void test_effect_initialization() { // Create MainSequence (use init_test for test environment) MainSequence main_seq; - main_seq.init_test(fixture.device(), fixture.queue(), fixture.format()); + main_seq.init_test(fixture.ctx()); // Create FlashEffect auto effect = std::make_shared<FlashEffect>( - fixture.device(), fixture.queue(), fixture.format()); + fixture.ctx()); assert(!effect->is_initialized && "Effect should not be initialized yet"); @@ -123,14 +123,14 @@ static void test_sequence_add_effect() { } MainSequence main_seq; - main_seq.init_test(fixture.device(), fixture.queue(), fixture.format()); + main_seq.init_test(fixture.ctx()); // Create sequence auto seq = std::make_shared<Sequence>(); // Create effect auto effect = std::make_shared<FlashEffect>( - fixture.device(), fixture.queue(), fixture.format()); + fixture.ctx()); assert(!effect->is_initialized && "Effect should not be initialized before Sequence::init()"); @@ -156,11 +156,11 @@ static void test_sequence_activation() { } MainSequence main_seq; - main_seq.init_test(fixture.device(), fixture.queue(), fixture.format()); + main_seq.init_test(fixture.ctx()); auto seq = std::make_shared<Sequence>(); auto effect = std::make_shared<FlashEffect>( - fixture.device(), fixture.queue(), fixture.format()); + fixture.ctx()); // Effect active from 5.0 to 10.0 seconds seq->add_effect(effect, 5.0f, 10.0f, 0); diff --git a/src/tests/test_sequence.cc b/src/tests/test_sequence.cc index 788e0b1..e00e606 100644 --- a/src/tests/test_sequence.cc +++ b/src/tests/test_sequence.cc @@ -12,6 +12,7 @@ static WGPUDevice dummy_device = (WGPUDevice)1; static WGPUQueue dummy_queue = (WGPUQueue)1; static WGPUTextureFormat dummy_format = (WGPUTextureFormat)1; +static const GpuContext dummy_ctx = {dummy_device, dummy_queue, dummy_format}; static WGPUSurface dummy_surface = (WGPUSurface)1; static WGPUCommandEncoder dummy_encoder = (WGPUCommandEncoder)1; static WGPURenderPassEncoder dummy_render_pass_encoder = @@ -26,8 +27,8 @@ class DummyEffect : public Effect { int end_calls = 0; bool is_pp = false; - DummyEffect(WGPUDevice device, WGPUQueue queue, bool post_process = false) - : Effect(device, queue), is_pp(post_process) { + DummyEffect(const GpuContext& ctx, bool post_process = false) + : Effect(ctx), is_pp(post_process) { } void init(MainSequence* demo) override { @@ -69,10 +70,8 @@ class DummyPostProcessEffect : public PostProcessEffect { int render_calls = 0; int update_bind_group_calls = 0; - DummyPostProcessEffect(WGPUDevice device, WGPUQueue queue, - WGPUTextureFormat format) - : PostProcessEffect(device, queue) { - (void)format; + DummyPostProcessEffect(const GpuContext& ctx) + : PostProcessEffect(ctx) { } void init(MainSequence* demo) override { @@ -99,9 +98,9 @@ class DummyPostProcessEffect : public PostProcessEffect { void test_effect_lifecycle() { printf(" test_effect_lifecycle...\n"); MainSequence main_seq; - main_seq.init_test(dummy_device, dummy_queue, dummy_format); + main_seq.init_test(dummy_ctx); - auto effect1 = std::make_shared<DummyEffect>(dummy_device, dummy_queue); + auto effect1 = std::make_shared<DummyEffect>(dummy_ctx); auto seq1 = std::make_shared<Sequence>(); seq1->add_effect(effect1, 1.0f, 3.0f); main_seq.add_sequence(seq1, 0.0f, 0); @@ -145,9 +144,9 @@ void test_simulate_until() { #if !defined(STRIP_ALL) printf(" test_simulate_until...\n"); MainSequence main_seq; - main_seq.init_test(dummy_device, dummy_queue, dummy_format); + main_seq.init_test(dummy_ctx); - auto effect1 = std::make_shared<DummyEffect>(dummy_device, dummy_queue); + auto effect1 = std::make_shared<DummyEffect>(dummy_ctx); auto seq1 = std::make_shared<Sequence>(); seq1->add_effect(effect1, 1.0f, 3.0f); main_seq.add_sequence(seq1, 0.0f, 0); diff --git a/src/tests/webgpu_test_fixture.h b/src/tests/webgpu_test_fixture.h index 2c700a4..fd08276 100644 --- a/src/tests/webgpu_test_fixture.h +++ b/src/tests/webgpu_test_fixture.h @@ -4,6 +4,7 @@ #pragma once +#include "gpu/gpu.h" #include "platform/platform.h" // Shared test fixture for WebGPU tests @@ -25,6 +26,7 @@ class WebGPUTestFixture { WGPUDevice device() const { return device_; } WGPUQueue queue() const { return queue_; } WGPUTextureFormat format() const { return WGPUTextureFormat_BGRA8Unorm; } + GpuContext ctx() const { return {device_, queue_, format()}; } // Check if fixture is ready bool is_initialized() const { return device_ != nullptr; } |