Separate atlas pages from textures, and draw both through one instance list

Rework of the review on #11. Pages and standalone images were one
`Textures` manager separated by a `TextureKind` tag, and images were a
second instance list beside `Primitives::instances`. The tag forced
`image_index()`/`layer()` to panic on the wrong kind of handle, and the
second list forced an `is_image` branch through `free`, `region_mut`,
`apply_free` and `PrimitiveChange`.

Pages are now their own thing. `GlyphAtlas` owns its page images
outright and hands the renderer dirty rectangles; `GpuPages` owns the
array texture they upload to. `Textures` is standalone images only, so
`TextureHandle` has one kind, `slot()` cannot be wrong, and nothing
needs a free list that skips pages. `GlyphAtlas::insert` no longer takes
a `Textures`, which drops that parameter from `TextData::render` and
`SizeCtx` too.

Images go back through the one instance list. A texture instance is an
ordinary `PrimitiveInstance` whose `idx` names a texture rather than a
group-1 entry, which `PrimitiveHandle::data_idx: Option` records.
`RenderLayer::plan_draws` batches the layer's instances into runs
sharing a bind group, so a ui with no images still plans a single draw,
and an image draws in instance order rather than on top of its layer.

Group 2 is now one `texture_2d_array` and a sampler, bound per run: the
atlas for rects and glyphs, or one image viewed as an array of one. That
removes the second texture binding and the 1x1 null view that had to
fill it. Masks move to group 3, so resizing that buffer no longer stales
every texture bind group, and `GpuTextures` no longer reports whether
the caller must rebuild one.

`GlyphPrimitive` drops its manual pad: the WGSL struct now declares the
uvs as scalars, which matches the Rust layout exactly. `#[repr(C,
align(8))]` would have left real padding bytes, which `bytemuck::Pod`
forbids.

Verified with a headless run of the `tabs` example and of a scratch
example mixing images, rects, glyphs and a mask in one layer; 52 glyphs
at size 300 grew the atlas array from 1 to 4 layers with every earlier
page still sampling correctly.

core/src/render/atlas.rs

@@ -1,15 +1,11 @@
 use crate::{
-    PatchRect, TextureHandle, Textures,
+    PatchRect,
     util::{HashMap, Vec2},
 };
 use image::RgbaImage;
 use swash::scale::image::{Content, Image};
 
-/// Side of one atlas page, in pixels. 1024 is 4 MB at RGBA8 -- enough for a
-/// few thousand glyphs at UI sizes, and small enough that a page nobody fills
-/// is not a big waste. Also the fixed width/height of every layer of the
-/// shared array texture in `render::texture` -- `pub(crate)` so that module
-/// can size it without a second constant to keep in sync.
+/// 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
@@ -40,7 +36,7 @@ pub struct GlyphEntry {
     pub width: u32,
     pub height: u32,
     pub is_colored: bool,
-    /// The atlas array layer this glyph's page occupies.
+    /// Which atlas array layer this glyph is on.
     pub layer: u32,
 }
 
@@ -53,18 +49,26 @@ impl GlyphEntry {
 }
 
 struct Page {
-    handle: TextureHandle,
+    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 {
@@ -72,12 +76,7 @@ impl GlyphAtlas {
         self.entries.get(key).copied()
     }
 
-    pub fn insert(
-        &mut self,
-        key: GlyphKey,
-        image: &Image,
-        textures: &mut Textures,
-    ) -> Option<GlyphEntry> {
+    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 {
@@ -99,23 +98,18 @@ impl GlyphAtlas {
             return None;
         }
 
-        let (page_idx, x, y) = self.allocate(w, h, textures);
-        let page = &self.pages[page_idx];
+        let (layer, x, y) = self.allocate(w, h);
+        write_glyph(&mut self.pages[layer as usize].image, image, x, y);
+        self.uploads.push(PageUpload {
+            layer,
+            rect: PatchRect {
+                x,
+                y,
+                width: w,
+                height: h,
+            },
+        });
 
-        let img = textures.image_mut(&page.handle);
-        let rgba = img.as_mut_rgba8().expect("atlas page is rgba8");
-        write_glyph(rgba, image, x, y);
-
-        let handle = page.handle.clone();
-        let rect = PatchRect {
-            x,
-            y,
-            width: w,
-            height: h,
-        };
-        textures.patch(&handle, rect);
-
-        let page = &self.pages[page_idx];
         let scale = 1.0 / PAGE as f32;
         let entry = GlyphEntry {
             uv_min: Vec2::new(x as f32 * scale, y as f32 * scale),
@@ -125,38 +119,47 @@ impl GlyphAtlas {
             width: w,
             height: h,
             is_colored: matches!(image.content, Content::Color),
-            layer: page.handle.layer(),
+            layer,
         };
         self.entries.insert(key, Some(entry));
         Some(entry)
     }
 
-    fn allocate(&mut self, w: u32, h: u32, textures: &mut Textures) -> (usize, u32, u32) {
+    fn allocate(&mut self, w: u32, h: u32) -> (u32, u32, u32) {
         if let Some((i, (x, y))) = self
             .pages
             .iter_mut()
             .enumerate()
             .find_map(|(i, page)| page.allocate(w, h).map(|position| (i, position)))
         {
-            return (i, x, y);
+            return (i as u32, x, y);
         }
 
-        let handle = textures.add_page(RgbaImage::new(PAGE, PAGE));
         self.pages.push(Page {
-            handle,
+            image: RgbaImage::new(PAGE, PAGE),
             x: PAD + w + PAD,
             y: PAD,
             shelf_height: h + PAD,
         });
-        (self.pages.len() - 1, PAD, PAD)
+        (self.pages.len() as u32 - 1, PAD, PAD)
+    }
+
+    /// Drains what has been written since the last call, for the renderer to
+    /// upload. Nothing else is needed for a new page: 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) -> usize {
-        self.pages.len()
+    pub fn page_count(&self) -> u32 {
+        self.pages.len() as u32
     }
 
     pub fn glyph_count(&self) -> usize {