1use cuneus::compute::*;
2use cuneus::prelude::*;
3
4cuneus::uniform_params! {
5 struct BuddhabrotParams {
6 max_iterations: u32,
7 escape_radius: f32,
8 zoom: f32,
9 offset_x: f32,
10 offset_y: f32,
11 rotation: f32,
12 exposure: f32,
13 sample_density: f32,
14 motion_speed: f32,
15 dithering: f32,
16 wavelength_min: f32,
17 wavelength_max: f32,
18 gamma: f32,
19 saturation: f32,
20 color_shift: f32,
21 intensity_scale: f32,
22 white_balance_r: f32,
23 white_balance_g: f32,
24 white_balance_b: f32,
25 min_trajectory_len: u32,
26 }
27}
28
29struct BuddhabrotShader {
30 base: RenderKit,
31 compute_shader: ComputeShader,
32 frame_count: u32,
33 accumulated_rendering: bool,
34 current_params: BuddhabrotParams,
35}
36
37impl BuddhabrotShader {
38 fn clear_buffers(&mut self, core: &Core) {
39 self.compute_shader.clear_atomic_buffer(core);
40 self.compute_shader.current_frame = 0;
41 self.frame_count = 0;
42 self.accumulated_rendering = false;
43 }
44}
45
46impl ShaderManager for BuddhabrotShader {
47 fn init(core: &Core) -> Self {
48 let base = RenderKit::new(core);
49
50 let initial_params = BuddhabrotParams {
51 max_iterations: 500,
52 escape_radius: 4.0,
53 zoom: 0.5,
54 offset_x: -0.5,
55 offset_y: 0.0,
56 rotation: 1.55,
57 exposure: 6.5,
58 sample_density: 0.5,
59 motion_speed: 0.0,
60 dithering: 0.2,
61 wavelength_min: 485.0,
62 wavelength_max: 660.0,
63 gamma: 0.6,
64 saturation: 1.2,
65 color_shift: 1.1,
66 intensity_scale: 5.0,
67 white_balance_r: 1.2,
68 white_balance_g: 1.0,
69 white_balance_b: 1.08,
70 min_trajectory_len: 20,
71 };
72
73 let mut config = ComputeShader::builder()
74 .with_entry_point("Splat")
75 .with_custom_uniforms::<BuddhabrotParams>()
76 .with_atomic_buffer(3)
77 .with_workgroup_size([16, 16, 1])
78 .with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
79 .with_label("Spectral Buddhabrot")
80 .build();
81
82 config.entry_points.push("main_image".to_string());
83
84 let compute_shader = cuneus::compute_shader!(core, "shaders/buddhabrot.wgsl", config);
85 compute_shader.set_custom_params(initial_params, &core.queue);
86
87 Self {
88 base,
89 compute_shader,
90 frame_count: 0,
91 accumulated_rendering: false,
92 current_params: initial_params,
93 }
94 }
95
96 fn update(&mut self, core: &Core) {
97 self.compute_shader.handle_export_dispatch(
98 core,
99 &mut self.base,
100 |shader, encoder, core| {
101 shader.dispatch_stage_with_workgroups(encoder, 0, [2048, 1, 1]);
102 shader.dispatch_stage(encoder, core, 1);
103 },
104 );
105 }
106
107 fn resize(&mut self, core: &Core) {
108 self.base.default_resize(core, &mut self.compute_shader);
109 }
110
111 fn render(&mut self, core: &Core) -> Result<(), cuneus::SurfaceError> {
112 let mut frame = self.base.begin_frame(core)?;
113
114 let mut params = self.current_params;
115 let mut changed = false;
116 let mut should_start_export = false;
117 let mut export_request = self.base.export_manager.get_ui_request();
118 let mut controls_request = self
119 .base
120 .controls
121 .get_ui_request(&self.base.start_time, &core.size, self.base.fps_tracker.fps());
122 let full_output = if self.base.key_handler.show_ui {
123 self.base.render_ui(core, |ctx| {
124 RenderKit::apply_default_style(ctx);
125
126 egui::Window::new("Spectral Buddhabrot")
127 .collapsible(true)
128 .resizable(true)
129 .default_width(300.0)
130 .min_width(250.0)
131 .max_width(500.0)
132 .show(ctx, |ui| {
133 egui::CollapsingHeader::new("Fractal")
134 .default_open(false)
135 .show(ui, |ui| {
136 changed |= ui
137 .add(egui::Slider::new(&mut params.max_iterations, 100..=2000).text("Max Iterations"))
138 .changed();
139 changed |= ui
140 .add(egui::Slider::new(&mut params.escape_radius, 2.0..=20.0).text("Escape Radius"))
141 .changed();
142 changed |= ui
143 .add(egui::Slider::new(&mut params.min_trajectory_len, 5..=200).text("Min Trajectory"))
144 .changed();
145 changed |= ui
146 .add(egui::Slider::new(&mut params.sample_density, 0.1..=2.0).text("Sample Density"))
147 .changed();
148 });
149
150 egui::CollapsingHeader::new("View")
151 .default_open(false)
152 .show(ui, |ui| {
153 changed |= ui
154 .add(egui::Slider::new(&mut params.zoom, 0.1..=10.0).logarithmic(true).text("Zoom"))
155 .changed();
156 changed |= ui
157 .add(egui::Slider::new(&mut params.offset_x, -2.0..=1.0).text("Offset X"))
158 .changed();
159 changed |= ui
160 .add(egui::Slider::new(&mut params.offset_y, -1.5..=1.5).text("Offset Y"))
161 .changed();
162 changed |= ui
163 .add(egui::Slider::new(&mut params.rotation, -3.14159..=3.14159).text("Rotation"))
164 .changed();
165 });
166
167 egui::CollapsingHeader::new("Spectral")
168 .default_open(true)
169 .show(ui, |ui| {
170 ui.label("Wavelength range (nm)");
171 changed |= ui
172 .add(egui::Slider::new(&mut params.wavelength_min, 390.0..=700.0).text("Min"))
173 .changed();
174 changed |= ui
175 .add(egui::Slider::new(&mut params.wavelength_max, 390.0..=700.0).text("Max"))
176 .changed();
177 ui.separator();
178 changed |= ui
179 .add(egui::Slider::new(&mut params.color_shift, 0.0..=2.0).text("Color Curve"))
180 .changed();
181 changed |= ui
182 .add(egui::Slider::new(&mut params.saturation, 0.0..=3.0).text("Saturation"))
183 .changed();
184 changed |= ui
185 .add(egui::Slider::new(&mut params.intensity_scale, 0.1..=10.0).logarithmic(true).text("Intensity"))
186 .changed();
187 });
188
189 egui::CollapsingHeader::new("Tone Mapping")
190 .default_open(false)
191 .show(ui, |ui| {
192 changed |= ui
193 .add(egui::Slider::new(&mut params.exposure, 0.5..=10.0).text("Exposure"))
194 .changed();
195 changed |= ui
196 .add(egui::Slider::new(&mut params.gamma, 0.2..=2.2).text("Gamma"))
197 .changed();
198 changed |= ui
199 .add(egui::Slider::new(&mut params.dithering, 0.0..=1.0).text("Dithering"))
200 .changed();
201 ui.separator();
202 ui.label("White Balance");
203 changed |= ui
204 .add(egui::Slider::new(&mut params.white_balance_r, 0.5..=2.0).text("R"))
205 .changed();
206 changed |= ui
207 .add(egui::Slider::new(&mut params.white_balance_g, 0.5..=2.0).text("G"))
208 .changed();
209 changed |= ui
210 .add(egui::Slider::new(&mut params.white_balance_b, 0.5..=2.0).text("B"))
211 .changed();
212 });
213
214 egui::CollapsingHeader::new("Rendering")
215 .default_open(false)
216 .show(ui, |ui| {
217 changed |= ui
218 .add(egui::Slider::new(&mut params.motion_speed, 0.0..=1.0).text("Motion (clears buf)"))
219 .changed();
220 ui.horizontal(|ui| {
221 ui.label("Accumulate:");
222 ui.checkbox(&mut self.accumulated_rendering, "");
223 });
224 });
225
226 ui.separator();
227 ShaderControls::render_controls_widget(ui, &mut controls_request);
228 ui.separator();
229 should_start_export =
230 ExportManager::render_export_ui_widget(ui, &mut export_request);
231 });
232 })
233 } else {
234 self.base.render_ui(core, |_ctx| {})
235 };
236
237 self.base.export_manager.apply_ui_request(export_request);
238 if controls_request.should_clear_buffers {
239 self.clear_buffers(core);
240 }
241 self.base.apply_control_request(controls_request);
242
243 let current_time = self.base.controls.get_time(&self.base.start_time);
244 let delta = 1.0 / 60.0;
245 self.compute_shader
246 .set_time(current_time, delta, &core.queue);
247
248 if changed {
249 self.current_params = params;
250 self.compute_shader.set_custom_params(params, &core.queue);
251 if !self.accumulated_rendering {
252 self.clear_buffers(core);
253 }
254 }
255
256 if should_start_export {
257 self.base.export_manager.start_export();
258 }
259
260 let should_generate_samples =
261 !self.accumulated_rendering || self.compute_shader.current_frame < 500;
262
263 if should_generate_samples {
264 self.compute_shader
265 .dispatch_stage_with_workgroups(&mut frame.encoder, 0, [2048, 1, 1]);
266 }
267
268 self.compute_shader
269 .dispatch_stage(&mut frame.encoder, core, 1);
270 self.compute_shader.current_frame += 1;
271
272 self.base
273 .renderer
274 .render_to_view(&mut frame.encoder, &frame.view, &self.compute_shader.get_output_texture().bind_group);
275
276 self.base.end_frame(core, frame, full_output);
277 self.frame_count = self.frame_count.wrapping_add(1);
278
279 Ok(())
280 }
281
282 fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
283 self.base.default_handle_input(core, event)
284 }
285}
286
287fn main() -> Result<(), Box<dyn std::error::Error>> {
288 env_logger::init();
289 let (app, event_loop) = cuneus::ShaderApp::new("Spectral Buddhabrot", 800, 600);
290
291 app.run(event_loop, BuddhabrotShader::init)
292}