use std::sync::Arc; use wgpu::util::DeviceExt; /// Vertex data for rendering #[repr(C)] #[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)] struct Vertex { position: [f32; 2], color: [f32; 4], } impl Vertex { fn desc() -> wgpu::VertexBufferLayout<'static> { wgpu::VertexBufferLayout { array_stride: std::mem::size_of::() as wgpu::BufferAddress, step_mode: wgpu::VertexStepMode::Vertex, attributes: &[ // Position wgpu::VertexAttribute { offset: 0, shader_location: 0, format: wgpu::VertexFormat::Float32x2, }, // Color wgpu::VertexAttribute { offset: std::mem::size_of::<[f32; 2]>() as wgpu::BufferAddress, shader_location: 1, format: wgpu::VertexFormat::Float32x4, }, ], } } } /// Main renderer state that manages the wgpu rendering pipeline pub struct Renderer { surface: wgpu::Surface<'static>, device: wgpu::Device, queue: wgpu::Queue, config: wgpu::SurfaceConfiguration, size: winit::dpi::PhysicalSize, render_pipeline: wgpu::RenderPipeline, vertex_buffer: wgpu::Buffer, num_vertices: u32, } impl Renderer { /// Create a new renderer for the given window pub async fn new(window: Arc) -> Self { let size = window.inner_size(); // Create wgpu instance let instance = wgpu::Instance::new(wgpu::InstanceDescriptor { backends: wgpu::Backends::PRIMARY, ..Default::default() }); // Create surface from window let surface = instance.create_surface(window.clone()).unwrap(); // Request adapter let adapter = instance .request_adapter(&wgpu::RequestAdapterOptions { power_preference: wgpu::PowerPreference::HighPerformance, compatible_surface: Some(&surface), force_fallback_adapter: false, }) .await .unwrap(); // Request device and queue let (device, queue) = adapter .request_device( &wgpu::DeviceDescriptor { label: Some("Lightningbeam Render Device"), required_features: wgpu::Features::empty(), required_limits: wgpu::Limits::default(), }, None, ) .await .unwrap(); // Configure surface let surface_caps = surface.get_capabilities(&adapter); let surface_format = surface_caps .formats .iter() .find(|f| f.is_srgb()) .copied() .unwrap_or(surface_caps.formats[0]); let config = wgpu::SurfaceConfiguration { usage: wgpu::TextureUsages::RENDER_ATTACHMENT, format: surface_format, width: size.width, height: size.height, present_mode: wgpu::PresentMode::Fifo, // VSync alpha_mode: surface_caps.alpha_modes[0], view_formats: vec![], desired_maximum_frame_latency: 2, }; surface.configure(&device, &config); // Create shader module let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { label: Some("Gradient Shader"), source: wgpu::ShaderSource::Wgsl(include_str!("shaders/gradient.wgsl").into()), }); // Create render pipeline let render_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { label: Some("Render Pipeline Layout"), bind_group_layouts: &[], push_constant_ranges: &[], }); let render_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { label: Some("Render Pipeline"), layout: Some(&render_pipeline_layout), vertex: wgpu::VertexState { module: &shader, entry_point: "vs_main", buffers: &[Vertex::desc()], }, fragment: Some(wgpu::FragmentState { module: &shader, entry_point: "fs_main", targets: &[Some(wgpu::ColorTargetState { format: config.format, blend: Some(wgpu::BlendState::ALPHA_BLENDING), write_mask: wgpu::ColorWrites::ALL, })], }), primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, strip_index_format: None, front_face: wgpu::FrontFace::Ccw, cull_mode: None, 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, }); // Create initial gradient vertices (two triangles forming a quad) let vertices = Self::create_gradient_vertices(); let vertex_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor { label: Some("Vertex Buffer"), contents: bytemuck::cast_slice(&vertices), usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST, }); Self { surface, device, queue, config, size, render_pipeline, vertex_buffer, num_vertices: vertices.len() as u32, } } /// Create vertices for a gradient quad covering the entire viewport fn create_gradient_vertices() -> Vec { vec![ // First triangle Vertex { position: [-1.0, 1.0], color: [0.2, 0.3, 0.8, 1.0], // Blue at top }, Vertex { position: [-1.0, -1.0], color: [0.6, 0.2, 0.8, 1.0], // Purple at bottom }, Vertex { position: [1.0, -1.0], color: [0.6, 0.2, 0.8, 1.0], // Purple at bottom }, // Second triangle Vertex { position: [-1.0, 1.0], color: [0.2, 0.3, 0.8, 1.0], // Blue at top }, Vertex { position: [1.0, -1.0], color: [0.6, 0.2, 0.8, 1.0], // Purple at bottom }, Vertex { position: [1.0, 1.0], color: [0.2, 0.3, 0.8, 1.0], // Blue at top }, ] } /// Resize the renderer (call when window is resized) pub fn resize(&mut self, new_size: winit::dpi::PhysicalSize) { if new_size.width > 0 && new_size.height > 0 { self.size = new_size; self.config.width = new_size.width; self.config.height = new_size.height; self.surface.configure(&self.device, &self.config); } } /// Render a frame pub fn render(&mut self) -> Result<(), wgpu::SurfaceError> { let output = self.surface.get_current_texture()?; let view = output .texture .create_view(&wgpu::TextureViewDescriptor::default()); let mut encoder = self .device .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: Some("Render Encoder"), }); { let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { label: Some("Render Pass"), color_attachments: &[Some(wgpu::RenderPassColorAttachment { view: &view, resolve_target: None, ops: wgpu::Operations { load: wgpu::LoadOp::Clear(wgpu::Color { r: 0.1, g: 0.1, b: 0.1, a: 1.0, }), store: wgpu::StoreOp::Store, }, })], depth_stencil_attachment: None, occlusion_query_set: None, timestamp_writes: None, }); render_pass.set_pipeline(&self.render_pipeline); render_pass.set_vertex_buffer(0, self.vertex_buffer.slice(..)); render_pass.draw(0..self.num_vertices, 0..1); } self.queue.submit(std::iter::once(encoder.finish())); output.present(); Ok(()) } /// Update gradient colors (for future customization) pub fn update_gradient(&mut self, color_top: [f32; 4], color_bottom: [f32; 4]) { let vertices = vec![ Vertex { position: [-1.0, 1.0], color: color_top, }, Vertex { position: [-1.0, -1.0], color: color_bottom, }, Vertex { position: [1.0, -1.0], color: color_bottom, }, Vertex { position: [-1.0, 1.0], color: color_top, }, Vertex { position: [1.0, -1.0], color: color_bottom, }, Vertex { position: [1.0, 1.0], color: color_top, }, ]; self.queue .write_buffer(&self.vertex_buffer, 0, bytemuck::cast_slice(&vertices)); } }