Hide Storage from Primitive for type-safety

examples/custom_shader/src/scene.rs

@@ -128,26 +128,25 @@ impl Primitive {
 }
 
 impl shader::Primitive for Primitive {
-    fn prepare(
+    type Renderer = Pipeline;
+
+    fn initialize(
         &self,
         device: &wgpu::Device,
         queue: &wgpu::Queue,
         format: wgpu::TextureFormat,
-        storage: &mut shader::Storage,
+    ) -> Pipeline {
+        Pipeline::new(device, queue, format)
+    }
+
+    fn prepare(
+        &self,
+        pipeline: &mut Pipeline,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
         _bounds: &Rectangle,
         viewport: &Viewport,
     ) {
-        if !storage.has::<Pipeline>() {
-            storage.store(Pipeline::new(
-                device,
-                queue,
-                format,
-                viewport.physical_size(),
-            ));
-        }
-
-        let pipeline = storage.get_mut::<Pipeline>().unwrap();
-
         // Upload data to GPU
         pipeline.update(
             device,
@@ -161,14 +160,11 @@ impl shader::Primitive for Primitive {
 
     fn render(
         &self,
+        pipeline: &Pipeline,
         encoder: &mut wgpu::CommandEncoder,
-        storage: &shader::Storage,
         target: &wgpu::TextureView,
         clip_bounds: &Rectangle<u32>,
     ) {
-        // At this point our pipeline should always be initialized
-        let pipeline = storage.get::<Pipeline>().unwrap();
-
         // Render primitive
         pipeline.render(
             target,

examples/custom_shader/src/scene/pipeline.rs

@@ -32,7 +32,6 @@ impl Pipeline {
         device: &wgpu::Device,
         queue: &wgpu::Queue,
         format: wgpu::TextureFormat,
-        target_size: Size<u32>,
     ) -> Self {
         //vertices of one cube
         let vertices =
@@ -62,8 +61,8 @@ impl Pipeline {
         let depth_texture = device.create_texture(&wgpu::TextureDescriptor {
             label: Some("cubes depth texture"),
             size: wgpu::Extent3d {
-                width: target_size.width,
+                width: 1,
-                height: target_size.height,
+                height: 1,
                 depth_or_array_layers: 1,
             },
             mip_level_count: 1,
@@ -297,7 +296,7 @@ impl Pipeline {
             uniforms,
             uniform_bind_group,
             vertices,
-            depth_texture_size: target_size,
+            depth_texture_size: Size::new(1, 1),
             depth_view,
             depth_pipeline,
         }

wgpu/src/layer.rs

@@ -235,13 +235,13 @@ impl Layer {
     pub fn draw_primitive(
         &mut self,
         bounds: Rectangle,
-        primitive: Box<dyn Primitive>,
+        primitive: impl Primitive,
         transformation: Transformation,
     ) {
         let bounds = bounds * transformation;
 
         self.primitives
-            .push(primitive::Instance { bounds, primitive });
+            .push(primitive::Instance::new(bounds, primitive));
     }
 
     fn flush_meshes(&mut self) {

wgpu/src/lib.rs

@@ -365,10 +365,10 @@ impl Renderer {
 
                 for instance in &layer.primitives {
                     instance.primitive.prepare(
+                        &mut primitive_storage,
                         &self.engine.device,
                         &self.engine.queue,
                         self.engine.format,
-                        &mut primitive_storage,
                         &instance.bounds,
                         viewport,
                     );
@@ -548,8 +548,8 @@ impl Renderer {
                         .and_then(Rectangle::snap)
                     {
                         instance.primitive.render(
-                            encoder,
                             &primitive_storage,
+                            encoder,
                             frame,
                             &clip_bounds,
                         );
@@ -805,7 +805,7 @@ impl graphics::geometry::Renderer for Renderer {
 impl primitive::Renderer for Renderer {
     fn draw_primitive(&mut self, bounds: Rectangle, primitive: impl Primitive) {
         let (layer, transformation) = self.layers.current_mut();
-        layer.draw_primitive(bounds, Box::new(primitive), transformation);
+        layer.draw_primitive(bounds, primitive, transformation);
     }
 }
 

wgpu/src/primitive.rs

@@ -12,13 +12,32 @@ pub type Batch = Vec<Instance>;
 
 /// A set of methods which allows a [`Primitive`] to be rendered.
 pub trait Primitive: Debug + MaybeSend + MaybeSync + 'static {
-    /// Processes the [`Primitive`], allowing for GPU buffer allocation.
+    /// The shared renderer of this [`Primitive`].
-    fn prepare(
+    ///
+    /// Normally, this will contain a bunch of [`wgpu`] state; like
+    /// a rendering pipeline, buffers, and textures.
+    ///
+    /// All instances of this [`Primitive`] type will share the same
+    /// [`Renderer`].
+    type Renderer: MaybeSend + MaybeSync;
+
+    /// Initializes the [`Renderer`](Self::Renderer) of the [`Primitive`].
+    ///
+    /// This will only be called once, when the first [`Primitive`] of this kind
+    /// is encountered.
+    fn initialize(
         &self,
         device: &wgpu::Device,
         queue: &wgpu::Queue,
         format: wgpu::TextureFormat,
-        storage: &mut Storage,
+    ) -> Self::Renderer;
+
+    /// Processes the [`Primitive`], allowing for GPU buffer allocation.
+    fn prepare(
+        &self,
+        renderer: &mut Self::Renderer,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
         bounds: &Rectangle,
         viewport: &Viewport,
     );
@@ -26,21 +45,92 @@ pub trait Primitive: Debug + MaybeSend + MaybeSync + 'static {
     /// Renders the [`Primitive`].
     fn render(
         &self,
+        renderer: &Self::Renderer,
         encoder: &mut wgpu::CommandEncoder,
+        target: &wgpu::TextureView,
+        clip_bounds: &Rectangle<u32>,
+    );
+}
+
+pub(crate) trait Stored:
+    Debug + MaybeSend + MaybeSync + 'static
+{
+    fn prepare(
+        &self,
+        storage: &mut Storage,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        format: wgpu::TextureFormat,
+        bounds: &Rectangle,
+        viewport: &Viewport,
+    );
+
+    fn render(
+        &self,
         storage: &Storage,
+        encoder: &mut wgpu::CommandEncoder,
         target: &wgpu::TextureView,
         clip_bounds: &Rectangle<u32>,
     );
 }
 
+#[derive(Debug)]
+struct BlackBox<P: Primitive> {
+    primitive: P,
+}
+
+impl<P: Primitive> Stored for BlackBox<P> {
+    fn prepare(
+        &self,
+        storage: &mut Storage,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        format: wgpu::TextureFormat,
+        bounds: &Rectangle,
+        viewport: &Viewport,
+    ) {
+        if !storage.has::<P>() {
+            storage.store::<P, _>(
+                self.primitive.initialize(device, queue, format),
+            );
+        }
+
+        let renderer = storage
+            .get_mut::<P>()
+            .expect("renderer should be initialized")
+            .downcast_mut::<P::Renderer>()
+            .expect("renderer should have the proper type");
+
+        self.primitive
+            .prepare(renderer, device, queue, bounds, viewport);
+    }
+
+    fn render(
+        &self,
+        storage: &Storage,
+        encoder: &mut wgpu::CommandEncoder,
+        target: &wgpu::TextureView,
+        clip_bounds: &Rectangle<u32>,
+    ) {
+        let renderer = storage
+            .get::<P>()
+            .expect("renderer should be initialized")
+            .downcast_ref::<P::Renderer>()
+            .expect("renderer should have the proper type");
+
+        self.primitive
+            .render(renderer, encoder, target, clip_bounds);
+    }
+}
+
 #[derive(Debug)]
 /// An instance of a specific [`Primitive`].
 pub struct Instance {
     /// The bounds of the [`Instance`].
-    pub bounds: Rectangle,
+    pub(crate) bounds: Rectangle,
 
     /// The [`Primitive`] to render.
-    pub primitive: Box<dyn Primitive>,
+    pub(crate) primitive: Box<dyn Stored>,
 }
 
 impl Instance {
@@ -48,7 +138,7 @@ impl Instance {
     pub fn new(bounds: Rectangle, primitive: impl Primitive) -> Self {
         Instance {
             bounds,
-            primitive: Box::new(primitive),
+            primitive: Box::new(BlackBox { primitive }),
         }
     }
 }
@@ -73,26 +163,25 @@ impl Storage {
     }
 
     /// Inserts the data `T` in to [`Storage`].
-    pub fn store<T: 'static + MaybeSend + MaybeSync>(&mut self, data: T) {
+    pub fn store<T: 'static, D: Any + MaybeSend + MaybeSync>(
+        &mut self,
+        data: D,
+    ) {
         let _ = self.pipelines.insert(TypeId::of::<T>(), Box::new(data));
     }
 
     /// Returns a reference to the data with type `T` if it exists in [`Storage`].
-    pub fn get<T: 'static>(&self) -> Option<&T> {
+    pub fn get<T: 'static>(&self) -> Option<&dyn Any> {
-        self.pipelines.get(&TypeId::of::<T>()).map(|pipeline| {
+        self.pipelines
-            (pipeline.as_ref() as &dyn Any)
+            .get(&TypeId::of::<T>())
-                .downcast_ref::<T>()
+            .map(|pipeline| pipeline.as_ref() as &dyn Any)
-                .expect("Value with this type does not exist in Storage.")
-        })
     }
 
     /// Returns a mutable reference to the data with type `T` if it exists in [`Storage`].
-    pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
+    pub fn get_mut<T: 'static>(&mut self) -> Option<&mut dyn Any> {
-        self.pipelines.get_mut(&TypeId::of::<T>()).map(|pipeline| {
+        self.pipelines
-            (pipeline.as_mut() as &mut dyn Any)
+            .get_mut(&TypeId::of::<T>())
-                .downcast_mut::<T>()
+            .map(|pipeline| pipeline.as_mut() as &mut dyn Any)
-                .expect("Value with this type does not exist in Storage.")
-        })
     }
 }