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

porting over the graphics example

Browse Source
master
mitchellhansen 5 years ago
parent d6b81ae468
commit c8a968f4f6
4 changed files with 154 additions and 30 deletions
Show Stats Download Patch File Download Diff File

7
resources/shaders/simple.fragment
Unescape View File

@ -0,0 +1,7 @@
#version 450
layout(location = 0) out vec4 f_color;
void main() {
f_color = vec4(1.0, 0.0, 0.0, 1.0);
}

7
resources/shaders/simple.vertex
Unescape View File

@ -0,0 +1,7 @@
#version 450
layout(location = 0) in vec2 position;
void main() {
gl_Position = vec4(position, 0.0, 1.0);
}

32
src/main.rs
Unescape View File

@ -3,8 +3,6 @@
#![allow(unused_variables)]
#![allow(unused_mut)]
/*
extern crate cgmath;
extern crate image;
extern crate nalgebra as na;
@ -54,8 +52,8 @@ mod util;
mod button;
mod workpiece;
/*
/*
What next?
Second sprite for rendering paths at x10 or so resolution
color bucketing
@ -205,32 +203,9 @@ fn main() {
window.display();
}
}
*/
//use vulkano::buffer::{BufferAccess, BufferUsage, CpuAccessibleBuffer, DeviceLocalBuffer, ImmutableBuffer};
//use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState};
//use vulkano::descriptor::descriptor_set::{PersistentDescriptorSet, PersistentDescriptorSetBuf, StdDescriptorPoolAlloc};
//use vulkano::descriptor::pipeline_layout::PipelineLayout;
//use vulkano::device::{Device, DeviceExtensions, Queue, QueuesIter};
//use vulkano::framebuffer::{Framebuffer, FramebufferAbstract, RenderPassAbstract, Subpass};
//use vulkano::image::SwapchainImage;
//use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice, QueueFamily};
//use vulkano::pipeline::{ComputePipeline, GraphicsPipeline};
//use vulkano::pipeline::viewport::Viewport;
//use vulkano::swapchain::{AcquireError, PresentMode, SurfaceTransform, Swapchain, SwapchainCreationError};
//use vulkano::swapchain;
//use vulkano::sync::{FlushError, GpuFuture};
//use vulkano::sync;
//use vulkano_win::VkSurfaceBuild;
//use winit::{Event, EventsLoop, Window, WindowBuilder, WindowEvent};
//use shade_runner::{ComputeLayout, CompileError};
//use shaderc::CompileOptions;
/*
use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer, DeviceLocalBuffer, ImmutableBuffer, BufferAccess};
use vulkano::command_buffer::{AutoCommandBufferBuilder, DynamicState};
use vulkano::descriptor::descriptor_set::{PersistentDescriptorSet, StdDescriptorPoolAlloc};
@ -258,6 +233,8 @@ use winit::{Event, EventsLoop, Window, WindowBuilder, WindowEvent};
use vulkano_win::VkSurfaceBuild;
use vulkano::SafeDeref;
fn main() {
let instance = {
let extensions = vulkano_win::required_extensions();
@ -751,3 +728,4 @@ fn window_size_dependent_setup(
}).collect::<Vec<_>>()
}
*/

138
src/vkprocessor.rs
Unescape View File

