refactoring the shader container. To Trait or not to Trait? Probably Trait

src/canvas/canvas_state.rs

@@ -21,7 +21,7 @@ use vulkano::descriptor::descriptor::DescriptorDescTy::TexelBuffer;
 use crate::canvas::canvas_frame::CanvasFrame;
 use std::hash::Hash;
 use crate::canvas::canvas_text::{CanvasText, CanvasTextHandle};
-use crate::canvas::canvas_shader::{CanvasShader, CanvasShaderHandle};
+use crate::canvas::canvas_shader::{GenericShader, CanvasShaderHandle, CompiledGraphicsPipelineHandle, CompiledGraphicsPipeline};
 use crate::canvas::canvas_buffer::{CanvasImage, CanvasTexture, CanvasTextCache};
 use crate::util::vertex_3d::Vertex3D;
 use vulkano::pipeline::depth_stencil::{StencilFaceFlags, DynamicStencilValue};
@@ -32,7 +32,6 @@ use vulkano::pipeline::depth_stencil::{StencilFaceFlags, DynamicStencilValue};
 ///     Split out to two drawables?
 ///
 pub trait Drawable {
-
     fn get_vertices(&self) -> Vec<(f32, f32, f32)>;
     fn get_color(&self) -> (f32, f32, f32, f32);
     fn get_ti_coords(&self) -> Vec<(f32, f32)>;
@@ -84,7 +83,7 @@ pub struct CanvasState {
     // hold the image, texture, and shader buffers the same was as we do CompuState
     image_buffers: Vec<Arc<CanvasImage>>,
     texture_buffers: Vec<Arc<CanvasTexture>>,
-    shader_buffers: Vec<Arc<CanvasShader>>,
+    shader_buffers: Vec<Arc<Box<dyn CompiledGraphicsPipeline>>>,
     text_buffers: Vec<Arc<(CanvasText, CanvasTextCache)>>,
 
     // Hold onto the vertices we get from the Compu and Canvas Frames
@@ -218,7 +217,6 @@ impl CanvasState {
 
     /// Using the dimensions and suggested usage, load a CanvasImage and return it's handle
     pub fn create_text_buffers(&mut self, dimensions: (u32, u32)) -> Arc<CanvasTextHandle> {
-
         let handle = Arc::new(CanvasTextHandle { handle: self.text_buffers.len() as u32 });
 //
 //        let text = CanvasText {
@@ -348,39 +346,21 @@ impl CanvasState {
                        filename: String,
                        shader_type: ShaderType,
                        physical: PhysicalDevice,
-                       capabilities: Capabilities) -> Option<Arc<CanvasShaderHandle>> {
+                       capabilities: Capabilities) -> Option<Arc<CompiledGraphicsPipelineHandle>> {
 
-        let handle = Arc::new(CanvasShaderHandle {
+        let handle = Arc::new(CompiledGraphicsPipelineHandle {
             handle: self.shader_buffers.len() as u32
         });
 
-        // TODO : what is even going on here
-        let shader = match shader_type {
-            ShaderType::SOLID => {
-                Arc::new(CanvasShader::new(
-                    filename.clone(),
-                    capabilities.clone(),
-                    self.queue.clone(),
-                    physical.clone(),
-                    self.device.clone(),
-                    handle.clone(),
-                    self.render_pass.clone())
-                )
-            }
-            ShaderType::IMAGE | ShaderType::TEXTURED => {
-                Arc::new(CanvasShader::new(
-                    filename.clone(),
-                    capabilities.clone(),
-                    self.queue.clone(),
-                    physical.clone(),
-                    self.device.clone(),
-                    handle.clone(),
-                    self.render_pass.clone())
-                )
-            }
-        };
 
-        self.shader_buffers.push(shader.clone());
+        let shader : Box<dyn CompiledGraphicsPipeline> = Box::new(GenericShader::new(
+            filename.clone(),
+            self.device.clone(),
+            handle.clone(),
+            self.render_pass.clone()
+        ));
+
+        self.shader_buffers.push(Arc::new(shader));
 
         Some(handle)
     }
@@ -398,10 +378,10 @@ impl CanvasState {
 
     /// Using the shader name, iterates through the stored textures and matches by the name
     pub fn get_shader_handle(&self, shader_name: String)
-                             -> Option<Arc<CanvasShaderHandle>> {
+                             -> Option<Arc<CompiledGraphicsPipelineHandle>> {
         for shader in self.shader_buffers.clone() {
-            if shader.name == shader_name {
-                return Some(shader.handle.clone());
+            if shader.get_name() == shader_name {
+                return Some(shader.get_handle().clone());
             }
         }
         None
@@ -487,7 +467,7 @@ impl CanvasState {
     }
 
     /// Builds the descriptor set for solid colors using the input kernel (needs to support solid colors)
-    fn get_solid_color_descriptor_set(&self, kernel: Arc<CanvasShader>) -> Box<dyn DescriptorSet + Send + Sync> {
+    fn get_solid_color_descriptor_set(&self, kernel: Arc<GenericShader>) -> Box<dyn DescriptorSet + Send + Sync> {
         let o: Box<dyn DescriptorSet + Send + Sync> = Box::new(
             PersistentDescriptorSet::start(
                 kernel.clone().get_pipeline().clone(), 0,
@@ -547,7 +527,7 @@ impl CanvasState {
             for (image_handle, vertex_buffer) in self.image_vertex_buffer.clone() {
                 let handle = image_handle.clone().handle as usize;
                 let descriptor_set = self.image_buffers.get(handle).clone().unwrap().clone()
-                    .get_descriptor_set(shader.clone());
+                    .get_descriptor_set(shader.get_pipeline().clone());
 
                 command_buffer = command_buffer.draw(
                     shader.get_pipeline().clone(),
@@ -555,7 +535,6 @@ impl CanvasState {
                     &self.dynamic_state.clone(), vec![vertex_buffer],
                     vec![descriptor_set], (),
                 ).unwrap();
-
             }
         }
 
@@ -569,7 +548,7 @@ impl CanvasState {
             for (texture_handle, vertex_buffer) in self.textured_vertex_buffer.clone() {
                 let handle = texture_handle.clone().handle as usize;
                 let descriptor_set = self.texture_buffers.get(handle).clone().unwrap().clone()
-                    .get_descriptor_set(shader.clone(), self.sampler.clone());
+                    .get_descriptor_set(shader.get_pipeline(), self.sampler.clone());
 
                 command_buffer = command_buffer.draw(
                     shader.get_pipeline().clone(),