in the midst of a very messy refactor of the way i build the command buffer

src/util/compute_image.rs

@@ -0,0 +1,197 @@
+use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer, DeviceLocalBuffer, ImmutableBuffer, BufferAccess};
+use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState};
+use vulkano::descriptor::descriptor_set::{PersistentDescriptorSet, StdDescriptorPoolAlloc};
+use vulkano::device::{Device, DeviceExtensions, QueuesIter, Queue};
+use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice, QueueFamily};
+use vulkano::pipeline::{ComputePipeline, GraphicsPipeline, GraphicsPipelineAbstract, GraphicsPipelineBuilder};
+use vulkano::sync::{GpuFuture, FlushError};
+use vulkano::sync;
+use std::time::SystemTime;
+use std::sync::Arc;
+use std::ffi::CStr;
+use std::path::PathBuf;
+use shade_runner as sr;
+use image::{DynamicImage, ImageBuffer};
+use image::GenericImageView;
+use vulkano::descriptor::pipeline_layout::PipelineLayout;
+use image::GenericImage;
+use shade_runner::{ComputeLayout, CompileError, FragLayout, FragInput, FragOutput, VertInput, VertOutput, VertLayout, CompiledShaders, Entry};
+use vulkano::descriptor::descriptor_set::{PersistentDescriptorSetBuf, PersistentDescriptorSetImg, PersistentDescriptorSetSampler};
+use shaderc::CompileOptions;
+use vulkano::framebuffer::{Subpass, RenderPass, RenderPassAbstract, Framebuffer, FramebufferAbstract};
+use vulkano::pipeline::shader::{GraphicsShaderType, ShaderModule, GraphicsEntryPoint, SpecializationConstants, SpecializationMapEntry};
+use vulkano::swapchain::{Swapchain, PresentMode, SurfaceTransform, Surface, SwapchainCreationError, AcquireError};
+use vulkano::swapchain::acquire_next_image;
+use vulkano::image::swapchain::SwapchainImage;
+use winit::{EventsLoop, WindowBuilder, Window, Event, WindowEvent};
+use vulkano_win::VkSurfaceBuild;
+use vulkano::pipeline::vertex::{SingleBufferDefinition, Vertex};
+use vulkano::descriptor::PipelineLayoutAbstract;
+use std::alloc::Layout;
+use vulkano::pipeline::viewport::Viewport;
+use image::ImageFormat;
+use vulkano::image::immutable::ImmutableImage;
+use vulkano::image::attachment::AttachmentImage;
+use vulkano::image::{Dimensions, ImageUsage};
+use vulkano::format::Format;
+use vulkano::sampler::{Sampler, Filter, MipmapMode, SamplerAddressMode};
+use image::flat::NormalForm::ColumnMajorPacked;
+use image::Rgba;
+use crate::vertex_2d::ColoredVertex2D;
+
+/*
+
+Compute Image holds read write swap and settings buffers for the kernel
+
+This is a pretty specific use case. One in for settings. One in for data, two for the transfer.
+
+multiple data inputs might be nice?
+
+
+*/
+
+#[derive(Clone)]
+pub struct ComputeImage {
+
+    device: Arc<Device>,
+
+    compute_graphics_swap_buffer: std::sync::Arc<vulkano::image::attachment::AttachmentImage>,
+
+    pub rw_buffers: Vec<Arc<CpuAccessibleBuffer<[u8]>>>,
+    pub settings_buffer: Arc<CpuAccessibleBuffer<[u32]>>,
+}
+
+
+impl ComputeImage {
+
+    fn load_raw(filename: String) -> (Vec<u8>, (u32,u32)) {
+
+        let project_root =
+            std::env::current_dir()
+                .expect("failed to get root directory");
+
+        let mut compute_path = project_root.clone();
+        compute_path.push(PathBuf::from("resources/images/"));
+        compute_path.push(PathBuf::from(filename.clone()));
+
+        let img = image::open(compute_path).expect("Couldn't find image");
+
+        let xy = img.dimensions();
+
+        let data_length = xy.0 * xy.1 * 4;
+        let pixel_count = img.raw_pixels().len();
+
+        let mut image_buffer = Vec::new();
+
+        if pixel_count != data_length as usize {
+            println!("Creating apha channel...");
+            for i in img.raw_pixels().iter() {
+                if (image_buffer.len() + 1) % 4 == 0 {
+                    image_buffer.push(255);
+                }
+                image_buffer.push(*i);
+            }
+            image_buffer.push(255);
+        } else {
+            image_buffer = img.raw_pixels();
+        }
+
+        (image_buffer, xy)
+    }
+
+    pub fn new(device: Arc<Device>, image_filename: String) -> ComputeImage {
+
+        let (image_buffer, xy) = ComputeImage::load_raw(image_filename);
+
+        let compute_graphics_swap_buffer = {
+
+            let mut usage = ImageUsage::none();
+            usage.transfer_destination = true;
+            usage.storage = true;
+
+            AttachmentImage::with_usage(
+                device.clone(),
+                [xy.0, xy.1],
+                Format::R8G8B8A8Uint,
+                usage)
+        };
+
+        let data_length = xy.0 * xy.1 * 4;
+
+        // Pull out the image data and place it in a buffer for the kernel to write to and for us to read from
+        let write_buffer = {
+            let mut buff = image_buffer.iter();
+            let data_iter = (0..data_length).map(|n| *(buff.next().unwrap()));
+            CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), data_iter).unwrap()
+        };
+
+
+        // Pull out the image data and place it in a buffer for the kernel to read from
+        let read_buffer = {
+            let mut buff = image_buffer.iter();
+            let data_iter = (0..data_length).map(|n| *(buff.next().unwrap()));
+            CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), data_iter).unwrap()
+        };
+
+
+        // A buffer to hold many i32 values to use as settings
+        let settings_buffer = {
+            let vec = vec![xy.0, xy.1];
+            let mut buff = vec.iter();
+            let data_iter =
+                (0..2).map(|n| *(buff.next().unwrap()));
+            CpuAccessibleBuffer::from_iter(device.clone(),
+                                           BufferUsage::all(),
+                                           data_iter).unwrap()
+        };
+
+        ComputeImage{
+            device: device.clone(),
+            compute_graphics_swap_buffer: compute_graphics_swap_buffer.unwrap(),
+
+            rw_buffers: vec![write_buffer, read_buffer],
+            settings_buffer: settings_buffer
+        }
+    }
+
+    pub fn get_swap_buffer(&mut self) -> Arc<AttachmentImage> {
+        self.compute_graphics_swap_buffer.clone()
+    }
+
+    pub fn get_size(&self) -> (u32, u32) {
+        let xy = self.compute_graphics_swap_buffer.dimensions();
+        (xy[0], xy[1])
+    }
+
+    pub fn read_read_buffer(&self) -> ImageBuffer<Rgba<u8>, Vec<u8>>{
+
+        let xy = self.get_size();
+
+        let data_buffer_content = self.rw_buffers.get(0).unwrap().read().unwrap();
+        ImageBuffer::from_fn(xy.0, xy.1, |x, y| {
+            let r = data_buffer_content[((xy.0 * y + x) * 4 + 0) as usize] as u8;
+            let g = data_buffer_content[((xy.0 * y + x) * 4 + 1) as usize] as u8;
+            let b = data_buffer_content[((xy.0 * y + x) * 4 + 2) as usize] as u8;
+            let a = data_buffer_content[((xy.0 * y + x) * 4 + 3) as usize] as u8;
+
+            image::Rgba([r, g, b, a])
+        })
+    }
+
+    pub fn save_image(&self) {
+        self.read_read_buffer().save(format!("output/{}.jpg", SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs()));
+    }
+
+    pub fn get_descriptor_set(&self, compute_pipeline: std::sync::Arc<ComputePipeline<PipelineLayout<shade_runner::layouts::ComputeLayout>>>)
+        -> Arc<PersistentDescriptorSet<std::sync::Arc<ComputePipeline<PipelineLayout<shade_runner::layouts::ComputeLayout>>>, ((((),
+                PersistentDescriptorSetBuf<std::sync::Arc<vulkano::buffer::cpu_access::CpuAccessibleBuffer<[u8]>>>),
+                PersistentDescriptorSetBuf<std::sync::Arc<vulkano::buffer::cpu_access::CpuAccessibleBuffer<[u8]>>>),
+                PersistentDescriptorSetBuf<std::sync::Arc<vulkano::buffer::cpu_access::CpuAccessibleBuffer<[u32]>>>)>> {
+
+        Arc::new(PersistentDescriptorSet::start(compute_pipeline.clone(), 0)
+            .add_buffer(self.rw_buffers.get(0).unwrap().clone()).unwrap()
+            .add_buffer(self.rw_buffers.get(1).unwrap().clone()).unwrap()
+            .add_buffer(self.settings_buffer.clone()).unwrap()
+            .build().unwrap())
+    }
+}

