Improve boundaries between `quad` submodules in `iced_wgpu`

3 files changed, 75 insertions, 55 deletions

diff --git a/wgpu/src/quad.rs b/wgpu/src/quad.rs
index deb6d59a..9c5ed05f 100644
--- a/wgpu/src/quad.rs
+++ b/wgpu/src/quad.rs
@@ -116,21 +116,23 @@ impl Pipeline {
             for (kind, count) in &quads.order {
                 match kind {
                     Kind::Solid => {
-                        render_pass.set_pipeline(&self.solid.pipeline);
-                        layer.solid.draw(
-                            &layer.constants,
+                        self.solid.render(
                             render_pass,
+                            &layer.constants,
+                            &layer.solid,
                             solid_offset..(solid_offset + count),
                         );
+
                         solid_offset += count;
                     }
                     Kind::Gradient => {
-                        render_pass.set_pipeline(&self.gradient.pipeline);
-                        layer.gradient.draw(
-                            &layer.constants,
+                        self.gradient.render(
                             render_pass,
+                            &layer.constants,
+                            &layer.gradient,
                             gradient_offset..(gradient_offset + count),
                         );
+
                         gradient_offset += count;
                     }
                 }
@@ -199,17 +201,8 @@ impl Layer {
             bytemuck::bytes_of(&uniforms),
         );
 
-        let _ = self.solid.instances.resize(device, quads.solids.len());
-        let _ = self
-            .gradient
-            .instances
-            .resize(device, quads.gradients.len());
-
-        let _ = self.solid.instances.write(queue, 0, &quads.solids);
-        let _ = self.gradient.instances.write(queue, 0, &quads.gradients);
-
-        self.solid.instance_count = quads.solids.len();
-        self.gradient.instance_count = quads.gradients.len();
+        self.solid.prepare(device, queue, &quads.solids);
+        self.gradient.prepare(device, queue, &quads.gradients);
     }
 }
 
diff --git a/wgpu/src/quad/gradient.rs b/wgpu/src/quad/gradient.rs
index 2729afdf..d3884ce1 100644
--- a/wgpu/src/quad/gradient.rs
+++ b/wgpu/src/quad/gradient.rs
@@ -24,13 +24,13 @@ unsafe impl Zeroable for Gradient {}
 
 #[derive(Debug)]
 pub struct Pipeline {
-    pub pipeline: wgpu::RenderPipeline,
+    pipeline: wgpu::RenderPipeline,
 }
 
 #[derive(Debug)]
 pub struct Layer {
-    pub instances: Buffer<Gradient>,
-    pub instance_count: usize,
+    instances: Buffer<Gradient>,
+    instance_count: usize,
 }
 
 impl Layer {
@@ -48,23 +48,16 @@ impl Layer {
         }
     }
 
-    pub fn draw<'a>(
-        &'a self,
-        constants: &'a wgpu::BindGroup,
-        render_pass: &mut wgpu::RenderPass<'a>,
-        range: Range<usize>,
+    pub fn prepare(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        instances: &[Gradient],
     ) {
-        #[cfg(feature = "tracing")]
-        let _ = tracing::info_span!("Wgpu::Quad::Gradient", "DRAW").entered();
-
-        render_pass.set_bind_group(0, constants, &[]);
-        render_pass.set_vertex_buffer(1, self.instances.slice(..));
+        let _ = self.instances.resize(device, instances.len());
+        let _ = self.instances.write(queue, 0, instances);
 
-        render_pass.draw_indexed(
-            0..quad::INDICES.len() as u32,
-            0,
-            range.start as u32..range.end as u32,
-        );
+        self.instance_count = instances.len();
     }
 }
 
@@ -158,4 +151,25 @@ impl Pipeline {
 
         Self { pipeline }
     }
+
+    pub fn render<'a>(
+        &'a self,
+        render_pass: &mut wgpu::RenderPass<'a>,
+        constants: &'a wgpu::BindGroup,
+        layer: &'a Layer,
+        range: Range<usize>,
+    ) {
+        #[cfg(feature = "tracing")]
+        let _ = tracing::info_span!("Wgpu::Quad::Gradient", "DRAW").entered();
+
+        render_pass.set_pipeline(&self.pipeline);
+        render_pass.set_bind_group(0, constants, &[]);
+        render_pass.set_vertex_buffer(1, layer.instances.slice(..));
+
+        render_pass.draw_indexed(
+            0..quad::INDICES.len() as u32,
+            0,
+            range.start as u32..range.end as u32,
+        );
+    }
 }
diff --git a/wgpu/src/quad/solid.rs b/wgpu/src/quad/solid.rs
index 3540ce3a..a3a7a0af 100644
--- a/wgpu/src/quad/solid.rs
+++ b/wgpu/src/quad/solid.rs
@@ -17,13 +17,13 @@ pub struct Solid {
 
 #[derive(Debug)]
 pub struct Pipeline {
-    pub pipeline: wgpu::RenderPipeline,
+    pipeline: wgpu::RenderPipeline,
 }
 
 #[derive(Debug)]
 pub struct Layer {
-    pub instances: Buffer<quad::Solid>,
-    pub instance_count: usize,
+    instances: Buffer<Solid>,
+    instance_count: usize,
 }
 
 impl Layer {
@@ -41,23 +41,16 @@ impl Layer {
         }
     }
 
-    pub fn draw<'a>(
-        &'a self,
-        constants: &'a wgpu::BindGroup,
-        render_pass: &mut wgpu::RenderPass<'a>,
-        range: Range<usize>,
+    pub fn prepare(
+        &mut self,
+        device: &wgpu::Device,
+        queue: &wgpu::Queue,
+        instances: &[Solid],
     ) {
-        #[cfg(feature = "tracing")]
-        let _ = tracing::info_span!("Wgpu::Quad::Solid", "DRAW").entered();
-
-        render_pass.set_bind_group(0, constants, &[]);
-        render_pass.set_vertex_buffer(1, self.instances.slice(..));
+        let _ = self.instances.resize(device, instances.len());
+        let _ = self.instances.write(queue, 0, instances);
 
-        render_pass.draw_indexed(
-            0..quad::INDICES.len() as u32,
-            0,
-            range.start as u32..range.end as u32,
-        );
+        self.instance_count = instances.len();
     }
 }
 
@@ -92,8 +85,7 @@ impl Pipeline {
                     buffers: &[
                         quad::Vertex::buffer_layout(),
                         wgpu::VertexBufferLayout {
-                            array_stride: std::mem::size_of::<quad::Solid>()
-                                as u64,
+                            array_stride: std::mem::size_of::<Solid>() as u64,
                             step_mode: wgpu::VertexStepMode::Instance,
                             attributes: &wgpu::vertex_attr_array!(
                                 // Color
@@ -133,4 +125,25 @@ impl Pipeline {
 
         Self { pipeline }
     }
+
+    pub fn render<'a>(
+        &'a self,
+        render_pass: &mut wgpu::RenderPass<'a>,
+        constants: &'a wgpu::BindGroup,
+        layer: &'a Layer,
+        range: Range<usize>,
+    ) {
+        #[cfg(feature = "tracing")]
+        let _ = tracing::info_span!("Wgpu::Quad::Solid", "DRAW").entered();
+
+        render_pass.set_pipeline(&self.pipeline);
+        render_pass.set_bind_group(0, constants, &[]);
+        render_pass.set_vertex_buffer(1, layer.instances.slice(..));
+
+        render_pass.draw_indexed(
+            0..quad::INDICES.len() as u32,
+            0,
+            range.start as u32..range.end as u32,
+        );
+    }
 }