Struct Core 

pub struct Core {
    pub surface: Surface<'static>,
    pub device: Arc<Device>,
    pub queue: Queue,
    pub config: SurfaceConfiguration,
    pub size: PhysicalSize<u32>,
    pub window: Window,
}

Fields

surface: Surface<'static>

device: Arc<Device>

queue: Queue

config: SurfaceConfiguration

size: PhysicalSize<u32>

window: Window

Implementations

impl Core

pub async fn new(window: Window) -> Self

pub fn window(&self) -> &Window

Examples found in repository

examples/veridisquo.rs (line 221)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        if self.base.forward_to_egui(core, event) {
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if event.state == winit::event::ElementState::Pressed {
                if let winit::keyboard::Key::Character(ref s) = event.logical_key {
                    if s.as_str() == "r" || s.as_str() == "R" {
                        self.base.start_time = std::time::Instant::now();
                        // Reset audio stream
                        if let Some(ref mut stream) = self.pcm_stream {
                            let _ = stream.stop();
                            let _ = stream.start();
                        }
                        return true;
                    }
                }
            }
            return self
                .base
                .key_handler
                .handle_keyboard_input(core.window(), event);
        }

        false
    }

examples/blockgame.rs (line 244)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        let ui_handled = self.base.forward_to_egui(core, event);

        if self.base.handle_mouse_input(core, event, ui_handled) {
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if let winit::keyboard::PhysicalKey::Code(key_code) = event.physical_key {
                if event.state == ElementState::Pressed {
                    let camera_speed = 0.5;

                    match key_code {
                        winit::keyboard::KeyCode::KeyQ => {
                            self.game_params.camera_height += camera_speed;
                            return true;
                        }
                        winit::keyboard::KeyCode::KeyE => {
                            self.game_params.camera_height -= camera_speed;
                            return true;
                        }
                        winit::keyboard::KeyCode::KeyW => {
                            self.game_params.camera_angle += 0.1;
                            return true;
                        }
                        winit::keyboard::KeyCode::KeyS => {
                            self.game_params.camera_angle -= 0.1;
                            return true;
                        }
                        _ => {}
                    }
                }
            }
            return self
                .base
                .key_handler
                .handle_keyboard_input(core.window(), event);
        }

        false
    }

examples/synth.rs (line 342)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        if self.base.forward_to_egui(core, event) {
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if let winit::keyboard::Key::Character(ref s) = event.logical_key {
                if let Some(key_index) = s.chars().next().and_then(|c| c.to_digit(10)) {
                    if (1..=9).contains(&key_index) {
                        let index = (key_index - 1) as usize;

                        let current_time = self.base.controls.get_time(&self.base.start_time);
                        if event.state == winit::event::ElementState::Pressed && !self.keys_held[index] {
                            self.keys_held[index] = true;
                            let has_previous = self.current_params.key_states[index / 4][index % 4] > 0.0;
                            let in_release = self.current_params.key_decay[index / 4][index % 4] > 0.0;
                            if has_previous && in_release {
                                // Retrigger: just cancel the release, note continues from current level
                                self.set_key_release_time(index, 0.0);
                            } else {
                                // Fresh note
                                self.set_key_press_time(index, current_time);
                                self.set_key_release_time(index, 0.0);
                            }
                            self.compute_shader
                                .set_custom_params(self.current_params, &core.queue);
                        } else if event.state == winit::event::ElementState::Released {
                            self.keys_held[index] = false;
                            // Store release time — shader ADSR handles the fade
                            self.set_key_release_time(index, current_time);
                            self.compute_shader
                                .set_custom_params(self.current_params, &core.queue);
                        }
                        return true;
                    }
                }
            }
            return self
                .base
                .key_handler
                .handle_keyboard_input(core.window(), event);
        }

        false
    }

