feat(ie-render): GPU-accelerated rendering with wgpu #77

Replace softbuffer CPU rendering with wgpu GPU pipeline:

GpuRenderer (gpu.rs):
- wgpu surface/device/queue initialization from winit window
- WGSL vertex+fragment shaders for colored rectangles (rect.wgsl)
- Vertex format: position (vec2) + color (vec4), 6 vertices per rect
- Uniform buffer for viewport size → pixel-to-clip-space transform
- Alpha blending enabled for transparency
- resize() reconfigures surface and updates viewport uniform
- render() builds vertex buffer from PaintCommands, single draw call
- Text rendered as placeholder character rectangles (glyphon in #76)

Shell integration (app.rs):
- GpuRenderer replaces softbuffer surface
- Created via tokio_runtime.block_on() in resumed() handler
- render_page() returns Vec<PaintCommand> (not pixels)
- paint() passes commands to gpu_renderer.render()
- Resized handler calls renderer.resize()
- Removed softbuffer dependency from ie-shell

Software renderer kept for headless mode and unit tests.

Author: thomasnemer

Cargo.lock

@@ -53,6 +53,7 @@ serde_json = "1"
 clap = { version = "4", features = ["derive"] }
 softbuffer = "0.4"
 bytes = "1"
+bytemuck = { version = "1", features = ["derive"] }
 async-trait = "0.1"
 chrono = { version = "0.4", features = ["serde"] }
 tempfile = "3"

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "ie-render"
 version = "0.1.0"
-description = "Rendering engine for Internet Exploder — display list and software rasterizer"
+description = "Rendering engine for Internet Exploder — GPU-accelerated via wgpu"
 edition.workspace = true
 authors.workspace = true
 license.workspace = true
@@ -11,6 +11,9 @@ repository.workspace = true
 anyhow.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
+wgpu.workspace = true
+winit.workspace = true
+bytemuck.workspace = true
 ie-layout.workspace = true
 ie-css.workspace = true
 

crates/ie-render/Cargo.toml

@@ -0,0 +1,320 @@
+use std::sync::Arc;
+
+use anyhow::Result;
+use wgpu::util::DeviceExt;
+
+use crate::paint::{Color, PaintCommand};
+
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+struct Vertex {
+    position: [f32; 2],
+    color: [f32; 4],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
+struct Uniforms {
+    viewport_size: [f32; 2],
+    _padding: [f32; 2],
+}
+
+pub struct GpuRenderer {
+    surface: wgpu::Surface<'static>,
+    device: wgpu::Device,
+    queue: wgpu::Queue,
+    config: wgpu::SurfaceConfiguration,
+    pipeline: wgpu::RenderPipeline,
+    uniform_buffer: wgpu::Buffer,
+    uniform_bind_group: wgpu::BindGroup,
+    size: (u32, u32),
+}
+
+impl GpuRenderer {
+    pub async fn new(window: Arc<winit::window::Window>) -> Result<Self> {
+        let size = window.inner_size();
+        let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor::default());
+        let surface = instance.create_surface(window)?;
+        let adapter = instance
+            .request_adapter(&wgpu::RequestAdapterOptions {
+                compatible_surface: Some(&surface),
+                ..Default::default()
+            })
+            .await
+            .ok_or_else(|| anyhow::anyhow!("no suitable GPU adapter"))?;
+        let (device, queue) = adapter
+            .request_device(&wgpu::DeviceDescriptor::default(), None)
+            .await?;
+
+        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.max(1),
+            height: size.height.max(1),
+            present_mode: wgpu::PresentMode::AutoVsync,
+            desired_maximum_frame_latency: 2,
+            alpha_mode: surface_caps.alpha_modes[0],
+            view_formats: vec![],
+        };
+        surface.configure(&device, &config);
+
+        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("rect shader"),
+            source: wgpu::ShaderSource::Wgsl(include_str!("shaders/rect.wgsl").into()),
+        });
+
+        let uniforms = Uniforms {
+            viewport_size: [size.width.max(1) as f32, size.height.max(1) as f32],
+            _padding: [0.0; 2],
+        };
+        let uniform_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("uniform buffer"),
+            contents: bytemuck::cast_slice(&[uniforms]),
+            usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+        });
+
+        let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            label: Some("uniform bind group layout"),
+            entries: &[wgpu::BindGroupLayoutEntry {
+                binding: 0,
+                visibility: wgpu::ShaderStages::VERTEX,
+                ty: wgpu::BindingType::Buffer {
+                    ty: wgpu::BufferBindingType::Uniform,
+                    has_dynamic_offset: false,
+                    min_binding_size: None,
+                },
+                count: None,
+            }],
+        });
+
+        let uniform_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            label: Some("uniform bind group"),
+            layout: &bind_group_layout,
+            entries: &[wgpu::BindGroupEntry {
+                binding: 0,
+                resource: uniform_buffer.as_entire_binding(),
+            }],
+        });
+
+        let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+            label: Some("pipeline layout"),
+            bind_group_layouts: &[&bind_group_layout],
+            push_constant_ranges: &[],
+        });
+
+        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("rect pipeline"),
+            layout: Some(&pipeline_layout),
+            vertex: wgpu::VertexState {
+                module: &shader,
+                entry_point: Some("vs_main"),
+                buffers: &[wgpu::VertexBufferLayout {
+                    array_stride: std::mem::size_of::<Vertex>() as u64,
+                    step_mode: wgpu::VertexStepMode::Vertex,
+                    attributes: &[
+                        wgpu::VertexAttribute {
+                            offset: 0,
+                            shader_location: 0,
+                            format: wgpu::VertexFormat::Float32x2,
+                        },
+                        wgpu::VertexAttribute {
+                            offset: 8,
+                            shader_location: 1,
+                            format: wgpu::VertexFormat::Float32x4,
+                        },
+                    ],
+                }],
+                compilation_options: Default::default(),
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &shader,
+                entry_point: Some("fs_main"),
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: surface_format,
+                    blend: Some(wgpu::BlendState::ALPHA_BLENDING),
+                    write_mask: wgpu::ColorWrites::ALL,
+                })],
+                compilation_options: Default::default(),
+            }),
+            primitive: wgpu::PrimitiveState {
+                topology: wgpu::PrimitiveTopology::TriangleList,
+                ..Default::default()
+            },
+            depth_stencil: None,
+            multisample: wgpu::MultisampleState::default(),
+            multiview: None,
+            cache: None,
+        });
+
+        Ok(Self {
+            surface,
+            device,
+            queue,
+            config,
+            pipeline,
+            uniform_buffer,
+            uniform_bind_group,
+            size: (size.width.max(1), size.height.max(1)),
+        })
+    }
+
+    pub fn resize(&mut self, width: u32, height: u32) {
+        if width == 0 || height == 0 {
+            return;
+        }
+        self.size = (width, height);
+        self.config.width = width;
+        self.config.height = height;
+        self.surface.configure(&self.device, &self.config);
+
+        let uniforms = Uniforms {
+            viewport_size: [width as f32, height as f32],
+            _padding: [0.0; 2],
+        };
+        self.queue
+            .write_buffer(&self.uniform_buffer, 0, bytemuck::cast_slice(&[uniforms]));
+    }
+
+    pub fn render(&mut self, commands: &[PaintCommand]) -> Result<()> {
+        let output = self.surface.get_current_texture()?;
+        let view = output
+            .texture
+            .create_view(&wgpu::TextureViewDescriptor::default());
+
+        let mut vertices: Vec<Vertex> = Vec::new();
+        for cmd in commands {
+            match cmd {
+                PaintCommand::FillRect {
+                    x,
+                    y,
+                    width,
+                    height,
+                    color,
+                } => {
+                    push_rect(&mut vertices, *x, *y, *width, *height, color);
+                }
+                PaintCommand::Text {
+                    text,
+                    x,
+                    y,
+                    font_size,
+                    color,
+                } => {
+                    // Placeholder: character rectangles (replaced by glyphon in #76)
+                    let char_w = font_size * 0.5;
+                    let char_h = font_size * 0.7;
+                    let glyph_y = y + (font_size - char_h) * 0.5;
+                    let mut cx = *x;
+                    for ch in text.chars() {
+                        if ch != ' ' {
+                            let glyph_w = char_w * 0.7;
+                            push_rect(&mut vertices, cx, glyph_y, glyph_w, char_h, color);
+                        }
+                        cx += char_w;
+                    }
+                }
+            }
+        }
+
+        let vertex_buffer = self
+            .device
+            .create_buffer_init(&wgpu::util::BufferInitDescriptor {
+                label: Some("vertex buffer"),
+                contents: bytemuck::cast_slice(&vertices),
+                usage: wgpu::BufferUsages::VERTEX,
+            });
+
+        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("render pass"),
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &view,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: None,
+                ..Default::default()
+            });
+
+            if !vertices.is_empty() {
+                pass.set_pipeline(&self.pipeline);
+                pass.set_bind_group(0, &self.uniform_bind_group, &[]);
+                pass.set_vertex_buffer(0, vertex_buffer.slice(..));
+                pass.draw(0..vertices.len() as u32, 0..1);
+            }
+        }
+
+        self.queue.submit(std::iter::once(encoder.finish()));
+        output.present();
+        Ok(())
+    }
+
+    pub fn size(&self) -> (u32, u32) {
+        self.size
+    }
+
+    pub fn device(&self) -> &wgpu::Device {
+        &self.device
+    }
+
+    pub fn queue(&self) -> &wgpu::Queue {
+        &self.queue
+    }
+
+    pub fn surface_format(&self) -> wgpu::TextureFormat {
+        self.config.format
+    }
+}
+
+fn push_rect(vertices: &mut Vec<Vertex>, x: f32, y: f32, w: f32, h: f32, color: &Color) {
+    let c = [
+        color.r as f32 / 255.0,
+        color.g as f32 / 255.0,
+        color.b as f32 / 255.0,
+        color.a as f32 / 255.0,
+    ];
+    let (x0, y0, x1, y1) = (x, y, x + w, y + h);
+    vertices.extend_from_slice(&[
+        Vertex {
+            position: [x0, y0],
+            color: c,
+        },
+        Vertex {
+            position: [x1, y0],
+            color: c,
+        },
+        Vertex {
+            position: [x0, y1],
+            color: c,
+        },
+        Vertex {
+            position: [x0, y1],
+            color: c,
+        },
+        Vertex {
+            position: [x1, y0],
+            color: c,
+        },
+        Vertex {
+            position: [x1, y1],
+            color: c,
+        },
+    ]);
+}

