Move text layout and rendering to Parley

core/src/render/texture.rs

@@ -1,11 +1,13 @@
-use image::{DynamicImage, EncodableLayout};
+use image::{DynamicImage, EncodableLayout, GenericImageView};
 use wgpu::{util::DeviceExt, *};
 
-use crate::{TextureUpdate, Textures};
+use crate::{PatchRect, TextureUpdate, Textures};
 
 pub struct GpuTextures {
     device: Device,
     queue: Queue,
+    /// Parallel to `views`; patches require textures rather than views.
+    textures: Vec<Option<Texture>>,
     views: Vec<TextureView>,
     view_count: usize,
     samplers: Vec<Sampler>,
@@ -17,37 +19,95 @@ impl GpuTextures {
     pub fn update(&mut self, textures: &mut Textures) -> bool {
         let mut changed = false;
         for update in textures.updates() {
-            changed = true;
             match update {
-                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(),
+                TextureUpdate::Push(image) => {
+                    self.push(image);
+                    changed = true;
+                }
+                TextureUpdate::Set(i, image) => {
+                    self.set(i, image);
+                    changed = true;
+                }
+                TextureUpdate::Patch(i, rect, image) => {
+                    // Patching contents leaves the binding array unchanged.
+                    self.patch(i, rect, image);
+                }
+                TextureUpdate::SetFree => {
+                    self.view_count += 1;
+                    changed = true;
+                }
+                TextureUpdate::Free(i) => {
+                    self.free(i);
+                    changed = true;
+                }
+                TextureUpdate::PushFree => {
+                    self.push_free();
+                    changed = true;
+                }
             }
         }
         changed
     }
     fn set(&mut self, i: u32, image: &DynamicImage) {
         self.view_count += 1;
-        let view = self.create_view(image);
+        let (texture, view) = self.create(image);
+        self.textures[i as usize] = Some(texture);
         self.views[i as usize] = view;
     }
     fn free(&mut self, i: u32) {
         self.view_count -= 1;
+        self.textures[i as usize] = None;
         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);
+        let (texture, view) = self.create(image);
+        self.textures.push(Some(texture));
         self.views.push(view);
     }
     fn push_free(&mut self) {
         self.view_count += 1;
+        self.textures.push(None);
         self.views.push(self.null_view.clone());
     }
 
-    fn create_view(&self, image: &DynamicImage) -> TextureView {
+    fn patch(&mut self, i: u32, rect: PatchRect, image: &DynamicImage) {
+        let Some(texture) = &self.textures[i as usize] else {
+            return;
+        };
+        if rect.width == 0 || rect.height == 0 {
+            return;
+        }
+        // `write_texture` requires tightly packed rows, unlike the atlas image.
+        let sub = image
+            .view(rect.x, rect.y, rect.width, rect.height)
+            .to_image();
+        self.queue.write_texture(
+            TexelCopyTextureInfo {
+                texture,
+                mip_level: 0,
+                origin: Origin3d {
+                    x: rect.x,
+                    y: rect.y,
+                    z: 0,
+                },
+                aspect: TextureAspect::All,
+            },
+            sub.as_bytes(),
+            TexelCopyBufferLayout {
+                offset: 0,
+                bytes_per_row: Some(rect.width * 4),
+                rows_per_image: Some(rect.height),
+            },
+            Extent3d {
+                width: rect.width,
+                height: rect.height,
+                depth_or_array_layers: 1,
+            },
+        );
+    }
+
+    fn create(&self, image: &DynamicImage) -> (Texture, TextureView) {
         let image = image.to_rgba8();
         let (width, height) = image.dimensions();
         let texture = self.device.create_texture_with_data(
@@ -63,13 +123,14 @@ 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(),
         );
-        texture.create_view(&TextureViewDescriptor::default())
+        let view = texture.create_view(&TextureViewDescriptor::default());
+        (texture, view)
     }
 
     pub fn new(device: &Device, queue: &Queue) -> Self {
@@ -77,6 +138,7 @@ impl GpuTextures {
         Self {
             device: device.clone(),
             queue: queue.clone(),
+            textures: Vec::new(),
             views: Vec::new(),
             samplers: vec![default_sampler(device)],
             no_views: vec![null_view.clone()],