moved to rust style file tree

src/compute/compu_buffer.rs

@@ -0,0 +1,106 @@
+use std::sync::Arc;
+use vulkano::device::Device;
+use vulkano::buffer::{CpuAccessibleBuffer, BufferUsage};
+use vulkano::pipeline::ComputePipeline;
+use vulkano::descriptor::pipeline_layout::PipelineLayout;
+use vulkano::descriptor::descriptor_set::{PersistentDescriptorSet, PersistentDescriptorSetBuf};
+use image::ImageBuffer;
+use image::Rgba;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct CompuBufferHandle {
+    pub handle: u32,
+}
+
+
+#[derive(Clone)]
+pub struct CompuBuffers {
+    dimensions: (u32, u32),
+    device: Arc<Device>,
+    handle: Arc<CompuBufferHandle>,
+
+    io_buffers: Vec<Arc<CpuAccessibleBuffer<[u8]>>>,
+    settings_buffer: Arc<CpuAccessibleBuffer<[u32]>>,
+}
+
+impl CompuBuffers {
+    pub fn new(device: Arc<Device>, data: Vec<u8>,
+               dimensions: (u32, u32), stride: u32,
+               handle: Arc<CompuBufferHandle>) -> CompuBuffers {
+
+        let data_length = dimensions.0 * dimensions.1 * stride;
+
+        let input_buffer = {
+            let mut buff = data.iter();
+            let data_iter = (0..data_length).map(|n| *(buff.next().unwrap()));
+            CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), data_iter).unwrap()
+        };
+
+        let output_buffer = {
+            let mut buff = data.iter();
+            let data_iter = (0..data_length).map(|n| *(buff.next().unwrap()));
+            CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), data_iter).unwrap()
+        };
+
+        // Settings buffer which holds i32's
+        // Compile macros into the kernel eventually to index them
+        let settings_buffer = {
+            let vec = vec![dimensions.0, dimensions.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()
+        };
+
+        CompuBuffers {
+            dimensions: dimensions,
+            device: device.clone(),
+
+            handle: handle,
+            io_buffers: vec![input_buffer, output_buffer],
+            settings_buffer: settings_buffer,
+        }
+    }
+
+    pub fn get_size(&self) -> (u32, u32) {
+        self.dimensions
+    }
+
+    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.io_buffers.get(0).unwrap().clone()).unwrap()
+            .add_buffer(self.io_buffers.get(1).unwrap().clone()).unwrap()
+            .add_buffer(self.settings_buffer.clone()).unwrap()
+            .build().unwrap())
+    }
+
+    pub fn read_output_buffer(&self) -> ImageBuffer<Rgba<u8>, Vec<u8>> {
+        let xy = self.get_size();
+
+        self.io_buffers.get(1).unwrap().write().unwrap().map(|x| x);
+        let data_buffer_content = self.io_buffers.get(1).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 get_input_buffer(&self) -> Arc<CpuAccessibleBuffer<[u8]>> {
+        self.io_buffers.get(0).unwrap().clone()
+    }
+
+    pub fn get_output_buffer(&self) -> Arc<CpuAccessibleBuffer<[u8]>> {
+        self.io_buffers.get(1).unwrap().clone()
+    }
+}

src/compute/compu_frame.rs

