Drop the prelude-bounds test

The rename is the guarantee; there is no way back to a name that is not
there any more.

Cargo.toml

@@ -8,8 +8,7 @@ edition.workspace = true
 [dependencies]
 iris-core = { workspace = true }
 iris-macro = { workspace = true }
-cosmic-text = { workspace = true }
+parley = { workspace = true }
-unicode-segmentation = { workspace = true }
 winit = { workspace = true }
 arboard = { workspace = true, features = ["wayland-data-control"] }
 pollster = { workspace = true }
@@ -30,12 +29,13 @@ edition = "2024"
 [workspace.dependencies]
 pollster = "0.4.0"
 winit = "0.30.12"
-wgpu = "28.0.0"
+wgpu = "30.0.1"
 bytemuck = "1.23.1"
-image = "0.25.6"
+image = "0.25.10"
-cosmic-text = "0.16.0"
+parley = "0.11.1"
-unicode-segmentation = "1.12.0"
+swash = "0.2.10"
 fxhash = "0.2.1"
+log = "0.4.29"
 arboard = "3.6.1"
 iris-core = { path = "core" }
 iris-macro = { path = "macro" }

TODO

@@ -1,19 +1,6 @@
 images
     settings (sampler)
-
+    consider typed TextureHandle<T> variants for distinct texture uses
-text
-    figure out ways to speed up / what costs the most
-    resizing (per frame) is really slow (assuming painter isn't griefing)
-    j is weird / fix x offset
-
-masks r just made to bare minimum work
-
-scaling
-    could be just a simple scaling factor that multiplies abs
-    and need to ensure text uses raw abs and not scaled abs
-    naming? (pt, px)
-    want to keep (drawn) regions using px? or should I add another field to UiScalar/Vec
-    field could be best solution so redrawing stuff isn't needed & you can specify both as user
 
 WidgetRef<W> or smth instead of Id
     enum that's either an Id or an actual concrete instance of W
@@ -24,17 +11,6 @@ WidgetRef<W> or smth instead of Id
     maybe introduce InnerWidget trait to allow for editors to expose & modify inner type
     maybe could also store a parent widget and keep using InnerWidget trait? unsure if possible
 
-really weird limitation:
-    I don't think you can currently remove an element from a parent and put it in a child of the same parent
-    because it removes the unused children after the entire parent redraw
-    but the child gets drawn during that, so it will think the child is still active !!!
-    or something like that idk, maybe I need a special enum for parent that includes a undecided state where it may or may not get redrawn by the parent
-    or just do ref counting and ensure all drawn things == 1 afterwards (seems like best way)
-    ok so I'm removing the limit for now
-
-don't forget I'm streaming
-
-tags
 vecs for each widget type?
 
 POTENTIAL BUG: closures that store IDs will not decrement the id!!! need to not increment id if moved into closure somehow??? wait no, need to decrement ID every time an event fn is added...... only if the id is used in it..??

core/Cargo.toml

@@ -4,9 +4,10 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-winit = { workspace = true }
 wgpu = { workspace = true }
 bytemuck ={ workspace = true }
 image = { workspace = true }
-cosmic-text = { workspace = true }
+parley = { workspace = true }
+swash = { workspace = true }
 fxhash = { workspace = true }
+log = { workspace = true }

core/src/attr.rs

@@ -1,4 +1,4 @@
-use crate::{UiRsc, WidgetIdFn, WidgetLike, WeakWidget};
+use crate::{UiRsc, WeakWidget, WidgetIdFn, WidgetLike};
 
 pub trait WidgetAttr<Rsc, W: ?Sized> {
     type Input;

core/src/lib.rs

@@ -2,12 +2,9 @@
 #![feature(const_ops)]
 #![feature(const_trait_impl)]
 #![feature(const_convert)]
-#![feature(map_try_insert)]
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
-#![feature(const_cmp)]
 #![feature(const_destruct)]
-#![feature(portable_simd)]
 #![feature(associated_type_defaults)]
 #![feature(unsize)]
 #![feature(coerce_unsized)]

core/src/num.rs

@@ -5,19 +5,19 @@ pub const trait UiNum {
     fn to_f32(self) -> f32;
 }
 
-impl const UiNum for f32 {
+const impl UiNum for f32 {
     fn to_f32(self) -> f32 {
         self
     }
 }
 
-impl const UiNum for u32 {
+const impl UiNum for u32 {
     fn to_f32(self) -> f32 {
         self as f32
     }
 }
 
-impl const UiNum for i32 {
+const impl UiNum for i32 {
     fn to_f32(self) -> f32 {
         self as f32
     }
@@ -27,7 +27,7 @@ pub const fn vec2(x: impl const UiNum, y: impl const UiNum) -> Vec2 {
     Vec2::new(x.to_f32(), y.to_f32())
 }
 
-impl<T: const UiNum + Copy> const From<T> for Vec2 {
+const impl<T: const UiNum + Copy> From<T> for Vec2 {
     fn from(v: T) -> Self {
         Self {
             x: v.to_f32(),
@@ -36,7 +36,7 @@ impl<T: const UiNum + Copy> const From<T> for Vec2 {
     }
 }
 
-impl<T: const UiNum, U: const UiNum> const From<(T, U)> for Vec2
+const impl<T: const UiNum, U: const UiNum> From<(T, U)> for Vec2
 where
     (T, U): const Destruct,
 {

core/src/orientation/align.rs

@@ -187,7 +187,7 @@ impl From<CardinalAlign> for Align {
     }
 }
 
-impl const From<RegionAlign> for UiVec2 {
+const impl From<RegionAlign> for UiVec2 {
     fn from(align: RegionAlign) -> Self {
         Self::rel(align.rel())
     }

core/src/orientation/axis.rs

@@ -74,14 +74,14 @@ pub const trait AxisT {
 }
 
 pub struct XAxis;
-impl const AxisT for XAxis {
+const impl AxisT for XAxis {
     fn get() -> Axis {
         Axis::X
     }
 }
 
 pub struct YAxis;
-impl const AxisT for YAxis {
+const impl AxisT for YAxis {
     fn get() -> Axis {
         Axis::Y
     }

core/src/orientation/pos.rs

@@ -124,13 +124,13 @@ impl Display for UiVec2 {
 impl_op!(UiVec2 Add add; x y);
 impl_op!(UiVec2 Sub sub; x y);
 
-impl const From<Vec2> for UiVec2 {
+const impl From<Vec2> for UiVec2 {
     fn from(abs: Vec2) -> Self {
         Self::abs(abs)
     }
 }
 
-impl<T: const UiNum, U: const UiNum> const From<(T, U)> for UiVec2
+const impl<T: const UiNum, U: const UiNum> From<(T, U)> for UiVec2
 where
     (T, U): const Destruct,
 {

core/src/primitive/color.rs

@@ -10,6 +10,12 @@ pub struct Color<T> {
     pub a: T,
 }
 
+impl<T: ColorNum> Default for Color<T> {
+    fn default() -> Self {
+        Self::BLACK
+    }
+}
+
 impl<T: ColorNum> Color<T> {
     pub const BLACK: Self = Self::rgb(T::MIN, T::MIN, T::MIN);
     pub const WHITE: Self = Self::rgb(T::MAX, T::MAX, T::MAX);
@@ -144,7 +150,7 @@ impl ColorNum for f32 {
 
 unsafe impl bytemuck::Pod for Color<u8> {}
 
-impl const F32Conversion for f32 {
+const impl F32Conversion for f32 {
     fn to(self) -> f32 {
         self
     }
@@ -153,7 +159,7 @@ impl const F32Conversion for f32 {
     }
 }
 
-impl const F32Conversion for u8 {
+const impl F32Conversion for u8 {
     fn to(self) -> f32 {
         self as f32 / 255.0
     }

core/src/primitive/layer.rs

@@ -1,7 +1,7 @@
 use std::ops::{Index, IndexMut};
 
 use crate::{
-    render::{MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, Primitives},
+    render::{LayerDraws, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
     util::to_mut,
 };
 
@@ -39,7 +39,7 @@ struct Child {
     tail: usize,
 }
 
-pub type PrimitiveLayers = Layers<Primitives>;
+pub type DrawLayers = Layers<LayerDraws>;
 
 impl<T: Default> Layers<T> {
     pub fn new() -> Layers<T> {
@@ -119,7 +119,7 @@ impl<T: Default> Layers<T> {
     }
 }
 
-impl PrimitiveLayers {
+impl DrawLayers {
     pub fn write<P: Primitive>(
         &mut self,
         layer: LayerId,

core/src/primitive/text.rs

@@ -1,60 +1,66 @@
-use crate::{Align, RegionAlign, TextureHandle, Textures, UiColor, util::Vec2};
+use crate::{
-use cosmic_text::{
+    Align, GlyphAtlas, GlyphEntry, GlyphKey, PlacedGlyph, RegionAlign, UiColor, util::Vec2,
-    Attrs, AttrsList, Buffer, CacheKey, Color, Family, FontSystem, Metrics, Placement, SwashCache,
+};
-    SwashContent,
+use parley::{
+    Alignment, AlignmentOptions, FontContext, FontFamily, FontFamilyName, GenericFamily, Layout,
+    LayoutContext, LineHeight, PositionedLayoutItem, StyleProperty,
+};
+use std::hash::{DefaultHasher, Hash, Hasher};
+use swash::{
+    FontRef,
+    scale::{Render, ScaleContext, Source, StrikeWith},
+    zeno::{Format, Vector},
 };
-use image::{DynamicImage, GenericImageView, RgbaImage};
-use std::simd::{Simd, num::SimdUint};
-
-/// TODO: properly wrap this
-pub mod text_lib {
-    pub use cosmic_text::*;
-}
 
 pub struct TextData {
-    pub font_system: FontSystem,
+    pub font_ctx: FontContext,
-    pub swash_cache: SwashCache,
+    pub layout_ctx: LayoutContext<UiColor>,
-    glyph_cache: Vec<(Placement, CacheKey, Color)>,
+    scale_ctx: ScaleContext,
+    pub atlas: GlyphAtlas,
 }
 
 impl Default for TextData {
     fn default() -> Self {
         Self {
-            font_system: FontSystem::new(),
+            font_ctx: FontContext::new(),
-            swash_cache: SwashCache::new(),
+            layout_ctx: LayoutContext::new(),
-            glyph_cache: Default::default(),
+            scale_ctx: ScaleContext::new(),
+            atlas: GlyphAtlas::default(),
         }
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, PartialEq)]
+pub enum Family {
+    SansSerif,
+    Serif,
+    Monospace,
+    Named(String),
+}
+
+impl Family {
+    fn family(&self) -> FontFamily<'_> {
+        let name = match self {
+            Self::SansSerif => FontFamilyName::Generic(GenericFamily::SansSerif),
+            Self::Serif => FontFamilyName::Generic(GenericFamily::Serif),
+            Self::Monospace => FontFamilyName::Generic(GenericFamily::Monospace),
+            Self::Named(name) => FontFamilyName::Named(name.as_str().into()),
+        };
+        FontFamily::Single(name)
+    }
+}
+
+#[derive(Clone, PartialEq)]
 pub struct TextAttrs {
     pub color: UiColor,
     pub font_size: f32,
     pub line_height: f32,
-    pub family: Family<'static>,
+    pub family: Family,
     pub wrap: bool,
-    /// inner alignment of text region (within where it's drawn)
     pub align: RegionAlign,
 }
 
-impl TextAttrs {
+pub const LINE_HEIGHT_MULT: f32 = 1.1;
-    pub fn apply(&self, font_system: &mut FontSystem, buf: &mut Buffer, width: Option<f32>) {
-        buf.set_metrics_and_size(
-            font_system,
-            Metrics::new(self.font_size, self.line_height),
-            width,
-            None,
-        );
-        let attrs = Attrs::new().family(self.family);
-        let list = AttrsList::new(&attrs);
-        for line in &mut buf.lines {
-            line.set_attrs_list(list.clone());
-        }
-    }
-}
-
-pub type TextBuffer = Buffer;
 
 impl Default for TextAttrs {
     fn default() -> Self {
@@ -70,122 +76,207 @@ impl Default for TextAttrs {
     }
 }
 
-pub const LINE_HEIGHT_MULT: f32 = 1.1;
+/// Keeps text and its corresponding layout from getting out of sync.
+pub struct TextBuffer {
+    text: String,
+    layout: Layout<UiColor>,
+    layout_key: Option<LayoutKey>,
+}
+
+#[derive(PartialEq)]
+struct LayoutKey {
+    attrs: TextAttrs,
+    max_width: Option<f32>,
+}
+
+impl TextBuffer {
+    pub fn new(text: impl Into<String>) -> Self {
+        Self {
+            text: text.into(),
+            layout: Layout::new(),
+            layout_key: None,
+        }
+    }
+
+    pub fn new_empty() -> Self {
+        Self::new("")
+    }
+
+    pub fn text(&self) -> &str {
+        &self.text
+    }
+
+    pub fn layout(&self) -> &Layout<UiColor> {
+        &self.layout
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.text.is_empty()
+    }
+
+    pub fn set_text(&mut self, text: impl Into<String>) {
+        let text = text.into();
+        if text != self.text {
+            self.text = text;
+            self.layout_key = None;
+        }
+    }
+
+    /// Invalidates the layout and returns the underlying string for editing.
+    pub fn edit(&mut self) -> &mut String {
+        self.layout_key = None;
+        &mut self.text
+    }
+
+    pub fn size(&self) -> Vec2 {
+        Vec2::new(self.layout.width(), self.layout.height())
+    }
+
+    pub fn shape(&mut self, data: &mut TextData, attrs: &TextAttrs, width: Option<f32>) {
+        let layout_key = LayoutKey {
+            attrs: attrs.clone(),
+            max_width: width,
+        };
+        if self.layout_key.as_ref() == Some(&layout_key) {
+            return;
+        }
+        let mut builder = data
+            .layout_ctx
+            .ranged_builder(&mut data.font_ctx, &self.text, 1.0, true);
+        builder.push_default(StyleProperty::FontFamily(attrs.family.family()));
+        builder.push_default(StyleProperty::FontSize(attrs.font_size));
+        builder.push_default(StyleProperty::LineHeight(LineHeight::Absolute(
+            attrs.line_height,
+        )));
+        builder.push_default(StyleProperty::Brush(attrs.color));
+        builder.build_into(&mut self.layout, &self.text);
+        self.layout.break_all_lines(width);
+        self.layout
+            .align(Alignment::Start, AlignmentOptions::default());
+        self.layout_key = Some(layout_key);
+    }
+}
 
 impl TextData {
-    pub fn draw(
+    pub fn place(&mut self, buffer: &TextBuffer) -> Vec<PlacedGlyph> {
+        let mut placed = Vec::new();
+        for line in buffer.layout.lines() {
+            for item in line.items() {
+                let PositionedLayoutItem::GlyphRun(run) = item else {
+                    continue;
+                };
+                let font = run.run().font();
+                let font_size = run.run().font_size();
+                let coords = run.run().normalized_coords();
+                let Some(font_ref) = FontRef::from_index(font.data.as_ref(), font.index as usize)
+                else {
+                    continue;
+                };
+                let coords_hash = hash_coords(coords);
+                let font_id = font.data.id();
+
+                for glyph in run.positioned_glyphs() {
+                    let subpixel = ((glyph.x.fract() * 4.0).round() as i32).rem_euclid(4) as u8;
+                    let key = GlyphKey {
+                        font: font_id,
+                        glyph: glyph.id,
+                        size: glyph_size_key(font_size),
+                        subpixel,
+                        coords: coords_hash,
+                    };
+                    let Some(entry) = self.glyph_entry(GlyphRaster {
+                        key,
+                        font: font_ref,
+                        font_size,
+                        coords,
+                        subpixel,
+                        glyph_id: glyph.id,
+                    }) else {
+                        continue;
+                    };
+                    placed.push(PlacedGlyph {
+                        entry,
+                        offset: Vec2::new(
+                            glyph.x.floor() + entry.left as f32,
+                            glyph.y.floor() - entry.top as f32,
+                        ),
+                    });
+                }
+            }
+        }
+        placed
+    }
+
+    fn glyph_entry(&mut self, glyph: GlyphRaster<'_>) -> Option<GlyphEntry> {
+        if let Some(entry) = self.atlas.get(&glyph.key) {
+            return entry;
+        }
+
+        let mut scaler = self
+            .scale_ctx
+            .builder(glyph.font)
+            .size(glyph.font_size)
+            .hint(true)
+            .normalized_coords(glyph.coords)
+            .build();
+        let image = Render::new(&[
+            Source::ColorOutline(0),
+            Source::ColorBitmap(StrikeWith::BestFit),
+            Source::Outline,
+        ])
+        .format(Format::Alpha)
+        .offset(Vector::new(glyph.subpixel as f32 / 4.0, 0.0))
+        .render(&mut scaler, glyph.glyph_id as u16);
+
+        if let Some(image) = image {
+            self.atlas.insert(glyph.key, &image)
+        } else {
+            self.atlas.insert_empty(glyph.key);
+            None
+        }
+    }
+}
+
+struct GlyphRaster<'a> {
+    key: GlyphKey,
+    font: FontRef<'a>,
+    font_size: f32,
+    coords: &'a [i16],
+    subpixel: u8,
+    glyph_id: u32,
+}
+
+fn hash_coords(coords: &[i16]) -> u64 {
+    let mut hasher = DefaultHasher::new();
+    coords.hash(&mut hasher);
+    hasher.finish()
+}
+
+const GLYPH_SIZE_STEPS_PER_PIXEL: f32 = 16.0;
+
+fn glyph_size_key(font_size: f32) -> u32 {
+    (font_size * GLYPH_SIZE_STEPS_PER_PIXEL).round() as u32
+}
+
+pub struct RenderedText {
+    pub glyphs: Vec<PlacedGlyph>,
+    pub size: Vec2,
+    pub color: UiColor,
+}
+
+impl TextData {
+    pub fn render(
         &mut self,
         buffer: &mut TextBuffer,
         attrs: &TextAttrs,
-        textures: &mut Textures,
+        width: Option<f32>,
     ) -> RenderedText {
-        // TODO: either this or the layout stuff (or both) is super slow,
+        buffer.shape(self, attrs, width);
-        // should probably do texture packing and things if possible.
+        let glyphs = self.place(buffer);
-        // very visible if you add just a couple of wrapping texts and resize window
-        // should also be timed to figure out exactly what points need to be sped up
-        // let mut pixels = HashMap::<_, [u8; 4]>::default();
-        let mut min_x = 0;
-        let mut min_y = 0;
-        let mut max_x = 0;
-        let mut max_y = 0;
-        let text_color = {
-            let c = attrs.color;
-            cosmic_text::Color::rgba(c.r, c.g, c.b, c.a)
-        };
-        let mut max_width = 0.0f32;
-        let mut height = 0.0;
-
-        for run in buffer.layout_runs() {
-            for glyph in run.glyphs.iter() {
-                let physical_glyph = glyph.physical((0., 0.), 1.0);
-
-                let glyph_color = match glyph.color_opt {
-                    Some(some) => some,
-                    None => text_color,
-                };
-
-                if let Some(img) = self
-                    .swash_cache
-                    .get_image(&mut self.font_system, physical_glyph.cache_key)
-                {
-                    let mut pos = img.placement;
-                    pos.left += physical_glyph.x;
-                    pos.top = physical_glyph.y + run.line_y as i32 - pos.top;
-                    min_x = min_x.min(pos.left);
-                    min_y = min_y.min(pos.top);
-                    max_x = max_x.max(pos.left + pos.width as i32);
-                    max_y = max_y.max(pos.top + pos.height as i32);
-                    self.glyph_cache
-                        .push((pos, physical_glyph.cache_key, glyph_color));
-                }
-            }
-            max_width = max_width.max(run.line_w);
-            height += run.line_height;
-        }
-        let img_width = (max_x - min_x + 1) as u32;
-        let img_height = (max_y - min_y + 1) as u32;
-        let mut image = RgbaImage::new(img_width, img_height);
-
-        for (pos, key, color) in self.glyph_cache.drain(..) {
-            let img = self
-                .swash_cache
-                .get_image(&mut self.font_system, key)
-                .as_ref()
-                .unwrap();
-            let mut merge = |i, color: [u8; 4]| {
-                let i = i as i32;
-                let x = (i % pos.width as i32 + pos.left - min_x) as u32;
-                let y = (i / pos.width as i32 + pos.top - min_y) as u32;
-                let pixel = &mut image[(x, y)].0;
-                // TODO: no clue if proper alpha blending should be done
-                *pixel = Simd::from(color).saturating_add(Simd::from(*pixel)).into();
-            };
-
-            match img.content {
-                SwashContent::Mask => {
-                    for (i, a) in img.data.iter().enumerate() {
-                        let mut color = color.as_rgba();
-                        color[3] = ((color[3] as u32 * *a as u32) / u8::MAX as u32) as u8;
-                        merge(i, color);
-                    }
-                }
-                SwashContent::SubpixelMask => todo!("subpixel mask text rendering"),
-                SwashContent::Color => {
-                    let (colors, _) = img.data.as_chunks::<4>();
-                    for (i, color) in colors.iter().enumerate() {
-                        merge(i, *color);
-                    }
-                }
-            }
-        }
-
-        let max_dim = 8192;
-        if image.width() > max_dim || image.height() > max_dim {
-            let width = image.width().min(max_dim);
-            let height = image.height().min(max_dim);
-            eprintln!(
-                "WARNING: image of size {:?} cropped to {:?} (texture too big)",
-                image.dimensions(),
-                (width, height)
-            );
-            image = image.view(0, 0, width, height).to_image();
-        }
-
         RenderedText {
-            handle: textures.add(image),
+            glyphs,
-            top_left_offset: Vec2::new(min_x as f32, min_y as f32),
+            size: buffer.size(),
-            size: Vec2::new(max_width, height),
+            color: attrs.color,
         }
     }
 }
-
-#[derive(Clone)]
-pub struct RenderedText {
-    pub handle: TextureHandle,
-    pub top_left_offset: Vec2,
-    pub size: Vec2,
-}
-
-pub trait HasTextures {
-    fn add_texture(&mut self, image: DynamicImage) -> TextureHandle;
-}

core/src/primitive/texture.rs

@@ -1,7 +1,4 @@
-use crate::{
+use crate::util::{RefCounter, Vec2};
-    render::TexturePrimitive,
-    util::{RefCounter, Vec2},
-};
 use image::{DynamicImage, GenericImageView};
 use std::{
     ops::Index,
@@ -10,7 +7,7 @@ use std::{
 
 #[derive(Debug, Clone)]
 pub struct TextureHandle {
-    inner: TexturePrimitive,
+    slot: u32,
     size: Vec2,
     counter: RefCounter,
     send: Sender<u32>,
@@ -29,14 +26,26 @@ pub struct Textures {
 pub enum TextureUpdate<'a> {
     Push(&'a DynamicImage),
     Set(u32, &'a DynamicImage),
+    Patch(u32, PatchRect, &'a DynamicImage),
     Free(u32),
+    /// Added and freed before the renderer drained either update. It still has
+    /// to push a slot to stay lined up with `images`; `Free` then empties it.
     PushFree,
     SetFree,
 }
 
+#[derive(Debug, Clone, Copy)]
+pub struct PatchRect {
+    pub x: u32,
+    pub y: u32,
+    pub width: u32,
+    pub height: u32,
+}
+
 enum Update {
     Push(u32),
     Set(u32),
+    Patch(u32, PatchRect),
     Free(u32),
 }
 
@@ -54,14 +63,8 @@ impl Textures {
     pub fn add(&mut self, image: impl Into<DynamicImage>) -> TextureHandle {
         let image = image.into();
         let size = image.dimensions().into();
-        let view_idx = self.push(image);
-        // 0 == default in renderer; TODO: actually create samplers here
-        let sampler_idx = 0;
         TextureHandle {
-            inner: TexturePrimitive {
+            slot: self.push(image),
-                view_idx,
-                sampler_idx,
-            },
             size,
             counter: RefCounter::new(),
             send: self.send.clone(),
@@ -81,6 +84,23 @@ impl Textures {
         }
     }
 
+    pub fn image_mut(&mut self, handle: &TextureHandle) -> &mut DynamicImage {
+        self.images[handle.slot as usize]
+            .as_mut()
+            .expect("texture was freed while still held")
+    }
+
+    /// Queue an upload of just `rect`, after writing it with `image_mut`.
+    pub fn patch(&mut self, handle: &TextureHandle, rect: PatchRect) {
+        self.updates.push(Update::Patch(handle.slot, rect));
+    }
+
+    /// How many textures are live, which is what a ui can ask; the renderer's
+    /// copies follow from the updates it drains.
+    pub fn count(&self) -> usize {
+        self.images.iter().flatten().count()
+    }
+
     pub fn free(&mut self) {
         for idx in self.recv.try_iter() {
             self.images[idx as usize] = None;
@@ -99,14 +119,19 @@ impl Textures {
                 .as_ref()
                 .map(|img| TextureUpdate::Set(i, img))
                 .unwrap_or(TextureUpdate::SetFree),
+            Update::Patch(i, rect) => self.images[i as usize]
+                .as_ref()
+                .map(|img| TextureUpdate::Patch(i, rect, img))
+                .unwrap_or(TextureUpdate::SetFree),
             Update::Free(i) => TextureUpdate::Free(i),
         })
     }
 }
 
 impl TextureHandle {
-    pub fn primitive(&self) -> TexturePrimitive {
+    /// Index into `Textures`, and into the renderer's parallel slots.
-        self.inner
+    pub fn slot(&self) -> u32 {
+        self.slot
     }
     pub fn size(&self) -> Vec2 {
         self.size
@@ -116,7 +141,7 @@ impl TextureHandle {
 impl Drop for TextureHandle {
     fn drop(&mut self) {
         if self.counter.drop() {
-            let _ = self.send.send(self.inner.view_idx);
+            let _ = self.send.send(self.slot);
         }
     }
 }
@@ -125,7 +150,7 @@ impl Index<&TextureHandle> for Textures {
     type Output = DynamicImage;
 
     fn index(&self, index: &TextureHandle) -> &Self::Output {
-        self.images[index.inner.view_idx as usize].as_ref().unwrap()
+        self.images[index.slot as usize].as_ref().unwrap()
     }
 }
 

core/src/render/atlas.rs

@@ -0,0 +1,245 @@
+use crate::{
+    PatchRect,
+    util::{HashMap, Vec2},
+};
+use image::RgbaImage;
+use swash::scale::image::{Content, Image};
+
+/// Side of one page, and so of every layer of `render::page`'s array texture.
+pub(crate) const PAGE: u32 = 1024;
+
+/// Transparent margin kept around every glyph, so that sampling one cannot
+/// pick up its neighbour along a shared edge.
+const PAD: u32 = 1;
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GlyphKey {
+    pub font: u64,
+    pub glyph: u32,
+    /// Font size in 1/16 px, so sizes that round to the same pixels share a
+    /// raster instead of filling the atlas with near-duplicates.
+    pub size: u32,
+    /// Horizontal subpixel phase, in 1/4 px.
+    pub subpixel: u8,
+    /// Hash of the variation coordinates; a variable font at two weights is two
+    /// different sets of pixels from one glyph id.
+    pub coords: u64,
+}
+
+#[derive(Clone, Copy)]
+pub struct GlyphEntry {
+    pub uv_min: Vec2,
+    pub uv_max: Vec2,
+    /// Offset from the glyph's pen position to the top-left of its pixels.
+    pub left: i32,
+    pub top: i32,
+    pub width: u32,
+    pub height: u32,
+    pub is_colored: bool,
+    /// Which atlas array layer this glyph is on.
+    pub layer: u32,
+}
+
+impl GlyphEntry {
+    const IS_COLORED: u32 = 1;
+
+    pub(crate) fn flags(&self) -> u32 {
+        if self.is_colored { Self::IS_COLORED } else { 0 }
+    }
+}
+
+struct Page {
+    image: RgbaImage,
+    x: u32,
+    y: u32,
+    shelf_height: u32,
+}
+
+/// A rectangle of one page the renderer has not uploaded yet.
+#[derive(Clone, Copy)]
+pub struct PageUpload {
+    pub layer: u32,
+    pub rect: PatchRect,
+}
+
+#[derive(Default)]
+pub struct GlyphAtlas {
+    pages: Vec<Page>,
+    /// `None` for a glyph that rasterised to nothing -- a space, say. Cached
+    /// too, so it is not re-rasterised on every layout.
+    entries: HashMap<GlyphKey, Option<GlyphEntry>>,
+    uploads: Vec<PageUpload>,
+}
+
+impl GlyphAtlas {
+    pub fn get(&self, key: &GlyphKey) -> Option<Option<GlyphEntry>> {
+        self.entries.get(key).copied()
+    }
+
+    pub fn insert(&mut self, key: GlyphKey, image: &Image) -> Option<GlyphEntry> {
+        let w = image.placement.width;
+        let h = image.placement.height;
+        if w == 0 || h == 0 {
+            log::warn!(
+                "glyph {} in font {} rasterized at {w}x{h}; skipping it",
+                key.glyph,
+                key.font,
+            );
+            self.entries.insert(key, None);
+            return None;
+        }
+        if w > PAGE - PAD * 2 || h > PAGE - PAD * 2 {
+            log::warn!(
+                "glyph {} in font {} rasterized at {w}x{h}, too large for the {PAGE}x{PAGE} atlas; skipping it",
+                key.glyph,
+                key.font,
+            );
+            self.entries.insert(key, None);
+            return None;
+        }
+
+        let upload = self.allocate(w, h);
+        let PatchRect { x, y, .. } = upload.rect;
+        write_glyph(&mut self.pages[upload.layer as usize].image, image, x, y);
+        self.uploads.push(upload);
+
+        let scale = 1.0 / PAGE as f32;
+        let entry = GlyphEntry {
+            uv_min: Vec2::new(x as f32 * scale, y as f32 * scale),
+            uv_max: Vec2::new((x + w) as f32 * scale, (y + h) as f32 * scale),
+            left: image.placement.left,
+            top: image.placement.top,
+            width: w,
+            height: h,
+            is_colored: matches!(image.content, Content::Color),
+            layer: upload.layer,
+        };
+        self.entries.insert(key, Some(entry));
+        Some(entry)
+    }
+
+    /// Reserves room for a `w` by `h` glyph, adding a page if none has it.
+    fn allocate(&mut self, w: u32, h: u32) -> PageUpload {
+        let rect = |x, y| PatchRect {
+            x,
+            y,
+            width: w,
+            height: h,
+        };
+        if let Some((i, (x, y))) = self
+            .pages
+            .iter_mut()
+            .enumerate()
+            .find_map(|(i, page)| page.allocate(w, h).map(|position| (i, position)))
+        {
+            return PageUpload {
+                layer: i as u32,
+                rect: rect(x, y),
+            };
+        }
+
+        self.pages.push(Page {
+            image: RgbaImage::new(PAGE, PAGE),
+            x: PAD + w + PAD,
+            y: PAD,
+            shelf_height: h + PAD,
+        });
+        PageUpload {
+            layer: self.pages.len() as u32 - 1,
+            rect: rect(PAD, PAD),
+        }
+    }
+
+    /// Drains what has been written since the last call, for the renderer to
+    /// upload. A new page needs nothing more: wgpu leaves the rest of a fresh
+    /// layer transparent, which is what an atlas wants.
+    pub fn uploads(&mut self) -> impl Iterator<Item = (PageUpload, &RgbaImage)> {
+        let pages = &self.pages;
+        self.uploads
+            .drain(..)
+            .map(|upload| (upload, &pages[upload.layer as usize].image))
+    }
+
+    pub fn insert_empty(&mut self, key: GlyphKey) {
+        self.entries.insert(key, None);
+    }
+
+    pub fn page_count(&self) -> u32 {
+        self.pages.len() as u32
+    }
+
+    pub fn glyph_count(&self) -> usize {
+        self.entries.len()
+    }
+}
+
+impl Page {
+    fn allocate(&mut self, w: u32, h: u32) -> Option<(u32, u32)> {
+        let need_w = w + PAD;
+        let need_h = h + PAD;
+        if self.x + need_w > PAGE {
+            if need_w + PAD > PAGE || self.y + self.shelf_height + need_h > PAGE {
+                return None;
+            }
+            self.y += self.shelf_height;
+            self.x = PAD;
+            self.shelf_height = 0;
+        } else if self.y + need_h > PAGE {
+            return None;
+        }
+
+        let position = (self.x, self.y);
+        self.x += need_w;
+        self.shelf_height = self.shelf_height.max(need_h);
+        Some(position)
+    }
+}
+
+/// Mask glyphs keep coverage in alpha so their raster can be tinted at draw time.
+fn write_glyph(page: &mut RgbaImage, image: &Image, x: u32, y: u32) {
+    let width = image.placement.width as usize;
+    let height = image.placement.height as usize;
+    let page_stride = page.width() as usize * 4;
+    let x = x as usize * 4;
+    let y = y as usize;
+    let page = page.as_mut();
+
+    for row in 0..height {
+        let start = (y + row) * page_stride + x;
+        let target = &mut page[start..start + width * 4];
+        match image.content {
+            Content::Color => {
+                let start = row * width * 4;
+                target.copy_from_slice(&image.data[start..start + width * 4]);
+            }
+            Content::Mask => {
+                let start = row * width;
+                for (target, &alpha) in target
+                    .as_chunks_mut::<4>()
+                    .0
+                    .iter_mut()
+                    .zip(&image.data[start..start + width])
+                {
+                    target.copy_from_slice(&[255, 255, 255, alpha]);
+                }
+            }
+            Content::SubpixelMask => {
+                let start = row * width * 4;
+                for (target, source) in target
+                    .as_chunks_mut::<4>()
+                    .0
+                    .iter_mut()
+                    .zip(image.data[start..start + width * 4].as_chunks::<4>().0)
+                {
+                    target.copy_from_slice(&[255, 255, 255, source[1]]);
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct PlacedGlyph {
+    pub entry: GlyphEntry,
+    pub offset: Vec2,
+}

core/src/render/data.rs

@@ -12,20 +12,16 @@ pub struct WindowUniform {
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct PrimitiveInstance {
     pub region: UiRegion,
-    pub binding: u32,
-    pub idx: u32,
     pub mask_idx: MaskIdx,
 }
 
 impl PrimitiveInstance {
-    const ATTRIBS: [VertexAttribute; 7] = vertex_attr_array![
+    const ATTRIBS: [VertexAttribute; 5] = vertex_attr_array![
         0 => Float32x2,
         1 => Float32x2,
         2 => Float32x2,
         3 => Float32x2,
         4 => Uint32,
-        5 => Uint32,
-        6 => Uint32,
     ];
 
     pub fn desc() -> VertexBufferLayout<'static> {

core/src/render/mod.rs

@@ -1,61 +1,82 @@
-use std::num::NonZero;
-
 use crate::{
     UiData, UiRenderState,
-    render::{data::PrimitiveInstance, texture::GpuTextures, util::ArrBuf},
+    render::{data::PrimitiveInstance, util::ArrBuf},
-    util::HashMap,
+    util::{HashMap, Vec2},
 };
 use data::WindowUniform;
 use wgpu::{
     util::{BufferInitDescriptor, DeviceExt},
     *,
 };
-use winit::dpi::PhysicalSize;
 
+mod atlas;
 mod data;
+mod page;
 mod primitive;
 mod texture;
 mod util;
 
+pub use atlas::*;
 pub use data::{Mask, MaskIdx};
 pub use primitive::*;
 
-const SHAPE_SHADER: &str = include_str!("./shader.wgsl");
+const PRELUDE: &str = include_str!("./shader/prelude.wgsl");
 
 pub struct UiRenderNode {
-    uniform_group: BindGroup,
+    shared_layout: BindGroupLayout,
-    primitive_layout: BindGroupLayout,
+    shared_group: BindGroup,
-    rsc_layout: BindGroupLayout,
+    format: TextureFormat,
-    rsc_group: BindGroup,
 
-    pipeline: RenderPipeline,
+    /// One per registered primitive, in id order.
+    primitives: Vec<PrimitivePipeline>,
 
     layers: HashMap<usize, RenderLayer>,
     active: Vec<usize>,
     window_buffer: Buffer,
-    textures: GpuTextures,
     masks: ArrBuf<Mask>,
 }
 
 struct RenderLayer {
+    /// One per registered primitive, `None` where this layer draws none.
+    primitives: Vec<Option<ListBuffers>>,
+}
+
+/// What draws one registered primitive.
+struct PrimitivePipeline {
+    data_layout: BindGroupLayout,
+    pipeline: RenderPipeline,
+    render: Box<dyn PrimitiveRender>,
+}
+
+/// One list's vertex buffer and the data its shader reads.
+struct ListBuffers {
     instance: ArrBuf<PrimitiveInstance>,
-    primitives: PrimitiveBuffers,
+    data: ArrBuf<u8>,
-    primitive_group: BindGroup,
+    group: Option<BindGroup>,
+    /// What the primitive asked to keep per instance, if anything.
+    bindings: Vec<u32>,
 }
 
 impl UiRenderNode {
     pub fn draw<'a>(&'a self, pass: &mut RenderPass<'a>) {
-        pass.set_pipeline(&self.pipeline);
+        pass.set_bind_group(0, &self.shared_group, &[]);
-        pass.set_bind_group(0, &self.uniform_group, &[]);
-        pass.set_bind_group(2, &self.rsc_group, &[]);
         for i in &self.active {
             let layer = &self.layers[i];
-            if layer.instance.len() == 0 {
+            for (id, list) in layer.primitives.iter().enumerate() {
-                continue;
+                let Some(list) = list else { continue };
+                let Some(group) = &list.group else { continue };
+                let primitive = &self.primitives[id];
+                pass.set_pipeline(&primitive.pipeline);
+                pass.set_bind_group(1, group, &[]);
+                pass.set_vertex_buffer(0, list.instance.buffer.slice(..));
+                primitive.render.draw(
+                    pass,
+                    ListDraw {
+                        instances: list.instance.len() as u32,
+                        bindings: &list.bindings,
+                    },
+                );
             }
-            pass.set_bind_group(1, &layer.primitive_group, &[]);
-            pass.set_vertex_buffer(0, layer.instance.buffer.slice(..));
-            pass.draw(0..4, 0..layer.instance.len() as u32);
         }
     }
 
@@ -66,145 +87,146 @@ impl UiRenderNode {
         ui: &mut UiData,
         ui_render: &mut UiRenderState,
     ) {
+        // Before the layers: each list is given its pipeline's data layout.
+        self.build_pipelines(device, queue, &ui.primitives);
         self.active.clear();
-        for (i, primitives) in ui_render.layers.iter_mut() {
+        for (i, draws) in ui_render.layers.iter_mut() {
             self.active.push(i);
-            for change in primitives.apply_free() {
+            for change in draws.apply_free() {
                 if let Some(inst) = ui_render.active.get_mut(&change.id) {
                     for h in &mut inst.primitives {
-                        if h.layer == i && h.inst_idx == change.old {
+                        if h.layer == i && h.kind == change.kind && h.inst_idx == change.old {
                             h.inst_idx = change.new;
                             break;
                         }
                     }
                 }
             }
-            let rlayer = self.layers.entry(i).or_insert_with(|| {
+            let rlayer = self.layers.entry(i).or_insert_with(RenderLayer::new);
-                let primitives = PrimitiveBuffers::new(device);
+            if draws.updated {
-                let primitive_group =
+                let lists = draws.primitives();
-                    Self::primitive_group(device, &self.primitive_layout, primitives.buffers());
+                // The zip would otherwise skip a list with no pipeline.
-                RenderLayer {
+                assert!(lists.len() <= self.primitives.len());
-                    instance: ArrBuf::new(
+                rlayer.primitives.resize_with(lists.len(), || None);
-                        device,
+                for ((buffers, list), primitive) in rlayer
-                        BufferUsages::VERTEX | BufferUsages::COPY_DST,
+                    .primitives
-                        "instance",
+                    .iter_mut()
-                    ),
+                    .zip(lists)
-                    primitives,
+                    .zip(&self.primitives)
-                    primitive_group,
+                {
+                    let Some(list) = list else {
+                        continue;
+                    };
+                    buffers
+                        .get_or_insert_with(|| ListBuffers::new(device))
+                        .update(device, queue, primitive, list);
                 }
-            });
+                draws.updated = false;
-            if primitives.updated {
-                rlayer
-                    .instance
-                    .update(device, queue, primitives.instances());
-                rlayer.primitives.update(device, queue, primitives.data());
-                rlayer.primitive_group = Self::primitive_group(
-                    device,
-                    &self.primitive_layout,
-                    rlayer.primitives.buffers(),
-                );
-                primitives.updated = false;
             }
         }
-        let mut changed = false;
+        for primitive in &mut self.primitives {
-        changed |= self.textures.update(&mut ui.textures);
+            primitive.render.update(ui);
+        }
         if ui.masks.changed {
             ui.masks.changed = false;
-            self.masks.update(device, queue, &ui.masks[..]);
+            if self.masks.update(device, queue, &ui.masks[..]) {
-            changed = true;
+                self.shared_group = Self::shared_group(
+                    device,
+                    &self.shared_layout,
+                    &self.window_buffer,
+                    &self.masks,
+                );
             }
-        if changed {
-            self.rsc_group = Self::rsc_group(device, &self.rsc_layout, &self.textures, &self.masks);
         }
     }
 
-    pub fn resize(&mut self, size: &PhysicalSize<u32>, queue: &Queue) {
+    pub fn resize(&mut self, size: impl Into<Vec2>, queue: &Queue) {
+        let size = size.into();
         let slice = &[WindowUniform {
-            width: size.width as f32,
+            width: size.x,
-            height: size.height as f32,
+            height: size.y,
         }];
         queue.write_buffer(&self.window_buffer, 0, bytemuck::cast_slice(slice));
     }
 
-    pub fn new(
+    pub fn new(device: &Device, config: &SurfaceConfiguration) -> Self {
-        device: &Device,
+        let window_uniform = WindowUniform {
-        queue: &Queue,
+            width: config.width as f32,
-        config: &SurfaceConfiguration,
+            height: config.height as f32,
-        limits: UiLimits,
+        };
-    ) -> Self {
-        let shader = device.create_shader_module(ShaderModuleDescriptor {
-            label: Some("UI Shape Shader"),
-            source: ShaderSource::Wgsl(SHAPE_SHADER.into()),
-        });
-
-        let window_uniform = WindowUniform::default();
         let window_buffer = device.create_buffer_init(&BufferInitDescriptor {
             label: Some("window"),
             contents: bytemuck::cast_slice(&[window_uniform]),
             usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
         });
 
-        let uniform_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+        let shared_layout = Self::shared_layout(device);
-            entries: &[BindGroupLayoutEntry {
-                binding: 0,
-                visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
-                ty: BindingType::Buffer {
-                    ty: BufferBindingType::Uniform,
-                    has_dynamic_offset: false,
-                    min_binding_size: None,
-                },
-                count: None,
-            }],
-            label: Some("window"),
-        });
-
-        let uniform_group = Self::bind_group_0(device, &uniform_layout, &window_buffer);
-
-        let primitive_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            entries: &core::array::from_fn::<_, { PrimitiveBuffers::LEN }, _>(|i| {
-                BindGroupLayoutEntry {
-                    binding: i as u32,
-                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Buffer {
-                        ty: BufferBindingType::Storage { read_only: true },
-                        has_dynamic_offset: false,
-                        min_binding_size: None,
-                    },
-                    count: None,
-                }
-            }),
-            label: Some("primitive"),
-        });
-
-        let tex_manager = GpuTextures::new(device, queue);
         let masks = ArrBuf::new(
             device,
             BufferUsages::STORAGE | BufferUsages::COPY_DST,
             "ui masks",
         );
+        let shared_group = Self::shared_group(device, &shared_layout, &window_buffer, &masks);
 
-        let rsc_layout = Self::rsc_layout(device, &limits);
+        Self {
-        let rsc_group = Self::rsc_group(device, &rsc_layout, &tex_manager, &masks);
+            shared_layout,
+            shared_group,
+            format: config.format,
+            primitives: Vec::new(),
+            window_buffer,
+            layers: HashMap::default(),
+            active: Vec::new(),
+            masks,
+        }
+    }
 
-        let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
+    /// Compiles a pipeline for every primitive registered since the last call.
-            label: Some("UI Shape Pipeline Layout"),
+    /// Sources only ever arrive at the end, so an id keeps its pipeline.
-            bind_group_layouts: &[&uniform_layout, &primitive_layout, &rsc_layout],
+    fn build_pipelines(&mut self, device: &Device, queue: &Queue, registry: &PrimitiveRegistry) {
+        for source in &registry.sources()[self.primitives.len()..] {
+            let render = (source.render)(device, queue);
+            let data_layout = Self::data_layout(device, source.stride);
+            let mut groups = vec![Some(&self.shared_layout), Some(&data_layout)];
+            groups.extend(render.layout().map(Some));
+            let layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
+                label: Some(source.label),
+                bind_group_layouts: &groups,
                 immediate_size: 0,
             });
-        let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
+            let pipeline = Self::pipeline(device, &layout, self.format, source.wgsl, source.label);
-            label: Some("UI Shape Pipeline"),
+            self.primitives.push(PrimitivePipeline {
-            layout: Some(&pipeline_layout),
+                data_layout,
+                pipeline,
+                render,
+            });
+        }
+    }
+
+    fn pipeline(
+        device: &Device,
+        layout: &PipelineLayout,
+        format: TextureFormat,
+        wgsl: &str,
+        label: &str,
+    ) -> RenderPipeline {
+        let module = device.create_shader_module(ShaderModuleDescriptor {
+            label: Some(label),
+            source: ShaderSource::Wgsl(format!("{PRELUDE}\n{wgsl}").into()),
+        });
+        device.create_render_pipeline(&RenderPipelineDescriptor {
+            label: Some(label),
+            layout: Some(layout),
             vertex: VertexState {
-                module: &shader,
+                module: &module,
                 entry_point: Some("vs_main"),
-                buffers: &[PrimitiveInstance::desc()],
+                buffers: &[Some(PrimitiveInstance::desc())],
                 compilation_options: Default::default(),
             },
             fragment: Some(FragmentState {
-                module: &shader,
+                module: &module,
                 entry_point: Some("fs_main"),
                 targets: &[Some(ColorTargetState {
-                    format: config.format,
+                    format,
                     blend: Some(BlendState::ALPHA_BLENDING),
                     write_mask: ColorWrites::ALL,
                 })],
@@ -227,90 +249,42 @@ impl UiRenderNode {
             },
             multiview_mask: None,
             cache: None,
-        });
-
-        Self {
-            uniform_group,
-            primitive_layout,
-            rsc_layout,
-            rsc_group,
-            pipeline,
-            window_buffer,
-            layers: HashMap::default(),
-            active: Vec::new(),
-            textures: tex_manager,
-            masks,
-        }
-    }
-
-    fn bind_group_0(
-        device: &Device,
-        layout: &BindGroupLayout,
-        window_buffer: &Buffer,
-    ) -> BindGroup {
-        device.create_bind_group(&BindGroupDescriptor {
-            layout,
-            entries: &[BindGroupEntry {
-                binding: 0,
-                resource: window_buffer.as_entire_binding(),
-            }],
-            label: Some("ui window"),
         })
     }
 
-    fn primitive_group(
+    /// What every draw in the ui is given: the window and the masks.
-        device: &Device,
+    fn shared_layout(device: &Device) -> BindGroupLayout {
-        layout: &BindGroupLayout,
-        buffers: [(u32, &Buffer); PrimitiveBuffers::LEN],
-    ) -> BindGroup {
-        device.create_bind_group(&BindGroupDescriptor {
-            layout,
-            entries: &buffers.map(|(binding, buf)| BindGroupEntry {
-                binding,
-                resource: buf.as_entire_binding(),
-            }),
-            label: Some("ui primitives"),
-        })
-    }
-
-    fn rsc_layout(device: &Device, limits: &UiLimits) -> BindGroupLayout {
         device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[
                 BindGroupLayoutEntry {
                     binding: 0,
-                    visibility: ShaderStages::FRAGMENT,
+                    visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
-                    ty: BindingType::Texture {
+                    ty: BindingType::Buffer {
-                        sample_type: TextureSampleType::Float { filterable: false },
+                        ty: BufferBindingType::Uniform,
-                        view_dimension: TextureViewDimension::D2,
+                        has_dynamic_offset: false,
-                        multisampled: false,
+                        min_binding_size: BufferSize::new(size_of::<WindowUniform>() as u64),
                     },
-                    count: Some(NonZero::new(limits.max_textures).unwrap()),
+                    count: None,
                 },
                 BindGroupLayoutEntry {
                     binding: 1,
                     visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Sampler(SamplerBindingType::NonFiltering),
-                    count: Some(NonZero::new(limits.max_samplers).unwrap()),
-                },
-                BindGroupLayoutEntry {
-                    binding: 2,
-                    visibility: ShaderStages::FRAGMENT,
                     ty: BindingType::Buffer {
                         ty: BufferBindingType::Storage { read_only: true },
                         has_dynamic_offset: false,
-                        min_binding_size: None,
+                        min_binding_size: BufferSize::new(size_of::<Mask>() as u64),
                     },
                     count: None,
                 },
             ],
-            label: Some("ui rsc"),
+            label: Some("ui shared"),
         })
     }
 
-    fn rsc_group(
+    fn shared_group(
         device: &Device,
         layout: &BindGroupLayout,
-        tex_manager: &GpuTextures,
+        window: &Buffer,
         masks: &ArrBuf<Mask>,
     ) -> BindGroup {
         device.create_bind_group(&BindGroupDescriptor {
@@ -318,45 +292,85 @@ impl UiRenderNode {
             entries: &[
                 BindGroupEntry {
                     binding: 0,
-                    resource: BindingResource::TextureViewArray(&tex_manager.views()),
+                    resource: window.as_entire_binding(),
                 },
                 BindGroupEntry {
                     binding: 1,
-                    resource: BindingResource::SamplerArray(&tex_manager.samplers()),
-                },
-                BindGroupEntry {
-                    binding: 2,
                     resource: masks.buffer.as_entire_binding(),
                 },
             ],
-            label: Some("ui rsc"),
+            label: Some("ui shared"),
         })
     }
 
-    pub fn view_count(&self) -> usize {
+    /// Layout for a list of one primitive's data. Every size in the ui is
-        self.textures.view_count()
+    /// stated, so "is the buffer big enough for one entry?" is answered when
+    /// the bind group is made; a `None` size is wgpu's to check on every draw.
+    fn data_layout(device: &Device, stride: u64) -> BindGroupLayout {
+        device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[BindGroupLayoutEntry {
+                binding: 0,
+                visibility: ShaderStages::FRAGMENT,
+                ty: BindingType::Buffer {
+                    ty: BufferBindingType::Storage { read_only: true },
+                    has_dynamic_offset: false,
+                    min_binding_size: BufferSize::new(stride),
+                },
+                count: None,
+            }],
+            label: Some("ui primitive data"),
+        })
     }
 }
 
-pub struct UiLimits {
+impl RenderLayer {
-    max_textures: u32,
+    fn new() -> Self {
-    max_samplers: u32,
-}
-
-impl Default for UiLimits {
-    fn default() -> Self {
         Self {
-            max_textures: 100000,
+            primitives: Vec::new(),
-            max_samplers: 1000,
         }
     }
 }
 
-impl UiLimits {
+impl ListBuffers {
-    pub fn max_binding_array_elements_per_shader_stage(&self) -> u32 {
+    fn new(device: &Device) -> Self {
-        self.max_textures + self.max_samplers
+        Self {
+            instance: ArrBuf::new(
+                device,
+                BufferUsages::VERTEX | BufferUsages::COPY_DST,
+                "instance",
+            ),
+            data: ArrBuf::new(
+                device,
+                BufferUsages::STORAGE | BufferUsages::COPY_DST,
+                "primitive data",
+            ),
+            group: None,
+            bindings: Vec::new(),
         }
-    pub fn max_binding_array_sampler_elements_per_shader_stage(&self) -> u32 {
+    }
-        self.max_samplers
+
+    fn update(
+        &mut self,
+        device: &Device,
+        queue: &Queue,
+        primitive: &PrimitivePipeline,
+        list: &InstanceList,
+    ) {
+        self.bindings.clear();
+        primitive.render.instance_bindings(list, &mut self.bindings);
+        self.instance.update(device, queue, list.instances());
+        let resized = self.data.update(device, queue, list.data());
+        if list.instances().is_empty() {
+            self.group = None;
+        } else if resized || self.group.is_none() {
+            self.group = Some(device.create_bind_group(&BindGroupDescriptor {
+                layout: &primitive.data_layout,
+                entries: &[BindGroupEntry {
+                    binding: 0,
+                    resource: self.data.buffer.as_entire_binding(),
+                }],
+                label: Some("ui primitive data"),
+            }));
+        }
     }
 }

core/src/render/page.rs

@@ -0,0 +1,156 @@
+use wgpu::*;
+
+use crate::{GlyphAtlas, UiData};
+
+use super::{
+    atlas::PAGE,
+    primitive::{ListDraw, PrimitiveRender},
+    texture::{default_sampler, sampled_group, sampled_layout, write_region},
+};
+
+/// Draws glyphs from the atlas, which it owns: one array texture bound once
+/// for a whole list, since every glyph in it reads the same pages.
+pub struct GlyphRender {
+    pages: GpuPages,
+    layout: BindGroupLayout,
+    sampler: Sampler,
+}
+
+impl GlyphRender {
+    pub fn new(device: &Device, queue: &Queue) -> Self {
+        let layout = sampled_layout(device, TextureViewDimension::D2Array, "ui atlas");
+        let sampler = default_sampler(device);
+        Self {
+            pages: GpuPages::new(device, queue, &layout, &sampler),
+            layout,
+            sampler,
+        }
+    }
+}
+
+impl PrimitiveRender for GlyphRender {
+    fn layout(&self) -> Option<&BindGroupLayout> {
+        Some(&self.layout)
+    }
+
+    fn update(&mut self, ui: &mut UiData) {
+        self.pages
+            .update(&mut ui.text.atlas, &self.layout, &self.sampler);
+    }
+
+    fn draw<'a>(&'a self, pass: &mut RenderPass<'a>, list: ListDraw<'a>) {
+        pass.set_bind_group(2, self.pages.group(), &[]);
+        pass.draw(0..4, 0..list.instances);
+    }
+}
+
+/// The glyph atlas on the GPU: one array texture whose layers are the pages
+/// `GlyphAtlas` packs.
+///
+/// One array rather than a texture per page because a layer index is ordinary
+/// Vulkan 1.0 / GLES sampling, where a `binding_array` would need
+/// `VK_EXT_descriptor_indexing`, which a real share of Android GPUs lack.
+pub struct GpuPages {
+    device: Device,
+    queue: Queue,
+    texture: Texture,
+    group: BindGroup,
+}
+
+impl GpuPages {
+    pub fn new(
+        device: &Device,
+        queue: &Queue,
+        layout: &BindGroupLayout,
+        sampler: &Sampler,
+    ) -> Self {
+        let texture = create_array(device, 1);
+        Self {
+            device: device.clone(),
+            queue: queue.clone(),
+            group: atlas_group(device, layout, &texture, sampler),
+            texture,
+        }
+    }
+
+    pub fn update(&mut self, atlas: &mut GlyphAtlas, layout: &BindGroupLayout, sampler: &Sampler) {
+        if atlas.page_count() > self.texture.depth_or_array_layers() {
+            self.grow(atlas.page_count(), layout, sampler);
+        }
+        for (upload, page) in atlas.uploads() {
+            let dst = TexelCopyTextureInfo {
+                texture: &self.texture,
+                mip_level: 0,
+                origin: Origin3d {
+                    x: upload.rect.x,
+                    y: upload.rect.y,
+                    z: upload.layer,
+                },
+                aspect: TextureAspect::All,
+            };
+            write_region(&self.queue, dst, page, upload.rect);
+        }
+    }
+
+    pub fn group(&self) -> &BindGroup {
+        &self.group
+    }
+
+    /// Doubles until `needed` fits and copies the old layers across GPU side.
+    /// The new texture stales the group, so that is rebuilt here.
+    fn grow(&mut self, needed: u32, layout: &BindGroupLayout, sampler: &Sampler) {
+        let old = self.texture.depth_or_array_layers();
+        let mut layers = old;
+        while layers < needed {
+            layers *= 2;
+        }
+        let texture = create_array(&self.device, layers);
+        let mut encoder = self
+            .device
+            .create_command_encoder(&CommandEncoderDescriptor {
+                label: Some("atlas grow"),
+            });
+        encoder.copy_texture_to_texture(
+            self.texture.as_image_copy(),
+            texture.as_image_copy(),
+            Extent3d {
+                width: PAGE,
+                height: PAGE,
+                depth_or_array_layers: old,
+            },
+        );
+        self.queue.submit(std::iter::once(encoder.finish()));
+        self.group = atlas_group(&self.device, layout, &texture, sampler);
+        self.texture = texture;
+    }
+}
+
+fn atlas_group(
+    device: &Device,
+    layout: &BindGroupLayout,
+    texture: &Texture,
+    sampler: &Sampler,
+) -> BindGroup {
+    let view = texture.create_view(&TextureViewDescriptor {
+        dimension: Some(TextureViewDimension::D2Array),
+        ..Default::default()
+    });
+    sampled_group(device, layout, &view, sampler, "ui atlas")
+}
+
+fn create_array(device: &Device, layers: u32) -> Texture {
+    device.create_texture(&TextureDescriptor {
+        label: Some("glyph atlas"),
+        size: Extent3d {
+            width: PAGE,
+            height: PAGE,
+            depth_or_array_layers: layers,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: TextureDimension::D2,
+        format: TextureFormat::Rgba8Unorm,
+        usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST | TextureUsages::COPY_SRC,
+        view_formats: &[],
+    })
+}

core/src/render/primitive.rs

@@ -1,114 +1,247 @@
-use std::ops::{Deref, DerefMut};
+use std::{any::TypeId, marker::PhantomData};
 
 use crate::{
-    Color, UiRegion, WidgetId,
+    Color, TextureHandle, UiData, UiRegion, WidgetId,
     render::{
-        ArrBuf,
         data::{MaskIdx, PrimitiveInstance},
+        page::GlyphRender,
+        texture::ImageRender,
     },
+    util::{HashMap, Vec2},
 };
 use bytemuck::Pod;
-use wgpu::*;
+use wgpu::{BindGroupLayout, Device, Queue, RenderPass};
 
-pub struct Primitives {
+/// One instance of a primitive, laid out as the struct its shader reads.
+///
+/// The type carries its own shader, so drawing one is all the wiring it needs:
+/// its list, free list, buffers and pipeline follow from being registered.
+pub trait Primitive: Pod + 'static {
+    /// Compiled after `prelude.wgsl`, which states what it declares and what
+    /// it is given.
+    const WGSL: &'static str;
+
+    /// Made once, the first time the renderer sees this primitive. It owns
+    /// whatever the shader samples and records the primitive's own draws; the
+    /// default owns nothing and draws every instance in one call.
+    fn render(device: &Device, queue: &Queue) -> Box<dyn PrimitiveRender>
+    where
+        Self: Sized,
+    {
+        let _ = (device, queue);
+        Box::new(Instanced)
+    }
+}
+
+/// The renderer's half of a primitive: what it samples, what it uploads, and
+/// what draws it records.
+///
+/// Everything a draw shares -- the pipeline, the window and masks, the list's
+/// own data and instance buffer -- is set before this is called. What is left
+/// is what only this primitive knows: its group 2, and how many draws its
+/// instances are.
+pub trait PrimitiveRender {
+    /// The layout its shader reads at group 2. `None` for a primitive whose
+    /// shader samples nothing, whose pipeline then has no group 2 at all.
+    fn layout(&self) -> Option<&BindGroupLayout> {
+        None
+    }
+
+    /// Uploads whatever this primitive owns, once a frame, before any draw.
+    fn update(&mut self, ui: &mut UiData) {
+        let _ = ui;
+    }
+
+    /// Keeps what the primitive needs per instance at draw time, read from
+    /// the list's own data. A primitive that binds nothing per instance --
+    /// most of them -- leaves this empty and draws in one call.
+    fn instance_bindings(&self, list: &InstanceList, out: &mut Vec<u32>) {
+        let _ = (list, out);
+    }
+
+    fn draw<'a>(&'a self, pass: &mut RenderPass<'a>, list: ListDraw<'a>);
+}
+
+/// What a `PrimitiveRender` draws: this list's instances, and whatever
+/// `instance_bindings` kept for them.
+pub struct ListDraw<'a> {
+    pub instances: u32,
+    pub bindings: &'a [u32],
+}
+
+/// The default: nothing sampled, every instance in one call.
+pub struct Instanced;
+
+impl PrimitiveRender for Instanced {
+    fn draw<'a>(&'a self, pass: &mut RenderPass<'a>, list: ListDraw<'a>) {
+        pass.draw(0..4, 0..list.instances);
+    }
+}
+
+/// Which registered primitive an instance is.
+pub struct PrimitiveKind<P> {
+    id: u32,
+    _p: PhantomData<fn(P)>,
+}
+
+impl<P> PrimitiveKind<P> {
+    fn new(id: u32) -> Self {
+        Self {
+            id,
+            _p: PhantomData,
+        }
+    }
+}
+
+impl<P> Clone for PrimitiveKind<P> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<P> Copy for PrimitiveKind<P> {}
+
+/// Every primitive a ui can draw, in the order they were first drawn.
+#[derive(Default)]
+pub struct PrimitiveRegistry {
+    kinds: Vec<PrimitiveSource>,
+    ids: HashMap<TypeId, u32>,
+}
+
+pub struct PrimitiveSource {
+    pub wgsl: &'static str,
+    pub label: &'static str,
+    /// Size of one instance's entry, stated as the data binding's minimum.
+    pub stride: u64,
+    pub render: fn(&Device, &Queue) -> Box<dyn PrimitiveRender>,
+}
+
+impl PrimitiveRegistry {
+    /// Registers `P` if this is the first time it has been drawn.
+    pub fn kind<P: Primitive>(&mut self) -> PrimitiveKind<P> {
+        let Self { kinds, ids } = self;
+        let id = *ids.entry(TypeId::of::<P>()).or_insert_with(|| {
+            kinds.push(PrimitiveSource {
+                wgsl: P::WGSL,
+                label: std::any::type_name::<P>(),
+                stride: size_of::<P>() as u64,
+                render: P::render,
+            });
+            kinds.len() as u32 - 1
+        });
+        PrimitiveKind::new(id)
+    }
+
+    pub fn sources(&self) -> &[PrimitiveSource] {
+        &self.kinds
+    }
+}
+
+/// One registered primitive's instances in one layer. Everything per-instance
+/// rides here, so it stays in step through a `swap_remove`.
+pub struct InstanceList {
     instances: Vec<PrimitiveInstance>,
+    /// The widget each instance belongs to, for renumbering its handles.
     assoc: Vec<WidgetId>,
-    data: PrimitiveData,
     free: Vec<usize>,
+    /// `stride` bytes of the primitive's own data per instance.
+    data: Vec<u8>,
+    /// From the type the list was made for, so a write is never checked.
+    stride: usize,
+}
+
+impl InstanceList {
+    fn new<P: Primitive>() -> Self {
+        Self {
+            instances: Vec::new(),
+            assoc: Vec::new(),
+            free: Vec::new(),
+            data: Vec::new(),
+            stride: size_of::<P>(),
+        }
+    }
+
+    pub fn instances(&self) -> &[PrimitiveInstance] {
+        &self.instances
+    }
+
+    pub fn data(&self) -> &[u8] {
+        &self.data
+    }
+
+    pub fn stride(&self) -> usize {
+        self.stride
+    }
+
+    fn push(&mut self, id: WidgetId, inst: PrimitiveInstance, data: &[u8]) -> usize {
+        if let Some(i) = self.free.pop() {
+            self.instances[i] = inst;
+            self.assoc[i] = id;
+            self.data[i * self.stride..][..self.stride].copy_from_slice(data);
+            i
+        } else {
+            let i = self.instances.len();
+            self.instances.push(inst);
+            self.assoc.push(id);
+            self.data.extend_from_slice(data);
+            i
+        }
+    }
+
+    fn free(&mut self, i: usize) -> MaskIdx {
+        self.free.push(i);
+        self.instances[i].mask_idx
+    }
+
+    fn apply_free(&mut self, kind: u32) -> impl Iterator<Item = PrimitiveChange> {
+        self.free.sort_by(|a, b| b.cmp(a));
+        let instances = &mut self.instances;
+        let assoc = &mut self.assoc;
+        let data = &mut self.data;
+        let stride = self.stride;
+        self.free.drain(..).filter_map(move |i| {
+            instances.swap_remove(i);
+            assoc.swap_remove(i);
+            let last = instances.len();
+            data.copy_within(last * stride..(last + 1) * stride, i * stride);
+            data.truncate(last * stride);
+            if i == last {
+                return None;
+            }
+            let id = assoc[i];
+            Some(PrimitiveChange {
+                id,
+                kind,
+                old: last,
+                new: i,
+            })
+        })
+    }
+}
+
+/// Everything one layer draws, one list per registered primitive.
+pub struct LayerDraws {
+    /// `None` until this layer draws that primitive, because only the write
+    /// knows the type the list is for.
+    primitives: Vec<Option<InstanceList>>,
     pub updated: bool,
 }
 
-impl Default for Primitives {
+impl Default for LayerDraws {
     fn default() -> Self {
         Self {
-            instances: Default::default(),
+            primitives: Vec::new(),
-            assoc: Default::default(),
-            data: Default::default(),
-            free: Vec::new(),
             updated: true,
         }
     }
 }
 
-pub trait Primitive: Pod {
+impl LayerDraws {
-    const BINDING: u32;
-    fn vec(data: &mut PrimitiveData) -> &mut PrimitiveVec<Self>;
-}
-
-macro_rules! primitives {
-    ($($name:ident: $ty:ty => $binding:expr,)*) => {
-        #[derive(Default)]
-        pub struct PrimitiveData {
-            $(pub(crate) $name: PrimitiveVec<$ty>,)*
-        }
-
-        pub struct PrimitiveBuffers {
-            $($name: ArrBuf<$ty>,)*
-        }
-
-        impl PrimitiveBuffers {
-            pub fn update(&mut self, device: &Device, queue: &Queue, data: &PrimitiveData) {
-                $(self.$name.update(device, queue, &data.$name);)*
-            }
-        }
-
-        impl PrimitiveBuffers {
-            pub const LEN: usize = primitives!(@count $($name)*);
-            pub fn buffers(&self) -> [(u32, &Buffer); Self::LEN] {
-                [
-                    $((<$ty>::BINDING, &self.$name.buffer),)*
-                ]
-            }
-            pub fn new(device: &Device) -> Self {
-                Self {
-                    $($name: ArrBuf::new(
-                        device,
-                        BufferUsages::STORAGE | BufferUsages::COPY_DST,
-                        stringify!($name),
-                    ),)*
-                }
-            }
-        }
-
-        impl PrimitiveData {
-            pub fn clear(&mut self) {
-                $(self.$name.clear();)*
-            }
-            pub fn free(&mut self, binding: u32, idx: usize) {
-                match binding {
-                    $(<$ty>::BINDING => self.$name.free(idx),)*
-                    _ => unreachable!()
-                }
-            }
-        }
-
-        $(
-            unsafe impl bytemuck::Pod for $ty {}
-            unsafe impl bytemuck::Zeroable for $ty {}
-            impl Primitive for $ty {
-                const BINDING: u32 = $binding;
-                fn vec(data: &mut PrimitiveData) -> &mut PrimitiveVec<Self> {
-                    &mut data.$name
-                }
-            }
-        )*
-    };
-    (@count $t1:tt $($t:tt)+) => { 1 + primitives!(@count $($t),+) };
-    (@count $t:tt) => { 1 };
-}
-
-pub struct PrimitiveInst<P> {
-    pub id: WidgetId,
-    pub primitive: P,
-    pub region: UiRegion,
-    pub mask_idx: MaskIdx,
-}
-
-impl Primitives {
     pub fn write<P: Primitive>(
         &mut self,
         layer: usize,
         PrimitiveInst {
+            kind,
             id,
             primitive,
             region,
@@ -116,65 +249,67 @@ impl Primitives {
         }: PrimitiveInst<P>,
     ) -> PrimitiveHandle {
         self.updated = true;
-        let vec = P::vec(&mut self.data);
+        // Grown on first use rather than sized from the registry, which a
-        let i = vec.add(primitive);
+        // layer cannot see.
-        let inst = PrimitiveInstance {
+        if self.primitives.len() <= kind.id as usize {
-            region,
+            self.primitives.resize_with(kind.id as usize + 1, || None);
-            idx: i as u32,
+        }
-            mask_idx,
+        let inst_idx = self.primitives[kind.id as usize]
-            binding: P::BINDING,
+            .get_or_insert_with(InstanceList::new::<P>)
-        };
+            .push(
-        let inst_i = if let Some(i) = self.free.pop() {
+                id,
-            self.instances[i] = inst;
+                PrimitiveInstance { region, mask_idx },
-            self.assoc[i] = id;
+                bytemuck::bytes_of(&primitive),
-            i
+            );
-        } else {
+        PrimitiveHandle {
-            let i = self.instances.len();
+            layer,
-            self.instances.push(inst);
+            kind: kind.id,
-            self.assoc.push(id);
+            inst_idx,
-            i
+        }
-        };
-        PrimitiveHandle::new::<P>(layer, inst_i, i)
     }
 
-    /// returns (old index, new index)
+    pub fn primitives(&self) -> &[Option<InstanceList>] {
-    pub fn apply_free(&mut self) -> impl Iterator<Item = PrimitiveChange> {
+        &self.primitives
-        self.free.sort_by(|a, b| b.cmp(a));
-        self.free.drain(..).filter_map(|i| {
-            self.instances.swap_remove(i);
-            self.assoc.swap_remove(i);
-            if i == self.instances.len() {
-                return None;
     }
-            let id = self.assoc[i];
+
-            let old = self.instances.len();
+    pub fn apply_free(&mut self) -> impl Iterator<Item = PrimitiveChange> {
-            Some(PrimitiveChange { id, old, new: i })
+        self.primitives
-        })
+            .iter_mut()
+            .enumerate()
+            .filter_map(|(kind, list)| Some((kind as u32, list.as_mut()?)))
+            .flat_map(|(kind, list)| list.apply_free(kind))
     }
 
     pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx {
         self.updated = true;
-        self.data.free(h.binding, h.data_idx);
+        self.list(h).free(h.inst_idx)
-        self.free.push(h.inst_idx);
-        self.instances[h.inst_idx].mask_idx
-    }
-
-    pub fn data(&self) -> &PrimitiveData {
-        &self.data
-    }
-
-    pub fn instances(&self) -> &Vec<PrimitiveInstance> {
-        &self.instances
     }
 
     pub fn region_mut(&mut self, h: &PrimitiveHandle) -> &mut UiRegion {
         self.updated = true;
-        &mut self.instances[h.inst_idx].region
+        &mut self.list(h).instances[h.inst_idx].region
     }
+
+    /// A handle is only ever made by `write`, which is what created the list.
+    fn list(&mut self, h: &PrimitiveHandle) -> &mut InstanceList {
+        self.primitives[h.kind as usize]
+            .as_mut()
+            .expect("handle names a primitive this layer never drew")
+    }
+}
+
+pub struct PrimitiveInst<P> {
+    pub kind: PrimitiveKind<P>,
+    pub id: WidgetId,
+    pub primitive: P,
+    pub region: UiRegion,
+    pub mask_idx: MaskIdx,
 }
 
 pub struct PrimitiveChange {
     pub id: WidgetId,
+    /// Which registered primitive's list moved, since they index separately.
+    pub kind: u32,
     pub old: usize,
     pub new: usize,
 }
@@ -182,29 +317,12 @@ pub struct PrimitiveChange {
 #[derive(Debug)]
 pub struct PrimitiveHandle {
     pub layer: usize,
+    pub kind: u32,
     pub inst_idx: usize,
-    pub data_idx: usize,
-    pub binding: u32,
 }
 
-impl PrimitiveHandle {
-    fn new<P: Primitive>(layer: usize, inst_idx: usize, data_idx: usize) -> Self {
-        Self {
-            layer,
-            inst_idx,
-            data_idx,
-            binding: P::BINDING,
-        }
-    }
-}
-
-primitives!(
-    rects: RectPrimitive => 0,
-    textures: TexturePrimitive => 1,
-);
-
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct RectPrimitive {
     pub color: Color<u8>,
     pub radius: f32,
@@ -212,6 +330,10 @@ pub struct RectPrimitive {
     pub inner_radius: f32,
 }
 
+impl Primitive for RectPrimitive {
+    const WGSL: &'static str = include_str!("shader/rect.wgsl");
+}
+
 impl RectPrimitive {
     pub fn color(color: Color<u8>) -> Self {
         Self {
@@ -223,60 +345,51 @@ impl RectPrimitive {
     }
 }
 
-#[repr(C)]
+/// `color` is multiplied by the atlas alpha for a mask glyph; a colour glyph
+/// takes the texel unchanged, which `GlyphEntry::IS_COLORED` selects.
+#[repr(C, align(8))]
 #[derive(Debug, Copy, Clone)]
+pub struct GlyphPrimitive {
+    pub uv_min: Vec2,
+    pub uv_max: Vec2,
+    /// Which atlas array layer this glyph is on.
+    pub layer: u32,
+    pub color: Color<u8>,
+    pub flags: u32,
+}
+
+// Manual rather than derived: the align(8) leaves four bytes of padding, which
+// is how WGSL lays the struct out.
+unsafe impl bytemuck::Pod for GlyphPrimitive {}
+unsafe impl bytemuck::Zeroable for GlyphPrimitive {}
+impl Primitive for GlyphPrimitive {
+    const WGSL: &'static str = include_str!("shader/glyph.wgsl");
+
+    fn render(device: &Device, queue: &Queue) -> Box<dyn PrimitiveRender> {
+        Box::new(GlyphRender::new(device, queue))
+    }
+}
+
+/// One drawn image. Its shader reads nothing per instance; the slot names the
+/// texture to bind for it.
+#[repr(C)]
+#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct TexturePrimitive {
-    pub view_idx: u32,
+    pub slot: u32,
-    pub sampler_idx: u32,
 }
 
-pub struct PrimitiveVec<T> {
+impl Primitive for TexturePrimitive {
-    vec: Vec<T>,
+    const WGSL: &'static str = include_str!("shader/texture.wgsl");
-    free: Vec<usize>,
+
+    fn render(device: &Device, queue: &Queue) -> Box<dyn PrimitiveRender> {
+        Box::new(ImageRender::new(device, queue))
+    }
 }
 
-impl<T> PrimitiveVec<T> {
+impl From<&TextureHandle> for TexturePrimitive {
-    pub fn new() -> Self {
+    fn from(handle: &TextureHandle) -> Self {
         Self {
-            vec: Vec::new(),
+            slot: handle.slot(),
-            free: Vec::new(),
         }
     }
-    pub fn add(&mut self, t: T) -> usize {
-        if let Some(i) = self.free.pop() {
-            self.vec[i] = t;
-            i
-        } else {
-            let i = self.vec.len();
-            self.vec.push(t);
-            i
-        }
-    }
-    pub fn free(&mut self, i: usize) {
-        self.free.push(i);
-    }
-    pub fn clear(&mut self) {
-        self.free.clear();
-        self.vec.clear();
-    }
-}
-
-impl<T> Default for PrimitiveVec<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<T> Deref for PrimitiveVec<T> {
-    type Target = Vec<T>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.vec
-    }
-}
-
-impl<T> DerefMut for PrimitiveVec<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.vec
-    }
 }

core/src/render/shader.wgsl

@@ -1,178 +0,0 @@
-const RECT: u32 = 0u;
-const TEXTURE: u32 = 1u;
-
-@group(0) @binding(0)
-var<uniform> window: WindowUniform;
-@group(1) @binding(RECT)
-var<storage> rects: array<Rect>;
-@group(1) @binding(TEXTURE)
-var<storage> textures: array<TextureInfo>;
-
-struct Rect {
-    color: u32,
-    radius: f32,
-    thickness: f32,
-    inner_radius: f32,
-}
-
-struct TextureInfo {
-    view_idx: u32,
-    sampler_idx: u32,
-}
-
-struct Mask {
-    x: UiSpan,
-    y: UiSpan,
-}
-
-struct UiSpan {
-    start: UiScalar,
-    end: UiScalar,
-}
-
-struct UiScalar {
-    rel: f32,
-    abs: f32,
-}
-
-struct UiVec2 {
-    rel: vec2<f32>,
-    abs: vec2<f32>,
-}
-
-@group(2) @binding(0)
-var views: binding_array<texture_2d<f32>>;
-@group(2) @binding(1)
-var samplers: binding_array<sampler>;
-@group(2) @binding(2)
-var<storage> masks: array<Mask>;
-
-struct WindowUniform {
-    dim: vec2<f32>,
-};
-
-struct InstanceInput {
-    @location(0) x_start: vec2<f32>,
-    @location(1) x_end: vec2<f32>,
-    @location(2) y_start: vec2<f32>,
-    @location(3) y_end: vec2<f32>,
-    @location(4) binding: u32,
-    @location(5) idx: u32,
-    @location(6) mask_idx: u32,
-}
-
-struct VertexOutput {
-    @location(0) top_left: vec2<f32>,
-    @location(1) bot_right: vec2<f32>,
-    @location(2) uv: vec2<f32>,
-    @location(3) binding: u32,
-    @location(4) idx: u32,
-    @location(5) mask_idx: u32,
-    @builtin(position) clip_position: vec4<f32>,
-};
-
-struct Region {
-    pos: vec2<f32>,
-    uv: vec2<f32>,
-    top_left: vec2<f32>,
-    bot_right: vec2<f32>,
-}
-
-@vertex
-fn vs_main(
-    @builtin(vertex_index) vi: u32,
-    in: InstanceInput,
-) -> VertexOutput {
-    var out: VertexOutput;
-
-    let top_left_rel = vec2(in.x_start.x, in.y_start.x);
-    let top_left_abs = vec2(in.x_start.y, in.y_start.y);
-    let bot_right_rel = vec2(in.x_end.x, in.y_end.x);
-    let bot_right_abs = vec2(in.x_end.y, in.y_end.y);
-
-    let top_left = floor(top_left_rel * window.dim) + floor(top_left_abs);
-    let bot_right = floor(bot_right_rel * window.dim) + floor(bot_right_abs);
-    let size = bot_right - top_left;
-
-    let uv = vec2<f32>(
-        f32(vi % 2u),
-        f32(vi / 2u)
-    );
-    let pos = (top_left + uv * size) / window.dim * 2.0 - 1.0;
-    out.clip_position = vec4<f32>(pos.x, -pos.y, 0.0, 1.0);
-    out.uv = uv;
-    out.binding = in.binding;
-    out.idx = in.idx;
-    out.top_left = top_left;
-    out.bot_right = bot_right;
-    out.mask_idx = in.mask_idx;
-
-    return out;
-}
-
-@fragment
-fn fs_main(
-    in: VertexOutput
-) -> @location(0) vec4<f32> {
-    let pos = in.clip_position.xy;
-    let region = Region(pos, in.uv, in.top_left, in.bot_right);
-    let i = in.idx;
-    var color: vec4<f32>;
-    switch in.binding {
-        case RECT: {
-            color = draw_rounded_rect(region, rects[i]);
-        }
-        case TEXTURE: {
-            color = draw_texture(region, textures[i]);
-        }
-        default: {
-            color = vec4(1.0, 0.0, 1.0, 1.0);
-        }
-    }
-    if in.mask_idx != 4294967295u {
-        let mask = masks[in.mask_idx];
-        let tl = UiVec2(vec2(mask.x.start.rel, mask.y.start.rel), vec2(mask.x.start.abs, mask.y.start.abs));
-        let br = UiVec2(vec2(mask.x.end.rel, mask.y.end.rel), vec2(mask.x.end.abs, mask.y.end.abs));
-
-        let top_left = floor(tl.rel * window.dim) + floor(tl.abs);
-        let bot_right = floor(br.rel * window.dim) + floor(br.abs);
-        if pos.x < top_left.x || pos.x > bot_right.x || pos.y < top_left.y || pos.y > bot_right.y {
-            color *= 0.0;
-        }
-    }
-    return color;
-}
-
-// TODO: this seems really inefficient (per frag indexing)?
-fn draw_texture(region: Region, info: TextureInfo) -> vec4<f32> {
-    return textureSample(views[info.view_idx], samplers[info.sampler_idx], region.uv);
-}
-
-fn draw_rounded_rect(region: Region, rect: Rect) -> vec4<f32> {
-    var color = unpack4x8unorm(rect.color);
-
-    let edge = 0.5;
-
-    let size = region.bot_right - region.top_left;
-    let corner = size / 2.0;
-    let center = region.top_left + corner;
-
-    let dist = distance_from_rect(region.pos, center, corner, rect.radius);
-    color.a *= 1.0 - smoothstep(-min(edge, rect.radius), edge, dist);
-
-    if rect.thickness > 0.0 {
-        let dist2 = distance_from_rect(region.pos, center, corner - rect.thickness, rect.inner_radius);
-        color.a *= smoothstep(-min(edge, rect.inner_radius), edge, dist2);
-    }
-
-    return color;
-}
-
-fn distance_from_rect(pixel_pos: vec2<f32>, rect_center: vec2<f32>, rect_corner: vec2<f32>, radius: f32) -> f32 {
-    // vec from center to pixel
-    let p = pixel_pos - rect_center;
-    // vec from inner rect corner to pixel
-    let q = abs(p) - (rect_corner - radius);
-    return length(max(q, vec2(0.0))) - radius;
-}
-

core/src/render/shader/glyph.wgsl

@@ -0,0 +1,33 @@
+// Matches `GlyphEntry::IS_COLORED`.
+const COLORED: u32 = 1u;
+
+// The glyph atlas, whose array layers are its pages.
+@group(2) @binding(0)
+var atlas: texture_2d_array<f32>;
+@group(2) @binding(1)
+var samp: sampler;
+
+struct GlyphInfo {
+    uv_min: vec2<f32>,
+    uv_max: vec2<f32>,
+    // Which layer of the atlas array this glyph's page is.
+    layer: u32,
+    color: u32,
+    flags: u32,
+}
+
+@group(1) @binding(0)
+var<storage> glyphs: array<GlyphInfo>;
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    let g = glyphs[in.idx];
+    let uv = mix(g.uv_min, g.uv_max, in.uv);
+    let texel = textureSample(atlas, samp, uv, i32(g.layer));
+    if (g.flags & COLORED) != 0u {
+        return masked(in, texel);
+    }
+    var color = unpack4x8unorm(g.color);
+    color.a *= texel.a;
+    return masked(in, color);
+}

core/src/render/shader/prelude.wgsl

@@ -0,0 +1,96 @@
+// Prepended to every primitive's shader, which declares its own instance data
+// as `var<storage> <name>: array<T>` at group 1 binding 0, and an `fs_main`
+// shading one instance of it. What it samples, if anything, is bound at group
+// 2: the texture at binding 0 and the sampler at binding 1.
+
+@group(0) @binding(0)
+var<uniform> window: WindowUniform;
+@group(0) @binding(1)
+var<storage> masks: array<Mask>;
+
+struct WindowUniform {
+    dim: vec2<f32>,
+};
+
+struct Mask {
+    x: UiSpan,
+    y: UiSpan,
+}
+
+struct UiSpan {
+    start: UiScalar,
+    end: UiScalar,
+}
+
+struct UiScalar {
+    rel: f32,
+    abs: f32,
+}
+
+struct InstanceInput {
+    @location(0) x_start: vec2<f32>,
+    @location(1) x_end: vec2<f32>,
+    @location(2) y_start: vec2<f32>,
+    @location(3) y_end: vec2<f32>,
+    @location(4) mask_idx: u32,
+}
+
+struct VertexOutput {
+    @location(0) top_left: vec2<f32>,
+    @location(1) bot_right: vec2<f32>,
+    @location(2) uv: vec2<f32>,
+    @location(3) @interpolate(flat) mask_idx: u32,
+    @location(4) @interpolate(flat) idx: u32,
+    @builtin(position) clip_position: vec4<f32>,
+};
+
+@vertex
+fn vs_main(
+    @builtin(vertex_index) vi: u32,
+    @builtin(instance_index) ii: u32,
+    in: InstanceInput,
+) -> VertexOutput {
+    var out: VertexOutput;
+
+    let top_left_rel = vec2(in.x_start.x, in.y_start.x);
+    let top_left_abs = vec2(in.x_start.y, in.y_start.y);
+    let bot_right_rel = vec2(in.x_end.x, in.y_end.x);
+    let bot_right_abs = vec2(in.x_end.y, in.y_end.y);
+
+    let top_left = floor(top_left_rel * window.dim) + floor(top_left_abs);
+    let bot_right = floor(bot_right_rel * window.dim) + floor(bot_right_abs);
+    let size = bot_right - top_left;
+
+    let uv = vec2<f32>(
+        f32(vi % 2u),
+        f32(vi / 2u)
+    );
+    let pos = (top_left + uv * size) / window.dim * 2.0 - 1.0;
+    out.clip_position = vec4<f32>(pos.x, -pos.y, 0.0, 1.0);
+    out.uv = uv;
+    out.top_left = top_left;
+    out.bot_right = bot_right;
+    out.mask_idx = in.mask_idx;
+    out.idx = ii;
+
+    return out;
+}
+
+fn masked(in: VertexOutput, color: vec4<f32>) -> vec4<f32> {
+    if in.mask_idx == 4294967295u {
+        return color;
+    }
+    let mask = masks[in.mask_idx];
+    let tl = vec2(mask.x.start.rel, mask.y.start.rel);
+    let tl_abs = vec2(mask.x.start.abs, mask.y.start.abs);
+    let br = vec2(mask.x.end.rel, mask.y.end.rel);
+    let br_abs = vec2(mask.x.end.abs, mask.y.end.abs);
+
+    let top_left = floor(tl * window.dim) + floor(tl_abs);
+    let bot_right = floor(br * window.dim) + floor(br_abs);
+    let pos = in.clip_position.xy;
+    if pos.x < top_left.x || pos.x > bot_right.x || pos.y < top_left.y || pos.y > bot_right.y {
+        return color * 0.0;
+    }
+    return color;
+}

core/src/render/shader/rect.wgsl

@@ -0,0 +1,39 @@
+struct Rect {
+    color: u32,
+    radius: f32,
+    thickness: f32,
+    inner_radius: f32,
+}
+
+@group(1) @binding(0)
+var<storage> rects: array<Rect>;
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    let rect = rects[in.idx];
+    var color = unpack4x8unorm(rect.color);
+
+    let edge = 0.5;
+    let size = in.bot_right - in.top_left;
+    let corner = size / 2.0;
+    let center = in.top_left + corner;
+    let pos = in.clip_position.xy;
+
+    let dist = distance_from_rect(pos, center, corner, rect.radius);
+    color.a *= 1.0 - smoothstep(-min(edge, rect.radius), edge, dist);
+
+    if rect.thickness > 0.0 {
+        let dist2 = distance_from_rect(pos, center, corner - rect.thickness, rect.inner_radius);
+        color.a *= smoothstep(-min(edge, rect.inner_radius), edge, dist2);
+    }
+
+    return masked(in, color);
+}
+
+fn distance_from_rect(pixel_pos: vec2<f32>, rect_center: vec2<f32>, rect_corner: vec2<f32>, radius: f32) -> f32 {
+    // vec from center to pixel
+    let p = pixel_pos - rect_center;
+    // vec from inner rect corner to pixel
+    let q = abs(p) - (rect_corner - radius);
+    return length(max(q, vec2(0.0))) - radius;
+}

core/src/render/shader/texture.wgsl

@@ -0,0 +1,10 @@
+// The image this instance draws, bound for it alone.
+@group(2) @binding(0)
+var image: texture_2d<f32>;
+@group(2) @binding(1)
+var samp: sampler;
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    return masked(in, textureSample(image, samp, in.uv));
+}

core/src/render/texture.rs

@@ -1,59 +1,119 @@
-use image::{DynamicImage, EncodableLayout};
+use image::{DynamicImage, EncodableLayout, GenericImageView, RgbaImage};
 use wgpu::{util::DeviceExt, *};
 
-use crate::{TextureUpdate, Textures};
+use crate::{
+    PatchRect, TextureUpdate, Textures, UiData,
+    render::{
+        TexturePrimitive,
+        primitive::{ListDraw, PrimitiveRender},
+    },
+};
 
+/// Draws standalone images, which it owns. Each is its own texture, so each
+/// instance binds its own and is a draw of its own.
+pub struct ImageRender {
+    textures: GpuTextures,
+    layout: BindGroupLayout,
+    sampler: Sampler,
+}
+
+impl ImageRender {
+    pub fn new(device: &Device, queue: &Queue) -> Self {
+        Self {
+            textures: GpuTextures::new(device, queue),
+            layout: sampled_layout(device, TextureViewDimension::D2, "ui image"),
+            sampler: default_sampler(device),
+        }
+    }
+}
+
+impl PrimitiveRender for ImageRender {
+    fn layout(&self) -> Option<&BindGroupLayout> {
+        Some(&self.layout)
+    }
+
+    fn update(&mut self, ui: &mut UiData) {
+        self.textures
+            .update(&mut ui.textures, &self.layout, &self.sampler);
+    }
+
+    fn instance_bindings(&self, list: &super::InstanceList, out: &mut Vec<u32>) {
+        let slots = list
+            .data()
+            .chunks_exact(list.stride())
+            .map(|data| bytemuck::pod_read_unaligned::<TexturePrimitive>(data).slot);
+        out.extend(slots);
+    }
+
+    fn draw<'a>(&'a self, pass: &mut RenderPass<'a>, list: ListDraw<'a>) {
+        for (i, &slot) in list.bindings.iter().enumerate() {
+            let Some(image) = self.textures.group(slot) else {
+                continue;
+            };
+            pass.set_bind_group(2, image, &[]);
+            pass.draw(0..4, i as u32..i as u32 + 1);
+        }
+    }
+}
+
+/// The standalone images a ui draws, each its own texture and bind group --
+/// unlike the glyph atlas in `super::page`, which is one array they share.
 pub struct GpuTextures {
     device: Device,
     queue: Queue,
-    views: Vec<TextureView>,
+    slots: Vec<Option<ImageGpu>>,
-    view_count: usize,
+}
-    samplers: Vec<Sampler>,
+
-    null_view: TextureView,
+struct ImageGpu {
-    no_views: Vec<TextureView>,
+    /// Kept for `patch`, which needs the texture rather than the view.
+    texture: Texture,
+    group: BindGroup,
 }
 
 impl GpuTextures {
-    pub fn update(&mut self, textures: &mut Textures) -> bool {
+    pub fn new(device: &Device, queue: &Queue) -> Self {
-        let mut changed = false;
+        Self {
-        for update in textures.updates() {
+            device: device.clone(),
-            changed = true;
+            queue: queue.clone(),
-            match update {
+            slots: Vec::new(),
-                TextureUpdate::Push(image) => self.push(image),
-                TextureUpdate::Set(i, image) => self.set(i, image),
-                TextureUpdate::SetFree => self.view_count += 1,
-                TextureUpdate::Free(i) => self.free(i),
-                TextureUpdate::PushFree => self.push_free(),
         }
     }
-        changed
-    }
-    fn set(&mut self, i: u32, image: &DynamicImage) {
-        self.view_count += 1;
-        let view = self.create_view(image);
-        self.views[i as usize] = view;
-    }
-    fn free(&mut self, i: u32) {
-        self.view_count -= 1;
-        self.views[i as usize] = self.null_view.clone();
-    }
-    fn push(&mut self, image: &DynamicImage) {
-        self.view_count += 1;
-        let view = self.create_view(image);
-        self.views.push(view);
-    }
-    fn push_free(&mut self) {
-        self.view_count += 1;
-        self.views.push(self.null_view.clone());
-    }
 
-    fn create_view(&self, image: &DynamicImage) -> TextureView {
+    pub fn update(&mut self, textures: &mut Textures, layout: &BindGroupLayout, sampler: &Sampler) {
-        let image = image.to_rgba8();
+        for update in textures.updates() {
-        let (width, height) = image.dimensions();
+            match update {
+                TextureUpdate::Push(image) => {
+                    let image = self.create(image, layout, sampler);
+                    self.slots.push(Some(image));
+                }
+                TextureUpdate::Set(i, image) => {
+                    let image = self.create(image, layout, sampler);
+                    self.slots[i as usize] = Some(image);
+                }
+                TextureUpdate::Patch(i, rect, image) => self.patch(i, rect, image),
+                TextureUpdate::PushFree => self.slots.push(None),
+                TextureUpdate::SetFree => {}
+                TextureUpdate::Free(i) => self.slots[i as usize] = None,
+            }
+        }
+    }
+
+    pub fn group(&self, slot: u32) -> Option<&BindGroup> {
+        self.slots.get(slot as usize)?.as_ref().map(|i| &i.group)
+    }
+
+    fn create(
+        &self,
+        image: &DynamicImage,
+        layout: &BindGroupLayout,
+        sampler: &Sampler,
+    ) -> ImageGpu {
+        let rgba = image.to_rgba8();
+        let (width, height) = rgba.dimensions();
         let texture = self.device.create_texture_with_data(
             &self.queue,
             &TextureDescriptor {
-                label: None,
+                label: Some("image"),
                 size: Extent3d {
                     width,
                     height,
@@ -63,65 +123,119 @@ impl GpuTextures {
                 sample_count: 1,
                 dimension: TextureDimension::D2,
                 format: TextureFormat::Rgba8Unorm,
-                usage: TextureUsages::TEXTURE_BINDING,
+                usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST,
                 view_formats: &[],
             },
             wgt::TextureDataOrder::MipMajor,
-            image.as_bytes(),
+            rgba.as_bytes(),
         );
-        texture.create_view(&TextureViewDescriptor::default())
+        let view = texture.create_view(&TextureViewDescriptor::default());
+        let group = sampled_group(&self.device, layout, &view, sampler, "ui image");
+        ImageGpu { texture, group }
     }
 
-    pub fn new(device: &Device, queue: &Queue) -> Self {
+    fn patch(&mut self, i: u32, rect: PatchRect, image: &DynamicImage) {
-        let null_view = null_texture_view(device);
+        let Some(Some(slot)) = self.slots.get(i as usize) else {
-        Self {
+            return;
-            device: device.clone(),
+        };
-            queue: queue.clone(),
+        let dst = TexelCopyTextureInfo {
-            views: Vec::new(),
+            texture: &slot.texture,
-            samplers: vec![default_sampler(device)],
+            mip_level: 0,
-            no_views: vec![null_view.clone()],
+            origin: Origin3d {
-            null_view,
+                x: rect.x,
-            view_count: 0,
+                y: rect.y,
+                z: 0,
+            },
+            aspect: TextureAspect::All,
+        };
+        match image.as_rgba8() {
+            Some(rgba) => write_region(&self.queue, dst, rgba, rect),
+            // The texture is rgba8, so any other layout has to be converted --
+            // and converting the rectangle is cheaper than the whole image.
+            None => {
+                let sub = image
+                    .view(rect.x, rect.y, rect.width, rect.height)
+                    .to_image();
+                write_region(&self.queue, dst, &sub, PatchRect { x: 0, y: 0, ..rect });
+            }
+        }
     }
 }
 
-    pub fn views(&self) -> Vec<&TextureView> {
+pub fn write_region(queue: &Queue, dst: TexelCopyTextureInfo, src: &RgbaImage, rect: PatchRect) {
-        if self.views.is_empty() {
+    if rect.width == 0 || rect.height == 0 {
-            &self.no_views
+        return;
-        } else {
-            &self.views
     }
-        .iter()
+    let stride = src.width() * 4;
-        .by_ref()
+    queue.write_texture(
-        .collect()
+        dst,
-    }
+        src.as_bytes(),
-
+        TexelCopyBufferLayout {
-    pub fn samplers(&self) -> Vec<&Sampler> {
+            offset: (rect.y * stride + rect.x * 4) as u64,
-        self.samplers.iter().by_ref().collect()
+            bytes_per_row: Some(stride),
-    }
+            rows_per_image: Some(rect.height),
-
+        },
-    pub fn view_count(&self) -> usize {
+        Extent3d {
-        self.view_count
+            width: rect.width,
-    }
+            height: rect.height,
-}
-
-pub fn null_texture_view(device: &Device) -> TextureView {
-    device
-        .create_texture(&TextureDescriptor {
-            label: Some("null"),
-            size: Extent3d {
-                width: 1,
-                height: 1,
             depth_or_array_layers: 1,
         },
-            mip_level_count: 1,
+    );
-            sample_count: 1,
+}
-            dimension: TextureDimension::D2,
+
-            format: TextureFormat::Rgba8Unorm,
+/// What a primitive that samples binds: a texture, and the sampler that reads
-            usage: TextureUsages::TEXTURE_BINDING,
+/// it.
-            view_formats: &[],
+pub fn sampled_group(
+    device: &Device,
+    layout: &BindGroupLayout,
+    view: &TextureView,
+    sampler: &Sampler,
+    label: &'static str,
+) -> BindGroup {
+    device.create_bind_group(&BindGroupDescriptor {
+        layout,
+        entries: &[
+            BindGroupEntry {
+                binding: 0,
+                resource: BindingResource::TextureView(view),
+            },
+            BindGroupEntry {
+                binding: 1,
+                resource: BindingResource::Sampler(sampler),
+            },
+        ],
+        label: Some(label),
+    })
+}
+
+/// The layout for one of those. The dimension differs -- the atlas is an
+/// array of pages and an image is not -- and nothing else does.
+pub fn sampled_layout(
+    device: &Device,
+    dimension: TextureViewDimension,
+    label: &'static str,
+) -> BindGroupLayout {
+    device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+        entries: &[
+            BindGroupLayoutEntry {
+                binding: 0,
+                visibility: ShaderStages::FRAGMENT,
+                ty: BindingType::Texture {
+                    sample_type: TextureSampleType::Float { filterable: false },
+                    view_dimension: dimension,
+                    multisampled: false,
+                },
+                count: None,
+            },
+            BindGroupLayoutEntry {
+                binding: 1,
+                visibility: ShaderStages::FRAGMENT,
+                ty: BindingType::Sampler(SamplerBindingType::NonFiltering),
+                count: None,
+            },
+        ],
+        label: Some(label),
     })
-        .create_view(&TextureViewDescriptor::default())
 }
 
 pub fn default_sampler(device: &Device) -> Sampler {

core/src/render/util/mod.rs

@@ -21,17 +21,25 @@ impl<T: Pod> ArrBuf<T> {
             _pd: PhantomData,
         }
     }
-    pub fn update(&mut self, device: &Device, queue: &Queue, data: &[T]) {
+    /// Returns whether the `Buffer` was recreated, which stales any cached
-        if self.len != data.len() {
+    /// `BindGroup` holding it.
+    pub fn update(&mut self, device: &Device, queue: &Queue, data: &[T]) -> bool {
+        let resized = self.len != data.len();
+        if resized {
             self.len = data.len();
             self.buffer =
                 Self::init_buf(device, std::mem::size_of_val(data), self.usage, self.label);
         }
         queue.write_buffer(&self.buffer, 0, bytemuck::cast_slice(data));
+        resized
+    }
+    pub fn len(&self) -> usize {
+        self.len
     }
     fn init_buf(device: &Device, size: usize, usage: BufferUsages, label: &'static str) -> Buffer {
         let mut size = size as u64;
         if usage.contains(BufferUsages::STORAGE) {
+            // A binding cannot be empty or under the layout's minimum.
             size = size.max(std::mem::size_of::<T>() as u64);
         }
         device.create_buffer(&BufferDescriptor {
@@ -41,8 +49,4 @@ impl<T: Pod> ArrBuf<T> {
             usage,
         })
     }
-    #[allow(clippy::len_without_is_empty)]
-    pub fn len(&self) -> usize {
-        self.len
-    }
 }

core/src/ui/mod.rs

@@ -1,4 +1,6 @@
-use crate::{Mask, TextData, Textures, WeakWidget, WidgetId, Widgets, util::TrackedArena};
+use crate::{
+    Mask, PrimitiveRegistry, TextData, Textures, WeakWidget, WidgetId, Widgets, util::TrackedArena,
+};
 
 mod active;
 mod cache;
@@ -7,13 +9,15 @@ mod render_state;
 mod size;
 
 pub use active::*;
-pub use painter::Painter;
+pub use painter::{Painter, PrimitiveLike};
 pub use render_state::*;
 pub use size::*;
 
 #[derive(Default)]
 pub struct UiData {
     pub widgets: Widgets,
+    /// Every primitive this ui can draw.
+    pub primitives: PrimitiveRegistry,
     pub textures: Textures,
     pub text: TextData,
     pub masks: TrackedArena<Mask, u32>,

core/src/ui/painter.rs

@@ -1,7 +1,10 @@
 use crate::{
     Axis, Len, RenderedText, Size, SizeCtx, StrongWidget, TextAttrs, TextBuffer, TextData,
-    TextureHandle, UiRegion, UiRenderState, UiRsc, Widget, WidgetId,
+    TextureHandle, UiRegion, UiRenderState, UiRsc, UiScalar, UiVec2, Widget, WidgetId,
-    render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
+    render::{
+        GlyphPrimitive, Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, PrimitiveKind,
+        TexturePrimitive,
+    },
     util::Vec2,
 };
 
@@ -21,15 +24,26 @@ pub struct Painter<'a> {
 
 impl<'a> Painter<'a> {
     fn primitive_at<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
+        let kind = self.rsc.ui_mut().primitives.kind::<P>();
+        self.write(kind, primitive, region);
+    }
+
+    /// Takes the kind, for a caller writing many of one primitive.
+    fn write<P: Primitive>(&mut self, kind: PrimitiveKind<P>, primitive: P, region: UiRegion) {
         let h = self.state.layers.write(
             self.layer,
             PrimitiveInst {
+                kind,
                 id: self.id,
                 primitive,
                 region,
                 mask_idx: self.mask,
             },
         );
+        self.push_primitive(h);
+    }
+
+    fn push_primitive(&mut self, h: PrimitiveHandle) {
         if self.mask != MaskIdx::NONE {
             // TODO: I have no clue if this works at all :joy:
             self.rsc.ui_mut().masks.push_ref(self.mask);
@@ -38,11 +52,13 @@ impl<'a> Painter<'a> {
     }
 
     /// Writes a primitive to be rendered
-    pub fn primitive<P: Primitive>(&mut self, primitive: P) {
+    pub fn primitive(&mut self, primitive: impl PrimitiveLike) {
+        let primitive = primitive.into_primitive(self);
         self.primitive_at(primitive, self.region)
     }
 
-    pub fn primitive_within<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
+    pub fn primitive_within(&mut self, primitive: impl PrimitiveLike, region: UiRegion) {
+        let primitive = primitive.into_primitive(self);
         self.primitive_at(primitive, region.within(&self.region));
     }
 
@@ -75,25 +91,38 @@ impl<'a> Painter<'a> {
         );
     }
 
-    pub fn texture_within(&mut self, handle: &TextureHandle, region: UiRegion) {
+    pub fn render_text(
-        self.textures.push(handle.clone());
+        &mut self,
-        self.primitive_at(handle.primitive(), region.within(&self.region));
+        buffer: &mut TextBuffer,
-    }
+        attrs: &TextAttrs,
-
+        width: Option<f32>,
-    pub fn texture(&mut self, handle: &TextureHandle) {
+    ) -> RenderedText {
-        self.textures.push(handle.clone());
-        self.primitive(handle.primitive());
-    }
-
-    pub fn texture_at(&mut self, handle: &TextureHandle, region: UiRegion) {
-        self.textures.push(handle.clone());
-        self.primitive_at(handle.primitive(), region);
-    }
-
-    /// returns (handle, offset from top left)
-    pub fn render_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
         let ui = self.rsc.ui_mut();
-        ui.text.draw(buffer, attrs, &mut ui.textures)
+        ui.text.render(buffer, attrs, width)
+    }
+
+    // TODO: merge the text methods into the primitive ones.
+    pub fn glyphs(&mut self, text: &RenderedText, origin: UiRegion) {
+        let kind = self.rsc.ui_mut().primitives.kind::<GlyphPrimitive>();
+        for glyph in text.glyphs.iter() {
+            let mut region = origin;
+            region.x.end = region.x.start;
+            region.y.end = region.y.start;
+            let mut region = region.offset(UiVec2::abs(glyph.offset));
+            region.x.end = region.x.start + UiScalar::abs(glyph.entry.width as f32);
+            region.y.end = region.y.start + UiScalar::abs(glyph.entry.height as f32);
+            self.write(
+                kind,
+                GlyphPrimitive {
+                    uv_min: glyph.entry.uv_min,
+                    uv_max: glyph.entry.uv_max,
+                    layer: glyph.entry.layer,
+                    color: text.color,
+                    flags: glyph.entry.flags(),
+                },
+                region,
+            );
+        }
     }
 
     pub fn region(&self) -> UiRegion {
@@ -143,3 +172,28 @@ impl<'a> Painter<'a> {
         self.state.size_ctx(self.id, self.region.size(), self.rsc)
     }
 }
+
+/// What `Painter::primitive` takes: a primitive, or something that yields one
+/// and does whatever else drawing it needs.
+pub trait PrimitiveLike {
+    type Primitive: Primitive;
+    fn into_primitive(self, painter: &mut Painter) -> Self::Primitive;
+}
+
+impl<P: Primitive> PrimitiveLike for P {
+    type Primitive = P;
+    fn into_primitive(self, _: &mut Painter) -> P {
+        self
+    }
+}
+
+impl PrimitiveLike for &TextureHandle {
+    type Primitive = TexturePrimitive;
+
+    /// Retains a share of the handle, so the slot the primitive names cannot
+    /// be freed and reused while it is still drawn.
+    fn into_primitive(self, painter: &mut Painter) -> TexturePrimitive {
+        painter.textures.push(self.clone());
+        self.into()
+    }
+}

core/src/ui/render_state.rs

@@ -1,13 +1,13 @@
 use crate::{
-    ActiveData, Axis, IdLike, MaskIdx, Painter, PixelRegion, PrimitiveLayers, SizeCtx,
+    ActiveData, Axis, DrawLayers, IdLike, MaskIdx, Painter, PixelRegion, SizeCtx, StrongWidget,
-    StrongWidget, UiRegion, UiRsc, UiVec2, WidgetId, Widgets,
+    UiRegion, UiRsc, UiVec2, WidgetId, Widgets,
     ui::cache::Cache,
     util::{HashMap, HashSet, Vec2, forget_ref},
 };
 
 pub struct UiRenderState {
     pub active: HashMap<WidgetId, ActiveData>,
-    pub layers: PrimitiveLayers,
+    pub layers: DrawLayers,
     pub(super) output_size: Vec2,
     pub cache: Cache,
 
@@ -52,7 +52,7 @@ impl UiRenderState {
             );
         }
         let root = root.into();
-        if self.root_changed(root) || self.resized {
+        if self.needs_full_redraw(root) {
             self.redraw_all(root, rsc);
             self.old_root = root.map(|r| r.id());
             self.resized = false;
@@ -218,12 +218,17 @@ impl UiRenderState {
         root.into().map(|r| r.id()) != self.old_root
     }
 
+    // Scheduling and drawing must use the same full-redraw predicate.
+    fn needs_full_redraw<'a>(&self, root: impl Into<Option<&'a StrongWidget>>) -> bool {
+        self.root_changed(root) || self.resized
+    }
+
     pub fn needs_redraw<'a>(
         &self,
         root: impl Into<Option<&'a StrongWidget>>,
         widgets: &Widgets,
     ) -> bool {
-        self.root_changed(root) || widgets.has_updates()
+        self.needs_full_redraw(root) || widgets.has_updates()
     }
 
     pub fn active_widgets(&self) -> usize {
@@ -238,14 +243,14 @@ impl UiRenderState {
     }
 
     pub fn debug_layers(&self) {
-        for ((idx, depth), primitives) in self.layers.iter_depth() {
+        for ((idx, depth), draws) in self.layers.iter_depth() {
             let indent = " ".repeat(depth * 2);
-            let len = primitives.instances().len();
+            let counts: Vec<String> = draws
-            print!("{indent}{idx}: {len} primitives");
+                .primitives()
-            if len >= 1 {
+                .iter()
-                print!(" ({})", primitives.instances()[0].binding);
+                .map(|l| l.as_ref().map_or(0, |l| l.instances().len()).to_string())
-            }
+                .collect();
-            println!();
+            println!("{indent}{idx}: [{}]", counts.join(", "));
         }
     }
 
@@ -303,7 +308,6 @@ impl UiRenderState {
             source,
             cache: &mut self.cache,
             text: &mut ui.text,
-            textures: &mut ui.textures,
             widgets: &ui.widgets,
             outer,
             output_size: self.output_size,

core/src/ui/size.rs

@@ -1,11 +1,10 @@
 use crate::{
-    Axis, AxisT, IdLike, Len, RenderedText, Size, TextAttrs, TextBuffer, TextData, Textures,
+    Axis, AxisT, IdLike, Len, RenderedText, Size, TextAttrs, TextBuffer, TextData, UiVec2,
-    UiVec2, WidgetAxisFns, WidgetId, Widgets, XAxis, YAxis, ui::cache::Cache, util::Vec2,
+    WidgetAxisFns, WidgetId, Widgets, XAxis, YAxis, ui::cache::Cache, util::Vec2,
 };
 
 pub struct SizeCtx<'a> {
     pub text: &'a mut TextData,
-    pub textures: &'a mut Textures,
     pub(super) source: WidgetId,
     pub(super) widgets: &'a Widgets,
     pub(super) cache: &'a mut Cache,
@@ -33,7 +32,6 @@ impl SizeCtx<'_> {
             .get_dyn_dynamic(id)
             .desired_len::<A>(&mut SizeCtx {
                 text: self.text,
-                textures: self.textures,
                 source: self.source,
                 widgets: self.widgets,
                 cache: self.cache,
@@ -76,8 +74,13 @@ impl SizeCtx<'_> {
         self.output_size
     }
 
-    pub fn draw_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
+    pub fn draw_text(
-        self.text.draw(buffer, attrs, self.textures)
+        &mut self,
+        buffer: &mut TextBuffer,
+        attrs: &TextAttrs,
+        width: Option<f32>,
+    ) -> RenderedText {
+        self.text.render(buffer, attrs, width)
     }
 
     pub fn label(&self, id: WidgetId) -> &String {

core/src/util/math.rs

@@ -9,15 +9,16 @@ pub const trait DivOr {
     fn div_or(self, rhs: Self, other: Self) -> Self;
 }
 
-impl const DivOr for f32 {
+const impl DivOr for f32 {
     fn div_or(self, rhs: Self, other: Self) -> Self {
         let res = self / rhs;
         if res.is_nan() { other } else { res }
     }
 }
 
-impl<T: const Add<Output = T> + const Sub<Output = T> + const Mul<Output = T> + const DivOr + Copy> const
+const impl<
-    LerpUtil for T
+    T: const Add<Output = T> + const Sub<Output = T> + const Mul<Output = T> + const DivOr + Copy,
+> LerpUtil for T
 {
     /// linear interpolation
     /// from * (1.0 - self) + to * self
@@ -37,7 +38,7 @@ macro_rules! impl_op {
             use super::*;
             #[allow(unused_imports)]
             use std::ops::*;
-            impl const $op for $T {
+            const impl $op for $T {
                 type Output = Self;
 
                 fn $fn(self, rhs: Self) -> Self::Output {
@@ -46,12 +47,12 @@ macro_rules! impl_op {
                     }
                 }
             }
-            impl const $opa for $T {
+            const impl $opa for $T {
                 fn $fna(&mut self, rhs: Self) {
                     *self = self.$fn(rhs);
                 }
             }
-            impl const $op<f32> for $T {
+            const impl $op<f32> for $T {
                 type Output = Self;
 
                 fn $fn(self, rhs: f32) -> Self::Output {
@@ -60,7 +61,7 @@ macro_rules! impl_op {
                     }
                 }
             }
-            impl const $op<$T> for f32 {
+            const impl $op<$T> for f32 {
                 type Output = $T;
 
                 fn $fn(self, rhs: $T) -> Self::Output {
@@ -69,7 +70,7 @@ macro_rules! impl_op {
                     }
                 }
             }
-            impl const $opa<f32> for $T {
+            const impl $opa<f32> for $T {
                 fn $fna(&mut self, rhs: f32) {
                     *self = self.$fn(rhs);
                 }

core/src/util/mod.rs

@@ -16,7 +16,7 @@ pub use id::*;
 pub use math::*;
 pub use refcount::*;
 pub use slot::*;
-pub use trust::*;
+pub(crate) use trust::*;
 pub use typemap::*;
 pub use vec2::*;
 

core/src/util/trust.rs

@@ -1,15 +1,15 @@
 #[allow(clippy::missing_safety_doc)]
-pub unsafe fn forget_ref<'a, T>(x: &T) -> &'a T {
+pub(crate) unsafe fn forget_ref<'a, T>(x: &T) -> &'a T {
     unsafe { std::mem::transmute::<&T, &T>(x) }
 }
 
 #[allow(clippy::missing_safety_doc)]
-pub unsafe fn forget_mut<'a, T>(x: &mut T) -> &'a mut T {
+pub(crate) unsafe fn forget_mut<'a, T>(x: &mut T) -> &'a mut T {
     unsafe { std::mem::transmute::<&mut T, &mut T>(x) }
 }
 
 #[allow(clippy::mut_from_ref, clippy::missing_safety_doc)]
-pub unsafe fn to_mut<T>(x: &T) -> &mut T {
+pub(crate) unsafe fn to_mut<T>(x: &T) -> &mut T {
     #[allow(mutable_transmutes)]
     unsafe {
         std::mem::transmute::<&T, &mut T>(x)

core/src/util/vec2.rs

@@ -67,7 +67,7 @@ impl_op!(Vec2 Sub sub; x y);
 impl_op!(Vec2 Mul mul; x y);
 impl_op!(Vec2 Div div; x y);
 
-impl const DivOr for Vec2 {
+const impl DivOr for Vec2 {
     fn div_or(self, rhs: Self, other: Self) -> Self {
         Self {
             x: self.x.div_or(rhs.x, other.x),

examples/tabs/main.rs

@@ -1,4 +1,3 @@
-use cosmic_text::Family;
 use std::{cell::RefCell, rc::Rc};
 use winit::event::WindowEvent;
 
@@ -213,10 +212,10 @@ impl DefaultAppState for Client {
         render: &mut UiRenderState,
     ) {
         let new = format!(
-            "widgets: {}\nactive: {}\nviews: {}",
+            "widgets: {}\nactive: {}\ntextures: {}",
             rsc.widgets().len(),
             render.active_widgets(),
-            self.ui_state.renderer.ui.view_count(),
+            rsc.ui().textures.count(),
         );
         if new != *rsc.widgets()[self.info].content {
             *rsc.widgets_mut()[self.info].content = new;

rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "nightly"
+components = ["clippy", "rustfmt"]

src/default/mod.rs

@@ -1,10 +1,6 @@
 use crate::prelude::*;
 use arboard::Clipboard;
-use std::{
+use std::{marker::PhantomData, sync::Arc, time::Instant};
-    marker::{PhantomData, Sized},
-    sync::Arc,
-    time::Instant,
-};
 use winit::{
     event::{Ime, WindowEvent},
     event_loop::{ActiveEventLoop, EventLoopProxy},

src/default/render.rs

@@ -1,4 +1,4 @@
-use iris_core::{UiData, UiLimits, UiRenderNode, UiRenderState};
+use iris_core::{UiData, UiRenderNode, UiRenderState};
 use pollster::FutureExt;
 use std::sync::Arc;
 use wgpu::*;
@@ -22,7 +22,20 @@ impl UiRenderer {
     }
 
     pub fn draw(&mut self) {
-        let output = self.surface.get_current_texture().unwrap();
+        let output = match self.surface.get_current_texture() {
+            CurrentSurfaceTexture::Success(texture) => texture,
+            CurrentSurfaceTexture::Suboptimal(texture) => {
+                self.surface.configure(&self.device, &self.config);
+                texture
+            }
+            CurrentSurfaceTexture::Outdated | CurrentSurfaceTexture::Lost => {
+                self.surface.configure(&self.device, &self.config);
+                return;
+            }
+            CurrentSurfaceTexture::Timeout
+            | CurrentSurfaceTexture::Occluded
+            | CurrentSurfaceTexture::Validation => return,
+        };
         let view = output
             .texture
             .create_view(&TextureViewDescriptor::default());
@@ -45,14 +58,15 @@ impl UiRenderer {
         }
 
         self.queue.submit(std::iter::once(encoder.finish()));
-        output.present();
+        self.window.pre_present_notify();
+        self.queue.present(output);
     }
 
     pub fn resize(&mut self, size: &PhysicalSize<u32>) {
         self.config.width = size.width;
         self.config.height = size.height;
         self.surface.configure(&self.device, &self.config);
-        self.ui.resize(size, &self.queue);
+        self.ui.resize((size.width, size.height), &self.queue);
     }
 
     fn create_encoder(device: &Device) -> CommandEncoder {
@@ -64,9 +78,10 @@ impl UiRenderer {
     pub fn new(window: Arc<Window>) -> Self {
         let size = window.inner_size();
 
-        let instance = Instance::new(&InstanceDescriptor {
+        let instance = Instance::new(InstanceDescriptor {
             backends: Backends::PRIMARY,
-            ..Default::default()
+            display: Some(Box::new(window.clone())),
+            ..InstanceDescriptor::new_without_display_handle()
         });
 
         let surface = instance
@@ -78,22 +93,14 @@ impl UiRenderer {
                 power_preference: PowerPreference::default(),
                 compatible_surface: Some(&surface),
                 force_fallback_adapter: false,
+                apply_limit_buckets: false,
             })
             .block_on()
             .expect("Could not get adapter!");
 
-        let ui_limits = UiLimits::default();
-
         let (device, queue) = adapter
             .request_device(&DeviceDescriptor {
-                required_features: Features::TEXTURE_BINDING_ARRAY
-                    | Features::PARTIALLY_BOUND_BINDING_ARRAY
-                    | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
                 required_limits: Limits {
-                    max_binding_array_elements_per_shader_stage: ui_limits
-                        .max_binding_array_elements_per_shader_stage(),
-                    max_binding_array_sampler_elements_per_shader_stage: ui_limits
-                        .max_binding_array_sampler_elements_per_shader_stage(),
                     max_buffer_size: 1 << 30,
                     ..Default::default()
                 },
@@ -113,9 +120,10 @@ impl UiRenderer {
         let config = SurfaceConfiguration {
             usage: TextureUsages::RENDER_ATTACHMENT,
             format: surface_format,
+            color_space: SurfaceColorSpace::Auto,
             width: size.width,
             height: size.height,
-            present_mode: PresentMode::AutoNoVsync,
+            present_mode: PresentMode::AutoVsync,
             alpha_mode: surface_caps.alpha_modes[0],
             desired_maximum_frame_latency: 2,
             view_formats: vec![],
@@ -125,7 +133,7 @@ impl UiRenderer {
 
         let encoder = Self::create_encoder(&device);
 
-        let ui = UiRenderNode::new(&device, &queue, &config, ui_limits);
+        let ui = UiRenderNode::new(&device, &config);
 
         Self {
             surface,

src/lib.rs

@@ -1,6 +1,5 @@
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
-#![feature(gen_blocks)]
 #![feature(associated_type_defaults)]
 #![feature(unsize)]
 #![feature(option_into_flat_iter)]

src/widget/image.rs

@@ -7,7 +7,7 @@ pub struct Image {
 
 impl Widget for Image {
     fn draw(&mut self, painter: &mut Painter) {
-        painter.texture(&self.handle);
+        painter.primitive(&self.handle);
     }
 
     fn desired_width(&mut self, _: &mut SizeCtx) -> Len {

src/widget/position/mod.rs

@@ -4,7 +4,7 @@ mod max_size;
 mod offset;
 mod pad;
 mod scroll;
-mod sized;
+mod set_size;
 mod span;
 mod stack;
 
@@ -14,6 +14,6 @@ pub use max_size::*;
 pub use offset::*;
 pub use pad::*;
 pub use scroll::*;
-pub use sized::*;
+pub use set_size::*;
 pub use span::*;
 pub use stack::*;

src/widget/position/set_size.rs

@@ -1,12 +1,12 @@
 use crate::prelude::*;
 
-pub struct Sized {
+pub struct SetSize {
     pub inner: StrongWidget,
     pub x: Option<Len>,
     pub y: Option<Len>,
 }
 
-impl Sized {
+impl SetSize {
     fn apply_to_outer(&self, ctx: &mut SizeCtx) {
         if let Some(x) = self.x {
             ctx.outer.x.select_len(x.apply_rest());
@@ -17,7 +17,7 @@ impl Sized {
     }
 }
 
-impl Widget for Sized {
+impl Widget for SetSize {
     fn draw(&mut self, painter: &mut Painter) {
         painter.widget(&self.inner);
     }

src/widget/ptr.rs

@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use std::marker::{Sized, Unsize};
+use std::marker::Unsize;
 
 pub struct WidgetPtr {
     pub inner: Option<StrongWidget>,

src/widget/text/build.rs

@@ -1,6 +1,5 @@
 use crate::prelude::*;
-use cosmic_text::{Attrs, Family, Metrics};
+use std::marker::PhantomData;
-use std::marker::{PhantomData, Sized};
 
 pub struct TextBuilder<State, O = TextOutput, H: WidgetOption<State> = ()> {
     pub content: String,
@@ -20,7 +19,7 @@ impl<State, O, H: WidgetOption<State>> TextBuilder<State, O, H> {
         self.attrs.color = color;
         self
     }
-    pub fn family(mut self, family: Family<'static>) -> Self {
+    pub fn family(mut self, family: Family) -> Self {
         self.attrs.family = family;
         self
     }
@@ -82,19 +81,13 @@ impl<Rsc: UiRsc> TextBuilderOutput<Rsc> for TextOutput {
         state: &mut Rsc,
         builder: TextBuilder<Rsc, Self, H>,
     ) -> Self::Output {
-        let mut buf = TextBuffer::new_empty(Metrics::new(
+        let buf = TextBuffer::new(&builder.content);
-            builder.attrs.font_size,
-            builder.attrs.line_height,
-        ));
         let hint = builder.hint.get(state);
-        let font_system = &mut state.ui_mut().text.font_system;
-        buf.set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
         let mut text = Text {
             content: builder.content.into(),
             view: TextView::new(buf, builder.attrs, hint),
         };
         text.content.changed = false;
-        builder.attrs.apply(font_system, &mut text.view.buf, None);
         text
     }
 }
@@ -110,19 +103,11 @@ impl<State: UiRsc> TextBuilderOutput<State> for TextEditOutput {
         state: &mut State,
         builder: TextBuilder<State, Self, H>,
     ) -> Self::Output {
-        let buf = TextBuffer::new_empty(Metrics::new(
+        let buf = TextBuffer::new(&builder.content);
-            builder.attrs.font_size,
+        TextEdit::new(
-            builder.attrs.line_height,
-        ));
-        let mut text = TextEdit::new(
             TextView::new(buf, builder.attrs, builder.hint.get(state)),
             builder.output.mode,
-        );
+        )
-        let font_system = &mut state.ui_mut().text.font_system;
-        text.buf
-            .set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
-        builder.attrs.apply(font_system, &mut text.buf, None);
-        text
     }
 }
 

src/widget/text/edit.rs

@@ -1,17 +1,30 @@
 use crate::prelude::*;
-use cosmic_text::{Affinity, Attrs, Cursor, FontSystem, LayoutRun, Motion};
+use iris_core::{TextData, UiColor};
+use parley::{Affinity, Layout, Selection};
 use std::ops::{Deref, DerefMut};
-use unicode_segmentation::UnicodeSegmentation;
 use winit::{
     event::KeyEvent,
     keyboard::{Key, NamedKey},
 };
 
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Motion {
+    Left,
+    Right,
+    LeftWord,
+    RightWord,
+    Up,
+    Down,
+    LineStart,
+    LineEnd,
+}
+
 pub struct TextEdit {
     view: TextView,
-    selection: TextSelection,
+    /// `None` represents unfocused, which Parley's `Selection` cannot express.
-    history: Vec<(String, TextSelection)>,
+    selection: Option<Selection>,
-    double_hit: Option<Cursor>,
+    history: Vec<(String, Option<Selection>)>,
+    double_hit: Option<usize>,
     pub mode: EditMode,
 }
 
@@ -25,27 +38,19 @@ impl TextEdit {
     pub fn new(view: TextView, mode: EditMode) -> Self {
         Self {
             view,
-            selection: Default::default(),
+            selection: None,
             history: Default::default(),
             double_hit: None,
             mode,
         }
     }
-    pub fn select_content(&self, start: Cursor, end: Cursor) -> String {
+
-        let (start, end) = sort_cursors(start, end);
+    pub fn selected_text(&self) -> Option<String> {
-        let mut iter = self.buf.lines.iter().skip(start.line);
+        let sel = self.selection?;
-        let first = iter.next().unwrap();
+        if sel.is_collapsed() {
-        if start.line == end.line {
+            return None;
-            first.text()[start.index..end.index].to_string()
-        } else {
-            let mut str = first.text()[start.index..].to_string();
-            for _ in (start.line + 1)..end.line {
-                str = str + "\n" + iter.next().unwrap().text();
-            }
-            let last = iter.next().unwrap();
-            str = str + "\n" + &last.text()[..end.index];
-            str
         }
+        Some(self.buf.text()[sel.text_range()].to_string())
     }
 }
 
@@ -57,40 +62,30 @@ impl Widget for TextEdit {
         painter.layer = base;
         let region = self.region();
 
-        let size = vec2(1, self.attrs.line_height);
+        let Some(selection) = self.selection else {
-        match self.selection {
+            return;
-            TextSelection::None => (),
+        };
-            TextSelection::Pos(cursor) => {
+        let layout = self.view.buf.layout();
-                if let Some(offset) = cursor_pos(cursor, &self.buf) {
+
-                    painter.primitive_within(
+        // parley reports selection as boxes in layout space, so bidi and
-                        RectPrimitive::color(Color::WHITE),
+        // wrapped lines come out right without this code knowing about either.
-                        size.align(Align::TOP_LEFT).offset(offset).within(&region),
+        for (rect, _) in selection.geometry(layout) {
-                    );
+            let size = vec2(rect.width() as f32, rect.height() as f32);
-                }
+            let top_left = vec2(rect.x0 as f32, rect.y0 as f32);
-            }
-            TextSelection::Span { start, end } => {
-                let (start, end) = sort_cursors(start, end);
-                for (l, x, width) in iter_layout_lines(start, end, &self.buf) {
-                    let top_left = vec2(x, self.attrs.line_height * l as f32);
             painter.primitive_within(
                 RectPrimitive::color(Color::SKY),
-                        size.with_x(width)
+                size.align(Align::TOP_LEFT).offset(top_left).within(&region),
-                            .align(Align::TOP_LEFT)
-                            .offset(top_left)
-                            .within(&region),
             );
         }
-                if let Some(end_offset) = cursor_pos(end, &self.buf) {
+
+        let caret = selection.focus().geometry(layout, CARET_WIDTH);
+        let size = vec2(caret.width() as f32, caret.height() as f32);
+        let top_left = vec2(caret.x0 as f32, caret.y0 as f32);
         painter.primitive_within(
             RectPrimitive::color(Color::WHITE),
-                        size.align(Align::TOP_LEFT)
+            size.align(Align::TOP_LEFT).offset(top_left).within(&region),
-                            .offset(end_offset)
-                            .within(&region),
         );
     }
-            }
-        }
-    }
 
     fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
         self.view.desired_width(ctx)
@@ -101,154 +96,58 @@ impl Widget for TextEdit {
     }
 }
 
-/// provides top left + width
+const CARET_WIDTH: f32 = 1.0;
-fn iter_layout_lines(
-    start: Cursor,
-    end: Cursor,
-    buf: &TextBuffer,
-) -> impl Iterator<Item = (usize, f32, f32)> {
-    gen move {
-        let mut iter = buf.layout_runs().enumerate();
-        for (i, line) in iter.by_ref() {
-            if line.line_i == start.line
-                && let Some(start_x) = index_x(&line, start.index)
-            {
-                if start.line == end.line
-                    && let Some(end_x) = index_x(&line, end.index)
-                {
-                    yield (i, start_x, end_x - start_x);
-                    return;
-                }
-                yield (i, start_x, line.line_w - start_x);
-                break;
-            }
-        }
-        for (i, line) in iter {
-            if line.line_i > end.line {
-                return;
-            }
-            if line.line_i == end.line
-                && let Some(end_x) = index_x(&line, end.index)
-            {
-                yield (i, 0.0, end_x);
-                return;
-            }
-            yield (i, 0.0, line.line_w);
-        }
-    }
-}
-
-/// copied & modified from fn found in Editor in cosmic_text
-/// returns x pos of a (non layout) index within an layout run
-fn index_x(run: &LayoutRun, index: usize) -> Option<f32> {
-    for glyph in run.glyphs.iter() {
-        if index == glyph.start {
-            return Some(glyph.x);
-        } else if index > glyph.start && index < glyph.end {
-            // Guess x offset based on characters
-            let mut before = 0;
-            let mut total = 0;
-
-            let cluster = &run.text[glyph.start..glyph.end];
-            for (i, _) in cluster.grapheme_indices(true) {
-                if glyph.start + i < index {
-                    before += 1;
-                }
-                total += 1;
-            }
-
-            let offset = glyph.w * (before as f32) / (total as f32);
-            return Some(glyph.x + offset);
-        }
-    }
-    None
-}
-
-/// returns top of line segment where cursor should visually select
-fn cursor_pos(cursor: Cursor, buf: &TextBuffer) -> Option<Vec2> {
-    let mut prev = None;
-    for run in buf
-        .layout_runs()
-        .skip_while(|r| r.line_i < cursor.line)
-        .take_while(|r| r.line_i == cursor.line)
-    {
-        prev = Some(vec2(run.line_w, run.line_top));
-        if let Some(pos) = index_x(&run, cursor.index) {
-            return Some(vec2(pos, run.line_top));
-        }
-    }
-    prev
-}
 
 pub struct TextEditCtx<'a> {
     pub text: &'a mut TextEdit,
-    pub font_system: &'a mut FontSystem,
+    pub data: &'a mut TextData,
 }
 
 impl<'a> TextEditCtx<'a> {
+    fn layout(&mut self) -> &Layout<UiColor> {
+        let attrs = self.text.view.attrs.clone();
+        let width = self.text.view.wrap_width();
+        self.text.view.buf.shape(self.data, &attrs, width);
+        self.text.view.buf.layout()
+    }
+
+    fn clamp_selection_to_layout(&mut self) {
+        if let Some(sel) = self.text.selection {
+            let layout = self.layout();
+            self.text.selection = Some(sel.refresh(layout));
+        }
+    }
+
     pub fn take(&mut self) -> String {
-        let text = self
+        let text = std::mem::take(self.text.view.buf.edit());
-            .text
+        self.text.selection = None;
-            .buf
-            .lines
-            .drain(..)
-            .map(|l| l.into_text())
-            .collect::<Vec<_>>()
-            .join("\n");
-        self.text
-            .buf
-            .set_text(self.font_system, "", &Attrs::new(), SHAPING, None);
-        self.text.selection.clear();
         text
     }
 
     pub fn set(&mut self, text: &str) {
         let text = self.string(text);
-        self.text
+        self.text.view.buf.set_text(text);
-            .buf
+        self.text.view.buf.changed = true;
-            .set_text(self.font_system, &text, &Attrs::new(), SHAPING, None);
+        self.text.selection = None;
-        self.text.selection.clear();
     }
 
     pub fn motion(&mut self, motion: Motion, select: bool) {
-        if let TextSelection::Pos(cursor) = self.text.selection
+        let Some(sel) = self.text.selection else {
-            && let Some(new) = self.buf_motion(cursor, motion)
+            return;
-        {
-            if select {
-                self.text.selection = TextSelection::Span {
-                    start: cursor,
-                    end: new,
         };
-            } else {
+        let layout = self.layout();
-                self.text.selection = TextSelection::Pos(new);
+        let sel = apply_motion(sel, layout, motion, select);
-            }
+        self.text.selection = Some(sel);
-        } else if let TextSelection::Span { start, end } = self.text.selection {
-            if select {
-                if let Some(cursor) = self.buf_motion(end, motion) {
-                    self.text.selection = TextSelection::Span { start, end: cursor };
-                }
-            } else {
-                let (start, end) = sort_cursors(start, end);
-                let sel = &mut self.text.selection;
-                match motion {
-                    Motion::Left | Motion::LeftWord => *sel = TextSelection::Pos(start),
-                    Motion::Right | Motion::RightWord => *sel = TextSelection::Pos(end),
-                    _ => {
-                        if let Some(cursor) = self.buf_motion(end, motion) {
-                            self.text.selection = TextSelection::Pos(cursor);
-                        }
-                    }
-                }
-            }
-        }
     }
 
+    /// Replace the `len` characters before the caret. This is the IME's
+    /// preedit path: it re-sends the whole composition each time.
     pub fn replace(&mut self, len: usize, text: &str) {
         let text = self.string(text);
         for _ in 0..len {
-            self.delete(false);
+            self.backspace(false);
         }
-        self.insert_inner(&text, false);
+        self.insert_str(&text);
     }
 
     fn string(&self, text: &str) -> String {
@@ -261,202 +160,173 @@ impl<'a> TextEditCtx<'a> {
 
     pub fn insert(&mut self, text: &str) {
         let text = self.string(text);
-        let mut lines = text.split('\n');
+        self.insert_str(&text);
-        let Some(first) = lines.next() else {
-            return;
-        };
-        self.insert_inner(first, true);
-        for line in lines {
-            self.newline();
-            self.insert_inner(line, true);
     }
+
+    fn insert_str(&mut self, text: &str) {
+        if text.is_empty() {
+            return;
+        }
+        self.clear_span();
+        let at = match self.text.selection {
+            Some(sel) => sel.focus().index(),
+            None => return,
+        };
+        let at = at.min(self.text.view.buf.text().len());
+        self.text.view.buf.edit().insert_str(at, text);
+        self.text.view.buf.changed = true;
+        self.set_caret(at + text.len());
     }
 
     pub fn clear_span(&mut self) -> bool {
-        if let TextSelection::Span { start, end } = self.text.selection {
+        let Some(sel) = self.text.selection else {
-            self.delete_between(start, end);
+            return false;
-            let (start, _) = sort_cursors(start, end);
+        };
-            self.text.selection = TextSelection::Pos(start);
+        if sel.is_collapsed() {
+            return false;
+        }
+        let range = sel.text_range();
+        self.text.view.buf.edit().replace_range(range.clone(), "");
+        self.text.view.buf.changed = true;
+        self.set_caret(range.start);
         true
-        } else {
-            false
-        }
     }
 
-    pub fn delete_between(&mut self, start: Cursor, end: Cursor) {
+    fn set_caret(&mut self, index: usize) {
-        let lines = &mut self.text.view.buf.lines;
+        let index = index.min(self.text.view.buf.text().len());
-        let (start, end) = sort_cursors(start, end);
+        let layout = self.layout();
-        if start.line == end.line {
+        self.text.selection = Some(Selection::from_byte_index(
-            let line = &mut lines[start.line];
+            layout,
-            let text = line.text();
+            index,
-            let text = text[..start.index].to_string() + &text[end.index..];
+            Affinity::default(),
-            edit_line(line, text);
+        ));
-        } else {
-            // start
-            let start_text = lines[start.line].text()[..start.index].to_string();
-            let end_text = &lines[end.line].text()[end.index..];
-            let text = start_text + end_text;
-            edit_line(&mut lines[start.line], text);
-        }
-        // between
-        let range = (start.line + 1)..=end.line;
-        if !range.is_empty() {
-            lines.splice(range, None);
-        }
-    }
-
-    fn insert_inner(&mut self, text: &str, mov: bool) {
-        self.clear_span();
-        if let TextSelection::Pos(cursor) = &mut self.text.selection {
-            let line = &mut self.text.view.buf.lines[cursor.line];
-            let mut line_text = line.text().to_string();
-            line_text.insert_str(cursor.index, text);
-            edit_line(line, line_text);
-            if mov {
-                for _ in 0..text.chars().count() {
-                    self.motion(Motion::Right, false);
-                }
-            }
-        }
     }
 
     pub fn newline(&mut self) {
-        if self.text.mode == EditMode::SingleLine {
+        if self.text.mode == EditMode::MultiLine {
-            return;
+            self.insert_str("\n");
-        }
-        self.clear_span();
-        if let TextSelection::Pos(cursor) = &mut self.text.selection {
-            let lines = &mut self.text.view.buf.lines;
-            let line = &mut lines[cursor.line];
-            let new = line.split_off(cursor.index);
-            cursor.line += 1;
-            lines.insert(cursor.line, new);
-            cursor.index = 0;
         }
     }
 
     pub fn backspace(&mut self, word: bool) {
-        if !self.clear_span()
+        if self.clear_span() {
-            && let TextSelection::Pos(cursor) = &mut self.text.selection
+            return;
-            && (cursor.index != 0 || cursor.line != 0)
-        {
-            self.motion(if word { Motion::LeftWord } else { Motion::Left }, false);
-            self.delete(word);
         }
+        let Some(sel) = self.text.selection else {
+            return;
+        };
+        let end = sel.focus().index();
+        if end == 0 {
+            return;
+        }
+        let layout = self.layout();
+        let start = if word {
+            sel.focus().previous_logical_word(layout).index()
+        } else {
+            let Some(cluster) = sel.focus().logical_clusters(layout)[0] else {
+                return;
+            };
+            let range = cluster.text_range();
+            if cluster.is_hard_line_break() || cluster.is_emoji() {
+                range.start
+            } else {
+                self.text.view.buf.text()[..range.end]
+                    .char_indices()
+                    .next_back()
+                    .map_or(range.start, |(start, _)| start)
+            }
+        };
+        self.delete_range(start, end);
     }
 
     pub fn delete(&mut self, word: bool) {
-        if !self.clear_span()
+        if self.clear_span() {
-            && let TextSelection::Pos(cursor) = &mut self.text.selection
-        {
-            if word {
-                let start = *cursor;
-                if let Some(end) = self.buf_motion(start, Motion::RightWord) {
-                    self.delete_between(start, end);
-                }
-            } else {
-                let lines = &mut self.text.view.buf.lines;
-                let line = &mut lines[cursor.line];
-                if cursor.index == line.text().len() {
-                    if cursor.line == lines.len() - 1 {
             return;
         }
-                    let add = lines.remove(cursor.line + 1).into_text();
+        let Some(sel) = self.text.selection else {
-                    let line = &mut lines[cursor.line];
+            return;
-                    let mut cur = line.text().to_string();
+        };
-                    cur.push_str(&add);
+        let start = sel.focus().index();
-                    edit_line(line, cur);
+        if start >= self.text.view.buf.text().len() {
+            return;
+        }
+        let layout = self.layout();
+        let end = if word {
+            sel.focus().next_logical_word(layout).index()
         } else {
-                    let mut text = line.text().to_string();
+            let clusters = sel.focus().logical_clusters(layout);
-                    text.remove(cursor.index);
+            let Some(cluster) = clusters[1].as_ref() else {
-                    edit_line(line, text);
+                return;
-                }
+            };
-            }
+            cluster.text_range().end
-        }
+        };
+        self.delete_range(start, end);
     }
 
-    fn buf_motion(&mut self, cursor: Cursor, motion: Motion) -> Option<Cursor> {
+    fn delete_range(&mut self, start: usize, end: usize) {
-        self.text
+        self.text.view.buf.edit().replace_range(start..end, "");
-            .buf
+        self.text.view.buf.changed = true;
-            .cursor_motion(self.font_system, cursor, None, motion)
+        self.set_caret(start);
-            .map(|r| r.0)
     }
 
-    pub fn select_word_at(&mut self, cursor: Cursor) {
+    pub fn select_all(&mut self) {
-        if let (Some(start), Some(end)) = (
+        let len = self.text.view.buf.text().len();
-            self.buf_motion(cursor, Motion::LeftWord),
+        if len == 0 {
-            self.buf_motion(cursor, Motion::RightWord),
+            return;
-        ) {
-            self.text.selection = TextSelection::Span { start, end };
-        }
-    }
-
-    pub fn select_line_at(&mut self, cursor: Cursor) {
-        let end = self.text.buf.lines[cursor.line].text().len();
-        self.text.selection = TextSelection::Span {
-            start: Cursor::new(cursor.line, 0),
-            end: Cursor::new(cursor.line, end),
         }
+        let layout = self.layout();
+        let anchor = parley::Cursor::from_byte_index(layout, 0, Affinity::default());
+        let focus = parley::Cursor::from_byte_index(layout, len, Affinity::default());
+        self.text.selection = Some(Selection::new(anchor, focus));
     }
 
     pub fn select(&mut self, pos: Vec2, size: Vec2, drag: bool, recent: bool) {
         let pos = pos - self.text.region().top_left().to_abs(size);
-        let hit = self.text.buf.hit(pos.x, pos.y);
+        let prev_sel = self.text.selection;
-        let sel = &mut self.text.selection;
+        let prev_hit = self.text.double_hit;
-        match sel {
+
-            TextSelection::None => {
+        let layout = self.layout();
-                if !drag && let Some(hit) = hit {
+        let (selection, double_hit) = if drag {
-                    *sel = TextSelection::Pos(hit)
+            let Some(selection) = prev_sel else {
-                }
+                return;
-            }
+            };
-            TextSelection::Pos(pos) => match (hit, drag) {
+            (selection.extend_to_point(layout, pos.x, pos.y), prev_hit)
-                (None, false) => *sel = TextSelection::None,
-                (None, true) => (),
-                (Some(hit), false) => {
-                    if recent && hit == *pos {
-                        self.text.double_hit = Some(hit);
-                        return self.select_word_at(hit);
         } else {
-                        *pos = hit
+            let hit = Selection::from_point(layout, pos.x, pos.y);
-                    }
+            let index = hit.focus().index();
-                }
+            // Successive clicks at one index select the word, then the line.
-                (Some(end), true) => *sel = TextSelection::Span { start: *pos, end },
+            if recent && prev_hit == Some(index) {
-            },
+                (Selection::line_from_point(layout, pos.x, pos.y), None)
-            TextSelection::Span { start, end } => match (hit, drag) {
+            } else if recent && prev_sel.map(|s| s.focus().index()) == Some(index) {
-                (None, false) => *sel = TextSelection::None,
+                (
-                (None, true) => *sel = TextSelection::Pos(*start),
+                    Selection::word_from_point(layout, pos.x, pos.y),
-                (Some(hit), false) => {
+                    Some(index),
-                    if recent
+                )
-                        && let Some(double) = self.text.double_hit
-                        && double == hit
-                    {
-                        return self.select_line_at(hit);
             } else {
-                        *sel = TextSelection::Pos(hit)
+                (hit, None)
-                    }
-                }
-                (Some(hit), true) => *end = hit,
-            },
-        }
-        if let TextSelection::Span { start, end } = sel
-            && start == end
-        {
-            *sel = TextSelection::Pos(*start);
             }
+        };
+
+        self.text.selection = Some(selection);
+        self.text.double_hit = double_hit;
     }
 
     pub fn deselect(&mut self) {
-        self.text.selection = TextSelection::None;
+        self.text.selection = None;
+        self.text.double_hit = None;
     }
 
     pub fn apply_event(&mut self, event: &KeyEvent, modifiers: &Modifiers) -> TextInputResult {
-        let old = (self.text.content(), self.text.selection);
+        let old = (self.text.view.buf.text().to_string(), self.text.selection);
         let mut undo = false;
         let res = self.apply_event_inner(event, modifiers, &mut undo);
-        if undo && let Some((old, selection)) = self.text.history.pop() {
+        if undo {
+            if let Some((old, selection)) = self.text.history.pop() {
                 self.set(&old);
                 self.text.selection = selection;
-        } else if self.text.content() != old.0 {
+                self.clamp_selection_to_layout();
+            }
+        } else if self.text.view.buf.text() != old.0 {
             self.text.history.push(old);
         }
         res
@@ -481,21 +351,25 @@ impl<'a> TextEditCtx<'a> {
                     }
                 }
                 NamedKey::ArrowRight => {
-                    if modifiers.control {
+                    let motion = if modifiers.control {
-                        self.motion(Motion::RightWord, modifiers.shift)
+                        Motion::RightWord
                     } else {
-                        self.motion(Motion::Right, modifiers.shift)
+                        Motion::Right
-                    }
+                    };
+                    self.motion(motion, modifiers.shift);
                 }
                 NamedKey::ArrowLeft => {
-                    if modifiers.control {
+                    let motion = if modifiers.control {
-                        self.motion(Motion::LeftWord, modifiers.shift)
+                        Motion::LeftWord
                     } else {
-                        self.motion(Motion::Left, modifiers.shift)
+                        Motion::Left
-                    }
+                    };
+                    self.motion(motion, modifiers.shift);
                 }
                 NamedKey::ArrowUp => self.motion(Motion::Up, modifiers.shift),
                 NamedKey::ArrowDown => self.motion(Motion::Down, modifiers.shift),
+                NamedKey::Home => self.motion(Motion::LineStart, modifiers.shift),
+                NamedKey::End => self.motion(Motion::LineEnd, modifiers.shift),
                 NamedKey::Escape => {
                     self.deselect();
                     return TextInputResult::Unfocus;
@@ -507,34 +381,18 @@ impl<'a> TextEditCtx<'a> {
                     match text.as_str() {
                         "v" => return TextInputResult::Paste,
                         "c" => {
-                            if let TextSelection::Span { start, end } = self.text.selection {
+                            if let Some(content) = self.text.selected_text() {
-                                let content = self.text.select_content(start, end);
                                 return TextInputResult::Copy(content);
                             }
                         }
                         "x" => {
-                            if let TextSelection::Span { start, end } = self.text.selection {
+                            if let Some(content) = self.text.selected_text() {
-                                let content = self.text.select_content(start, end);
                                 self.clear_span();
                                 return TextInputResult::Copy(content);
                             }
                         }
-                        "a" => {
+                        "a" => self.select_all(),
-                            if !self.text.buf.lines[0].text().is_empty()
+                        "z" => *undo = true,
-                                || self.text.buf.lines.len() > 1
-                            {
-                                let lines = &self.text.buf.lines;
-                                let last_line = lines.len() - 1;
-                                let last_idx = lines[last_line].text().len();
-                                self.text.selection = TextSelection::Span {
-                                    start: Cursor::new(0, 0),
-                                    end: Cursor::new(last_line, last_idx),
-                                };
-                            }
-                        }
-                        "z" => {
-                            *undo = true;
-                        }
                         _ => self.insert(text),
                     }
                 } else {
@@ -547,6 +405,24 @@ impl<'a> TextEditCtx<'a> {
     }
 }
 
+fn apply_motion(
+    sel: Selection,
+    layout: &Layout<UiColor>,
+    motion: Motion,
+    extend: bool,
+) -> Selection {
+    match motion {
+        Motion::Left => sel.previous_visual(layout, extend),
+        Motion::Right => sel.next_visual(layout, extend),
+        Motion::LeftWord => sel.previous_visual_word(layout, extend),
+        Motion::RightWord => sel.next_visual_word(layout, extend),
+        Motion::Up => sel.previous_line(layout, extend),
+        Motion::Down => sel.next_line(layout, extend),
+        Motion::LineStart => sel.line_start(layout, extend),
+        Motion::LineEnd => sel.line_end(layout, extend),
+    }
+}
+
 #[derive(Default)]
 pub struct Modifiers {
     pub shift: bool,
@@ -569,33 +445,6 @@ pub enum TextInputResult {
     Paste,
 }
 
-#[derive(Debug, Default, Clone, Copy)]
-pub enum TextSelection {
-    #[default]
-    None,
-    Pos(Cursor),
-    Span {
-        start: Cursor,
-        end: Cursor,
-    },
-}
-
-impl TextSelection {
-    pub fn clear(&mut self) {
-        match self {
-            TextSelection::None => (),
-            TextSelection::Pos(cursor) => {
-                cursor.line = 0;
-                cursor.index = 0;
-                cursor.affinity = Affinity::default();
-            }
-            TextSelection::Span { start: _, end: _ } => {
-                *self = TextSelection::None;
-            }
-        }
-    }
-}
-
 impl TextInputResult {
     pub fn unfocus(&self) -> bool {
         matches!(self, TextInputResult::Unfocus)
@@ -625,7 +474,7 @@ impl<I: IdLike<Widget = TextEdit>> TextEditable for I {
         let ui = ui.ui_mut();
         TextEditCtx {
             text: ui.widgets.get_mut(self).unwrap(),
-            font_system: &mut ui.text.font_system,
+            data: &mut ui.text,
         }
     }
 }

src/widget/text/mod.rs

@@ -6,11 +6,8 @@ pub use edit::*;
 use iris_core::util::MutDetect;
 
 use crate::prelude::*;
-use cosmic_text::{Attrs, BufferLine, Cursor, Metrics, Shaping};
 use std::ops::{Deref, DerefMut};
 
-pub const SHAPING: Shaping = Shaping::Advanced;
-
 pub struct Text {
     pub content: MutDetect<String>,
     view: TextView,
@@ -25,6 +22,16 @@ pub struct TextView {
     pub hint: Option<StrongWidget>,
 }
 
+impl TextView {
+    fn is_empty(&self) -> bool {
+        self.buf.is_empty()
+    }
+
+    pub fn wrap_width(&self) -> Option<f32> {
+        self.width
+    }
+}
+
 impl TextView {
     pub fn new(buf: TextBuffer, attrs: TextAttrs, hint: Option<StrongWidget>) -> Self {
         Self {
@@ -45,45 +52,26 @@ impl TextView {
             .align(self.align)
     }
 
-    fn tex_region(&self, tex: &RenderedText) -> UiRegion {
+    fn render(&mut self, ctx: &mut SizeCtx) -> &RenderedText {
-        let region = tex.size.align(self.align);
-        let dims = tex.handle.size();
-        let mut region = region.offset(tex.top_left_offset);
-        region.x.end = region.x.start + UiScalar::abs(dims.x);
-        region.y.end = region.y.start + UiScalar::abs(dims.y);
-        region
-    }
-
-    fn render(&mut self, ctx: &mut SizeCtx) -> RenderedText {
         let width = if self.attrs.wrap {
             Some(ctx.px_size().x)
         } else {
             None
         };
-        if width == self.width
+        if width != self.width || self.tex.is_none() || self.attrs.changed || self.buf.changed {
-            && let Some(tex) = &self.tex
-            && !self.attrs.changed
-            && !self.buf.changed
-        {
-            return tex.clone();
-        }
             self.width = width;
-        let font_system = &mut ctx.text.font_system;
+            self.tex = Some(ctx.draw_text(&mut self.buf, &self.attrs, width));
-        self.attrs.apply(font_system, &mut self.buf, width);
-        self.buf.shape_until_scroll(font_system, false);
-        let tex = ctx.draw_text(&mut self.buf, &self.attrs);
-        self.tex = Some(tex.clone());
             self.attrs.changed = false;
             self.buf.changed = false;
-        tex
+        }
+        self.tex.as_ref().unwrap()
     }
     pub fn tex(&self) -> Option<&RenderedText> {
         self.tex.as_ref()
     }
     pub fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        if let Some(hint) = &self.hint
+        if self.is_empty()
-            && let [line] = &self.buf.lines[..]
+            && let Some(hint) = &self.hint
-            && line.text().is_empty()
         {
             ctx.width(hint)
         } else {
@@ -91,9 +79,8 @@ impl TextView {
         }
     }
     pub fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        if let Some(hint) = &self.hint
+        if self.is_empty()
-            && let [line] = &self.buf.lines[..]
+            && let Some(hint) = &self.hint
-            && line.text().is_empty()
         {
             ctx.height(hint)
         } else {
@@ -101,48 +88,39 @@ impl TextView {
         }
     }
     pub fn draw(&mut self, painter: &mut Painter) -> UiRegion {
-        let tex = self.render(&mut painter.size_ctx());
+        let align = self.align;
-        let region = self.tex_region(&tex);
+        if self.is_empty() && self.hint.is_some() {
-        if let Some(hint) = &self.hint
+            let region = self.render(&mut painter.size_ctx()).size.align(align);
-            && let [line] = &self.buf.lines[..]
+            if let Some(hint) = &self.hint {
-            && line.text().is_empty()
-        {
                 painter.widget(hint);
-        } else {
-            painter.texture_within(&tex.handle, region);
             }
+            return region;
+        }
+
+        let tex = self.render(&mut painter.size_ctx());
+        let region = tex.size.align(align);
+        let within = region.within(&painter.region());
+        painter.glyphs(tex, within);
         region
     }
 
     pub fn content(&self) -> String {
-        self.buf
+        self.buf.text().to_string()
-            .lines
-            .iter()
-            .map(|l| l.text())
-            .collect::<Vec<_>>()
-            .join("\n")
     }
 }
 
 impl Text {
     pub fn new(content: impl Into<String>) -> Self {
-        let attrs = TextAttrs::default();
+        let content: String = content.into();
-        let buf = TextBuffer::new_empty(Metrics::new(attrs.font_size, attrs.line_height));
         Self {
-            content: content.into().into(),
+            view: TextView::new(TextBuffer::new(&content), TextAttrs::default(), None),
-            view: TextView::new(buf, attrs, None),
+            content: content.into(),
         }
     }
-    fn update_buf(&mut self, ctx: &mut SizeCtx) {
+    fn update_buf(&mut self, _ctx: &mut SizeCtx) {
         if self.content.changed {
             self.content.changed = false;
-            self.view.buf.set_text(
+            self.view.buf.set_text(self.content.as_str());
-                &mut ctx.text.font_system,
-                &self.content,
-                &Attrs::new().family(self.view.attrs.family),
-                SHAPING,
-                None,
-            );
         }
     }
 }
@@ -164,16 +142,6 @@ impl Widget for Text {
     }
 }
 
-pub fn sort_cursors(a: Cursor, b: Cursor) -> (Cursor, Cursor) {
-    let start = a.min(b);
-    let end = a.max(b);
-    (start, end)
-}
-
-pub fn edit_line(line: &mut BufferLine, text: String) {
-    line.set_text(text, line.ending(), line.attrs_list().clone());
-}
-
 impl Deref for Text {
     type Target = TextAttrs;
 

src/widget/trait_fns.rs

@@ -31,9 +31,9 @@ widget_trait! {
         }
     }
 
-    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, Sized> {
+    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, SetSize> {
         let size = size.into();
-        move |state| Sized {
+        move |state| SetSize {
             inner: self.add_strong(state),
             x: Some(size.x),
             y: Some(size.y),
@@ -58,18 +58,18 @@ widget_trait! {
         }
     }
 
-    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
+    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, SetSize> {
         let len = len.into();
-        move |state| Sized {
+        move |state| SetSize {
             inner: self.add_strong(state),
             x: Some(len),
             y: None,
         }
     }
 
-    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
+    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, SetSize> {
         let len = len.into();
-        move |state| Sized {
+        move |state| SetSize {
             inner: self.add_strong(state),
             x: None,
             y: Some(len),

tests/draw_cost.rs

@@ -0,0 +1,205 @@
+//! What one frame of `UiRenderNode::draw` costs on the CPU, against the number
+//! of layers it walks. Recording only: the pass is built and dropped without
+//! being submitted, so this is the loop's cost and not the GPU's.
+//!
+//!     cargo test --release --test draw_cost -- --ignored --nocapture
+//!
+//! Wall time is the wrong number to read for anything under a few percent --
+//! it varied by 2x between runs of one unchanged binary where instructions
+//! retired varied by 0.1%. Count those instead:
+//!
+//!     perf stat -e instructions:u target/release/.../draw_cost-* --ignored
+//!
+//! That is how `PrimitiveRender` was measured against a match in the renderer:
+//! 6 instructions per list drawn, against the ~5,400 wgpu spends recording
+//! one.
+//!
+//! The instance is leaked deliberately. A Vulkan loader may unload the driver
+//! when the last one drops, which can fault as a thread that used it exits --
+//! and every test runs on a spawned thread.
+
+use std::time::Instant;
+
+use iris::prelude::*;
+use iris_core::{
+    GlyphPrimitive, MaskIdx, PrimitiveInst, RectPrimitive, TextureHandle, TexturePrimitive, UiData,
+    UiRegion, UiRenderNode, UiRenderState,
+};
+use wgpu::{Color as GpuColor, *};
+
+const SIZE: u32 = 1024;
+const FRAMES: u32 = 200;
+/// Reported as the best of this many batches, since the mean moves by more
+/// than the thing being measured.
+const BATCHES: u32 = 8;
+
+fn gpu() -> Option<(Device, Queue)> {
+    // Probed rather than assumed: there may be no Vulkan adapter, and GL is
+    // what is left when there is not.
+    let all = Instance::new(InstanceDescriptor::new_without_display_handle());
+    let instance = match pollster::block_on(all.request_adapter(&RequestAdapterOptions::default()))
+    {
+        Ok(_) => all,
+        Err(_) => Instance::new(InstanceDescriptor {
+            backends: Backends::GL,
+            ..InstanceDescriptor::new_without_display_handle()
+        }),
+    };
+    // Leaked rather than dropped: see the note at the top of the file.
+    let instance: &'static Instance = Box::leak(Box::new(instance));
+    let adapter =
+        pollster::block_on(instance.request_adapter(&RequestAdapterOptions::default())).ok()?;
+    println!("adapter: {:?}", adapter.get_info());
+    pollster::block_on(adapter.request_device(&DeviceDescriptor::default())).ok()
+}
+
+fn config(format: TextureFormat) -> SurfaceConfiguration {
+    SurfaceConfiguration {
+        usage: TextureUsages::RENDER_ATTACHMENT,
+        format,
+        color_space: SurfaceColorSpace::Auto,
+        width: SIZE,
+        height: SIZE,
+        present_mode: PresentMode::Fifo,
+        desired_maximum_frame_latency: 2,
+        alpha_mode: CompositeAlphaMode::Auto,
+        view_formats: vec![],
+    }
+}
+
+/// Every layer draws all three primitives, so the renderer takes a different
+/// path for each list it walks -- which is the case a single-primitive layer
+/// would never exercise. Images are bound per instance, so there are few.
+fn fill(
+    ui: &mut UiData,
+    render: &mut UiRenderState,
+    layers: usize,
+    per_layer: usize,
+) -> Vec<TextureHandle> {
+    let rect = ui.primitives.kind::<RectPrimitive>();
+    let glyph = ui.primitives.kind::<GlyphPrimitive>();
+    let texture = ui.primitives.kind::<TexturePrimitive>();
+    let id = ui.widgets.add_strong(Rect::new(UiColor::WHITE)).id();
+    let handles: Vec<_> = (0..4)
+        .map(|_| ui.textures.add(image::RgbaImage::new(4, 4)))
+        .collect();
+
+    let mut layer = 0;
+    for _ in 0..layers {
+        for _ in 0..per_layer {
+            render.layers.write(
+                layer,
+                PrimitiveInst {
+                    kind: rect,
+                    id,
+                    primitive: RectPrimitive::color(UiColor::WHITE),
+                    region: UiRegion::FULL,
+                    mask_idx: MaskIdx::NONE,
+                },
+            );
+            render.layers.write(
+                layer,
+                PrimitiveInst {
+                    kind: glyph,
+                    id,
+                    primitive: GlyphPrimitive {
+                        uv_min: vec2(0.0, 0.0),
+                        uv_max: vec2(1.0, 1.0),
+                        layer: 0,
+                        color: UiColor::WHITE,
+                        flags: 0,
+                    },
+                    region: UiRegion::FULL,
+                    mask_idx: MaskIdx::NONE,
+                },
+            );
+        }
+        for h in &handles[..2] {
+            render.layers.write(
+                layer,
+                PrimitiveInst {
+                    kind: texture,
+                    id,
+                    primitive: TexturePrimitive::from(h),
+                    region: UiRegion::FULL,
+                    mask_idx: MaskIdx::NONE,
+                },
+            );
+        }
+        layer = render.layers.next(layer);
+    }
+    handles
+}
+
+fn frame_cost(device: &Device, queue: &Queue, layers: usize, per_layer: usize) -> f64 {
+    let format = TextureFormat::Bgra8Unorm;
+    let mut node = UiRenderNode::new(device, &config(format));
+    let mut ui = UiData::default();
+    let mut render = UiRenderState::new();
+    let _handles = fill(&mut ui, &mut render, layers, per_layer);
+    node.update(device, queue, &mut ui, &mut render);
+
+    let target = device.create_texture(&TextureDescriptor {
+        label: Some("draw cost"),
+        size: Extent3d {
+            width: SIZE,
+            height: SIZE,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: TextureDimension::D2,
+        format,
+        usage: TextureUsages::RENDER_ATTACHMENT,
+        view_formats: &[],
+    });
+    let view = target.create_view(&TextureViewDescriptor::default());
+
+    let record = |frames: u32| {
+        let start = Instant::now();
+        for _ in 0..frames {
+            let mut encoder = device.create_command_encoder(&CommandEncoderDescriptor::default());
+            {
+                let pass = &mut encoder.begin_render_pass(&RenderPassDescriptor {
+                    color_attachments: &[Some(RenderPassColorAttachment {
+                        view: &view,
+                        resolve_target: None,
+                        ops: Operations {
+                            load: LoadOp::Clear(GpuColor::BLACK),
+                            store: StoreOp::Store,
+                        },
+                        depth_slice: None,
+                    })],
+                    ..Default::default()
+                });
+                node.draw(pass);
+            }
+            drop(encoder.finish());
+        }
+        start.elapsed().as_secs_f64() / frames as f64
+    };
+    record(FRAMES / 4);
+    (0..BATCHES)
+        .map(|_| record(FRAMES))
+        .fold(f64::MAX, f64::min)
+}
+
+#[test]
+#[ignore = "measurement, not a check"]
+fn draw_cost_by_layer_count() {
+    let Some((device, queue)) = gpu() else {
+        panic!("no wgpu device; see the this-machine-graphics notes");
+    };
+    println!(
+        "layers, each 8 rects + 8 glyphs + 2 images: us/frame (us per layer), best of {BATCHES}"
+    );
+    let base = frame_cost(&device, &queue, 1, 8) * 1e6;
+    for layers in [8, 64, 256, 1024] {
+        let per_frame = frame_cost(&device, &queue, layers, 8) * 1e6;
+        // Net of the empty pass, which is the same in any version of this.
+        println!(
+            "{layers:>5}: {per_frame:8.1} us ({:.3} us)",
+            (per_frame - base).max(0.0) / layers as f64
+        );
+    }
+}

tests/text_edit.rs

@@ -0,0 +1,67 @@
+use iris::prelude::*;
+
+fn editor(text: &str, mode: EditMode) -> (TextEdit, TextData) {
+    let view = TextView::new(TextBuffer::new(text), TextAttrs::default(), None);
+    (TextEdit::new(view, mode), TextData::default())
+}
+
+fn press(edit: &mut TextEditCtx<'_>, x: f32) {
+    edit.select(vec2(x, 10.0), vec2(400.0, 200.0), false, false);
+}
+
+#[test]
+fn pressing_an_empty_field_places_input() {
+    let (mut text, mut data) = editor("", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    press(&mut edit, 40.0);
+    edit.insert("hello");
+
+    assert_eq!(edit.text.content(), "hello");
+}
+
+#[test]
+fn preedit_replaces_the_previous_composition() {
+    let (mut text, mut data) = editor("", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    press(&mut edit, 0.0);
+    edit.replace(0, "に");
+    edit.replace(1, "日本");
+
+    assert_eq!(edit.text.content(), "日本");
+}
+
+#[test]
+fn backspace_respects_utf8_boundaries() {
+    let (mut text, mut data) = editor("aé", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    press(&mut edit, f32::MAX);
+    edit.backspace(false);
+
+    assert_eq!(edit.text.content(), "a");
+}
+
+#[test]
+fn typing_replaces_the_selection() {
+    let (mut text, mut data) = editor("hello", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    edit.select_all();
+    edit.insert("goodbye");
+
+    assert_eq!(edit.text.content(), "goodbye");
+}