diff --git a/resources/images/test2.png b/resources/images/test2.png index 7b6efa96..02dbe9da 100644 Binary files a/resources/images/test2.png and b/resources/images/test2.png differ diff --git a/src/main.rs b/src/main.rs index b8813e5f..15af7479 100644 --- a/src/main.rs +++ b/src/main.rs @@ -51,7 +51,10 @@ mod vkprocessor; fn main() { - let processor = vkprocessor::VkProcessor::new(); + let mut processor = vkprocessor::VkProcessor::new(); + processor.compile_kernel(); + processor.load_buffers(); + let mut window = RenderWindow::new( @@ -66,8 +69,9 @@ fn main() { let font = Font::from_file("resources/fonts/sansation.ttf").unwrap(); + let xy = processor.img.unwrap().dimensions(); let mut bg_texture = Texture::new(xy.0, xy.1).unwrap(); - bg_texture.update_from_pixels(image_buffer.as_slice(), xy.0, xy.1, 0, 0); + bg_texture.update_from_pixels(processor.image_buffer.as_slice(), xy.0, xy.1, 0, 0); let mut background_sprite = Sprite::with_texture(&bg_texture); background_sprite.set_position((0., 0.)); diff --git a/src/vkprocessor.rs b/src/vkprocessor.rs index 87d00718..8bc596c7 100644 --- a/src/vkprocessor.rs +++ b/src/vkprocessor.rs @@ -1,6 +1,6 @@ use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer, DeviceLocalBuffer, ImmutableBuffer, BufferAccess}; use vulkano::command_buffer::AutoCommandBufferBuilder; -use vulkano::descriptor::descriptor_set::PersistentDescriptorSet; +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; @@ -12,21 +12,30 @@ use std::ffi::CStr; use std::path::PathBuf; use shade_runner as sr; use image::DynamicImage; +use image::GenericImageView; +use vulkano::descriptor::pipeline_layout::PipelineLayout; +use image::GenericImage; +use shade_runner::ComputeLayout; +use vulkano::descriptor::descriptor_set::PersistentDescriptorSetBuf; pub struct VkProcessor<'a> { - instance: Arc, - physical: PhysicalDevice<'a>, - queue_family: QueueFamily<'a>, - device: Arc, - queues: QueuesIter, - queue: Arc, - img: Option, - image_buffer: Vec, - buffers: Vec:: + pub instance: Arc, + pub physical: PhysicalDevice<'a>, + pub queue_family: QueueFamily<'a>, + pub pipeline: Option>>>, + pub device: Arc, + pub queues: QueuesIter, + pub queue: Arc, + pub set: Option>>, ((((), PersistentDescriptorSetBuf>>), PersistentDescriptorSetBuf>>), PersistentDescriptorSetBuf>>)>>>, + pub img: Option, + pub image_buffer: Vec, + pub img_buffers: Vec>>, + pub settings_buffer: Option>>, } -impl VkProcessor { - pub fn new() -> VkProcessor { +impl<'a> VkProcessor<'a> { + pub fn new() -> VkProcessor<'a> { + let instance = Instance::new(None, &InstanceExtensions::none(), None).unwrap(); let physical = PhysicalDevice::enumerate(&instance).next().unwrap(); let queue_family = physical.queue_families().find(|&q| q.supports_compute()).unwrap(); @@ -34,17 +43,23 @@ impl VkProcessor { physical.supported_features(), &DeviceExtensions::none(), [(queue_family, 0.5)].iter().cloned()).unwrap(); + + // Self referential struct problem VkProcessor { - instance: instance, - physical: physical, - queue_family: queue_family, + instance: instance.clone(), + physical: physical.clone(), + queue_family: physical.queue_families().find(|&q| q.supports_compute()).unwrap(), + pipeline: Option::None, device: device, queues: queues, queue: queues.next().unwrap(), img: Option::None, + set: Option::None, image_buffer: Vec::new(), - buffers: Vec::new(), + img_buffers: Vec::new(), + settings_buffer: Option::None, } + } pub fn compile_kernel(&mut self) { @@ -68,20 +83,21 @@ impl VkProcessor { ).unwrap() } }); + } pub fn load_buffers(&mut self) { self.img = Option::Some(image::open("resources/images/funky-bird.jpg").unwrap()); - let xy = self.img.dimensions(); + let xy = self.img.unwrap().dimensions(); let data_length = xy.0 * xy.1 * 4; - let pixel_count = self.img.raw_pixels().len(); + let pixel_count = self.img.unwrap().raw_pixels().len(); println!("Pixel count {}", pixel_count); if pixel_count != data_length as usize { println!("Creating apha channel..."); - for i in self.img.raw_pixels().iter() { + for i in self.img.unwrap().raw_pixels().iter() { if (self.image_buffer.len() + 1) % 4 == 0 { self.image_buffer.push(255); } @@ -89,58 +105,63 @@ impl VkProcessor { } self.image_buffer.push(255); } else { - self.image_buffer = self.img.raw_pixels(); + self.image_buffer = self.img.unwrap().raw_pixels(); } println!("Buffer length {}", self.image_buffer.len()); println!("Size {:?}", xy); println!("Allocating Buffers..."); - { - // 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() - }; - } + + // 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 = self.image_buffer.iter(); + let data_iter = (0..data_length).map(|n| *(buff.next().unwrap())); + CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::all(), data_iter).unwrap() + }; + self.img_buffers.push(write_buffer); + + // Pull out the image data and place it in a buffer for the kernel to read from + let read_buffer = { + let mut buff = self.image_buffer.iter(); + let data_iter = (0..data_length).map(|n| *(buff.next().unwrap())); + CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::all(), data_iter).unwrap() + }; + self.img_buffers.push(read_buffer); + + // 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(self.device.clone(), BufferUsage::all(), data_iter).unwrap() + }; + self.settings_buffer = Some(settings_buffer); println!("Done"); // Create the data descriptor set for our previously created shader pipeline - let mut set = PersistentDescriptorSet::start(pipeline.clone(), 0) + let mut set = PersistentDescriptorSet::start(self.pipeline.unwrap().clone(), 0) .add_buffer(write_buffer.clone()).unwrap() .add_buffer(read_buffer.clone()).unwrap() .add_buffer(settings_buffer.clone()).unwrap(); - let mut set = Arc::new(set.build().unwrap()); +// self.set = Some(Arc::new(set.build().unwrap())); } pub fn run_kernel(&mut self) { + println!("Running Kernel..."); + let xy = self.img.unwrap().dimensions(); + // The command buffer I think pretty much serves to define what runs where for how many times - let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(device.clone(), queue.family()).unwrap() - .dispatch([xy.0, xy.1, 1], pipeline.clone(), set.clone(), ()).unwrap() + let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(self.device.clone(), self.queue.family()).unwrap() + .dispatch([xy.0, xy.1, 1], self.pipeline.unwrap().clone(), self.set.unwrap().clone(), ()).unwrap() .build().unwrap(); // Create a future for running the command buffer and then just fence it - let future = sync::now(device.clone()) - .then_execute(queue.clone(), command_buffer).unwrap() + let future = sync::now(self.device.clone()) + .then_execute(self.queue.clone(), command_buffer).unwrap() .then_signal_fence_and_flush().unwrap(); // I think this is redundant and returns immediately @@ -148,10 +169,12 @@ impl VkProcessor { println!("Done running kernel"); } - pub fn read_image() -> Vec { + pub fn read_image(&self) -> Vec { + + let xy = self.img.unwrap().dimensions(); // The buffer is sync'd so we can just read straight from the handle - let mut data_buffer_content = write_buffer.read().unwrap(); + let mut data_buffer_content = self.img_buffers.get(0).unwrap().read().unwrap(); println!("Reading output"); @@ -170,7 +193,7 @@ impl VkProcessor { image_buffer.push(b); image_buffer.push(a); - img.put_pixel(x, y, image::Rgba([r, g, b, a])) + self.img.unwrap().put_pixel(x, y, image::Rgba([r, g, b, a])) } } @@ -179,7 +202,7 @@ impl VkProcessor { pub fn save_image(&self) { println!("Saving output"); - img.save(format!("output/{}.png", SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs())); + self.img.unwrap().save(format!("output/{}.png", SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs())); } }