@@ -0,0 +1,57 @@
+use crate::canvas::canvas_state::{CanvasImageHandle, Drawable};
+use std::sync::Arc;
+use crate::compute::compu_sprite::CompuSprite;
+use crate::compute::compu_kernel::{CompuKernel, CompuKernelHandle};
+use crate::compute::compu_buffer::{CompuBuffers, CompuBufferHandle};
+
+pub struct CompuFrame {
+    // Vec<(Buffer, Kernel)>
+    pub pure_compute: Vec<(
+        Arc<CompuBufferHandle>,
+        Arc<CompuKernelHandle>)>,
+
+    // Vec<(Buffer, Image, Kernel)>
+    pub swapped_to_image: Vec<(
+        Arc<CompuBufferHandle>,
+        Arc<CanvasImageHandle>,
+        Arc<CompuKernelHandle>)>,
+
+    // Vec<(Input Buffer, Output Buffer, Kernel)>
+    pub swapped_to_buffer: Vec<(
+        Arc<CompuBufferHandle>,
+        Arc<CompuBufferHandle>,
+        Arc<CompuKernelHandle>)>,
+}
+
+impl CompuFrame {
+    pub fn new() -> CompuFrame {
+        CompuFrame {
+            pure_compute: vec![],
+            swapped_to_image: vec![],
+            swapped_to_buffer: vec![],
+        }
+    }
+
+    pub fn add(&mut self, buffer: Arc<CompuBufferHandle>, kernel: Arc<CompuKernelHandle>) {
+        self.pure_compute.push((buffer, kernel));
+    }
+
+    /*
+       INPUT_BUFFER -> input -> kernel -> output
+                           v------------------^
+       OUTPUT_BUFFER -> input X kernel X output
+    */
+    pub fn add_chained(&mut self,
+                       input_buffer: Arc<CompuBufferHandle>,
+                       output_buffer: Arc<CompuBufferHandle>,
+                       kernel: Arc<CompuKernelHandle>) {
+        self.swapped_to_buffer.push((input_buffer, output_buffer, kernel));
+    }
+
+    pub fn add_with_image_swap(&mut self,
+                               buffer: Arc<CompuBufferHandle>,
+                               kernel: Arc<CompuKernelHandle>,
+                               sprite: &CompuSprite) {
+        self.swapped_to_image.push((buffer, sprite.get_image_handle().unwrap().clone(), kernel))
+    }
+}

src/compute/compu_kernel.rs

@@ -0,0 +1,165 @@
+use vulkano::device::{Device};
+use vulkano::pipeline::{ComputePipeline};
+use std::sync::Arc;
+use std::ffi::CStr;
+use std::path::PathBuf;
+use shade_runner as sr;
+use vulkano::descriptor::pipeline_layout::PipelineLayout;
+use shade_runner::{CompileError, FragLayout, FragInput, FragOutput, VertInput, VertOutput, VertLayout, CompiledShaders, Entry};
+use shaderc::CompileOptions;
+use vulkano::pipeline::shader::{ShaderModule, GraphicsEntryPoint, SpecializationConstants, SpecializationMapEntry};
+use crate::compute::compu_buffer::{CompuBuffers, CompuBufferHandle};
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct CompuKernelHandle {
+    pub handle: u32,
+}
+
+#[derive(Clone)]
+pub struct CompuKernel {
+
+    handle: Arc<CompuKernelHandle>,
+
+    compute_pipeline: Option<std::sync::Arc<ComputePipeline<PipelineLayout<shade_runner::layouts::ComputeLayout>>>>,
+    compute_kernel_path: PathBuf,
+
+    name: String,
+
+    shader: CompiledShaders,
+    entry: Entry,
+    shader_module: Arc<ShaderModule>,
+    device: Arc<Device>,
+    specialization_constants: ComputeSpecializationConstants,
+}
+
+impl CompuKernel {
+
+    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>,
+               handle: Arc<CompuKernelHandle>) -> CompuKernel {
+
+        let compute_path = CompuKernel::get_path(filename.clone());
+
+        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();
+
+
+        CompuKernel {
+            name: filename,
+            handle: handle,
+            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 = CompuKernel::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()
+    }
+
+    pub fn get_handle(&self) -> Arc<CompuKernelHandle> {
+        self.handle.clone()
+    }
+    pub fn get_name(&self) -> String {
+        self.name.clone()
+    }
+}
+
+#[repr(C)]
+#[derive(Default, Debug, Clone)]
+pub 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/compute/compu_sprite.rs