examples/gaussian3d.rs (line 437)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        if self.base.forward_to_egui(core, event) {
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if self.base.key_handler.handle_keyboard_input(core.window(), event) {
                return true;
            }
            if let winit::keyboard::Key::Character(ch) = &event.logical_key {
                let key = ch.as_str().to_lowercase();
                match event.state {
                    winit::event::ElementState::Pressed => {
                        if key == "r" {
                            self.camera.reset();
                            self.sorter.force_sort();
                            return true;
                        }
                        if matches!(key.as_str(), "w" | "a" | "s" | "d" | "q" | "e") {
                            self.camera.keys_held.insert(key);
                            return true;
                        }
                    }
                    winit::event::ElementState::Released => {
                        self.camera.keys_held.remove(&key);
                    }
                }
            }
        }

        if let WindowEvent::MouseInput { state, button, .. } = event {
            if *button == winit::event::MouseButton::Left {
                self.camera.is_dragging = *state == winit::event::ElementState::Pressed;
                return true;
            }
        }

        if let WindowEvent::CursorMoved { position, .. } = event {
            let x = position.x as f32;
            let y = position.y as f32;
            if self.camera.is_dragging {
                let dx = x - self.camera.last_mouse[0];
                let dy = y - self.camera.last_mouse[1];
                self.camera.yaw += dx * 0.01;
                self.camera.pitch = (self.camera.pitch + dy * 0.01).clamp(-1.5, 1.5);
            }
            self.camera.last_mouse = [x, y];
            return self.camera.is_dragging;
        }

        if let WindowEvent::MouseWheel { delta, .. } = event {
            let d = match delta {
                winit::event::MouseScrollDelta::LineDelta(_, y) => *y,
                winit::event::MouseScrollDelta::PixelDelta(p) => (p.y as f32 / 100.0).clamp(-3.0, 3.0)};
            let factor = (1.0 + d * 0.1).clamp(0.5, 2.0);
            self.camera.distance = (self.camera.distance * factor).clamp(0.1, 500.0);
            return true;
        }

        if let WindowEvent::DroppedFile(path) = event {
            if path.extension().map(|e| e == "ply").unwrap_or(false) {
                self.load_ply(core, path);
            }
            return true;
        }

        false
    }

examples/mandelbulb.rs (line 661)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        if self.base.forward_to_egui(core, event) {
            return true;
        }

        if self.base.handle_mouse_input(core, event, false) {
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if let winit::keyboard::Key::Character(ch) = &event.logical_key {
                match ch.as_str() {
                    " " => {
                        if event.state == winit::event::ElementState::Released {
                            self.current_params.accumulate = 1 - self.current_params.accumulate;
                            self.should_reset_accumulation = true;
                            self.compute_shader
                                .set_custom_params(self.current_params, &core.queue);
                            return true;
                        }
                    }
                    "m" | "M" => {
                        if event.state == winit::event::ElementState::Released {
                            self.mouse_enabled = !self.mouse_enabled;
                            self.mouse_initialized = false;
                            return true;
                        }
                    }
                    "w" | "W" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[1] -= 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    "s" | "S" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[1] += 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    "a" | "A" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[0] -= 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    "d" | "D" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[0] += 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    "q" | "Q" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[2] -= 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    "e" | "E" => {
                        if event.state == winit::event::ElementState::Pressed {
                            self.accumulated_rotation[2] += 0.1;
                            self.should_reset_accumulation = true;
                            return true;
                        }
                    }
                    _ => {}
                }
            }
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if self
                .base
                .key_handler
                .handle_keyboard_input(core.window(), event)
            {
                return true;
            }
        }

        false
    }

