Allow to load an image from memory

New `image::Handle` opaque type uniquely identifying some `image::Data`,
allowing reliable caching.

wgpu/src/image.rs

@@ -1,11 +1,14 @@
 use crate::Transformation;
-use iced_native::Rectangle;
+use iced_native::{
+    image::{Data, Handle},
+    Rectangle,
+};
 
 use std::{cell::RefCell, collections::HashMap, mem, rc::Rc};
 
 #[derive(Debug)]
 pub struct Pipeline {
-    cache: RefCell<HashMap<String, Memory>>,
+    cache: RefCell<HashMap<u64, Memory>>,
 
     pipeline: wgpu::RenderPipeline,
     uniforms: wgpu::Buffer,
@@ -197,23 +200,36 @@ impl Pipeline {
         }
     }
 
-    pub fn dimensions(&self, path: &str) -> (u32, u32) {
-        self.load(path);
+    pub fn dimensions(&self, handle: &Handle) -> (u32, u32) {
+        self.load(handle);
 
-        self.cache.borrow().get(path).unwrap().dimensions()
+        self.cache.borrow().get(&handle.id()).unwrap().dimensions()
     }
 
-    fn load(&self, path: &str) {
-        if !self.cache.borrow().contains_key(path) {
-            let memory = if let Ok(image) = image::open(path) {
-                Memory::Host {
-                    image: image.to_bgra(),
+    fn load(&self, handle: &Handle) {
+        if !self.cache.borrow().contains_key(&handle.id()) {
+            let memory = match handle.data() {
+                Data::Path(path) => {
+                    if let Ok(image) = image::open(path) {
+                        Memory::Host {
+                            image: image.to_bgra(),
+                        }
+                    } else {
+                        Memory::NotFound
+                    }
+                }
+                Data::Bytes(bytes) => {
+                    if let Ok(image) = image::load_from_memory(&bytes) {
+                        Memory::Host {
+                            image: image.to_bgra(),
+                        }
+                    } else {
+                        Memory::Invalid
+                    }
                 }
-            } else {
-                Memory::NotFound
             };
 
-            let _ = self.cache.borrow_mut().insert(path.to_string(), memory);
+            let _ = self.cache.borrow_mut().insert(handle.id(), memory);
         }
     }
 
@@ -245,12 +261,12 @@ impl Pipeline {
         //
         // [1]: https://github.com/nical/guillotiere
         for image in instances {
-            self.load(&image.path);
+            self.load(&image.handle);
 
             if let Some(texture) = self
                 .cache
                 .borrow_mut()
-                .get_mut(&image.path)
+                .get_mut(&image.handle.id())
                 .unwrap()
                 .upload(device, encoder, &self.texture_layout)
             {
@@ -327,6 +343,7 @@ enum Memory {
         height: u32,
     },
     NotFound,
+    Invalid,
 }
 
 impl Memory {
@@ -335,6 +352,7 @@ impl Memory {
             Memory::Host { image } => image.dimensions(),
             Memory::Device { width, height, .. } => (*width, *height),
             Memory::NotFound => (1, 1),
+            Memory::Invalid => (1, 1),
         }
     }
 
@@ -417,12 +435,13 @@ impl Memory {
             }
             Memory::Device { bind_group, .. } => Some(bind_group.clone()),
             Memory::NotFound => None,
+            Memory::Invalid => None,
         }
     }
 }
 
 pub struct Image {
-    pub path: String,
+    pub handle: Handle,
     pub position: [f32; 2],
     pub scale: [f32; 2],
 }

wgpu/src/primitive.rs

@@ -1,5 +1,5 @@
 use iced_native::{
-    Background, Color, Font, HorizontalAlignment, Rectangle, Vector,
+    image, Background, Color, Font, HorizontalAlignment, Rectangle, Vector,
     VerticalAlignment,
 };
 
@@ -41,8 +41,8 @@ pub enum Primitive {
     },
     /// An image primitive
     Image {
-        /// The path of the image
-        path: String,
+        /// The handle of the image
+        handle: image::Handle,
         /// The bounds of the image
         bounds: Rectangle,
     },

wgpu/src/renderer.rs

@@ -229,9 +229,9 @@ impl Renderer {
                     border_radius: *border_radius as f32,
                 });
             }
-            Primitive::Image { path, bounds } => {
+            Primitive::Image { handle, bounds } => {
                 layer.images.push(Image {
-                    path: path.clone(),
+                    handle: handle.clone(),
                     position: [bounds.x, bounds.y],
                     scale: [bounds.width, bounds.height],
                 });

wgpu/src/renderer/widget/image.rs

@@ -2,14 +2,18 @@ use crate::{Primitive, Renderer};
 use iced_native::{image, Layout, MouseCursor};
 
 impl image::Renderer for Renderer {
-    fn dimensions(&self, path: &str) -> (u32, u32) {
-        self.image_pipeline.dimensions(path)
+    fn dimensions(&self, handle: &image::Handle) -> (u32, u32) {
+        self.image_pipeline.dimensions(handle)
     }
 
-    fn draw(&mut self, path: &str, layout: Layout<'_>) -> Self::Output {
+    fn draw(
+        &mut self,
+        handle: image::Handle,
+        layout: Layout<'_>,
+    ) -> Self::Output {
         (
             Primitive::Image {
-                path: String::from(path),
+                handle,
                 bounds: layout.bounds(),
             },
             MouseCursor::OutOfBounds,