@@ -0,0 +1,70 @@
+use crate::canvas::canvas_state::{CanvasImageHandle, Drawable, CanvasTextureHandle};
+use std::sync::Arc;
+
+pub struct CompuSprite {
+    pub vertices: [(f32, f32, f32); 6],
+    pub ti_position: [(f32, f32); 6],
+
+    position: (f32, f32),
+    size: (f32, f32),
+    color: (f32, f32, f32, f32),
+    image_handle: Arc<CanvasImageHandle>,
+
+}
+
+impl CompuSprite {
+    pub fn new(position: (f32, f32),
+               size: (f32, f32),
+               depth: u32,
+               image_size: (f32, f32),
+               image_handle: Arc<CanvasImageHandle>) -> CompuSprite {
+
+        let normalized_depth = (depth as f32 / 255.0);
+
+        CompuSprite {
+            vertices: [
+                (position.0, position.1                  , normalized_depth),    // top left
+                (position.0, position.1 + size.1         , normalized_depth),    // bottom left
+                (position.0 + size.0, position.1 + size.1, normalized_depth),    // bottom right
+                (position.0, position.1                  , normalized_depth),    // top left
+                (position.0 + size.0, position.1 + size.1, normalized_depth),    // bottom right
+                (position.0 + size.0, position.1         , normalized_depth),    // top right
+            ],
+
+            ti_position: [
+                (0.0         ,  0.0         ),          // top left
+                (0.0         ,  image_size.1),          // bottom left
+                (image_size.0,  image_size.1),          // bottom right
+                (0.0         ,  0.0         ),          // top left
+                (image_size.0,  image_size.1),          // bottom right
+                (image_size.0,  0.0         ),          // top right
+            ],
+            position: position,
+            size: size,
+            color: (0.0, 0.0, 0.0, 0.0),
+            image_handle: image_handle.clone(),
+        }
+    }
+}
+
+impl Drawable for CompuSprite {
+    fn get_vertices(&self) -> Vec<(f32, f32, f32)> {
+        self.vertices.to_vec()
+    }
+
+    fn get_color(&self) -> (f32, f32, f32, f32) {
+        self.color
+    }
+
+    fn get_ti_coords(&self) -> Vec<(f32, f32)> {
+        self.ti_position.to_vec()
+    }
+
+    fn get_texture_handle(&self) -> Option<Arc<CanvasTextureHandle>> {
+        None
+    }
+
+    fn get_image_handle(&self) -> Option<Arc<CanvasImageHandle>> {
+        Some(self.image_handle.clone())
+    }
+}

src/compute/compu_state.rs

