Initial commit

src/lib.rs

@@ -0,0 +1,566 @@
+use std::{
+    borrow::Cow,
+    collections::{HashMap, HashSet},
+    error::Error,
+    fmt::{self, Display, Formatter},
+    iter, mem,
+    num::{NonZeroU32, NonZeroU64},
+    slice,
+};
+
+use etagere::{size2, AllocId, Allocation, BucketedAtlasAllocator};
+use fontdue::{
+    layout::{GlyphRasterConfig, Layout},
+    Font,
+};
+use wgpu::{
+    util::{BufferInitDescriptor, DeviceExt},
+    BindGroup, BindGroupEntry, BindGroupLayoutEntry, BindingResource, BindingType, BlendState,
+    Buffer, BufferBindingType, BufferDescriptor, BufferUsages, ColorTargetState, ColorWrites,
+    Device, Extent3d, FilterMode, FragmentState, ImageCopyTexture, ImageDataLayout, IndexFormat,
+    MultisampleState, Origin3d, PipelineLayoutDescriptor, PrimitiveState, Queue, RenderPass,
+    RenderPipeline, RenderPipelineDescriptor, SamplerBindingType, SamplerDescriptor,
+    ShaderModuleDescriptor, ShaderSource, ShaderStages, Texture, TextureAspect, TextureDescriptor,
+    TextureDimension, TextureFormat, TextureSampleType, TextureUsages, TextureViewDescriptor,
+    TextureViewDimension, VertexFormat, VertexState,
+};
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PrepareError {
+    AtlasFull,
+}
+
+impl Display for PrepareError {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "prepare error")
+    }
+}
+
+impl Error for PrepareError {}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum RenderError {}
+
+impl Display for RenderError {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(f, "render error")
+    }
+}
+
+enum GpuCache {
+    InAtlas { x: u16, y: u16 },
+    SkipRasterization,
+}
+
+struct GlyphDetails {
+    width: u32,
+    height: u32,
+    gpu_cache: GpuCache,
+    atlas_id: Option<AllocId>,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+struct GlyphToRender {
+    x: f32,
+    y: f32,
+    width: f32,
+    height: f32,
+    atlas_x: f32,
+    atlas_y: f32,
+    color: [u8; 4],
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct Resolution {
+    pub width: u32,
+    pub height: u32,
+}
+
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct Params {
+    screen_resolution: Resolution,
+}
+
+fn try_allocate(
+    atlas_packer: &mut BucketedAtlasAllocator,
+    layout: &Layout,
+    glyph_cache: &mut HashMap<GlyphRasterConfig, GlyphDetails>,
+    width: usize,
+    height: usize,
+) -> Option<Allocation> {
+    let size = size2(width as i32, height as i32);
+    let allocation = atlas_packer.allocate(size);
+
+    if allocation.is_some() {
+        return allocation;
+    }
+
+    // Try to free any allocations not used in the current layout
+    let used_glyphs = layout
+        .glyphs()
+        .iter()
+        .map(|gp| gp.key)
+        .collect::<HashSet<_>>();
+
+    glyph_cache.retain(|key, details| {
+        if used_glyphs.contains(&key) {
+            true
+        } else {
+            if let Some(atlas_id) = details.atlas_id {
+                atlas_packer.deallocate(atlas_id)
+            }
+            false
+        }
+    });
+
+    // Attempt to reallocate
+    atlas_packer.allocate(size)
+}
+
+pub struct TextRenderer {
+    glyph_cache: HashMap<GlyphRasterConfig, GlyphDetails>,
+    atlas_texture_pending: Vec<u8>,
+    atlas_texture: Texture,
+    atlas_packer: BucketedAtlasAllocator,
+    atlas_width: u32,
+    atlas_height: u32,
+    pipeline: RenderPipeline,
+    vertex_buffer: Buffer,
+    vertex_buffer_size: u64,
+    index_buffer: Buffer,
+    index_buffer_size: u64,
+    params: Params,
+    params_buffer: Buffer,
+    bind_group: BindGroup,
+    vertices_to_render: u32,
+}
+
+impl TextRenderer {
+    pub fn new(
+        device: &Device,
+        _queue: &Queue,
+        format: TextureFormat,
+        screen_resolution: Resolution,
+    ) -> Self {
+        let glyph_cache = HashMap::new();
+        let max_texture_dimension_2d = device.limits().max_texture_dimension_2d;
+        let atlas_width = max_texture_dimension_2d;
+        let atlas_height = max_texture_dimension_2d;
+
+        let atlas_packer =
+            BucketedAtlasAllocator::new(size2(atlas_width as i32, atlas_height as i32));
+
+        // Create a texture to use for our atlas
+        let atlas_texture_pending = vec![0; (atlas_width * atlas_height) as usize];
+        let atlas_texture = device.create_texture(&TextureDescriptor {
+            label: Some("glyphon atlas"),
+            size: Extent3d {
+                width: atlas_width,
+                height: atlas_height,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: TextureDimension::D2,
+            format: TextureFormat::R8Unorm,
+            usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST,
+        });
+        let atlas_texture_view = atlas_texture.create_view(&TextureViewDescriptor::default());
+        let atlas_sampler = device.create_sampler(&SamplerDescriptor {
+            label: Some("glyphon sampler"),
+            min_filter: FilterMode::Nearest,
+            mag_filter: FilterMode::Nearest,
+            mipmap_filter: FilterMode::Nearest,
+            lod_min_clamp: 0f32,
+            lod_max_clamp: 0f32,
+            ..Default::default()
+        });
+
+        // Create a render pipeline to use for rendering later
+        let shader = device.create_shader_module(&ShaderModuleDescriptor {
+            label: Some("glyphon shader"),
+            source: ShaderSource::Wgsl(Cow::Borrowed(include_str!("shader.wgsl"))),
+        });
+
+        let vertex_buffers = [wgpu::VertexBufferLayout {
+            array_stride: mem::size_of::<GlyphToRender>() as wgpu::BufferAddress,
+            step_mode: wgpu::VertexStepMode::Vertex,
+            attributes: &[
+                wgpu::VertexAttribute {
+                    format: VertexFormat::Float32x4,
+                    offset: 0,
+                    shader_location: 0,
+                },
+                wgpu::VertexAttribute {
+                    format: VertexFormat::Float32x2,
+                    offset: mem::size_of::<f32>() as u64 * 4,
+                    shader_location: 1,
+                },
+                wgpu::VertexAttribute {
+                    format: VertexFormat::Uint32,
+                    offset: mem::size_of::<f32>() as u64 * 6,
+                    shader_location: 2,
+                },
+            ],
+        }];
+
+        let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+            entries: &[
+                BindGroupLayoutEntry {
+                    binding: 0,
+                    visibility: ShaderStages::VERTEX,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: NonZeroU64::new(mem::size_of::<Params>() as u64),
+                    },
+                    count: None,
+                },
+                BindGroupLayoutEntry {
+                    binding: 1,
+                    visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        multisampled: false,
+                        view_dimension: TextureViewDimension::D2,
+                        sample_type: TextureSampleType::Float { filterable: true },
+                    },
+                    count: None,
+                },
+                BindGroupLayoutEntry {
+                    binding: 2,
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Sampler(SamplerBindingType::Filtering),
+                    count: None,
+                },
+            ],
+            label: Some("glyphon bind group layout"),
+        });
+
+        let params = Params { screen_resolution };
+
+        let params_raw = unsafe {
+            slice::from_raw_parts(
+                &params as *const Params as *const u8,
+                mem::size_of::<Params>(),
+            )
+        };
+
+        let params_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+            label: Some("glyphon params"),
+            contents: params_raw,
+            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
+        });
+
+        let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+            layout: &bind_group_layout,
+            entries: &[
+                BindGroupEntry {
+                    binding: 0,
+                    resource: params_buffer.as_entire_binding(),
+                },
+                BindGroupEntry {
+                    binding: 1,
+                    resource: BindingResource::TextureView(&atlas_texture_view),
+                },
+                BindGroupEntry {
+                    binding: 2,
+                    resource: BindingResource::Sampler(&atlas_sampler),
+                },
+            ],
+            label: Some("glyphon bind group"),
+        });
+
+        let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
+            label: None,
+            bind_group_layouts: &[&bind_group_layout],
+            push_constant_ranges: &[],
+        });
+
+        let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
+            label: Some("glyphon pipeline"),
+            layout: Some(&pipeline_layout),
+            vertex: VertexState {
+                module: &shader,
+                entry_point: "vs_main",
+                buffers: &vertex_buffers,
+            },
+            fragment: Some(FragmentState {
+                module: &shader,
+                entry_point: "fs_main",
+                targets: &[ColorTargetState {
+                    format,
+                    blend: Some(BlendState::ALPHA_BLENDING),
+                    write_mask: ColorWrites::default(),
+                }],
+            }),
+            primitive: PrimitiveState::default(),
+            depth_stencil: None,
+            multisample: MultisampleState {
+                count: 1,
+                mask: !0,
+                alpha_to_coverage_enabled: false,
+            },
+            multiview: None,
+        });
+
+        let vertex_buffer_size = 4096;
+        let vertex_buffer = device.create_buffer(&BufferDescriptor {
+            label: Some("glyphon vertices"),
+            size: vertex_buffer_size,
+            usage: BufferUsages::VERTEX | BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+
+        let index_buffer_size = 4096;
+        let index_buffer = device.create_buffer(&BufferDescriptor {
+            label: Some("glyphon indices"),
+            size: index_buffer_size,
+            usage: BufferUsages::INDEX | BufferUsages::COPY_DST,
+            mapped_at_creation: false,
+        });
+
+        Self {
+            glyph_cache,
+            atlas_texture_pending,
+            atlas_texture,
+            atlas_packer,
+            atlas_width,
+            atlas_height,
+            pipeline,
+            vertex_buffer,
+            vertex_buffer_size,
+            index_buffer,
+            index_buffer_size,
+            params,
+            params_buffer,
+            bind_group,
+            vertices_to_render: 0,
+        }
+    }
+
+    pub fn prepare(
+        &mut self,
+        device: &Device,
+        queue: &Queue,
+        screen_resolution: Resolution,
+        fonts: &[Font],
+        layouts: &[&Layout],
+    ) -> Result<(), PrepareError> {
+        if screen_resolution != self.params.screen_resolution {
+            self.params.screen_resolution = screen_resolution;
+            queue.write_buffer(&self.params_buffer, 0, unsafe {
+                slice::from_raw_parts(
+                    &self.params as *const Params as *const u8,
+                    mem::size_of::<Params>(),
+                )
+            });
+        }
+
+        struct UploadBounds {
+            x_min: usize,
+            x_max: usize,
+            y_min: usize,
+            y_max: usize,
+        }
+        let mut upload_bounds = None::<UploadBounds>;
+
+        for layout in layouts.iter() {
+            for glyph in layout.glyphs() {
+                let already_on_gpu = self.glyph_cache.contains_key(&glyph.key);
+                if already_on_gpu {
+                    continue;
+                }
+
+                let font = &fonts[glyph.font_index];
+                let (metrics, bitmap) = font.rasterize_config(glyph.key);
+
+                let (gpu_cache, atlas_id) = if glyph.char_data.rasterize() {
+                    // Find a position in the packer
+                    let allocation = match try_allocate(
+                        &mut self.atlas_packer,
+                        layout,
+                        &mut self.glyph_cache,
+                        metrics.width,
+                        metrics.height,
+                    ) {
+                        Some(a) => a,
+                        None => return Err(PrepareError::AtlasFull),
+                    };
+                    let atlas_min = allocation.rectangle.min;
+                    let atlas_max = allocation.rectangle.max;
+
+                    for row in 0..metrics.height {
+                        let y_offset = atlas_min.y as usize;
+                        let x_offset =
+                            (y_offset + row) * self.atlas_width as usize + atlas_min.x as usize;
+                        let bitmap_row = &bitmap[row * metrics.width..(row + 1) * metrics.width];
+                        self.atlas_texture_pending[x_offset..x_offset + metrics.width]
+                            .copy_from_slice(bitmap_row);
+                    }
+
+                    match upload_bounds.as_mut() {
+                        Some(ub) => {
+                            ub.x_min = ub.x_min.min(atlas_min.x as usize);
+                            ub.x_max = ub.x_max.max(atlas_max.x as usize);
+                            ub.y_min = ub.y_min.min(atlas_min.y as usize);
+                            ub.y_max = ub.y_max.max(atlas_max.y as usize);
+                        }
+                        None => {
+                            upload_bounds = Some(UploadBounds {
+                                x_min: atlas_min.x as usize,
+                                x_max: atlas_max.x as usize,
+                                y_min: atlas_min.y as usize,
+                                y_max: atlas_max.y as usize,
+                            });
+                        }
+                    }
+
+                    (
+                        GpuCache::InAtlas {
+                            x: atlas_min.x as u16,
+                            y: atlas_min.y as u16,
+                        },
+                        Some(allocation.id),
+                    )
+                } else {
+                    (GpuCache::SkipRasterization, None)
+                };
+
+                self.glyph_cache.insert(
+                    glyph.key,
+                    GlyphDetails {
+                        width: metrics.width as u32,
+                        height: metrics.height as u32,
+                        gpu_cache,
+                        atlas_id,
+                    },
+                );
+            }
+        }
+
+        if let Some(ub) = upload_bounds {
+            queue.write_texture(
+                ImageCopyTexture {
+                    texture: &self.atlas_texture,
+                    mip_level: 0,
+                    origin: Origin3d {
+                        x: ub.x_min as u32,
+                        y: ub.y_min as u32,
+                        z: 0,
+                    },
+                    aspect: TextureAspect::All,
+                },
+                &self.atlas_texture_pending[ub.y_min * self.atlas_width as usize + ub.x_min..],
+                ImageDataLayout {
+                    offset: 0,
+                    bytes_per_row: NonZeroU32::new(self.atlas_width as u32),
+                    rows_per_image: NonZeroU32::new(self.atlas_height as u32),
+                },
+                Extent3d {
+                    width: (ub.x_max - ub.x_min) as u32,
+                    height: (ub.y_max - ub.y_min) as u32,
+                    depth_or_array_layers: 1,
+                },
+            );
+        }
+
+        let mut glyph_vertices = Vec::new();
+        let mut glyph_indices = Vec::new();
+        let mut glyphs_added = 0;
+
+        for layout in layouts.iter() {
+            for glyph in layout.glyphs() {
+                let details = self.glyph_cache.get_mut(&glyph.key).unwrap();
+                let (atlas_x, atlas_y) = match details.gpu_cache {
+                    GpuCache::InAtlas { x, y } => (x, y),
+                    GpuCache::SkipRasterization => continue,
+                };
+
+                glyph_vertices.extend(
+                    iter::repeat(GlyphToRender {
+                        x: glyph.x,
+                        y: glyph.y,
+                        width: details.width as f32,
+                        height: details.height as f32,
+                        atlas_x: atlas_x as f32,
+                        atlas_y: atlas_y as f32,
+                        color: [255, 255, 0, 255],
+                    })
+                    .take(4),
+                );
+
+                let start = 4 * glyphs_added as u32;
+                glyph_indices.extend([start, start + 1, start + 2, start, start + 2, start + 3]);
+
+                glyphs_added += 1;
+            }
+        }
+
+        const VERTICES_PER_GLYPH: u32 = 6;
+        self.vertices_to_render = glyphs_added as u32 * VERTICES_PER_GLYPH;
+
+        let will_render = glyphs_added > 0;
+        if !will_render {
+            return Ok(());
+        }
+
+        let vertices = glyph_vertices.as_slice();
+        let vertices_raw = unsafe {
+            slice::from_raw_parts(
+                vertices as *const _ as *const u8,
+                mem::size_of::<GlyphToRender>() * vertices.len(),
+            )
+        };
+
+        if self.vertex_buffer_size >= vertices_raw.len() as u64 {
+            queue.write_buffer(&self.vertex_buffer, 0, vertices_raw);
+        } else {
+            self.vertex_buffer.destroy();
+            self.vertex_buffer_size = vertices_raw.len().next_power_of_two() as u64;
+            self.vertex_buffer = device.create_buffer_init(&BufferInitDescriptor {
+                label: Some("glyphon vertices"),
+                contents: vertices_raw,
+                usage: BufferUsages::VERTEX | BufferUsages::COPY_DST,
+            });
+        }
+
+        let indices = glyph_indices.as_slice();
+        let indices_raw = unsafe {
+            slice::from_raw_parts(
+                indices as *const _ as *const u8,
+                mem::size_of::<u32>() * indices.len(),
+            )
+        };
+
+        if self.index_buffer_size >= indices_raw.len() as u64 {
+            queue.write_buffer(&self.index_buffer, 0, indices_raw);
+        } else {
+            self.index_buffer.destroy();
+            self.index_buffer_size = indices_raw.len().next_power_of_two() as u64;
+            self.index_buffer = device.create_buffer_init(&BufferInitDescriptor {
+                label: Some("glyphon indices"),
+                contents: indices_raw,
+                usage: BufferUsages::INDEX | BufferUsages::COPY_DST,
+            });
+        }
+
+        Ok(())
+    }
+
+    pub fn render<'pass>(&'pass mut self, pass: &mut RenderPass<'pass>) -> Result<(), ()> {
+        if self.vertices_to_render == 0 {
+            return Ok(());
+        }
+
+        pass.set_pipeline(&self.pipeline);
+        pass.set_bind_group(0, &self.bind_group, &[]);
+        pass.set_vertex_buffer(0, self.vertex_buffer.slice(..));
+        pass.set_index_buffer(self.index_buffer.slice(..), IndexFormat::Uint32);
+        pass.draw_indexed(0..self.vertices_to_render, 0, 0..1);
+
+        Ok(())
+    }
+}

