| use std::sync::Arc; |
|
|
| use wgpu; |
| use bytemuck::{Pod, Zeroable}; |
|
|
| use spectral_core::Terminal; |
| use spectral_font::{GlyphAtlas, GlyphKey}; |
|
|
| use crate::shaders::{BG_VERTEX, BG_FRAGMENT, TEXT_VERTEX, TEXT_FRAGMENT}; |
|
|
| #[repr(C)] |
| #[derive(Clone, Copy, Debug, Pod, Zeroable)] |
| pub struct BgInstance { |
| pub col: u32, pub row: u32, |
| pub bg_r: u32, pub bg_g: u32, pub bg_b: u32, pub bg_a: u32, |
| } |
|
|
| #[repr(C)] |
| #[derive(Clone, Copy, Debug, Pod, Zeroable)] |
| pub struct TextInstance { |
| pub col: f32, pub row: f32, |
| pub bearing_x: f32, pub bearing_y: f32, |
| pub glyph_w: f32, pub glyph_h: f32, |
| pub atlas_x: f32, pub atlas_y: f32, |
| pub atlas_w: f32, pub atlas_h: f32, |
| pub fg_r: u32, pub fg_g: u32, pub fg_b: u32, |
| pub flags: u32, pub thickening: f32, |
| } |
|
|
| #[repr(C)] |
| #[derive(Clone, Copy, Debug, Pod, Zeroable)] |
| pub struct Uniforms { |
| pub cell_width: f32, pub cell_height: f32, pub atlas_size: f32, |
| pub screen_cols: u32, pub screen_rows: u32, |
| _pad: u32, _pad2: u32, |
| } |
|
|
| pub struct Renderer { |
| pub device: wgpu::Device, |
| pub queue: wgpu::Queue, |
| pub surface: wgpu::Surface<'static>, |
| pub surface_config: wgpu::SurfaceConfiguration, |
| pub bg_pipeline: wgpu::RenderPipeline, |
| pub text_pipeline: wgpu::RenderPipeline, |
| pub bg_instance_buf: wgpu::Buffer, |
| pub text_instance_buf: wgpu::Buffer, |
| pub uniform_buf: wgpu::Buffer, |
| pub atlas_texture: wgpu::Texture, |
| pub atlas_view: wgpu::TextureView, |
| pub atlas_sampler: wgpu::Sampler, |
| pub bg_bind_group: wgpu::BindGroup, |
| pub text_uniform_bind_group: wgpu::BindGroup, |
| pub text_texture_bind_group: wgpu::BindGroup, |
| pub glyph_atlas: GlyphAtlas, |
| pub bg_instances: Vec<BgInstance>, |
| pub text_instances: Vec<TextInstance>, |
| pub needs_atlas_upload: bool, |
| } |
|
|
| impl Renderer { |
| pub async fn new(window: Arc<winit::window::Window>, term_cols: u32, term_rows: u32, atlas_size: u16) -> Self { |
| let instance = wgpu::Instance::new(wgpu::InstanceDescriptor { |
| backends: wgpu::Backends::all(), ..Default::default() |
| }); |
| let surface = instance.create_surface(window).unwrap(); |
| let adapter = instance.request_adapter(&wgpu::RequestAdapterOptions { |
| power_preference: wgpu::PowerPreference::HighPerformance, |
| compatible_surface: Some(&surface), force_fallback_adapter: false, |
| }).await.unwrap(); |
|
|
| let (device, queue) = adapter.request_device(&wgpu::DeviceDescriptor { |
| required_features: wgpu::Features::empty(), |
| required_limits: wgpu::Limits::default(), |
| label: Some("Spectral Device"), |
| memory_hints: wgpu::MemoryHints::Performance, |
| }, None).await.unwrap(); |
|
|
| let surface_caps = surface.get_capabilities(&adapter); |
| let surface_format = surface_caps.formats.iter().copied() |
| .find(|f| f.is_srgb()).unwrap_or(surface_caps.formats[0]); |
|
|
| let config = wgpu::SurfaceConfiguration { |
| usage: wgpu::TextureUsages::RENDER_ATTACHMENT, |
| format: surface_format, width: 1280, height: 720, |
| present_mode: wgpu::PresentMode::AutoNoVsync, |
| desired_maximum_frame_latency: 1, |
| alpha_mode: wgpu::CompositeAlphaMode::Auto, |
| view_formats: vec![], |
| }; |
| surface.configure(&device, &config); |
|
|
| let glyph_atlas = GlyphAtlas::new(atlas_size); |
| let max_instances = (term_cols * term_rows) as usize; |
| let atlas_size_px = 2048u32; |
|
|
| let bg_instance_buf = device.create_buffer(&wgpu::BufferDescriptor { |
| label: Some("bg_instances"), |
| size: (max_instances * std::mem::size_of::<BgInstance>()) as u64, |
| usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST, |
| mapped_at_creation: false, |
| }); |
|
|
| let text_instance_buf = device.create_buffer(&wgpu::BufferDescriptor { |
| label: Some("text_instances"), |
| size: (max_instances * std::mem::size_of::<TextInstance>()) as u64, |
| usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST, |
| mapped_at_creation: false, |
| }); |
|
|
| let uniform_buf = device.create_buffer(&wgpu::BufferDescriptor { |
| label: Some("uniforms"), |
| size: std::mem::size_of::<Uniforms>() as u64, |
| usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST, |
| mapped_at_creation: false, |
| }); |
|
|
| let atlas_texture = device.create_texture(&wgpu::TextureDescriptor { |
| label: Some("atlas_texture"), |
| size: wgpu::Extent3d { width: atlas_size_px, height: atlas_size_px, depth_or_array_layers: 1 }, |
| mip_level_count: 1, sample_count: 1, dimension: wgpu::TextureDimension::D2, |
| format: wgpu::TextureFormat::Rgba8UnormSrgb, |
| usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, |
| view_formats: &[], |
| }); |
|
|
| let atlas_view = atlas_texture.create_view(&wgpu::TextureViewDescriptor::default()); |
| let atlas_sampler = device.create_sampler(&wgpu::SamplerDescriptor { |
| label: Some("atlas_sampler"), |
| mag_filter: wgpu::FilterMode::Linear, |
| min_filter: wgpu::FilterMode::Linear, |
| ..Default::default() |
| }); |
|
|
| let uniform_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { |
| label: Some("uniform_layout"), |
| entries: &[ |
| wgpu::BindGroupLayoutEntry { |
| binding: 0, visibility: wgpu::ShaderStages::VERTEX, |
| ty: wgpu::BindingType::Buffer { |
| ty: wgpu::BufferBindingType::Storage { read_only: true }, |
| has_dynamic_offset: false, min_binding_size: None, |
| }, count: None, |
| }, |
| wgpu::BindGroupLayoutEntry { |
| binding: 1, visibility: wgpu::ShaderStages::VERTEX, |
| ty: wgpu::BindingType::Buffer { |
| ty: wgpu::BufferBindingType::Uniform, |
| has_dynamic_offset: false, min_binding_size: None, |
| }, count: None, |
| }, |
| ], |
| }); |
|
|
| let text_texture_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { |
| label: Some("text_texture_layout"), |
| entries: &[ |
| wgpu::BindGroupLayoutEntry { |
| binding: 2, visibility: wgpu::ShaderStages::FRAGMENT, |
| ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering), |
| count: None, |
| }, |
| wgpu::BindGroupLayoutEntry { |
| binding: 3, visibility: wgpu::ShaderStages::FRAGMENT, |
| ty: wgpu::BindingType::Texture { |
| sample_type: wgpu::TextureSampleType::Float { filterable: true }, |
| view_dimension: wgpu::TextureViewDimension::D2, |
| multisampled: false, |
| }, count: None, |
| }, |
| ], |
| }); |
|
|
| let bg_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { |
| label: Some("bg_pipeline_layout"), |
| bind_group_layouts: &[&uniform_layout], push_constant_ranges: &[], |
| }); |
|
|
| let text_pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { |
| label: Some("text_pipeline_layout"), |
| bind_group_layouts: &[&uniform_layout, &text_texture_layout], push_constant_ranges: &[], |
| }); |
|
|
| let bg_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { |
| label: Some("bg_shader"), source: wgpu::ShaderSource::Wgsl(BG_VERTEX.into()), |
| }); |
| let bg_frag = device.create_shader_module(wgpu::ShaderModuleDescriptor { |
| label: Some("bg_frag"), source: wgpu::ShaderSource::Wgsl(BG_FRAGMENT.into()), |
| }); |
| let text_shader = device.create_shader_module(wgpu::ShaderModuleDescriptor { |
| label: Some("text_shader"), source: wgpu::ShaderSource::Wgsl(TEXT_VERTEX.into()), |
| }); |
| let text_frag = device.create_shader_module(wgpu::ShaderModuleDescriptor { |
| label: Some("text_frag"), source: wgpu::ShaderSource::Wgsl(TEXT_FRAGMENT.into()), |
| }); |
|
|
| let bg_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { |
| label: Some("bg_pipeline"), |
| layout: Some(&bg_pipeline_layout), |
| vertex: wgpu::VertexState { |
| module: &bg_shader, entry_point: Some("main"), |
| buffers: &[], compilation_options: wgpu::PipelineCompilationOptions::default(), |
| }, |
| fragment: Some(wgpu::FragmentState { |
| module: &bg_frag, entry_point: Some("main"), |
| targets: &[Some(wgpu::ColorTargetState { |
| format: surface_format, blend: Some(wgpu::BlendState::REPLACE), |
| write_mask: wgpu::ColorWrites::ALL, |
| })], |
| compilation_options: wgpu::PipelineCompilationOptions::default(), |
| }), |
| primitive: wgpu::PrimitiveState::default(), depth_stencil: None, |
| multisample: wgpu::MultisampleState::default(), multiview: None, cache: None, |
| }); |
|
|
| let text_pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor { |
| label: Some("text_pipeline"), |
| layout: Some(&text_pipeline_layout), |
| vertex: wgpu::VertexState { |
| module: &text_shader, entry_point: Some("main"), |
| buffers: &[], compilation_options: wgpu::PipelineCompilationOptions::default(), |
| }, |
| fragment: Some(wgpu::FragmentState { |
| module: &text_frag, entry_point: Some("main"), |
| targets: &[Some(wgpu::ColorTargetState { |
| format: surface_format, blend: Some(wgpu::BlendState::ALPHA_BLENDING), |
| write_mask: wgpu::ColorWrites::ALL, |
| })], |
| compilation_options: wgpu::PipelineCompilationOptions::default(), |
| }), |
| primitive: wgpu::PrimitiveState::default(), depth_stencil: None, |
| multisample: wgpu::MultisampleState::default(), multiview: None, cache: None, |
| }); |
|
|
| let bg_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor { |
| label: Some("bg_bind_group"), layout: &uniform_layout, |
| entries: &[ |
| wgpu::BindGroupEntry { binding: 0, resource: bg_instance_buf.as_entire_binding() }, |
| wgpu::BindGroupEntry { binding: 1, resource: uniform_buf.as_entire_binding() }, |
| ], |
| }); |
|
|
| let text_uniform_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor { |
| label: Some("text_uniform_bind_group"), layout: &uniform_layout, |
| entries: &[ |
| wgpu::BindGroupEntry { binding: 0, resource: text_instance_buf.as_entire_binding() }, |
| wgpu::BindGroupEntry { binding: 1, resource: uniform_buf.as_entire_binding() }, |
| ], |
| }); |
|
|
| let text_texture_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor { |
| label: Some("text_texture_bind_group"), layout: &text_texture_layout, |
| entries: &[ |
| wgpu::BindGroupEntry { binding: 2, resource: wgpu::BindingResource::Sampler(&atlas_sampler) }, |
| wgpu::BindGroupEntry { binding: 3, resource: wgpu::BindingResource::TextureView(&atlas_view) }, |
| ], |
| }); |
|
|
| Self { |
| device, queue, surface, surface_config: config, |
| bg_pipeline, text_pipeline, |
| bg_instance_buf, text_instance_buf, uniform_buf, |
| atlas_texture, atlas_view, atlas_sampler, |
| bg_bind_group, text_uniform_bind_group, text_texture_bind_group, |
| glyph_atlas, |
| bg_instances: Vec::with_capacity(max_instances), |
| text_instances: Vec::with_capacity(max_instances), |
| needs_atlas_upload: false, |
| } |
| } |
|
|
| pub fn resize(&mut self, width: u32, height: u32) { |
| if width == 0 || height == 0 { return; } |
| self.surface_config.width = width; |
| self.surface_config.height = height; |
| self.surface.configure(&self.device, &self.surface_config); |
| } |
|
|
| pub fn update_atlas(&mut self) { |
| if !self.needs_atlas_upload { return; } |
| for (page_idx, page_data) in self.glyph_atlas.texture_data.iter().enumerate() { |
| let page_size = self.glyph_atlas.page_size as u32; |
| self.queue.write_texture( |
| wgpu::ImageCopyTexture { |
| texture: &self.atlas_texture, mip_level: 0, |
| origin: wgpu::Origin3d { x: 0, y: 0, z: page_idx as u32 }, |
| aspect: wgpu::TextureAspect::All, |
| }, |
| page_data, |
| wgpu::ImageDataLayout { offset: 0, bytes_per_row: Some(page_size * 4), rows_per_image: Some(page_size) }, |
| wgpu::Extent3d { width: page_size, height: page_size, depth_or_array_layers: 1 }, |
| ); |
| } |
| self.needs_atlas_upload = false; |
| } |
|
|
| pub fn update_instances(&mut self, terminal: &Terminal) { |
| self.bg_instances.clear(); |
| self.text_instances.clear(); |
| let cell_width = 8.0f32; |
| let cell_height = 16.0f32; |
| let thickening = if terminal.config.font_thicken { terminal.config.font_thicken_strength } else { 0.0 }; |
|
|
| for (row_idx, line) in terminal.grid.lines.iter().enumerate() { |
| for (col_idx, cell) in line.cells.iter().enumerate() { |
| self.bg_instances.push(BgInstance { |
| col: col_idx as u32, row: row_idx as u32, |
| bg_r: ((cell.bg >> 16) & 0xFF) as u32, |
| bg_g: ((cell.bg >> 8) & 0xFF) as u32, |
| bg_b: (cell.bg & 0xFF) as u32, |
| bg_a: ((cell.bg >> 24) & 0xFF) as u32, |
| }); |
| if cell.ch == ' ' || cell.ch == '\0' { continue; } |
| let key = GlyphKey { font_id: 0, glyph_id: cell.ch as u16, size_bucket: (cell_height * 4.0) as u16, style_flags: 0 }; |
| if let Some((_page, slot)) = self.glyph_atlas.get(&key) { |
| self.text_instances.push(TextInstance { |
| col: col_idx as f32, row: row_idx as f32, |
| bearing_x: 0.0, bearing_y: 0.0, |
| glyph_w: slot.w as f32, glyph_h: slot.h as f32, |
| atlas_x: slot.x as f32, atlas_y: slot.y as f32, |
| atlas_w: slot.w as f32, atlas_h: slot.h as f32, |
| fg_r: ((cell.fg >> 16) & 0xFF) as u32, |
| fg_g: ((cell.fg >> 8) & 0xFF) as u32, |
| fg_b: (cell.fg & 0xFF) as u32, |
| flags: cell.flags.bits() as u32, |
| thickening, |
| }); |
| } |
| } |
| } |
|
|
| if !self.bg_instances.is_empty() { |
| self.queue.write_buffer(&self.bg_instance_buf, 0, bytemuck::cast_slice(&self.bg_instances)); |
| } |
| if !self.text_instances.is_empty() { |
| self.queue.write_buffer(&self.text_instance_buf, 0, bytemuck::cast_slice(&self.text_instances)); |
| } |
|
|
| let uniforms = Uniforms { |
| cell_width, cell_height, |
| atlas_size: self.glyph_atlas.page_size as f32, |
| screen_cols: terminal.grid.cols as u32, |
| screen_rows: terminal.grid.rows as u32, |
| _pad: 0, _pad2: 0, |
| }; |
| self.queue.write_buffer(&self.uniform_buf, 0, bytemuck::bytes_of(&uniforms)); |
| } |
|
|
| pub fn render(&mut self) { |
| let output = match self.surface.get_current_texture() { Ok(t) => t, Err(_) => return }; |
| 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 pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { |
| label: Some("bg_pass"), |
| 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_stencil_attachment: None, timestamp_writes: None, occlusion_query_set: None, |
| }); |
| pass.set_pipeline(&self.bg_pipeline); |
| pass.set_bind_group(0, &self.bg_bind_group, &[]); |
| pass.draw(0..6, 0..self.bg_instances.len() as u32); |
| } |
|
|
| { |
| let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor { |
| label: Some("text_pass"), |
| color_attachments: &[Some(wgpu::RenderPassColorAttachment { |
| view: &view, resolve_target: None, |
| ops: wgpu::Operations { load: wgpu::LoadOp::Load, store: wgpu::StoreOp::Store }, |
| })], |
| depth_stencil_attachment: None, timestamp_writes: None, occlusion_query_set: None, |
| }); |
| pass.set_pipeline(&self.text_pipeline); |
| pass.set_bind_group(0, &self.text_uniform_bind_group, &[]); |
| pass.set_bind_group(1, &self.text_texture_bind_group, &[]); |
| pass.draw(0..6, 0..self.text_instances.len() as u32); |
| } |
|
|
| self.queue.submit(std::iter::once(encoder.finish())); |
| output.present(); |
| } |
| } |
|
|
