moved around the file heirarchy to make these handles safer

src/canvas/canvas_frame.rs

@@ -2,11 +2,11 @@ use crate::util::vertex_3d::{Vertex3D};
 use std::sync::Arc;
 use std::collections::HashMap;
 use crate::canvas::canvas_state::{Drawable};
-use crate::canvas::shader::text_shader::GlyphInstance;
 use std::hash::Hash;
 use crate::canvas::*;
-use crate::canvas::shader::dynamic_vertex::RuntimeVertexDef;
-use crate::canvas::canvas_state::CanvasFontHandle;
+use crate::canvas::managed::shader::dynamic_vertex::RuntimeVertexDef;
+use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle};
+use crate::canvas::managed::shader::text_shader::GlyphInstance;
 
 /// I dont know why this isnt working
 /// fqowiejf

src/canvas/canvas_state.rs

@@ -20,20 +20,19 @@ use vulkano::pipeline::viewport::Viewport;
 use vulkano::descriptor::descriptor::DescriptorDescTy::TexelBuffer;
 use crate::canvas::canvas_frame::CanvasFrame;
 use std::hash::Hash;
-use crate::canvas::canvas_buffer::{CanvasImage, CanvasTexture, CanvasFont};
 use crate::util::vertex_3d::{Vertex3D, TextVertex3D};
 use vulkano::pipeline::depth_stencil::{StencilFaceFlags, DynamicStencilValue};
-use crate::canvas::shader::common::{CompiledGraphicsPipeline};
-use crate::canvas::shader::generic_shader::GenericShader;
 use vulkano::memory::pool::PotentialDedicatedAllocation::Generic;
 use std::borrow::Borrow;
-use crate::canvas::shader::text_shader::GlyphInstance;
 use std::fs::File;
 use std::io::Read;
 use rusttype::{Font, PositionedGlyph, Scale, Rect, point, GlyphId};
 use vulkano::pipeline::vertex::VertexDefinition;
-use crate::canvas::{CanvasTextureHandle, CanvasImageHandle, CompiledGraphicsPipelineHandle, Handle};
-use crate::canvas::shader::dynamic_vertex::RuntimeVertexDef;
+use crate::canvas::managed::shader::dynamic_vertex::RuntimeVertexDef;
+use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle, CompiledGraphicsPipelineHandle, Handle};
+use crate::canvas::managed::gpu_buffers::{CanvasImage, CanvasTexture, CanvasFont};
+use crate::canvas::managed::shader::shader_common::CompiledGraphicsPipeline;
+use crate::canvas::managed::shader::generic_shader::GenericShader;
 
 
 // I don't think this is going to work without getting into Box'ing
@@ -72,19 +71,6 @@ pub trait Drawable {
     }
 }
 
-/// Typed wrapper for a u32 font handle (index id)
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-pub struct CanvasFontHandle {
-    handle: u32
-}
-
-impl Handle for CanvasFontHandle {
-    fn get_handle(&self) -> u32 {
-        self.handle
-    }
-}
-
-
 /// Canvas state is used for storage of texture and image buffers in addition to vertex buffers
 /// Canvas state also contains logic for writing the stored buffers to the command_buffer
 #[derive(Clone)]