src/shader.wgsl

@@ -0,0 +1,71 @@
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) color: vec4<f32>,
+    @location(1) tex_coords: vec2<f32>,
+};
+
+struct Params {
+    screen_resolution: vec2<u32>,
+};
+
+@group(0) @binding(0)
+var<uniform> params: Params;
+
+@group(0) @binding(1)
+var atlas_texture: texture_2d<f32>;
+
+@group(0) @binding(2)
+var atlas_sampler: sampler;
+
+@vertex
+fn vs_main(@builtin(vertex_index) vertex_idx: u32, @location(0) in_vert: vec4<f32>, @location(1) tex_coords: vec2<f32>, @location(2) color: u32) -> VertexOutput {
+    let width = in_vert.z;
+    let height = in_vert.w;
+
+    let v = vertex_idx % 4u;
+    var pos = in_vert.xy;
+    var uv = tex_coords;
+
+    switch v {
+        case 0u: {
+        }
+        case 1u: {
+            pos.x += width;
+            uv.x += width;
+        }
+        case 2u: {
+            pos.x += width;
+            pos.y += height;
+            uv.x += width;
+            uv.y += height;
+        }
+        case 3u: {
+            pos.y += height;
+            uv.y += height;
+        }
+        default: {}
+    }
+
+    pos = 2.0 * pos / vec2<f32>(params.screen_resolution) - 1.0;
+    pos.y *= -1.0;
+
+    var vert_output: VertexOutput;
+
+    vert_output.position = vec4<f32>(pos.xy, 0.0, 1.0);
+
+    vert_output.color = vec4<f32>(
+        f32((color & 0xffu)),
+        f32((color & 0xff00u) >> 8u),
+        f32((color & 0xff0000u) >> 16u),
+        f32((color & 0xff000000u) >> 24u),
+    ) / 255.0;
+
+    vert_output.tex_coords = uv / vec2<f32>(textureDimensions(atlas_texture).xy);
+
+    return vert_output;
+}
+
+@fragment
+fn fs_main(in_frag: VertexOutput) -> @location(0) vec4<f32> {
+    return in_frag.color * textureSample(atlas_texture, atlas_sampler, in_frag.tex_coords).x;
+}