crates/ie-render/src/gpu.rs

@@ -1,11 +1,12 @@
 //! # ie-render
 //!
 //! Rendering engine for Internet Exploder.
-//! Currently uses software rendering via softbuffer.
-//! GPU rendering (wgpu) will be added later.
+//! GPU-accelerated via wgpu, with software fallback for tests.
 
+pub mod gpu;
 pub mod paint;
 pub mod software;
 
+pub use gpu::GpuRenderer;
 pub use paint::{Color, PaintCommand, build_display_list};
 pub use software::{SoftwareTextMeasure, render_to_buffer};

crates/ie-render/src/lib.rs

@@ -0,0 +1,31 @@
+struct VertexInput {
+    @location(0) position: vec2<f32>,
+    @location(1) color: vec4<f32>,
+};
+
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) color: vec4<f32>,
+};
+
+struct Uniforms {
+    viewport_size: vec2<f32>,
+};
+
+@group(0) @binding(0)
+var<uniform> uniforms: Uniforms;
+
+@vertex
+fn vs_main(in: VertexInput) -> VertexOutput {
+    var out: VertexOutput;
+    let x = (in.position.x / uniforms.viewport_size.x) * 2.0 - 1.0;
+    let y = 1.0 - (in.position.y / uniforms.viewport_size.y) * 2.0;
+    out.position = vec4<f32>(x, y, 0.0, 1.0);
+    out.color = in.color;
+    return out;
+}
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    return in.color;
+}