mitchellhansen
/
Trac3r-rust
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Moved the framebuffer gen to the canvas. Cleaned up a lot of unused imports

Browse Source
master
mitchellhansen 5 years ago
parent 8cd5e3e562
commit dfd4cbb6a2
9 changed files with 156 additions and 418 deletions
Show Stats Download Patch File Download Diff File

4
src/button.rs
Unescape View File

@ -1,5 +1,5 @@
use sfml::graphics::{CircleShape, Color, Drawable, RectangleShape, RenderStates, RenderTarget, RenderWindow, Shape, Transformable, Text, Font}; use sfml::graphics::{Color, Drawable, RectangleShape, RenderStates, RenderTarget, RenderWindow, Shape, Transformable, Text, Font};
use sfml::window::{Event, Key, Style};
use sfml::system::Vector2f; use sfml::system::Vector2f;
trait Clickable { trait Clickable {

88
src/canvas.rs
Unescape View File

@ -1,16 +1,16 @@
use crate::vertex_2d::{ColoredVertex2D, Vertex2D}; use crate::vertex_2d::{ColoredVertex2D, Vertex2D};
use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState}; use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState};
use crate::Sprite;
use std::collections::HashMap; use std::collections::HashMap;
use vulkano::buffer::{BufferAccess, CpuAccessibleBuffer, BufferUsage, ImmutableBuffer}; use vulkano::buffer::{BufferAccess, BufferUsage, ImmutableBuffer};
use std::sync::Arc; use std::sync::Arc;
use vulkano::format::{ClearValue, Format}; use vulkano::format::{ClearValue, Format};
use vulkano::framebuffer::FramebufferAbstract; use vulkano::framebuffer::{FramebufferAbstract, Framebuffer};
use vulkano::device::{Device, Queue}; use vulkano::device::{Device, Queue};
use vulkano::instance::PhysicalDevice; use vulkano::instance::PhysicalDevice;
use vulkano::image::immutable::ImmutableImage; use vulkano::image::immutable::ImmutableImage;
use crate::util::shader_kernels::ShaderKernels; use crate::util::shader_kernels::ShaderKernels;
use vulkano::image::{Dimensions, ImageUsage, ImageAccess, ImageDimensions}; use vulkano::image::{Dimensions, ImageAccess, ImageDimensions, SwapchainImage};
use vulkano::sampler::{Sampler, SamplerAddressMode, MipmapMode, Filter}; use vulkano::sampler::{Sampler, SamplerAddressMode, MipmapMode, Filter};
use vulkano::descriptor::DescriptorSet; use vulkano::descriptor::DescriptorSet;
use vulkano::descriptor::descriptor_set::PersistentDescriptorSet; use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
@ -19,7 +19,10 @@ use image::GenericImageView;
use crate::util::compute_image::ComputeImage; use crate::util::compute_image::ComputeImage;
use std::iter::FromIterator; use std::iter::FromIterator;
use vulkano::swapchain::Capabilities; use vulkano::swapchain::Capabilities;
use shaderc::TargetEnv;
use winit::Window;
use vulkano::pipeline::viewport::Viewport;
// Canvas is the accumulator of Sprites for drawing // Canvas is the accumulator of Sprites for drawing
// Needs to know: // Needs to know:
@ -32,8 +35,6 @@ use shaderc::TargetEnv;
If it is textured. It needs to be rendered with the texture shader which requires a separate If it is textured. It needs to be rendered with the texture shader which requires a separate
graphics pipeline. Might as well have a new render pass as well. graphics pipeline. Might as well have a new render pass as well.
I need a second version of shaderkernels
So framebuffer is tied to the swapchains images as well as the renderpass So framebuffer is tied to the swapchains images as well as the renderpass
@ -50,28 +51,6 @@ it appears that renderpass is tied to the individual shader
// The rest will be grouped by their texture and run individually // The rest will be grouped by their texture and run individually
/*
vertex count differing is a big nono
ColoredVertex2D
Non-Textured
Vertex2D
Textured
Colored, vs non-colored:
Calling the color() field or not
I just wanna
*/
pub trait Vertex { pub trait Vertex {
fn position(&self) -> (f32, f32) { fn position(&self) -> (f32, f32) {
(0.0,0.0) (0.0,0.0)
@ -215,7 +194,7 @@ impl Canvas {
pub fn load_texture_from_filename(&mut self, filename: String) -> Arc<ImmutableImage<Format>> { pub fn load_texture_from_filename(&mut self, filename: String) -> Arc<ImmutableImage<Format>> {
if (self.texture_store.contains_key(&filename.clone())) { if self.texture_store.contains_key(&filename.clone()) {
println!("{} Already exists, not going to replace it.", filename.clone()); println!("{} Already exists, not going to replace it.", filename.clone());
self.texture_store.get(&filename.clone()).unwrap().clone() self.texture_store.get(&filename.clone()).unwrap().clone()
} else { } else {
@ -331,31 +310,9 @@ impl Canvas {
o o
} }
/* /*
So I need the image set in order to get my texture or compute texture
Done
compute image currently holds the set for compute and its swap buffer
but during a descriptor set build, we corrow the compute_image and take
it's swap buffer
vkprocessor creates the image sets for draw calls
takes the pipeline from the ShaderKernel - Which we own
adds vk processor owned texture - Not any more
adds compute image taken from the ComputeImage - Still true
we have shaderkernel in here so thats fine
Who should own the texture?
I would need to borrow it each time I created an image set...
These are tied very closely to the input output of a shader, which we would own
I just need to add a third option on sprite and allow it to have a swap buffer
*/ */
pub fn draw_commands(&self, pub fn draw_commands(&self,
mut command_buffer: AutoCommandBufferBuilder, mut command_buffer: AutoCommandBufferBuilder,
framebuffers: Vec<Arc<dyn FramebufferAbstract + Send + Sync>>, framebuffers: Vec<Arc<dyn FramebufferAbstract + Send + Sync>>,
@ -395,6 +352,33 @@ impl Canvas {
.end_render_pass() .end_render_pass()
.unwrap() .unwrap()
} }
/// This method is called once during initialization, then again whenever the window is resized
pub fn window_size_dependent_setup(&self,
images: &[Arc<SwapchainImage<Window>>],
) -> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> {
let dimensions = images[0].dimensions();
let mut dynamic_state = DynamicState {
line_width: None,
viewports: Some(vec![Viewport {
origin: [0.0, 0.0],
dimensions: [dimensions.width() as f32, dimensions.height() as f32],
depth_range: 0.0..1.0,
}]),
scissors: None
};
images.iter().map(|image| {
Arc::new(
Framebuffer::start(self.shader_kernels.get(&ShaderType::SOLID).unwrap().render_pass.clone())
.add(image.clone()).unwrap()
.build().unwrap()
) as Arc<dyn FramebufferAbstract + Send + Sync>
}).collect::<Vec<_>>()
}
} }

55
src/main.rs
Unescape View File

@ -10,43 +10,41 @@ extern crate rand;
extern crate sfml; extern crate sfml;
extern crate time; extern crate time;
use sfml::graphics::*;
use sfml::graphics::{
Color, RenderTarget, RenderWindow,
};
use sfml::system::*; use sfml::system::*;
use sfml::window::{Key, Style};
use sfml::window::mouse::*;
use sfml::window::mouse;
use vulkano::sync; use vulkano::sync;
use std::sync::Arc;
use std::{fs, mem, iter, ptr};
use std::path::PathBuf;
use std::result;
use crate::input::Input;
use crate::slider::Slider;
use crate::timer::Timer; use crate::timer::Timer;
use na::DimAdd;
use std::time::{SystemTime, Duration};
use std::ffi::CStr;
use std::ptr::write;
use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer, DeviceLocalBuffer, ImmutableBuffer, BufferAccess};
use vulkano::command_buffer::AutoCommandBufferBuilder;
use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
use vulkano::device::{Device, DeviceExtensions};
use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice}; use vulkano::instance::{Instance};
use vulkano::pipeline::ComputePipeline;
use vulkano::descriptor::pipeline_layout::PipelineLayoutAbstract;
use vulkano::sync::GpuFuture; use vulkano::sync::GpuFuture;
use shaderc::CompileOptions;
use shade_runner::CompileError;
use winit::{EventsLoop, WindowBuilder, WindowEvent, Event, DeviceEvent, VirtualKeyCode, ElementState}; use winit::{EventsLoop, WindowBuilder, WindowEvent, Event, DeviceEvent, VirtualKeyCode, ElementState};
use winit::dpi::LogicalSize; use winit::dpi::LogicalSize;
use vulkano_win::VkSurfaceBuild; use vulkano_win::VkSurfaceBuild;
use sprite::Sprite; use sprite::Sprite;
use crate::canvas::Canvas;
mod util; mod util;
@ -75,8 +73,7 @@ fn main() {
let mut processor = vkprocessor::VkProcessor::new(&instance, &surface); let mut processor = vkprocessor::VkProcessor::new(&instance, &surface);
processor.compile_kernel(String::from("simple-edge.compute")); processor.compile_kernel(String::from("simple-edge.compute"));
processor.compile_shaders(String::from("simple_texture"), &surface); processor.load_textures(String::from("background.jpg"));
processor.load_buffers(String::from("background.jpg"));
processor.create_swapchain(&surface); processor.create_swapchain(&surface);
let mut timer = Timer::new(); let mut timer = Timer::new();

4
src/slider.rs
Unescape View File

@ -1,5 +1,5 @@
use sfml::window::{Key, Event};
use sfml::graphics::{CircleShape, Color, Drawable, RectangleShape, RenderStates, RenderTarget, RenderWindow, Shape, Transformable, Font}; use sfml::graphics::{Drawable, RectangleShape, RenderStates, RenderTarget, RenderWindow, Shape, Transformable, Font};
use crate::button::Button; use crate::button::Button;
use sfml::system::Vector2f; use sfml::system::Vector2f;

2
src/sprite.rs
Unescape View File

@ -1,4 +1,4 @@
use crate::vertex_2d::ColoredVertex2D;
use crate::canvas::Drawable; use crate::canvas::Drawable;
#[derive(Debug, Clone)] #[derive(Debug, Clone)]

41
src/util/compute_image.rs
Unescape View File

@ -1,43 +1,19 @@
use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer, DeviceLocalBuffer, ImmutableBuffer, BufferAccess}; use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer};
use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState};
use vulkano::descriptor::descriptor_set::{PersistentDescriptorSet, StdDescriptorPoolAlloc}; use vulkano::descriptor::descriptor_set::{PersistentDescriptorSet};
use vulkano::device::{Device, DeviceExtensions, QueuesIter, Queue}; use vulkano::device::{Device};
use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice, QueueFamily}; use vulkano::pipeline::{ComputePipeline};
use vulkano::pipeline::{ComputePipeline, GraphicsPipeline, GraphicsPipelineAbstract, GraphicsPipelineBuilder};
use vulkano::sync::{GpuFuture, FlushError};
use vulkano::sync;
use std::time::SystemTime; use std::time::SystemTime;
use std::sync::Arc; use std::sync::Arc;
use std::ffi::CStr;
use std::path::PathBuf; use std::path::PathBuf;
use shade_runner as sr; use image::{ImageBuffer};
use image::{DynamicImage, ImageBuffer};
use image::GenericImageView; use image::GenericImageView;
use vulkano::descriptor::pipeline_layout::PipelineLayout; use vulkano::descriptor::pipeline_layout::PipelineLayout;
use image::GenericImage; use vulkano::descriptor::descriptor_set::{PersistentDescriptorSetBuf};
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::attachment::AttachmentImage;
use vulkano::image::{Dimensions, ImageUsage}; use vulkano::image::{ImageUsage};
use vulkano::format::Format; use vulkano::format::Format;
use vulkano::sampler::{Sampler, Filter, MipmapMode, SamplerAddressMode};
use image::flat::NormalForm::ColumnMajorPacked;
use image::Rgba; use image::Rgba;
use crate::vertex_2d::ColoredVertex2D;
/* /*
@ -47,7 +23,6 @@ This is a pretty specific use case. One in for settings. One in for data, two fo
multiple data inputs might be nice? multiple data inputs might be nice?
*/ */
#[derive(Clone)] #[derive(Clone)]

64
src/util/compute_kernel.rs
Unescape View File

@ -1,41 +1,41 @@
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::device::{Device};
use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice, QueueFamily};
use vulkano::pipeline::{ComputePipeline, GraphicsPipeline, GraphicsPipelineAbstract}; use vulkano::pipeline::{ComputePipeline};
use vulkano::sync::{GpuFuture, FlushError};
use vulkano::sync;
use std::time::SystemTime;
use std::sync::Arc; use std::sync::Arc;
use std::ffi::CStr; use std::ffi::CStr;
use std::path::PathBuf; use std::path::PathBuf;
use shade_runner as sr; use shade_runner as sr;
use image::{DynamicImage, ImageBuffer};
use image::GenericImageView;
use vulkano::descriptor::pipeline_layout::PipelineLayout; use vulkano::descriptor::pipeline_layout::PipelineLayout;
use image::GenericImage;
use shade_runner::{ComputeLayout, CompileError, FragLayout, FragInput, FragOutput, VertInput, VertOutput, VertLayout, CompiledShaders, Entry}; use shade_runner::{CompileError, FragLayout, FragInput, FragOutput, VertInput, VertOutput, VertLayout, CompiledShaders, Entry};
use vulkano::descriptor::descriptor_set::{PersistentDescriptorSetBuf, PersistentDescriptorSetImg, PersistentDescriptorSetSampler};
use shaderc::CompileOptions; use shaderc::CompileOptions;
use vulkano::framebuffer::{Subpass, RenderPass, RenderPassAbstract, Framebuffer, FramebufferAbstract};
use vulkano::pipeline::shader::{GraphicsShaderType, ShaderModule, GraphicsEntryPoint, SpecializationConstants, SpecializationMapEntry}; use vulkano::pipeline::shader::{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)] #[derive(Clone)]