src/util/compute_kernel.rs

@@ -0,0 +1,175 @@
+use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer, DeviceLocalBuffer, ImmutableBuffer, BufferAccess};
+use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState};
+use vulkano::descriptor::descriptor_set::{PersistentDescriptorSet, StdDescriptorPoolAlloc};
+use vulkano::device::{Device, DeviceExtensions, QueuesIter, Queue};
+use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice, QueueFamily};
+use vulkano::pipeline::{ComputePipeline, GraphicsPipeline, GraphicsPipelineAbstract};
+use vulkano::sync::{GpuFuture, FlushError};
+use vulkano::sync;
+use std::time::SystemTime;
+use std::sync::Arc;
+use std::ffi::CStr;
+use std::path::PathBuf;
+use shade_runner as sr;
+use image::{DynamicImage, ImageBuffer};
+use image::GenericImageView;
+use vulkano::descriptor::pipeline_layout::PipelineLayout;
+use image::GenericImage;
+use shade_runner::{ComputeLayout, CompileError, FragLayout, FragInput, FragOutput, VertInput, VertOutput, VertLayout, CompiledShaders, Entry};
+use vulkano::descriptor::descriptor_set::{PersistentDescriptorSetBuf, PersistentDescriptorSetImg, PersistentDescriptorSetSampler};
+use shaderc::CompileOptions;
+use vulkano::framebuffer::{Subpass, RenderPass, RenderPassAbstract, Framebuffer, FramebufferAbstract};
+use vulkano::pipeline::shader::{GraphicsShaderType, ShaderModule, GraphicsEntryPoint, SpecializationConstants, SpecializationMapEntry};
+use vulkano::swapchain::{Swapchain, PresentMode, SurfaceTransform, Surface, SwapchainCreationError, AcquireError};
+use vulkano::swapchain::acquire_next_image;
+use vulkano::image::swapchain::SwapchainImage;
+use winit::{EventsLoop, WindowBuilder, Window, Event, WindowEvent};
+use vulkano_win::VkSurfaceBuild;
+use vulkano::pipeline::vertex::{SingleBufferDefinition, Vertex};
+use vulkano::descriptor::PipelineLayoutAbstract;
+use std::alloc::Layout;
+use vulkano::pipeline::viewport::Viewport;
+use image::ImageFormat;
+use vulkano::image::immutable::ImmutableImage;
+use vulkano::image::attachment::AttachmentImage;
+use vulkano::image::{Dimensions, ImageUsage};
+use vulkano::format::Format;
+use vulkano::sampler::{Sampler, Filter, MipmapMode, SamplerAddressMode};
+use image::flat::NormalForm::ColumnMajorPacked;
+
+
+#[derive(Clone)]
+pub struct ComputeKernel {
+
+    compute_pipeline: Option<std::sync::Arc<ComputePipeline<PipelineLayout<shade_runner::layouts::ComputeLayout>>>>,
+    compute_kernel_path: PathBuf,
+
+    shader: CompiledShaders,
+    entry: Entry,
+    shader_module: Arc<ShaderModule>,
+    device: Arc<Device>,
+    specialization_constants: ComputeSpecializationConstants,
+}
+
+impl ComputeKernel {
+
+    fn get_path(filename: String) -> PathBuf {
+
+        let project_root =
+            std::env::current_dir()
+                .expect("failed to get root directory");
+
+        let mut compute_path = project_root.clone();
+        compute_path.push(PathBuf::from("resources/shaders/"));
+        compute_path.push(PathBuf::from(filename));
+
+        compute_path
+    }
+
+    pub fn new(filename: String, device: Arc<Device>) -> ComputeKernel {
+
+        let compute_path = ComputeKernel::get_path(filename);
+
+        let mut options  = CompileOptions::new().ok_or(CompileError::CreateCompiler).unwrap();
+
+        let shader = sr::load_compute_with_options(compute_path.clone(), options)
+            .expect("Failed to compile");
+
+        let entry = sr::parse_compute(&shader)
+            .expect("Failed to parse");
+
+        let shader_module = unsafe {
+            vulkano::pipeline::shader::ShaderModule::from_words(device.clone(), &shader.compute)
+        }.unwrap();
+
+
+        ComputeKernel {
+            device: device,
+            shader: shader,
+            compute_pipeline: Option::None,
+            compute_kernel_path: compute_path,
+            entry: entry,
+            shader_module: shader_module,
+            specialization_constants: ComputeSpecializationConstants {
+                first_constant: 0,
+                second_constant: 0,
+                third_constant: 0.0
+            }
+        }
+    }
+
+    pub fn get_pipeline(&mut self) -> std::sync::Arc<ComputePipeline<PipelineLayout<shade_runner::layouts::ComputeLayout>>> {
+
+        match self.compute_pipeline.clone() {
+            Some(t) => t,
+            None => {
+                self.compute_pipeline = Some(Arc::new({
+                    unsafe {
+                        ComputePipeline::new(self.device.clone(), &self.shader_module.compute_entry_point(
+                            CStr::from_bytes_with_nul_unchecked(b"main\0"),
+                            self.entry.compute_layout.clone()), &self.specialization_constants,
+                        ).unwrap()
+                    }
+                }));
+                self.compute_pipeline.clone().unwrap()
+            }
+        }
+    }
+
+    pub fn recompile_kernel(&mut self) -> std::sync::Arc<ComputePipeline<PipelineLayout<shade_runner::layouts::ComputeLayout>>>  {
+        self.compile_kernel(String::from(self.compute_kernel_path.clone().to_str().unwrap()))
+    }
+
+    pub fn compile_kernel(&mut self, filename: String) -> std::sync::Arc<ComputePipeline<PipelineLayout<shade_runner::layouts::ComputeLayout>>> {
+
+        let mut options = CompileOptions::new().ok_or(CompileError::CreateCompiler).unwrap();
+        self.compute_kernel_path = ComputeKernel::get_path(filename);
+
+        self.shader =
+            sr::load_compute_with_options(self.compute_kernel_path.clone(), options)
+                .expect("Failed to compile");
+
+        self.entry =
+            sr::parse_compute(&self.shader)
+                .expect("Failed to parse");
+
+        self.shader_module = unsafe {
+            vulkano::pipeline::shader::ShaderModule::from_words(self.device.clone(), &self.shader.compute)
+        }.unwrap();
+
+        self.get_pipeline()
+    }
+}
+
+
+#[repr(C)]
+#[derive(Default, Debug, Clone)]
+struct ComputeSpecializationConstants {
+    first_constant: i32,
+    second_constant: u32,
+    third_constant: f32,
+}
+
+unsafe impl SpecializationConstants for ComputeSpecializationConstants {
+    fn descriptors() -> &'static [SpecializationMapEntry] {
+        static DESCRIPTORS: [SpecializationMapEntry; 3] = [
+            SpecializationMapEntry {
+                constant_id: 0,
+                offset: 0,
+                size: 4,
+            },
+            SpecializationMapEntry {
+                constant_id: 1,
+                offset: 4,
+                size: 4,
+            },
+            SpecializationMapEntry {
+                constant_id: 2,
+                offset: 8,
+                size: 4,
+            },
+        ];
+
+        &DESCRIPTORS
+    }
+}

