use cuneus::compute::*;
use cuneus::prelude::*;
cuneus::uniform_params! {
struct SystemParams {
a: f32,
b: f32,
c: f32,
dof_amount: f32,
dof_focal_dist: f32,
brightness: f32,
color1_r: f32,
color1_g: f32,
color1_b: f32,
color2_r: f32,
color2_g: f32,
color2_b: f32,
zoom: f32,
_pad_m1: f32,
_pad_m2: f32,
_pad_m3: f32,
}
}
struct SystemShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: SystemParams}
impl SystemShader {
fn clear_buffers(&mut self, core: &Core) {
self.compute_shader.clear_all_buffers(core);
}
}
impl ShaderManager for SystemShader {
fn init(core: &Core) -> Self {
let initial_params = SystemParams {
a: 0.0,
b: 0.0,
c: 0.4,
dof_amount: 0.0,
dof_focal_dist: 0.96,
brightness: 0.00004,
color1_r: 0.2,
color1_g: 0.8,
color1_b: 1.0,
color2_r: 1.0,
color2_g: 0.4,
color2_b: 0.1,
zoom: 1.0,
_pad_m1: 0.0,
_pad_m2: 0.0,
_pad_m3: 0.0,
};
let base = RenderKit::new(core);
let mut config = ComputeShader::builder()
.with_entry_point("Splat")
.with_custom_uniforms::<SystemParams>()
.with_atomic_buffer(2)
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Electric Field System")
.build();
config.entry_points.push("main_image".to_string());
let compute_shader = cuneus::compute_shader!(core, "shaders/system.wgsl", config);
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params}
}
fn update(&mut self, core: &Core) {
self.compute_shader.handle_export_dispatch(
core,
&mut self.base,
|shader, encoder, core| {
shader.dispatch_stage_with_workgroups(encoder, 0, [2048, 1, 1]);
shader.dispatch_stage(encoder, core, 1);
},
);
}
fn resize(&mut self, core: &Core) {
self.base.default_resize(core, &mut self.compute_shader);
}
fn render(&mut self, core: &Core) -> Result<(), cuneus::SurfaceError> {
let mut frame = self.base.begin_frame(core)?;
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size, self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
RenderKit::apply_default_style(ctx);
egui::Window::new("Settings")
.collapsible(true)
.resizable(true)
.default_width(250.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Field Parameters")
.default_open(true)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.a, 0.0..=2.0)
.text("Strength"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.b, 0.0..=1.0)
.text("Gradient"),
)
.changed();
changed |= ui
.add(egui::Slider::new(&mut params.c, 0.0..=2.0).text("Scale"))
.changed();
ui.separator();
});
egui::CollapsingHeader::new("Visuals")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.brightness, 0.00001..=0.0002)
.logarithmic(true)
.text("Brightness"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.zoom, 0.1..=5.0).text("Zoom"),
)
.changed();
ui.separator();
});
egui::CollapsingHeader::new("Depth of Field")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.dof_amount, 0.0..=3.0)
.text("DOF"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.dof_focal_dist, 0.0..=2.0)
.text("Focal Distance"),
)
.changed();
});
egui::CollapsingHeader::new("Colors")
.default_open(false)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Color 1:");
let mut color =
[params.color1_r, params.color1_g, params.color1_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color1_r = color[0];
params.color1_g = color[1];
params.color1_b = color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Color 2:");
let mut color =
[params.color2_r, params.color2_g, params.color2_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color2_r = color[0];
params.color2_g = color[1];
params.color2_b = color[2];
changed = true;
}
});
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
self.compute_shader
.dispatch_stage_with_workgroups(&mut frame.encoder, 0, [2048, 1, 1]);
self.compute_shader.dispatch_stage(&mut frame.encoder, core, 1);
self.base.renderer.render_to_view(&mut frame.encoder, &frame.view, &self.compute_shader.get_output_texture().bind_group);
self.base.end_frame(core, frame, full_output);
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
self.base.default_handle_input(core, event)
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = cuneus::ShaderApp::new("Attractor Universe", 800, 600);
app.run(event_loop, SystemShader::init)
}