Upload spectral-render/src/renderer.rs

spectral-render/src/renderer.rs

@@ -0,0 +1,385 @@
+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();
+    }
+}