src/util/mod.rs

@@ -0,0 +1,3 @@
+pub mod compute_image;
+pub mod compute_kernel;
+pub mod shader_kernels;

src/util/shader_kernels.rs

@@ -0,0 +1,229 @@
+use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer, DeviceLocalBuffer, ImmutableBuffer, BufferAccess};
+use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState};
+use vulkano::descriptor::descriptor_set::{PersistentDescriptorSet, StdDescriptorPoolAlloc, DescriptorSetDesc};
+use vulkano::device::{Device, DeviceExtensions, QueuesIter, Queue};
+use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice, QueueFamily};
+use vulkano::pipeline::{ComputePipeline, GraphicsPipeline, GraphicsPipelineAbstract, GraphicsPipelineBuilder};
+use vulkano::sync::{GpuFuture, FlushError};
+use vulkano::sync;
+use std::time::SystemTime;
+use std::sync::Arc;
+use std::ffi::CStr;
+use std::path::PathBuf;
+use shade_runner as sr;
+use image::{DynamicImage, ImageBuffer};
+use image::GenericImageView;
+use vulkano::descriptor::pipeline_layout::PipelineLayout;
+use image::GenericImage;
+use shade_runner::{ComputeLayout, CompileError, FragLayout, FragInput, FragOutput, VertInput, VertOutput, VertLayout, CompiledShaders, Entry};
+use vulkano::descriptor::descriptor_set::{PersistentDescriptorSetBuf, PersistentDescriptorSetImg, PersistentDescriptorSetSampler};
+use shaderc::CompileOptions;
+use vulkano::framebuffer::{Subpass, RenderPass, RenderPassAbstract, Framebuffer, FramebufferAbstract, RenderPassDesc};
+use vulkano::pipeline::shader::{GraphicsShaderType, ShaderModule, GraphicsEntryPoint, SpecializationConstants, SpecializationMapEntry};
+use vulkano::swapchain::{Swapchain, PresentMode, SurfaceTransform, Surface, SwapchainCreationError, AcquireError};
+use vulkano::swapchain::acquire_next_image;
+use vulkano::image::swapchain::SwapchainImage;
+use winit::{EventsLoop, WindowBuilder, Window, Event, WindowEvent};
+use vulkano_win::VkSurfaceBuild;
+use vulkano::pipeline::vertex::{SingleBufferDefinition, Vertex};
+use vulkano::descriptor::{PipelineLayoutAbstract, DescriptorSet};
+use std::alloc::Layout;
+use vulkano::pipeline::viewport::Viewport;
+use image::ImageFormat;
+use vulkano::image::immutable::ImmutableImage;
+use vulkano::image::attachment::AttachmentImage;
+use vulkano::image::{Dimensions, ImageUsage};
+use vulkano::format::Format;
+use vulkano::sampler::{Sampler, Filter, MipmapMode, SamplerAddressMode};
+use image::flat::NormalForm::ColumnMajorPacked;
+use crate::vertex_2d::ColoredVertex2D;
+
+/*
+
+Shaderkernel holds the pipeline and render pass for the inputted shader source
+
+*/
+
+#[derive(Clone)]
+pub struct ShaderKernels {
+
+    pub render_pass: Arc<RenderPassAbstract + Send + Sync>,
+    graphics_pipeline: Option<Arc<GraphicsPipelineAbstract + Sync + Send>>,
+
+    device: Arc<Device>,
+}
+
+impl ShaderKernels {
+
+    fn get_path(filename: String) -> (PathBuf, PathBuf) {
+
+        let project_root =
+            std::env::current_dir()
+                .expect("failed to get root directory");
+
+        let mut shader_path = project_root.clone();
+        shader_path.push(PathBuf::from("resources/shaders/"));
+
+        let mut vertex_shader_path = project_root.clone();
+        vertex_shader_path.push(PathBuf::from("resources/shaders/"));
+        vertex_shader_path.push(PathBuf::from(filename.clone() + ".vertex"));
+
+        let mut fragment_shader_path = project_root.clone();
+        fragment_shader_path.push(PathBuf::from("resources/shaders/"));
+        fragment_shader_path.push(PathBuf::from(filename.clone() + ".fragment"));
+
+        (vertex_shader_path, fragment_shader_path)
+    }
+
+    pub fn get_pipeline(&mut self) -> Arc<GraphicsPipelineAbstract + Sync + Send> {
+        self.graphics_pipeline.clone().unwrap()
+    }
+
+    pub fn new(filename: String,
+               surface: &Arc<Surface<Window>>,
+               queue: Arc<Queue>,
+               physical: PhysicalDevice,
+               device: Arc<Device>) -> ShaderKernels {
+
+        let capabilities = surface.capabilities(physical).unwrap();
+        let format = capabilities.supported_formats[0].0;
+
+        let filenames = ShaderKernels::get_path(filename.clone());
+
+        // TODO: better compile message, run til successful compile
+        let shader = sr::load(filenames.0, filenames.1)
+            .expect("Shader didn't compile");
+
+        let vulkano_entry =
+            sr::parse(&shader)
+                .expect("failed to parse");
+
+        let fragment_shader_module: Arc<ShaderModule> = unsafe {
+            let filenames1 = ShaderKernels::get_path(filename.clone());
+            let shader1 = sr::load(filenames1.0, filenames1.1)
+                .expect("Shader didn't compile");
+            vulkano::pipeline::shader::ShaderModule::from_words(device.clone(), &shader1.fragment.clone())
+        }.unwrap();
+
+        let vertex_shader_module: Arc<ShaderModule> = unsafe {
+            let filenames1 = ShaderKernels::get_path(filename.clone());
+            let shader1 = sr::load(filenames1.0, filenames1.1)
+                .expect("Shader didn't compile");
+            vulkano::pipeline::shader::ShaderModule::from_words(device.clone(), &shader1.vertex.clone())
+        }.unwrap();
+
+        let filenames = ShaderKernels::get_path(filename.clone());
+
+
+        let frag_entry_point = unsafe {
+            Some(fragment_shader_module.graphics_entry_point(CStr::from_bytes_with_nul_unchecked(b"main\0"),
+                                    vulkano_entry.frag_input,
+                                    vulkano_entry.frag_output,
+                                    vulkano_entry.frag_layout,
+                                    GraphicsShaderType::Fragment))
+        };
+
+        let vertex_entry_point = unsafe {
+            Some(vertex_shader_module.graphics_entry_point(CStr::from_bytes_with_nul_unchecked(b"main\0"),
+                                    vulkano_entry.vert_input,
+                                    vulkano_entry.vert_output,
+                                    vulkano_entry.vert_layout,
+                                    GraphicsShaderType::Vertex))
+        };
+
+        let render_pass = Arc::new(vulkano::single_pass_renderpass!(
+            device.clone(),
+            attachments: {
+                // `color` is a custom name we give to the first and only attachment.
+                color: {
+                    // `load: Clear` means that we ask the GPU to clear the content of this
+                    // attachment at the start of the drawing.
+                    load: Clear,
+                    // `store: Store` means that we ask the GPU to store the output of the draw
+                    // in the actual image. We could also ask it to discard the result.
+                    store: Store,
+                    // `format: <ty>` indicates the type of the format of the image. This has to
+                    // be one of the types of the `vulkano::format` module (or alternatively one
+                    // of your structs that implements the `FormatDesc` trait). Here we use the
+                    // same format as the swapchain.
+                    format: format,
+                    // TODO:
+                    samples: 1,
+                }
+            },
+            pass: {
+                // We use the attachment named `color` as the one and only color attachment.
+                color: [color],
+                // No depth-stencil attachment is indicated with empty brackets.
+                depth_stencil: {}
+            }
+        ).unwrap());
+
+
+        ShaderKernels {
+
+            graphics_pipeline: Some(Arc::new(GraphicsPipeline::start()
+
+                .vertex_input_single_buffer::<ColoredVertex2D>()
+
+                .vertex_shader(vertex_entry_point.clone().unwrap(), ShaderSpecializationConstants {
+                    first_constant: 0,
+                    second_constant: 0,
+                    third_constant: 0.0,
+                })
+
+                .triangle_fan()
+                // Use a resizable viewport set to draw over the entire window
+                .viewports_dynamic_scissors_irrelevant(1)
+
+                .fragment_shader(frag_entry_point.clone().unwrap(), ShaderSpecializationConstants {
+                    first_constant: 0,
+                    second_constant: 0,
+                    third_constant: 0.0,
+                })
+                // We have to indicate which subpass of which render pass this pipeline is going to be used
+                // in. The pipeline will only be usable from this particular subpass.
+                .render_pass(Subpass::from(render_pass.clone(), 0).unwrap())
+
+                .build(device.clone())
+                .unwrap())),
+
+            device: device,
+            render_pass: render_pass,
+        }
+    }
+
+}
+
+#[repr(C)]
+#[derive(Default, Debug, Clone)]
+// TODO: This needs to be duplicated and moved into their respective containers shaderkenrels copute
+struct ShaderSpecializationConstants {
+    first_constant: i32,
+    second_constant: u32,
+    third_constant: f32,
+}
+
+unsafe impl SpecializationConstants for ShaderSpecializationConstants {
+    fn descriptors() -> &'static [SpecializationMapEntry] {
+        static DESCRIPTORS: [SpecializationMapEntry; 3] = [
+            SpecializationMapEntry {
+                constant_id: 0,
+                offset: 0,
+                size: 4,
+            },
+            SpecializationMapEntry {
+                constant_id: 1,
+                offset: 4,
+                size: 4,
+            },
+            SpecializationMapEntry {
+                constant_id: 2,
+                offset: 8,
+                size: 4,
+            },
+        ];
+
+        &DESCRIPTORS
+    }
+}