Increasing maximum vertex indices

With the current dumb Gooey input implementation, the editor grows and
draws every glyph every frame. Pasting in the Advent of Code input for
day 1 caused too many indices to be queued, since the UI in Gooey is
gathered into a single IBO.

src/lib.rs

@@ -1527,11 +1527,11 @@ impl BuildHasher for DefaultHasher {
 #[derive(Default, Debug)]
 struct VertexCollection<T> {
     vertices: Vec<Vertex<T>>,
-    vertex_index_by_id: HashMap<VertexId, u16, DefaultHasher>,
+    vertex_index_by_id: HashMap<VertexId, u32, DefaultHasher>,
 }
 
 impl<T> VertexCollection<T> {
-    fn get_or_insert(&mut self, vertex: Vertex<T>) -> u16
+    fn get_or_insert(&mut self, vertex: Vertex<T>) -> u32
     where
         T: Copy,
         Vertex<T>: Into<Vertex<i32>>,
@@ -1577,7 +1577,7 @@ where
         &self.verticies
     }
 
-    fn indices(&self) -> &[u16] {
+    fn indices(&self) -> &[u32] {
         &[1, 0, 2, 1, 2, 3]
     }
 }

src/pipeline.rs

@@ -84,7 +84,7 @@ pub(crate) struct PushConstants {
 #[derive(Debug)]
 pub struct PreparedGraphic<Unit> {
     pub(crate) vertices: Buffer<Vertex<Unit>>,
-    pub(crate) indices: Buffer<u16>,
+    pub(crate) indices: Buffer<u32>,
     pub(crate) commands: SmallVec<[PreparedCommand; 2]>,
 }
 
@@ -115,7 +115,7 @@ where
         graphics.pass.set_vertex_buffer(0, self.vertices.as_slice());
         graphics
             .pass
-            .set_index_buffer(self.indices.as_slice(), wgpu::IndexFormat::Uint16);
+            .set_index_buffer(self.indices.as_slice(), wgpu::IndexFormat::Uint32);
 
         for command in &self.commands {
             if graphics.clip.current.size.is_zero() {

src/render.rs

@@ -115,7 +115,7 @@ impl<'render, 'gfx> Renderer<'render, 'gfx> {
         for &vertex_index in shape.source.indices() {
             self.data
                 .indices
-                .push(vertex_map[usize::from(vertex_index)]);
+                .push(vertex_map[usize::try_from(vertex_index).assert("too many drawn indices")]);
         }
 
         let mut flags = Unit::flags();
@@ -252,6 +252,7 @@ mod text {
 
     use figures::units::Px;
     use figures::{Fraction, ScreenScale, ScreenUnit, UnscaledUnit};
+    use intentional::Assert;
 
     use super::{
         Angle, Color, Command, IntoSigned, Point, PushConstants, Renderer, Vertex, Zero,
@@ -449,14 +450,14 @@ mod text {
         clip_index: u32,
         dpi_scale: Fraction,
         vertices: &mut VertexCollection<i32>,
-        indices: &mut Vec<u16>,
+        indices: &mut Vec<u32>,
         textures: &mut HashMap<TextureId, Arc<wgpu::BindGroup>, DefaultHasher>,
         commands: &mut Vec<Command>,
     ) where
         Unit: ScreenUnit,
     {
         let translation = translation.into_px(dpi_scale).map(Px::into_unscaled);
-        let corners: [u16; 4] = array::from_fn(|index| {
+        let corners: [u32; 4] = array::from_fn(|index| {
             let vertex = &blit.verticies[index];
             vertices.get_or_insert(Vertex {
                 location: vertex.location.into_signed().map(Px::into_unscaled),
@@ -466,7 +467,7 @@ mod text {
         });
         let start_index = u32::try_from(indices.len()).expect("too many drawn indices");
         for &index in blit.indices() {
-            indices.push(corners[usize::from(index)]);
+            indices.push(corners[usize::try_from(index).assert("too many drawn indices")]);
         }
         let mut flags = Px::flags() | FLAG_TEXTURED;
         if let hash_map::Entry::Vacant(vacant) = textures.entry(cached.texture.id()) {
@@ -566,7 +567,7 @@ pub struct Drawing {
     vertices: VertexCollection<i32>,
     clips: Vec<Rect<UPx>>,
     clip_lookup: HashMap<Rect<UPx>, u32, DefaultHasher>,
-    indices: Vec<u16>,
+    indices: Vec<u32>,
     textures: HashMap<sealed::TextureId, Arc<wgpu::BindGroup>, DefaultHasher>,
     commands: Vec<Command>,
     #[cfg(feature = "cosmic-text")]
@@ -577,7 +578,7 @@ pub struct Drawing {
 #[derive(Debug)]
 struct RenderingBuffers {
     vertex: DiffableBuffer<Vertex<i32>>,
-    index: DiffableBuffer<u16>,
+    index: DiffableBuffer<u32>,
 }
 
 impl Drawing {
@@ -626,7 +627,7 @@ impl Drawing {
                 .set_vertex_buffer(0, buffers.vertex.as_slice());
             graphics
                 .pass
-                .set_index_buffer(buffers.index.as_slice(), wgpu::IndexFormat::Uint16);
+                .set_index_buffer(buffers.index.as_slice(), wgpu::IndexFormat::Uint32);
 
             let mut current_clip_index = 0;
             let mut current_clip = graphics.clip.current.0;

src/sealed.rs

@@ -36,7 +36,7 @@ pub trait TextureSource {
 
 pub trait ShapeSource<Unit> {
     fn vertices(&self) -> &[Vertex<Unit>];
-    fn indices(&self) -> &[u16];
+    fn indices(&self) -> &[u32];
     fn prepare(
         &self,
         texture: Option<&impl TextureSource>,

src/shapes.rs

@@ -25,12 +25,12 @@ use crate::{
 #[derive(Debug, Clone, PartialEq)]
 pub struct Shape<Unit, const TEXTURED: bool> {
     pub(crate) vertices: SmallVec<[Vertex<Unit>; 6]>,
-    pub(crate) indices: SmallVec<[u16; 20]>,
+    pub(crate) indices: SmallVec<[u32; 20]>,
 }
 
 #[test]
 fn shape_size() {
-    assert_eq!(std::mem::size_of::<Shape<i32, true>>(), 176);
+    assert_eq!(std::mem::size_of::<Shape<i32, true>>(), 216);
 }
 
 impl<Unit, const TEXTURED: bool> Default for Shape<Unit, TEXTURED> {
@@ -221,7 +221,7 @@ where
         &self.vertices
     }
 
-    fn indices(&self) -> &[u16] {
+    fn indices(&self) -> &[u32] {
         &self.indices
     }
 }
@@ -274,7 +274,7 @@ where
                 .map_err(|_| GeometryBuilderError::TooManyVertices)?,
         );
         self.shape.vertices.push(vertex);
-        if self.shape.vertices.len() > u16::MAX as usize {
+        if self.shape.vertices.len() > u32::MAX as usize {
             return Err(GeometryBuilderError::TooManyVertices);
         }
 
@@ -339,15 +339,9 @@ where
     fn end_geometry(&mut self) {}
 
     fn add_triangle(&mut self, a: VertexId, b: VertexId, c: VertexId) {
-        self.shape
-            .indices
-            .push(a.0.try_into().expect("checked in new_vertex"));
-        self.shape
-            .indices
-            .push(b.0.try_into().expect("checked in new_vertex"));
-        self.shape
-            .indices
-            .push(c.0.try_into().expect("checked in new_vertex"));
+        self.shape.indices.push(a.0);
+        self.shape.indices.push(b.0);
+        self.shape.indices.push(c.0);
     }
 
     fn abort_geometry(&mut self) {

src/text.rs

@@ -363,11 +363,11 @@ impl<'gfx> Graphics<'gfx> {
             self.queue,
             &mut glyphs,
             |blit, cached, _glyph, _is_first_line, _baseline, _line_w| {
-                let corners: [u16; 4] =
+                let corners: [u32; 4] =
                     array::from_fn(|index| vertices.get_or_insert(blit.verticies[index]));
                 let start_index = u32::try_from(indices.len()).assert("too many drawn indices");
                 for &index in blit.indices() {
-                    indices.push(corners[usize::from(index)]);
+                    indices.push(corners[usize::try_from(index).assert("too many drawn indices")]);
                 }
                 let end_index = u32::try_from(indices.len()).assert("too many drawn indices");
                 match commands.last_mut() {