@@ -0,0 +1,163 @@
+use std::ffi::CStr;
+use vulkano::buffer::{CpuAccessibleBuffer, BufferUsage};
+use std::sync::Arc;
+use crate::canvas::canvas_state::{Drawable, CanvasState, CanvasImageHandle, CanvasTextureHandle};
+use vulkano::framebuffer::RenderPassAbstract;
+use vulkano::pipeline::{GraphicsPipelineAbstract, ComputePipeline};
+use vulkano::device::Device;
+use image::ImageBuffer;
+use image::GenericImageView;
+use vulkano::image::{ImageUsage, AttachmentImage};
+use vulkano::descriptor::descriptor_set::{PersistentDescriptorSetBuf, PersistentDescriptorSet};
+use vulkano::format::Format;
+use vulkano::descriptor::pipeline_layout::PipelineLayout;
+use std::borrow::Borrow;
+use image::Rgba;
+use vulkano::command_buffer::AutoCommandBufferBuilder;
+use std::path::PathBuf;
+use shade_runner::{CompiledShaders, Entry, CompileError};
+use vulkano::pipeline::shader::ShaderModule;
+use shaderc::CompileOptions;
+use crate::compute::compu_kernel::{CompuKernel, CompuKernelHandle};
+use crate::compute::compu_buffer::{CompuBuffers, CompuBufferHandle};
+use crate::compute::compu_frame::CompuFrame;
+
+
+// Canvas analog
+pub struct CompuState {
+    compute_buffers: Vec<CompuBuffers>,
+    kernels: Vec<CompuKernel>,
+}
+
+impl CompuState {
+    pub fn new() -> CompuState {
+        CompuState {
+            compute_buffers: vec![],
+            kernels: vec![],
+        }
+    }
+
+    pub fn new_compute_buffer(&mut self,
+                              data: Vec<u8>,
+                              dimensions: (u32, u32),
+                              stride: u32,
+                              device: Arc<Device>) -> Arc<CompuBufferHandle> {
+        let handle = Arc::new(CompuBufferHandle {
+            handle: self.compute_buffers.len() as u32
+        });
+
+        self.compute_buffers.push(
+            (CompuBuffers::new(device.clone(), data, dimensions, stride, handle.clone())));
+
+        handle
+    }
+
+    pub fn read_compute_buffer(&mut self, handle: Arc<CompuBufferHandle>) -> Vec<u8> {
+        // This is way more difficult than it should be
+        //let compute_buffer : CompuBuffers = self.compute_buffers.get(handle.into()).unwrap();
+        //compute_buffer.read_output_buffer().to_vec()
+        Vec::new()
+    }
+    pub fn write_compute_buffer(&self, handle: Arc<CompuBufferHandle>, data: Vec<u8>) {}
+
+    pub fn new_kernel(&mut self,
+                      filename: String,
+                      device: Arc<Device>) -> Arc<CompuKernelHandle> {
+        let handle = Arc::new(CompuKernelHandle {
+            handle: self.kernels.len() as u32
+        });
+
+        self.kernels.push((CompuKernel::new(filename, device.clone(), handle.clone())));
+
+        handle
+    }
+
+    pub fn get_kernel_handle(&self, kernel_name: String) -> Option<Arc<CompuKernelHandle>> {
+        for i in self.kernels.clone() {
+            if i.get_name() == kernel_name {
+                return Some(i.get_handle());
+            }
+        }
+        None
+    }
+
+    pub fn compute_commands(&mut self,
+                            compute_frame: CompuFrame,
+                            mut command_buffer: AutoCommandBufferBuilder,
+                            canvas: &CanvasState)
+                            -> AutoCommandBufferBuilder {
+
+        // i = (Buffer, Kernel)
+        for i in compute_frame.pure_compute {
+            let buffer_id = (*i.0).clone().handle as usize;
+            let kernel_id = (*i.1).clone().handle as usize;
+
+            let buffer = self.compute_buffers.get(buffer_id).unwrap();
+            let kernel = self.kernels.get(kernel_id).unwrap();
+
+            let p = kernel.clone().get_pipeline();
+            let d = buffer.get_descriptor_set(kernel.clone().get_pipeline());
+
+            let size = buffer.get_size();
+
+            command_buffer = command_buffer
+                .dispatch([size.0 / 8, size.1 / 8, 1], p, d, ()).unwrap()
+        }
+
+        // i = (Buffer, Image, Kernel)
+        for i in compute_frame.swapped_to_image {
+            let buffer_id = (*i.0).clone().handle as usize;
+            let image_id = i.1.clone();
+            let kernel_id = (*i.2).clone().handle as usize;
+
+            let buffer = self.compute_buffers.get(buffer_id).unwrap();
+            let image = canvas.get_image(image_id);
+            let kernel = self.kernels.get(kernel_id).unwrap();
+
+            let p = kernel.clone().get_pipeline();
+            let d = buffer.get_descriptor_set(kernel.clone().get_pipeline());
+
+            let dimensions = image.dimensions();
+            let dimensions = (dimensions[0], dimensions[1]);
+            if dimensions != buffer.get_size() {
+                panic!("Buffer sizes not the same");
+            }
+
+            let size = buffer.get_size();
+
+            command_buffer = command_buffer
+                .dispatch([size.0 / 8, size.1 / 8, 1], p, d, ()).unwrap()
+                .copy_buffer_to_image(buffer.get_input_buffer(), image).unwrap();
+        }
+
+
+        // i = (Input Buffer, Output Buffer, Kernel)
+        // Input buffer -> Kernel -> Output buffer
+        for i in compute_frame.swapped_to_buffer {
+            let input_buffer_id = (*i.0).clone().handle as usize;
+            let output_buffer_id = (*i.1).clone().handle as usize;
+            let kernel_id = (*i.2).clone().handle as usize;
+
+            let input_buffer = self.compute_buffers.get(input_buffer_id).unwrap();
+            let output_buffer = self.compute_buffers.get(output_buffer_id).unwrap();
+            let kernel = self.kernels.get(kernel_id).unwrap();
+
+            let pipeline = kernel.clone().get_pipeline();
+            let descriptor_set = input_buffer.get_descriptor_set(kernel.clone().get_pipeline());
+
+            if input_buffer.get_size() != output_buffer.get_size() {
+                panic!("Buffer sizes not the same");
+            }
+            let size = input_buffer.get_size();
+
+            command_buffer = command_buffer
+                //  .dispatch([size.0/8, size.1/8,1], pipeline, descriptor_set, ()).unwrap()
+                .copy_buffer(
+                    input_buffer.get_output_buffer(),
+                    output_buffer.get_input_buffer()).unwrap();
+        }
+
+        command_buffer
+    }
+}
+

src/compute/mod.rs

@@ -0,0 +1,11 @@
+pub mod compu_frame;
+pub mod compu_kernel;
+pub mod compu_sprite;
+pub mod compu_state;
+pub mod compu_buffer;
+
+use crate::compute::compu_state::CompuState;
+use crate::compute::compu_frame::CompuFrame;
+use crate::compute::compu_sprite::CompuSprite;
+use crate::compute::compu_kernel::CompuKernel;
+use crate::compute::compu_buffer::CompuBuffers;