@@ -251,7 +237,7 @@ impl CanvasState {
 
     /// Return the image buffer from an input image handle
     pub fn get_image(&self, image_handle: Arc<CanvasImageHandle>) -> Arc<AttachmentImage> {
-        self.image_buffers.get((*image_handle).clone().handle as usize).unwrap()
+        self.image_buffers.get((*image_handle).clone().get_handle() as usize).unwrap()
             .clone().buffer.clone()
     }
 
@@ -418,7 +404,7 @@ impl CanvasState {
     /// Using the texture handle, grab the stored texture and return the buffer
     pub fn get_texture(&self, texture_handle: Arc<CanvasTextureHandle>)
                        -> Arc<ImmutableImage<Format>> {
-        let handle = texture_handle.handle as usize;
+        let handle = texture_handle.get_handle() as usize;
 
         if let Some(i) = self.texture_buffers.get(handle) {
             return i.clone().buffer.clone();
@@ -550,7 +536,7 @@ impl CanvasState {
         // Solid colors
         let mut shader = self.shader_buffers.get(
             self.get_shader_handle(String::from("color-passthrough"))
-                .unwrap().clone().handle as usize
+                .unwrap().clone().get_handle() as usize
         ).unwrap();
 
         // This looks a little weird as colored_vertex_buffer is a vec of GPU allocated vecs.
@@ -568,12 +554,12 @@ impl CanvasState {
         // Images
         let mut shader = self.shader_buffers.get(
             self.get_shader_handle(String::from("simple_image"))
-                .unwrap().clone().handle as usize
+                .unwrap().clone().get_handle() as usize
         ).unwrap();
 
         if !self.image_vertex_buffer.is_empty() {
             for (image_handle, vertex_buffer) in self.image_vertex_buffer.clone() {
-                let handle = image_handle.clone().handle as usize;
+                let handle = image_handle.clone().get_handle() as usize;
                 let descriptor_set = self.image_buffers.get(handle).clone().unwrap().clone()
                     .get_descriptor_set(shader.get_pipeline().clone());
 
@@ -589,12 +575,12 @@ impl CanvasState {
         // Textures
         let mut shader = self.shader_buffers.get(
             self.get_shader_handle(String::from("simple_texture"))
-                .unwrap().clone().handle as usize
+                .unwrap().clone().get_handle() as usize
         ).unwrap();
 
         if !self.textured_vertex_buffer.is_empty() {
             for (texture_handle, vertex_buffer) in self.textured_vertex_buffer.clone() {
-                let handle = texture_handle.clone().handle as usize;
+                let handle = texture_handle.clone().get_handle() as usize;
                 let descriptor_set = self.texture_buffers.get(handle).clone().unwrap().clone()
                     .get_descriptor_set(shader.get_pipeline(), self.sampler.clone());
 
@@ -610,7 +596,7 @@ impl CanvasState {
         // Text
         let mut shader = self.shader_buffers.get(
             self.get_shader_handle(String::from("simple_text"))
-                .unwrap().clone().handle as usize
+                .unwrap().clone().get_handle() as usize
         ).unwrap();
 
 //

src/canvas/managed/canvas_text.rs

@@ -10,9 +10,7 @@ use vulkano::format::ClearValue;
 use vulkano::format::Format::R8Unorm;
 use std::fs::File;
 use std::io::Read;
-use crate::canvas::shader::text_shader::GlyphInstance;
 use crate::util::vertex_3d::{Vertex3D, TextVertex3D};
-use crate::canvas::canvas_buffer::CanvasFont;
 
 
 //pub struct Glyph {}

src/canvas/managed/gpu_buffers.rs

@@ -7,8 +7,7 @@ use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
 use vulkano::buffer::{CpuAccessibleBuffer, BufferAccess};
 use vulkano::pipeline::GraphicsPipelineAbstract;
 use rusttype::Font;
-use crate::canvas::{CanvasTextureHandle, CanvasImageHandle};
-use crate::canvas::canvas_state::CanvasFontHandle;
+use crate::canvas::managed::handles::{CanvasTextureHandle, CanvasImageHandle, CanvasFontHandle};
 
 
 /// Canvas buffer which represents an allocated Texture with a key and dimensions

src/canvas/managed/handles.rs

@@ -0,0 +1,66 @@
+
+pub trait Handle {
+    fn get_handle(&self) -> u32;
+}
+
+/// Typed wrapper for a u32 handle
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct CanvasFontHandle {
+    pub(in crate::canvas) handle: u32
+}
+
+impl Handle for CanvasFontHandle {
+    fn get_handle(&self) -> u32 {
+        self.handle
+    }
+}
+
+/// Typed wrapper for a u32 handle
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct CanvasTextureHandle {
+    pub(in crate::canvas) handle: u32
+}
+
+impl Handle for CanvasTextureHandle {
+    fn get_handle(&self) -> u32 {
+        self.handle
+    }
+}
+
+/// Typed wrapper for a u32 handle
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct CanvasImageHandle {
+    pub(in crate::canvas) handle: u32
+}
+
+impl Handle for CanvasImageHandle {
+    fn get_handle(&self) -> u32 {
+        self.handle
+    }
+}
+
+/// Typed wrapper for a u32 handle
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct CanvasShaderHandle {
+    pub(in crate::canvas) handle: u32
+}
+
+impl Handle for CanvasShaderHandle {
+    fn get_handle(&self) -> u32 {
+        self.handle
+    }
+}
+
+/// Typed wrapper for a u32 handle
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct CompiledGraphicsPipelineHandle {
+    pub(in crate::canvas) handle: u32
+}
+
+impl Handle for CompiledGraphicsPipelineHandle {
+    fn get_handle(&self) -> u32 {
+        self.handle
+    }
+}
+
+

src/canvas/managed/mod.rs

@@ -1,15 +1,8 @@
-use crate::canvas::shader::common::CompiledGraphicsPipeline;
-
-pub mod common;
-pub mod generic_shader;
-pub mod text_shader;
-pub mod dynamic_vertex;
-
-use crate::canvas::shader::common::*;
-use crate::canvas::shader::generic_shader::*;
-use crate::canvas::shader::text_shader::*;
-use crate::canvas::shader::dynamic_vertex::*;
 
+pub mod shader;
+pub mod handles;
+pub mod canvas_text;
+pub mod gpu_buffers;
 
 use vulkano::pipeline::shader::{SpecializationConstants, SpecializationMapEntry};
 

src/canvas/managed/shader/generic_shader.rs

@@ -1,13 +1,11 @@
 
 use vulkano::pipeline::GraphicsPipelineAbstract;
 use std::sync::Arc;
-use crate::canvas::shader::common::{ShaderType, CompiledGraphicsPipeline};
 use std::collections::{HashSet, HashMap};
 use vulkano::device::Device;
 use vulkano::framebuffer::{RenderPassAbstract, Subpass};
 use vulkano::pipeline::GraphicsPipeline;
 use vulkano::pipeline::shader::{GraphicsEntryPoint, ShaderModule, GraphicsShaderType, GeometryShaderExecutionMode, ShaderInterfaceDef};
-use crate::canvas::shader::ShaderSpecializationConstants;
 use shade_runner::{Input, Output, Layout, Entry};
 use std::ffi::CStr;
 use std::marker::PhantomData;
@@ -15,11 +13,12 @@ use vulkano::pipeline::depth_stencil::{DepthStencil, Compare, DepthBounds, Stenc
 use vulkano::pipeline::vertex::{SingleBufferDefinition, VertexDefinition};
 use crate::util::vertex_3d::Vertex3D;
 use shade_runner as sr;
-use crate::canvas::shader::common::CompiledGraphicsPipelineResources;
 use vulkano::memory::pool::PotentialDedicatedAllocation::Generic;
 use vulkano::SafeDeref;
-use crate::canvas::shader::dynamic_vertex::RuntimeVertexDef;
-use crate::canvas::CompiledGraphicsPipelineHandle;
+use crate::canvas::managed::shader::shader_common::{ShaderType, CompiledGraphicsPipelineResources, CompiledGraphicsPipeline};
+use crate::canvas::managed::handles::CompiledGraphicsPipelineHandle;
+use crate::canvas::managed::shader::dynamic_vertex::RuntimeVertexDef;
+use crate::canvas::managed::ShaderSpecializationConstants;
 
 /// CanvasShader holds the pipeline and render pass for the input shader source
 #[derive(Clone)]

src/canvas/managed/shader/mod.rs

@@ -0,0 +1,4 @@
+pub mod text_shader;
+pub mod generic_shader;
+pub mod dynamic_vertex;
+pub mod shader_common;

src/canvas/managed/shader/shader_common.rs

@@ -8,7 +8,7 @@ use vulkano::pipeline::shader::{ShaderModule, GraphicsShaderType, GeometryShader
 use vulkano::device::Device;
 use shade_runner::Entry;
 use shaderc::ShaderKind;
-use crate::canvas::CompiledGraphicsPipelineHandle;
+use crate::canvas::managed::handles::CompiledGraphicsPipelineHandle;
 
 /*
 
@@ -28,7 +28,7 @@ This best works I think if I allow users to
 
 
 /// Inheriting this gives private functions to grab resources
-pub(super) trait CompiledGraphicsPipelineResources {
+pub trait CompiledGraphicsPipelineResources {
 
     fn get_path(filename: String, shader_type: ShaderType) -> PathBuf {
         let project_root =

src/canvas/managed/shader/text_shader.rs

@@ -1,22 +1,22 @@
 use vulkano::pipeline::GraphicsPipelineAbstract;
 use std::sync::Arc;
-use crate::canvas::shader::common::{ShaderType, CompiledGraphicsPipeline, CompiledGraphicsPipelineResources};
 use std::collections::{HashSet, HashMap};
 use vulkano::device::Device;
 use vulkano::framebuffer::{RenderPassAbstract, Subpass};
 use vulkano::pipeline::GraphicsPipeline;
 use vulkano::pipeline::shader::{GraphicsEntryPoint, ShaderModule, GraphicsShaderType, GeometryShaderExecutionMode};
-use crate::canvas::shader::ShaderSpecializationConstants;
 use shade_runner::{Input, Output, Layout, Entry};
 use std::ffi::CStr;
 use std::marker::PhantomData;
 use vulkano::pipeline::depth_stencil::{DepthStencil, Compare, DepthBounds, Stencil, StencilOp};
 use vulkano::pipeline::vertex::{SingleBufferDefinition, OneVertexOneInstanceDefinition};
 use crate::util::vertex_3d::Vertex3D;
-use crate::canvas::shader::generic_shader::GenericShader;
 use shade_runner as sr;
-use crate::canvas::shader::dynamic_vertex::RuntimeVertexDef;
-use crate::canvas::CompiledGraphicsPipelineHandle;
+use crate::canvas::managed::shader::shader_common::{ShaderType, CompiledGraphicsPipelineResources, CompiledGraphicsPipeline};
+use crate::canvas::managed::handles::CompiledGraphicsPipelineHandle;
+use crate::canvas::managed::shader::generic_shader::GenericShader;
+use crate::canvas::managed::shader::dynamic_vertex::RuntimeVertexDef;
+use crate::canvas::managed::ShaderSpecializationConstants;
 
 #[derive(Default, Debug, Clone, Copy)]
 pub struct GlyphInstance {

src/canvas/mod.rs

@@ -1,39 +1,6 @@
 
 pub mod canvas_state;
 pub mod canvas_frame;
-pub mod shader;
-pub mod canvas_text;
-pub mod canvas_buffer;
+pub mod managed;
 
 
-
-pub trait Handle {
-    fn get_handle(&self) -> u32;
-}
-
-
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-pub struct CanvasTextureHandle {
-    pub handle: u32
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-pub struct CanvasImageHandle {
-    pub handle: u32
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-pub struct CanvasShaderHandle {
-    pub handle: u32
-}
-
-/// Typed wrapper for a u32 handle
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-pub struct CompiledGraphicsPipelineHandle {
-    pub handle: u32
-}
-
-#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
-pub struct CompuBufferHandle {
-    pub handle: u32,
-}