//! cimery-viewer — wgpu + winit viewer. //! //! # Sprint 1 scope //! - Opens a window and renders a coloured triangle (red/green/blue vertices). //! - Proves the wgpu pipeline, winit event loop, and shader infrastructure work. //! - No Girder mesh rendering yet — that comes in Sprint 2 after kernel integration. //! //! # Sprint 2 upgrade path //! - `CimeryApp::set_mesh(mesh: &cimery_kernel::Mesh)` — replace triangle with real geometry. //! - Camera orbit (Revit ViewCube pattern). //! - Depth buffer + back-face culling for solid geometry. use std::sync::Arc; use bytemuck::{Pod, Zeroable}; use winit::{ application::ApplicationHandler, event::{KeyEvent, WindowEvent}, event_loop::{ActiveEventLoop, ControlFlow, EventLoop}, keyboard::{KeyCode, PhysicalKey}, window::{Window, WindowId}, }; use wgpu::util::DeviceExt; // ─── Vertex ─────────────────────────────────────────────────────────────────── #[repr(C)] #[derive(Copy, Clone, Debug, Pod, Zeroable)] struct Vertex { position: [f32; 3], color: [f32; 3], } impl Vertex { const ATTRIBS: [wgpu::VertexAttribute; 2] = wgpu::vertex_attr_array![ 0 => Float32x3, // position 1 => Float32x3, // color ]; fn desc() -> wgpu::VertexBufferLayout<'static> { wgpu::VertexBufferLayout { array_stride: std::mem::size_of::() as wgpu::BufferAddress, step_mode: wgpu::VertexStepMode::Vertex, attributes: &Self::ATTRIBS, } } } // Sprint 1 triangle: red top / green left / blue right const TRIANGLE: &[Vertex] = &[ Vertex { position: [ 0.0, 0.5, 0.0], color: [1.0, 0.0, 0.0] }, Vertex { position: [-0.5, -0.5, 0.0], color: [0.0, 1.0, 0.0] }, Vertex { position: [ 0.5, -0.5, 0.0], color: [0.0, 0.0, 1.0] }, ]; // ─── RenderState ───────────────────────────────────────────────────────────── struct RenderState { window: Arc, device: wgpu::Device, queue: wgpu::Queue, surface: wgpu::Surface<'static>, surface_config: wgpu::SurfaceConfiguration, render_pipeline: wgpu::RenderPipeline, vertex_buffer: wgpu::Buffer, num_vertices: u32, } impl RenderState { async fn new(window: Arc) -> Self { let size = window.inner_size(); let instance = wgpu::Instance::new(wgpu::InstanceDescriptor { backends: wgpu::Backends::all(), ..Default::default() }); // Arc implements SurfaceTarget, giving Surface<'static> let surface = instance .create_surface(Arc::clone(&window)) .expect("create surface"); let adapter = instance .request_adapter(&wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::default(), compatible_surface: Some(&surface), force_fallback_adapter: false, }) .await .expect("no suitable GPU adapter found"); let (device, queue) = adapter .request_device( &wgpu::DeviceDescriptor { label: Some("cimery device"), required_features: wgpu::Features::empty(), required_limits: wgpu::Limits::default(), ..Default::default() }, None, ) .await .expect("failed to create GPU device"); let caps = surface.get_capabilities(&adapter); let format = caps.formats.iter() .find(|f| f.is_srgb()) .copied() .unwrap_or(caps.formats[0]); let surface_config = wgpu::SurfaceConfiguration { usage: wgpu::TextureUsages::RENDER_ATTACHMENT, format, width: size.width.max(1), height: size.height.max(1), present_mode: caps.present_modes[0], alpha_mode: caps.alpha_modes[0], view_formats: vec![], desired_maximum_frame_latency: 2, }; surface.configure(&device, &surface_config); let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("cimery shader"), source: wgpu::ShaderSource::Wgsl(include_str!("shader.wgsl").into()), }); let pipeline_layout = device.create_pipeline_layout( &wgpu::PipelineLayoutDescriptor { label: Some("pipeline layout"), bind_group_layouts: &[], push_constant_ranges: &[], }, ); let render_pipeline = device.create_render_pipeline( &wgpu::RenderPipelineDescriptor { label: Some("render pipeline"), layout: Some(&pipeline_layout), vertex: wgpu::VertexState { module: &shader, entry_point: "vs_main", buffers: &[Vertex::desc()], compilation_options: wgpu::PipelineCompilationOptions::default(), }, fragment: Some(wgpu::FragmentState { module: &shader, entry_point: "fs_main", targets: &[Some(wgpu::ColorTargetState { format, blend: Some(wgpu::BlendState::REPLACE), write_mask: wgpu::ColorWrites::ALL, })], compilation_options: wgpu::PipelineCompilationOptions::default(), }), primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, strip_index_format: None, front_face: wgpu::FrontFace::Ccw, cull_mode: Some(wgpu::Face::Back), polygon_mode: wgpu::PolygonMode::Fill, unclipped_depth: false, conservative: false, }, depth_stencil: None, multisample: wgpu::MultisampleState { count: 1, mask: !0, alpha_to_coverage_enabled: false, }, multiview: None, cache: None, }, ); let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { label: Some("triangle vertex buffer"), contents: bytemuck::cast_slice(TRIANGLE), usage: wgpu::BufferUsages::VERTEX, }); RenderState { window, device, queue, surface, surface_config, render_pipeline, vertex_buffer, num_vertices: TRIANGLE.len() as u32, } } fn resize(&mut self, new_size: winit::dpi::PhysicalSize) { if new_size.width > 0 && new_size.height > 0 { self.surface_config.width = new_size.width; self.surface_config.height = new_size.height; self.surface.configure(&self.device, &self.surface_config); } } fn render(&mut self) -> Result<(), wgpu::SurfaceError> { let output = self.surface.get_current_texture()?; let view = output.texture.create_view(&Default::default()); let mut enc = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("render encoder"), }); { let mut rp = enc.begin_render_pass(&wgpu::RenderPassDescriptor { label: Some("main render pass"), color_attachments: &[Some(wgpu::RenderPassColorAttachment { view: &view, resolve_target: None, ops: wgpu::Operations { load: wgpu::LoadOp::Clear(wgpu::Color { r: 0.12, g: 0.20, b: 0.30, a: 1.0, }), store: wgpu::StoreOp::Store, }, })], depth_stencil_attachment: None, occlusion_query_set: None, timestamp_writes: None, }); rp.set_pipeline(&self.render_pipeline); rp.set_vertex_buffer(0, self.vertex_buffer.slice(..)); rp.draw(0..self.num_vertices, 0..1); } self.queue.submit(std::iter::once(enc.finish())); output.present(); Ok(()) } } // ─── CimeryApp ──────────────────────────────────────────────────────────────── /// winit ApplicationHandler for the cimery viewer. pub struct CimeryApp { state: Option, } impl CimeryApp { pub fn new() -> Self { Self { state: None } } } impl Default for CimeryApp { fn default() -> Self { Self::new() } } impl ApplicationHandler for CimeryApp { fn resumed(&mut self, event_loop: &ActiveEventLoop) { let attrs = Window::default_attributes() .with_title("cimery viewer [Sprint 1]") .with_inner_size(winit::dpi::LogicalSize::new(1280u32, 720u32)); let window = Arc::new( event_loop.create_window(attrs) .expect("failed to create window"), ); let state = pollster::block_on(RenderState::new(Arc::clone(&window))); self.state = Some(state); } fn window_event( &mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent, ) { let Some(state) = self.state.as_mut() else { return }; if state.window.id() != window_id { return; } match event { WindowEvent::CloseRequested => event_loop.exit(), WindowEvent::KeyboardInput { event: KeyEvent { physical_key: PhysicalKey::Code(KeyCode::Escape), .. }, .. } => event_loop.exit(), WindowEvent::Resized(size) => state.resize(size), WindowEvent::RedrawRequested => { match state.render() { Ok(()) => {} Err(wgpu::SurfaceError::Lost | wgpu::SurfaceError::Outdated) => { let sz = state.window.inner_size(); state.resize(sz); } Err(wgpu::SurfaceError::OutOfMemory) => { log::error!("GPU out of memory — exiting"); event_loop.exit(); } Err(e) => log::warn!("surface error: {:?}", e), } state.window.request_redraw(); } _ => {} } } } // ─── Entry point ───────────────────────────────────────────────────────────── /// Run the cimery viewer event loop. Blocks until the window is closed. pub fn run_viewer() { let event_loop = EventLoop::new().expect("failed to create event loop"); event_loop.set_control_flow(ControlFlow::Poll); let mut app = CimeryApp::new(); event_loop.run_app(&mut app).expect("event loop error"); }