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