74
src/util/shader_kernels.rs
Unescape View File

@ -1,41 +1,41 @@
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::device::{Device, Queue};
use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice, QueueFamily}; use vulkano::instance::{PhysicalDevice, QueueFamily};
use vulkano::pipeline::{ComputePipeline, GraphicsPipeline, GraphicsPipelineAbstract, GraphicsPipelineBuilder}; use vulkano::pipeline::{GraphicsPipeline, GraphicsPipelineAbstract, GraphicsPipelineBuilder};
use vulkano::sync::{GpuFuture, FlushError};
use vulkano::sync;
use std::time::SystemTime;
use std::sync::Arc; use std::sync::Arc;
use std::ffi::CStr; use std::ffi::CStr;
use std::path::PathBuf; use std::path::PathBuf;
use shade_runner as sr; 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::framebuffer::{Subpass, RenderPassAbstract, Framebuffer, FramebufferAbstract};
use vulkano::pipeline::shader::{GraphicsShaderType, ShaderModule, GraphicsEntryPoint, SpecializationConstants, SpecializationMapEntry}; use vulkano::pipeline::shader::{GraphicsShaderType, ShaderModule, SpecializationConstants, SpecializationMapEntry};
use vulkano::swapchain::{Swapchain, PresentMode, SurfaceTransform, Surface, SwapchainCreationError, AcquireError, Capabilities}; use vulkano::swapchain::{Capabilities};
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; use crate::vertex_2d::ColoredVertex2D;
/* /*
@ -47,8 +47,8 @@ Shaderkernel holds the pipeline and render pass for the inputted shader source
#[derive(Clone)] #[derive(Clone)]
pub struct ShaderKernels { pub struct ShaderKernels {
pub render_pass: Arc<RenderPassAbstract + Send + Sync>, pub render_pass: Arc<dyn RenderPassAbstract + Send + Sync>,
graphics_pipeline: Option<Arc<GraphicsPipelineAbstract + Sync + Send>>, graphics_pipeline: Option<Arc<dyn GraphicsPipelineAbstract + Sync + Send>>,
device: Arc<Device>, device: Arc<Device>,
} }
@ -75,7 +75,7 @@ impl ShaderKernels {
(vertex_shader_path, fragment_shader_path) (vertex_shader_path, fragment_shader_path)
} }
pub fn get_pipeline(&mut self) -> Arc<GraphicsPipelineAbstract + Sync + Send> { pub fn get_pipeline(&mut self) -> Arc<dyn GraphicsPipelineAbstract + Sync + Send> {
self.graphics_pipeline.clone().unwrap() self.graphics_pipeline.clone().unwrap()
} }

242
src/vkprocessor.rs
Unescape View File

@ -1,80 +1,17 @@
use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer, DeviceLocalBuffer, ImmutableBuffer, BufferAccess};
use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState}; use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState};
use vulkano::descriptor::descriptor_set::{PersistentDescriptorSet, StdDescriptorPoolAlloc, PersistentDescriptorSetBuilder, FixedSizeDescriptorSetsPool, StdDescriptorPool};
use vulkano::descriptor::descriptor_set::collection::DescriptorSetsCollection;
use vulkano::device::{Device, DeviceExtensions, QueuesIter, Queue}; use vulkano::device::{Device, DeviceExtensions, QueuesIter, Queue};
use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice, QueueFamily}; use vulkano::instance::{Instance, PhysicalDevice};
use vulkano::pipeline::{ComputePipeline, GraphicsPipeline, GraphicsPipelineAbstract};
use vulkano::sync::{GpuFuture, FlushError}; use vulkano::sync::{GpuFuture, FlushError};
use vulkano::sync; use vulkano::sync;
use std::time::SystemTime;
use std::sync::Arc; 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, Capabilities}; use vulkano::swapchain::{Swapchain, PresentMode, SurfaceTransform, Surface, SwapchainCreationError, AcquireError, Capabilities};
use vulkano::swapchain::acquire_next_image;
use vulkano::image::swapchain::SwapchainImage; use vulkano::image::swapchain::SwapchainImage;
use winit::{EventsLoop, WindowBuilder, Window, Event, WindowEvent}; use winit::{Window};
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, ImageAccess, ImageDimensions};
use vulkano::format::Format;
use vulkano::format::ClearValue;
use vulkano::sampler::{Sampler, Filter, MipmapMode, SamplerAddressMode};
use image::flat::NormalForm::ColumnMajorPacked;
use crate::util::compute_kernel::ComputeKernel; use crate::util::compute_kernel::ComputeKernel;
use crate::util::shader_kernels::ShaderKernels;
use crate::util::compute_image::ComputeImage; use crate::util::compute_image::ComputeImage;
use vulkano::descriptor::descriptor::DescriptorDesc;
use crate::vertex_2d::ColoredVertex2D;
use crate::canvas::Canvas; use crate::canvas::Canvas;
use std::mem;
/// This method is called once during initialization, then again whenever the window is resized
fn window_size_dependent_setup(
images: &[Arc<SwapchainImage<Window>>],
render_pass: Arc<dyn RenderPassAbstract + Send + Sync>,
dynamic_state: &mut DynamicState,
) -> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> {
let dimensions = images[0].dimensions();
let viewport = Viewport {
origin: [0.0, 0.0],
dimensions: [dimensions.width() as f32, dimensions.height() as f32],
depth_range: 0.0..1.0,
};
dynamic_state.viewports = Some(vec!(viewport));
images.iter().map(|image| {
Arc::new(
Framebuffer::start(render_pass.clone())
.add(image.clone()).unwrap()
.build().unwrap()
) as Arc<dyn FramebufferAbstract + Send + Sync>
}).collect::<Vec<_>>()
}
pub struct VkProcessor<'a> { pub struct VkProcessor<'a> {
// Vulkan state fields // Vulkan state fields
pub instance: Arc<Instance>, pub instance: Arc<Instance>,
pub physical: PhysicalDevice<'a>, pub physical: PhysicalDevice<'a>,
@ -84,15 +21,7 @@ pub struct VkProcessor<'a> {
pub dynamic_state: DynamicState, pub dynamic_state: DynamicState,
// TODO: This will need to handle multiple of each type // TODO: This will need to handle multiple of each type
pub shader_kernels: Option<ShaderKernels>,
pub compute_kernel: Option<ComputeKernel>, pub compute_kernel: Option<ComputeKernel>,
// TODO: Move this into canvas
pub vertex_buffer: Option<Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync + 'static)>>,
pub vertex_buffer2: Option<Arc<(dyn BufferAccess + std::marker::Send + std::marker::Sync + 'static)>>,
pub textures: Vec<Arc<ImmutableImage<Format>>>,
pub compute_image: Option<ComputeImage>, pub compute_image: Option<ComputeImage>,
pub swapchain: Option<Arc<Swapchain<Window>>>, pub swapchain: Option<Arc<Swapchain<Window>>>,
@ -106,9 +35,7 @@ pub struct VkProcessor<'a> {
impl<'a> VkProcessor<'a> { impl<'a> VkProcessor<'a> {
pub fn new(instance: &'a Arc<Instance>, surface: &'a Arc<Surface<Window>>) -> VkProcessor<'a> { pub fn new(instance: &'a Arc<Instance>, surface: &'a Arc<Surface<Window>>) -> VkProcessor<'a> {
let physical = PhysicalDevice::enumerate(instance).next().unwrap(); let physical = PhysicalDevice::enumerate(instance).next().unwrap();
let queue_family = physical.queue_families().find(|&q| { let queue_family = physical.queue_families().find(|&q| {
@ -135,36 +62,23 @@ impl<'a> VkProcessor<'a> {
queue: queue.clone(), queue: queue.clone(),
queues: queues, queues: queues,
dynamic_state: DynamicState { line_width: None, viewports: None, scissors: None }, dynamic_state: DynamicState { line_width: None, viewports: None, scissors: None },
shader_kernels: None,
compute_kernel: None, compute_kernel: None,
vertex_buffer: None,
vertex_buffer2: None,
textures: vec![],
compute_image: None, compute_image: None,
swapchain: None, swapchain: None,
swapchain_images: None, swapchain_images: None,
swapchain_recreate_needed: false, swapchain_recreate_needed: false,
capabilities: capabilities.clone(), capabilities: capabilities.clone(),
canvas: Canvas::new(queue, device, physical, capabilities) canvas: Canvas::new(queue, device, physical, capabilities),
} }
} }
pub fn compile_kernel(&mut self, filename: String) { pub fn compile_kernel(&mut self, filename: String) {
self.compute_kernel = Some(ComputeKernel::new(filename, self.device.clone())); self.compute_kernel = Some(ComputeKernel::new(filename, self.device.clone()));
} }
pub fn compile_shaders(&mut self, filename: String, surface: &'a Arc<Surface<Window>>) {
self.shader_kernels = Some(
ShaderKernels::new(filename.clone(),
self.capabilities.clone(), self.queue.clone(),
self.physical,
self.device.clone())
);
}
pub fn create_swapchain(&mut self, surface: &'a Arc<Surface<Window>>) { pub fn create_swapchain(&mut self, surface: &'a Arc<Surface<Window>>) {
let (mut swapchain, images) = { let (mut swapchain, images) = {
let capabilities = surface.capabilities(self.physical).unwrap(); let capabilities = surface.capabilities(self.physical).unwrap();
let usage = capabilities.supported_usage_flags; let usage = capabilities.supported_usage_flags;
@ -197,12 +111,10 @@ impl<'a> VkProcessor<'a> {
self.swapchain = Some(swapchain); self.swapchain = Some(swapchain);
self.swapchain_images = Some(images); self.swapchain_images = Some(images);
} }
// On resizes we have to recreate the swapchain // On resizes we have to recreate the swapchain
pub fn recreate_swapchain(&mut self, surface: &'a Arc<Surface<Window>>) { pub fn recreate_swapchain(&mut self, surface: &'a Arc<Surface<Window>>) {
let dimensions = if let Some(dimensions) = surface.window().get_inner_size() { let dimensions = if let Some(dimensions) = surface.window().get_inner_size() {
let dimensions: (u32, u32) = dimensions.to_physical(surface.window().get_hidpi_factor()).into(); let dimensions: (u32, u32) = dimensions.to_physical(surface.window().get_hidpi_factor()).into();
[dimensions.0, dimensions.1] [dimensions.0, dimensions.1]
@ -220,143 +132,30 @@ impl<'a> VkProcessor<'a> {
self.swapchain = Some(new_swapchain); self.swapchain = Some(new_swapchain);
self.swapchain_images = Some(new_images); self.swapchain_images = Some(new_images);
}
fn get_texture_from_file(image_filename: String, queue: Arc<Queue>) -> Arc<ImmutableImage<Format>> {
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(image_filename));
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();
}
let (texture, tex_future) = ImmutableImage::from_iter(
image_buffer.iter().cloned(),
Dimensions::Dim2d { width: xy.0, height: xy.1 },
Format::R8G8B8A8Srgb,
queue.clone()
).unwrap();
texture
} }
pub fn load_compute_image(&mut self, image_filename: String) { pub fn load_compute_image(&mut self, image_filename: String) {
self.compute_image = Some(ComputeImage::new(self.device.clone(), image_filename.clone())); self.compute_image = Some(ComputeImage::new(self.device.clone(), image_filename.clone()));
} }
pub fn load_buffers(&mut self, image_filename: String) pub fn load_textures(&mut self, image_filename: String)
{ {
self.load_compute_image(image_filename.clone()); self.load_compute_image(image_filename.clone());
let color = [1.,0.,0.,0.]; self.canvas.load_texture_from_filename(image_filename.clone());
let vertex_buffer = {
CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::all(), [
ColoredVertex2D { position: [ 1.0, 1.0 ], color },
ColoredVertex2D { position: [ 1.0, 0.5 ], color },
ColoredVertex2D { position: [ 0.5, 0.5 ], color },
ColoredVertex2D { position: [ 0.5, 1.0 ], color },
].iter().cloned()).unwrap()
};
let vertex_buffer2 = {
CpuAccessibleBuffer::from_iter(self.device.clone(), BufferUsage::all(), [
ColoredVertex2D { position: [-1.0, -1.0 ], color },
ColoredVertex2D { position: [-1.0, -0.5 ], color },
ColoredVertex2D { position: [-0.5, -0.5 ], color },
ColoredVertex2D { position: [-0.5, -1.0 ], color },
].iter().cloned()).unwrap()
};
self.vertex_buffer = Some(vertex_buffer);
self.vertex_buffer2 = Some(vertex_buffer2);
let texture = VkProcessor::get_texture_from_file(image_filename.clone(), self.queue.clone());
self.textures.push(texture);
let texture1 = VkProcessor::get_texture_from_file(String::from("button.png"), self.queue.clone());
self.textures.push(texture1);
} }
pub fn save_edges_image(&mut self) {
// The image set is the containing object for all texture and image hooks.
fn get_image_set(&mut self) -> Box<DescriptorSet + Send + Sync> {
let sampler = Sampler::new(self.device.clone(), Filter::Linear, Filter::Linear,
MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, 0.0).unwrap();
let o : Box<DescriptorSet + Send + Sync> = Box::new(
PersistentDescriptorSet::start(
self.shader_kernels.clone().unwrap().get_pipeline(), 0
)
.add_sampled_image(self.textures.get(0).unwrap().clone(), sampler.clone()).unwrap()
.add_image(self.compute_image.clone().unwrap().clone().get_swap_buffer().clone()).unwrap()
.build().unwrap());
o
}
// The image set is the containing object for all texture and image hooks.
fn get_gui_image_set(&mut self) -> Box<DescriptorSet + Send + Sync> {
let sampler = Sampler::new(self.device.clone(), Filter::Linear, Filter::Linear,
MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, 0.0).unwrap();
let o : Box<DescriptorSet + Send + Sync> = Box::new(
PersistentDescriptorSet::start(
self.shader_kernels.clone().unwrap().get_pipeline(), 0
)
.add_sampled_image(self.textures.get(1).unwrap().clone(), sampler.clone()).unwrap()
.add_image(self.compute_image.clone().unwrap().clone().get_swap_buffer().clone()).unwrap()
.build().unwrap());
o
}
pub fn save_edges_image(&mut self){
self.compute_image.clone().unwrap().clone().save_image(); self.compute_image.clone().unwrap().clone().save_image();
} }
pub fn run(&mut self, pub fn run(&mut self,
surface: &'a Arc<Surface<Window>>, surface: &'a Arc<Surface<Window>>,
mut frame_future: Box<dyn GpuFuture>, mut frame_future: Box<dyn GpuFuture>,
) -> Box<dyn GpuFuture> { ) -> Box<dyn GpuFuture> {
let mut framebuffers =
let mut framebuffers = window_size_dependent_setup(&self.swapchain_images.clone().unwrap().clone(), self.canvas.window_size_dependent_setup(&self.swapchain_images.clone().unwrap().clone());
self.shader_kernels.clone().unwrap().render_pass.clone(),
&mut self.dynamic_state);
// The docs said to call this on each loop. // The docs said to call this on each loop.
frame_future.cleanup_finished(); frame_future.cleanup_finished();
@ -365,9 +164,8 @@ impl<'a> VkProcessor<'a> {
// In this example that includes the swapchain, the framebuffers and the dynamic state viewport. // In this example that includes the swapchain, the framebuffers and the dynamic state viewport.
if self.swapchain_recreate_needed { if self.swapchain_recreate_needed {
self.recreate_swapchain(surface); self.recreate_swapchain(surface);
framebuffers = window_size_dependent_setup(&self.swapchain_images.clone().unwrap().clone(), framebuffers =
self.shader_kernels.clone().unwrap().render_pass.clone(), self.canvas.window_size_dependent_setup(&self.swapchain_images.clone().unwrap().clone());
&mut self.dynamic_state);
self.swapchain_recreate_needed = false; self.swapchain_recreate_needed = false;
} }
@ -382,14 +180,6 @@ impl<'a> VkProcessor<'a> {
Err(err) => panic!("{:?}", err) Err(err) => panic!("{:?}", err)
}; };
// Specify the color to clear the framebuffer with i.e. blue
let clear_values = vec!(ClearValue::Float([0.0, 0.0, 1.0, 1.0]));
let mut v = Vec::new();
v.push(self.vertex_buffer.clone().unwrap().clone());
let mut v2 = Vec::new();
v2.push(self.vertex_buffer2.clone().unwrap().clone());
let xy = self.compute_image.clone().unwrap().get_size(); let xy = self.compute_image.clone().unwrap().get_size();
@ -403,19 +193,11 @@ impl<'a> VkProcessor<'a> {
.get_descriptor_set(self.compute_kernel.clone().unwrap().clone().get_pipeline()).clone(), ()).unwrap() .get_descriptor_set(self.compute_kernel.clone().unwrap().clone().get_pipeline()).clone(), ()).unwrap()
.copy_buffer_to_image(self.compute_image.clone().unwrap().clone().rw_buffers.get(0).unwrap().clone(), .copy_buffer_to_image(self.compute_image.clone().unwrap().clone().rw_buffers.get(0).unwrap().clone(),
self.compute_image.clone().unwrap().clone().get_swap_buffer().clone()).unwrap(); self.compute_image.clone().unwrap().clone().get_swap_buffer().clone()).unwrap();
/*
Fuck. So this is a problem...
I can't replace canvas.
*/
let mut command_buffer = self.canvas.draw_commands(command_buffer, framebuffers, image_num); let mut command_buffer = self.canvas.draw_commands(command_buffer, framebuffers, image_num);
//self.canvas = mem::replace(&mut self.canvas,
let command_buffer = command_buffer.build().unwrap(); let command_buffer = command_buffer.build().unwrap();
// Wait on the previous frame, then execute the command buffer and present the image // Wait on the previous frame, then execute the command buffer and present the image

Write Preview
Loading…
Cancel
Save