examples/pathtracing.rs (line 544)

    fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
        if self.base.forward_to_egui(core, event) {
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if let winit::keyboard::Key::Character(ch) = &event.logical_key {
                match ch.as_str() {
                    "w" | "W" => {
                        self.camera_movement.forward =
                            event.state == winit::event::ElementState::Pressed;
                        self.should_reset_accumulation = true;
                        return true;
                    }
                    "s" | "S" => {
                        self.camera_movement.backward =
                            event.state == winit::event::ElementState::Pressed;
                        self.should_reset_accumulation = true;
                        return true;
                    }
                    "a" | "A" => {
                        self.camera_movement.left =
                            event.state == winit::event::ElementState::Pressed;
                        self.should_reset_accumulation = true;
                        return true;
                    }
                    "d" | "D" => {
                        self.camera_movement.right =
                            event.state == winit::event::ElementState::Pressed;
                        self.should_reset_accumulation = true;
                        return true;
                    }
                    "q" | "Q" => {
                        self.camera_movement.down =
                            event.state == winit::event::ElementState::Pressed;
                        self.should_reset_accumulation = true;
                        return true;
                    }
                    "e" | "E" => {
                        self.camera_movement.up =
                            event.state == winit::event::ElementState::Pressed;
                        self.should_reset_accumulation = true;
                        return true;
                    }
                    " " => {
                        if event.state == winit::event::ElementState::Released {
                            self.current_params.accumulate = 1 - self.current_params.accumulate;
                            self.should_reset_accumulation = true;
                            self.compute_shader
                                .set_custom_params(self.current_params, &core.queue);
                            return true;
                        }
                    }
                    _ => {}
                }
            }
        }

        if let WindowEvent::CursorMoved { position, .. } = event {
            let x = position.x as f32;
            let y = position.y as f32;

            self.base.handle_mouse_input(core, event, false);

            if self.camera_movement.handle_mouse_movement(x, y) {
                self.should_reset_accumulation = true;
                return true;
            }
        }

        if let WindowEvent::MouseInput { state, button, .. } = event {
            if *button == winit::event::MouseButton::Right
                && *state == winit::event::ElementState::Released
            {
                self.camera_movement.toggle_mouse_look();
                return true;
            }
        }

        if let WindowEvent::DroppedFile(path) = event {
            if let Err(e) = self.base.load_media(core, path) {
                error!("Failed to load dropped file: {e:?}");
            }
            return true;
        }

        if let WindowEvent::KeyboardInput { event, .. } = event {
            if self
                .base
                .key_handler
                .handle_keyboard_input(core.window(), event)
            {
                return true;
            }
        }

        false
    }

pub fn resize(&mut self, new_size: PhysicalSize<u32>)

pub fn flush_encoder(&self, encoder: CommandEncoder) -> CommandEncoder

Submit the current encoder and create a new one.

Useful for multi-pass simulations where you need buffer updates to take effect before the next dispatch. wgpu batches all write_buffer calls before dispatches in the same submit, so this forces the GPU to see your changes.

Examples found in repository

