1use cuneus::compute::*;
2use cuneus::prelude::*;
3
4cuneus::uniform_params! {
5 struct JfaParams {
6 a: f32,
7 b: f32,
8 c: f32,
9 d: f32,
10 scale: f32,
11 n: f32,
12 gamma: f32,
13 color_intensity: f32,
14 color_r: f32,
15 color_g: f32,
16 color_b: f32,
17 color_w: f32,
18 accumulation_speed: f32,
19 fade_speed: f32,
20 freeze_accumulation: f32,
21 pattern_floor_add: f32,
22 pattern_temp_add: f32,
23 pattern_v_offset: f32,
24 pattern_temp_mul1: f32,
25 pattern_temp_mul2_3: f32,
26 _padding0: f32,
27 _padding1: f32,
28 _padding2: f32,
29 _pad_m: f32,
30 }
31}
32
33struct JfaShader {
34 base: RenderKit,
35 compute_shader: ComputeShader,
36 current_params: JfaParams,
37}
38
39impl ShaderManager for JfaShader {
40 fn init(core: &Core) -> Self {
41 let initial_params = JfaParams {
42 a: -2.7,
43 b: 0.7,
44 c: 0.2,
45 d: 0.2,
46 scale: 0.3,
47 n: 0.1,
48 gamma: 2.1,
49 color_intensity: 1.0,
50 color_r: 1.0,
51 color_g: 2.0,
52 color_b: 3.0,
53 color_w: 4.0,
54 accumulation_speed: 0.01,
55 fade_speed: 0.99,
56 freeze_accumulation: 0.0,
57 pattern_floor_add: 1.0,
58 pattern_temp_add: 0.1,
59 pattern_v_offset: 0.7,
60 pattern_temp_mul1: 0.7,
61 pattern_temp_mul2_3: 3.0,
62 _padding0: 0.0,
63 _padding1: 0.0,
64 _padding2: 0.0,
65 _pad_m: 0.0,
66 };
67 let base = RenderKit::new(core);
68
69 let passes = vec![
71 PassDescription::new("seed_points", &["seed_points"]),
72 PassDescription::new("flood_init", &[]),
73
74 PassDescription::new("flood_1024", &["seed_points", "flood_init"]),
76 PassDescription::new("flood_512", &["seed_points", "flood_1024"]),
77 PassDescription::new("flood_256", &["seed_points", "flood_512"]),
78 PassDescription::new("flood_128", &["seed_points", "flood_256"]),
79 PassDescription::new("flood_64", &["seed_points", "flood_128"]),
80 PassDescription::new("flood_32", &["seed_points", "flood_64"]),
81 PassDescription::new("flood_16", &["seed_points", "flood_32"]),
82 PassDescription::new("flood_8", &["seed_points", "flood_16"]),
83 PassDescription::new("flood_4", &["seed_points", "flood_8"]),
84 PassDescription::new("flood_2", &["seed_points", "flood_4"]),
85 PassDescription::new("flood_1", &["seed_points", "flood_2"]),
86
87 PassDescription::new("color_accumulate", &["seed_points", "flood_1", "color_accumulate"]),
89 PassDescription::new("main_image", &["color_accumulate"]),
90 ];
91
92 let config = ComputeShader::builder()
93 .with_entry_point("seed_points")
94 .with_multi_pass(&passes)
95 .with_custom_uniforms::<JfaParams>()
96 .with_workgroup_size([16, 16, 1])
97 .with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
98 .with_label("JFA Unified")
99 .build();
100
101 let compute_shader = cuneus::compute_shader!(core, "shaders/jfa.wgsl", config);
102
103 compute_shader.set_custom_params(initial_params, &core.queue);
104
105 Self {
106 base,
107 compute_shader,
108 current_params: initial_params,
109 }
110 }
111
112 fn update(&mut self, core: &Core) {
113 self.compute_shader.handle_export(core, &mut self.base);
114
115 let current_time = self.base.controls.get_time(&self.base.start_time);
116 let delta = 1.0 / 60.0;
117 self.compute_shader
118 .set_time(current_time, delta, &core.queue);
119 }
120
121 fn resize(&mut self, core: &Core) {
122 self.base.default_resize(core, &mut self.compute_shader);
123 }
124
125 fn render(&mut self, core: &Core) -> Result<(), cuneus::SurfaceError> {
126 let mut frame = self.base.begin_frame(core)?;
127
128 self.compute_shader.dispatch(&mut frame.encoder, core);
130
131 self.base.renderer.render_to_view(
132 &mut frame.encoder,
133 &frame.view,
134 &self.compute_shader.get_output_texture().bind_group,
135 );
136
137 let mut params = self.current_params;
138 let mut changed = false;
139 let mut should_start_export = false;
140 let mut export_request = self.base.export_manager.get_ui_request();
141 let mut controls_request = self
142 .base
143 .controls
144 .get_ui_request(&self.base.start_time, &core.size, self.base.fps_tracker.fps());
145
146 let full_output = if self.base.key_handler.show_ui {
147 self.base.render_ui(core, |ctx| {
148 RenderKit::apply_default_style(ctx);
149
150 egui::Window::new("JFA - Fully Unrolled")
151 .collapsible(true)
152 .resizable(true)
153 .default_width(280.0)
154 .show(ctx, |ui| {
155 egui::CollapsingHeader::new("JFA Parameters")
156 .default_open(true)
157 .show(ui, |ui| {
158 changed |= ui
159 .add(
160 egui::Slider::new(&mut params.n, 0.01..=1.0)
161 .text("Pattern Speed (N)"),
162 )
163 .changed();
164 ui.separator();
165 changed |= ui
166 .add(
167 egui::Slider::new(
168 &mut params.accumulation_speed,
169 0.01..=0.1,
170 )
171 .text("Accumulation Speed"),
172 )
173 .changed();
174 changed |= ui
175 .add(
176 egui::Slider::new(&mut params.fade_speed, 0.9..=1.0)
177 .text("Fade Speed"),
178 )
179 .changed();
180 });
181
182 egui::CollapsingHeader::new("Clifford Attractor")
183 .default_open(false)
184 .show(ui, |ui| {
185 changed |= ui
186 .add(egui::Slider::new(&mut params.a, -5.0..=5.0).text("a"))
187 .changed();
188 changed |= ui
189 .add(egui::Slider::new(&mut params.b, -5.0..=5.0).text("b"))
190 .changed();
191 changed |= ui
192 .add(egui::Slider::new(&mut params.c, -5.0..=5.0).text("c"))
193 .changed();
194 changed |= ui
195 .add(egui::Slider::new(&mut params.d, -5.0..=5.0).text("d"))
196 .changed();
197 ui.separator();
198 changed |= ui
199 .add(
200 egui::Slider::new(&mut params.scale, 0.1..=1.0)
201 .text("Scale"),
202 )
203 .changed();
204 });
205
206 egui::CollapsingHeader::new("Colors")
207 .default_open(false)
208 .show(ui, |ui| {
209 ui.horizontal(|ui| {
210 ui.label("Color Pattern:");
211 let mut color =
212 [params.color_r, params.color_g, params.color_b];
213 if ui.color_edit_button_rgb(&mut color).changed() {
214 params.color_r = color[0];
215 params.color_g = color[1];
216 params.color_b = color[2];
217 changed = true;
218 }
219 });
220 changed |= ui
221 .add(
222 egui::Slider::new(&mut params.color_w, 0.0..=10.0)
223 .text("Color W"),
224 )
225 .changed();
226 changed |= ui
227 .add(
228 egui::Slider::new(&mut params.color_intensity, 0.1..=3.0)
229 .text("Color Intensity"),
230 )
231 .changed();
232 ui.separator();
233 changed |= ui
234 .add(
235 egui::Slider::new(&mut params.gamma, 0.1..=4.0)
236 .text("Gamma"),
237 )
238 .changed();
239 });
240
241 ui.separator();
242 ShaderControls::render_controls_widget(ui, &mut controls_request);
243
244 ui.separator();
245 should_start_export =
246 ExportManager::render_export_ui_widget(ui, &mut export_request);
247
248 ui.separator();
249 ui.label(format!("Frame: {}", self.compute_shader.current_frame));
250 ui.label("15-Pass Realtime Unrolled JFA");
251 });
252 })
253 } else {
254 self.base.render_ui(core, |_ctx| {})
255 };
256
257 if controls_request.is_paused != (params.freeze_accumulation > 0.5) {
258 params.freeze_accumulation = if controls_request.is_paused { 1.0 } else { 0.0 };
259 changed = true;
260 }
261
262 self.base.export_manager.apply_ui_request(export_request);
263 if controls_request.should_clear_buffers {
264 self.compute_shader.current_frame = 0;
265 }
266 self.base.apply_control_request(controls_request);
267
268 if changed {
269 self.current_params = params;
270 self.compute_shader.set_custom_params(params, &core.queue);
271 }
272
273 if should_start_export {
274 self.base.export_manager.start_export();
275 }
276
277 self.base.end_frame(core, frame, full_output);
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) = ShaderApp::new("JFA", 800, 600);
290
291 app.run(event_loop, JfaShader::init)
292}