@ -3,7 +3,7 @@ use vulkano::command_buffer::AutoCommandBufferBuilder;
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;
use vulkano::pipeline::{ComputePipeline, GraphicsPipeline};
use vulkano::sync::GpuFuture;
use vulkano::sync;
use std::time::SystemTime;
@ -15,14 +15,17 @@ use image::{DynamicImage, ImageBuffer};
use image::GenericImageView;
use vulkano::descriptor::pipeline_layout::PipelineLayout;
use image::GenericImage;
use shade_runner::{ComputeLayout, CompileError};
use shade_runner::{ComputeLayout, CompileError, FragLayout};
use vulkano::descriptor::descriptor_set::PersistentDescriptorSetBuf;
use shaderc::CompileOptions;
use vulkano::framebuffer::Subpass;
use vulkano::pipeline::shader::GraphicsShaderType;
pub struct VkProcessor<'a> {
pub instance: Arc<Instance>,
pub physical: PhysicalDevice<'a>,
pub pipeline: Option<Arc<ComputePipeline<PipelineLayout<shade_runner::layouts::ComputeLayout>>>>,
pub pipeline: Option<Arc<ComputePipeline<PipelineLayout<shade_runner::layouts::ComputeLayout>>>>,
pub compute_pipeline: (),
pub device: Arc<Device>,
pub queues: QueuesIter,
pub queue: Arc<Queue>,
@ -47,6 +50,7 @@ impl<'a> VkProcessor<'a> {
instance: instance.clone(),
physical: physical.clone(),
pipeline: Option::None,
compute_pipeline: Option::None,
device: device,
queue: queues.next().unwrap(),
queues: queues,
@ -88,6 +92,103 @@ impl<'a> VkProcessor<'a> {
vulkano::pipeline::shader::ShaderModule::from_words(self.device.clone(), &shader.compute)
}.unwrap();
let compute_pipeline = Arc::new({
unsafe {
ComputePipeline::new(self.device.clone(), &x.compute_entry_point(
CStr::from_bytes_with_nul_unchecked(b"main\0"),
vulkano_entry.compute_layout), &(),
).unwrap()
}
});
self.compute_pipeline = Some(compute_pipeline);
}
pub fn compile_shaders(&mut self, filename: String) {
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()
.push(PathBuf::from("resources/shaders/"));
vertex_shader_path.push(PathBuf::from(filename.clone()));
vertex_shader_path.push(PathBuf::from(".vertex"));
let mut fragment_shader_path = project_root.clone()
.push(PathBuf::from("resources/shaders/"));
vertex_shader_path.push(PathBuf::from(filename.clone()));
vertex_shader_path.push(PathBuf::from(".fragment"));
let mut options = CompileOptions::new().ok_or(CompileError::CreateCompiler).unwrap();
options.add_macro_definition("SETTING_POS_X", Some("0"));
options.add_macro_definition("SETTING_POS_Y", Some("1"));
options.add_macro_definition("SETTING_BUCKETS_START", Some("2"));
options.add_macro_definition("SETTING_BUCKETS_LEN", Some("2"));
let shader =
sr::load(vertex_shader_path, fragment_shader_path)
.expect("Failed to compile");
let vulkano_entry =
sr::parse(&shader)
.expect("failed to parse");
let x = unsafe {
vulkano::pipeline::shader::ShaderModule::from_words(self.device.clone(), &shader.fragment)
}.unwrap();
let frag_entry_point = unsafe {
&x.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 vert_entry_point = unsafe {
&x.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)
};
// Before we draw we have to create what is called a pipeline. This is similar to an OpenGL
// program, but much more specific.
self.pipeline = Option::Some(Arc::new(GraphicsPipeline::start()
// We need to indicate the layout of the vertices.
// The type `SingleBufferDefinition` actually contains a template parameter corresponding
// to the type of each vertex. But in this code it is automatically inferred.
.vertex_input_single_buffer()
// A Vulkan shader can in theory contain multiple entry points, so we have to specify
// which one. The `main` word of `main_entry_point` actually corresponds to the name of
// the entry point.
.vertex_shader(vert_entry_point, ())
// The content of the vertex buffer describes a list of triangles.
.triangle_list()
// Use a resizable viewport set to draw over the entire window
.viewports_dynamic_scissors_irrelevant(1)
// See `vertex_shader`.
.fragment_shader(frag_entry_point, ())
// 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())
// Now that our builder is filled, we call `build()` to obtain an actual pipeline.
.build(device.clone())
.unwrap()));
let x = unsafe {
vulkano::pipeline::shader::ShaderModule::from_words(self.device.clone(), &shader.fragment)
}.unwrap();
let pipeline = Arc::new({
unsafe {
ComputePipeline::new(self.device.clone(), &x.compute_entry_point(
@ -179,6 +280,37 @@ impl<'a> VkProcessor<'a> {
self.settings_buffer = Some(settings_buffer);
}
pub fn create_renderpass(&mut self) {
let render_pass = Arc::new(vulkano::single_pass_renderpass!(
self.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: swapchain.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());
}
pub fn run_kernel(&mut self) {
println!("Running Kernel...");

Write Preview
Loading…
Cancel
Save