examples/gaussian3d.rs (line 394)

    fn render(&mut self, core: &Core) -> Result<(), cuneus::SurfaceError> {
        let output = match core.surface.get_current_texture() {
            wgpu::CurrentSurfaceTexture::Success(texture)
            | wgpu::CurrentSurfaceTexture::Suboptimal(texture) => texture,
            wgpu::CurrentSurfaceTexture::Timeout
            | wgpu::CurrentSurfaceTexture::Occluded => {
                return Err(cuneus::SurfaceError::SkipFrame);
            }
            wgpu::CurrentSurfaceTexture::Outdated => {
                return Err(cuneus::SurfaceError::Outdated);
            }
            wgpu::CurrentSurfaceTexture::Lost => {
                return Err(cuneus::SurfaceError::Lost);
            }
            wgpu::CurrentSurfaceTexture::Validation => {
                return Err(cuneus::SurfaceError::Lost);
            }
        };
        let view = output.texture.create_view(&wgpu::TextureViewDescriptor::default());

        let mut params = self.params;
        let mut changed = false;
        let mut load_ply_path: Option<std::path::PathBuf> = None;
        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("3D Gaussian Splatting")
                    .collapsible(true)
                    .resizable(true)
                    .default_width(300.0)
                    .show(ctx, |ui| {
                        if params.num_gaussians > 0 {
                            ui.label(format!("Gaussians: {}", params.num_gaussians));
                        } else {
                            ui.label("Drag & drop a .ply file");
                        }
                        ui.small("WASD: move | QE: up/down | R: reset | Drag: rotate");

                        if ui.button("Load PLY...").clicked() {
                            if let Some(p) = rfd::FileDialog::new().add_filter("PLY", &["ply"]).pick_file() {
                                load_ply_path = Some(p);
                            }
                        }

                        ui.separator();

                        egui::CollapsingHeader::new("Visual Settings")
                            .default_open(true)
                            .show(ui, |ui| {
                                changed |= ui.add(egui::Slider::new(&mut params.scene_scale, 0.01..=100.0)
                                    .logarithmic(true).text("Scene Scale")).changed();
                                changed |= ui.add(egui::Slider::new(&mut params.gaussian_size, 0.1..=2.0)
                                    .text("Gaussian Size")).changed();
                                changed |= ui.add(egui::Slider::new(&mut params.gamma, 0.1..=2.2)
                                    .text("Gamma")).changed();

                                let mut depth_shift_f = params.depth_shift as f32;
                                if ui.add(egui::Slider::new(&mut depth_shift_f, 1.0..=30.0)
                                    .step_by(1.0)
                                    .text("Depth Blur")).changed() {
                                    params.depth_shift = depth_shift_f as u32;
                                    changed = true;
                                }
                            });

                        egui::CollapsingHeader::new("Camera Settings")
                            .default_open(false)
                            .show(ui, |ui| {
                                changed |= ui.add(egui::Slider::new(&mut self.camera.distance, 0.1..=100.0)
                                    .logarithmic(true).text("Distance")).changed();
                                changed |= ui.add(egui::Slider::new(&mut self.camera.fov, 20.0..=120.0)
                                    .text("FOV")).changed();
                                changed |= ui.add(egui::DragValue::new(&mut self.camera.yaw)
                                    .speed(0.05).prefix("Yaw: ")).changed();
                                changed |= ui.add(egui::Slider::new(&mut self.camera.pitch, -1.5..=1.5)
                                    .text("Pitch")).changed();

                                if ui.button("Reset Camera").clicked() {
                                    self.camera.reset();
                                    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);
        self.base.apply_control_request(controls_request);

        if should_start_export {
            self.base.export_manager.start_export();
        }

        if let Some(path) = load_ply_path {
            self.load_ply(core, &path);
        }
        if changed {
            self.params = params;
            self.sync_params(core);
        }

        let mut encoder = core.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
            label: Some("Gaussian3D")});

        let count = self.params.num_gaussians;
        if count > 0 && self.render_bind_group.is_some() {
            self.update_camera(core);

            // Compute preprocess
            let workgroups = (count + 255) / 256;
            self.preprocess.dispatch_stage_with_workgroups(&mut encoder, 0, [workgroups, 1, 1]);

            // GPU Radix Sort
            self.sorter.sort(&mut encoder, count);

            // Split submission: submit preprocess+sort, start new encoder for render
            encoder = core.flush_encoder(encoder);

            // Fragment render
            {
                let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                    label: Some("Gaussian Render"),
                    color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                        view: &view,
                        resolve_target: None,
                        ops: wgpu::Operations {
                            load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
                            store: wgpu::StoreOp::Store},
                        depth_slice: None})],
                    ..Default::default()
                });
                self.renderer.render(&mut pass, self.render_bind_group.as_ref().unwrap(), count);
            }
        } else {
            let _pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
                label: Some("Clear"),
                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
                    view: &view,
                    resolve_target: None,
                    ops: wgpu::Operations {
                        load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
                        store: wgpu::StoreOp::Store},
                    depth_slice: None})],
                ..Default::default()
            });
        }

        self.base.handle_render_output(core, &view, full_output, &mut encoder);
        core.queue.submit(Some(encoder.finish()));
        output.present();
        Ok(())
    }