asuro/rust-engine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

vulkano reeeeeeeeeeee

Browse Source
This commit is contained in:
Asuro
2021-10-24 18:57:46 +02:00
parent 23e19bf9d0
commit 2834623ba7
12 changed files with 193 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
src/vulkan/pipelines.rs
View File

@@ -1,27 +1,22 @@
use std::{convert::TryInto, io::{self, ErrorKind, Read, Write}, path::PathBuf, sync::Arc};
use vulkano::{command_buffer::AutoCommandBufferBuilder, descriptor::{DescriptorSet, descriptor::ShaderStages, descriptor_set::PersistentDescriptorSet, pipeline_layout::PipelineLayoutDesc}, pipeline::{shader::{ShaderModule}}};
use vulkano::command_buffer::DynamicState;
use vulkano::{buffer::TypedBufferAccess, command_buffer::{AutoCommandBufferBuilder, PrimaryAutoCommandBuffer}, descriptor_set::PersistentDescriptorSet, image::view::ImageView, pipeline::{PipelineBindPoint, shader::ShaderModule}, render_pass::{RenderPass, Subpass}};
use vulkano::device::Device;
use vulkano::framebuffer::RenderPassAbstract;
use vulkano::framebuffer::Subpass;
use vulkano::pipeline::GraphicsPipeline;
use vulkano::pipeline::GraphicsPipelineAbstract;
use vulkano::pipeline::shader::GraphicsShaderType;
use crate::{GameObject, vulkan::{TextVertex}};
use crate::vulkan::{LinePoint, Vertex};
use crate::{GameObject, vulkan::TextVertex};
use crate::vulkan::Vertex;
use crate::vulkan::GameData;
use crate::VulkanRenderer;
use super::TextureHandle;
type RP = Arc<dyn RenderPassAbstract + Send + Sync>;
type GP = Arc<dyn GraphicsPipelineAbstract + Send + Sync>;
type DS = Arc<dyn DescriptorSet + Send + Sync>;
type RP = Arc<RenderPass>;
type GP = Arc<GraphicsPipeline>;
type DS = Arc<PersistentDescriptorSet>;
pub trait Drawcall {
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder, fb_index: usize, game_objects: Vec<&GameObject>, game_data: &GameData, dynamic_state: &DynamicState);
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>, fb_index: usize, game_objects: Vec<&GameObject>, game_data: &GameData);
fn create_descriptor_sets(self: &Self, textures: &Vec<TextureHandle>, renderer: &VulkanRenderer) -> Vec<Vec<DS>>;
fn recreate_pipeline(self: &mut Self, device: Arc<Device>, render_pass: RP);
fn get_pipeline(self: &Self) -> &GP;
@@ -46,7 +41,7 @@ pub struct DefaultShader {
pipeline: GP,
}
fn shader_module_from_file(device: Arc<Device>, path: &str) -> Arc<ShaderModule> {
fn _shader_module_from_file(device: Arc<Device>, path: &str) -> Arc<ShaderModule> {
let mut file = std::fs::File::open(path).unwrap();
let mut buffer = vec![];
file.read_to_end(&mut buffer).unwrap();
@@ -105,11 +100,12 @@ impl DefaultShader {
}
unsafe {
/*
static ENTRY_NAME: [u8; 5usize] = [109u8, 97u8, 105u8, 110u8, 0];
let entry_name_c = std::ffi::CStr::from_ptr(ENTRY_NAME.as_ptr() as *const _);
let fs_module = shader_module_from_file(device.clone(), "shaders/triangle.frag.spv");
let fs_layout = fs::Layout(ShaderStages {
let fs_layout = fs::MainLayout(ShaderStages {
fragment: true,
..ShaderStages::none()
});
@@ -121,14 +117,17 @@ impl DefaultShader {
..ShaderStages::none()
});
let vs_entry = vs_module.graphics_entry_point(entry_name_c, vs::MainInput, vs::MainOutput, vs_layout, GraphicsShaderType::Vertex);
*/
let vs = vs::Shader::load(device.clone()).unwrap();
let fs = fs::Shader::load(device.clone()).unwrap();
Arc::new(GraphicsPipeline::start()
.vertex_input_single_buffer::<Vertex>()
.vertex_shader(vs_entry, ())
.vertex_shader(vs.main_entry_point(), ())
.triangle_list()
.viewports_dynamic_scissors_irrelevant(1)
.depth_stencil_simple_depth()
.fragment_shader(fs_entry, ())
.fragment_shader(fs.main_entry_point(), ())
.blend_alpha_blending()
.cull_mode_back()
.render_pass(sub_pass.clone())
@@ -139,39 +138,39 @@ impl DefaultShader {
}
impl Drawcall for DefaultShader {
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder, fb_index: usize, game_objects: Vec<&GameObject>, game_data: &GameData, dynamic_state: &DynamicState) {
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>, fb_index: usize, game_objects: Vec<&GameObject>, game_data: &GameData) {
for i in 0..game_objects.len() {
let game_object = &game_objects[i];
let mesh = &game_data.meshes[game_object.mesh_index];
let push_constants = game_object.get_push_constants();
builder.draw_indexed(
self.pipeline.clone(),
dynamic_state,
vec![mesh.vertex_buffer.clone()],
mesh.index_buffer.clone(),
game_object.descriptor_sets[fb_index].clone(),
push_constants).unwrap();
builder
.bind_pipeline_graphics(self.pipeline.clone())
.bind_descriptor_sets(PipelineBindPoint::Graphics, self.pipeline.layout().clone(), 0, game_object.descriptor_sets[fb_index].clone())
.bind_vertex_buffers(0, mesh.vertex_buffer.clone())
.bind_index_buffer(mesh.index_buffer.clone())
.push_constants(self.pipeline.layout().clone(), 0, push_constants)
.draw_indexed(mesh.index_buffer.len() as u32, 1, 0, 0, 0).unwrap();
}
}
fn create_descriptor_sets(self: &Self, textures: &Vec<TextureHandle>, renderer: &VulkanRenderer) -> Vec<Vec<DS>> {
let descriptor_set_layout_0 = self.get_pipeline().descriptor_set_layout(0).unwrap().clone();
let descriptor_set_layout_0 = self.get_pipeline().layout().descriptor_set_layouts().get(0).unwrap().clone();
renderer.uniform_buffers.iter().map(|uniform_buffer| {
let descriptor_set_0: Arc<(dyn vulkano::descriptor::DescriptorSet + std::marker::Send + std::marker::Sync + 'static)>;
debug_assert!(textures.len() == 2, "Expected diffuse and normal map for object shader!");
let diffuse = &renderer.game_data.textures[textures[0]];
let diffuse_view = ImageView::new(diffuse.image.clone()).unwrap();
let normal_map = &renderer.game_data.textures[textures[1]];
let normal_view = ImageView::new(normal_map.image.clone()).unwrap();
descriptor_set_0 = Arc::new(PersistentDescriptorSet::start(descriptor_set_layout_0.clone())
let mut builder = PersistentDescriptorSet::start(descriptor_set_layout_0.clone());
builder
.add_buffer(uniform_buffer.clone()).unwrap()
.add_sampled_image(diffuse.image.clone(), diffuse.sampler.clone()).unwrap()
.add_sampled_image(normal_map.image.clone(), normal_map.sampler.clone()).unwrap()
.build().unwrap());
.add_sampled_image(diffuse_view, diffuse.sampler.clone()).unwrap()
.add_sampled_image(normal_view, normal_map.sampler.clone()).unwrap();
vec![descriptor_set_0]
vec![Arc::new(builder.build().unwrap())]
}).collect()
}
@@ -184,6 +183,7 @@ impl Drawcall for DefaultShader {
}
}
/*
pub mod line_vs {
vulkano_shaders::shader!{
ty: "vertex",
@@ -231,9 +231,8 @@ impl LineShader {
}
impl Drawcall for LineShader {
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder, _fb_index: usize, _game_objects: Vec<&GameObject>, game_data: &GameData, dynamic_state: &DynamicState) {
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>, _fb_index: usize, _game_objects: Vec<&GameObject>, game_data: &GameData) {
builder.draw(self.pipeline.clone(),
&dynamic_state,
vec![self.vertex_buffer.clone()],
(),
game_data.line_push_constants.clone()).unwrap();
@@ -251,6 +250,7 @@ impl Drawcall for LineShader {
&self.pipeline
}
}
*/
pub mod vs_text {
vulkano_shaders::shader!{
@@ -287,6 +287,7 @@ impl TextShader {
}
unsafe {
/*
static ENTRY_NAME: [u8; 5usize] = [109u8, 97u8, 105u8, 110u8, 0];
let entry_name_c = std::ffi::CStr::from_ptr(ENTRY_NAME.as_ptr() as *const _);
@@ -303,23 +304,27 @@ impl TextShader {
..ShaderStages::none()
});
let vs_entry = vs_module.graphics_entry_point(entry_name_c, vs_text::MainInput, vs_text::MainOutput, vs_layout, GraphicsShaderType::Vertex);
*/
let vs = vs_text::Shader::load(device.clone()).unwrap();
let fs = fs_text::Shader::load(device.clone()).unwrap();
let gp = Arc::new(GraphicsPipeline::start()
.vertex_input_single_buffer::<TextVertex>()
.vertex_shader(vs_entry, ())
.vertex_shader(vs.main_entry_point(), ())
.triangle_list()
.viewports_dynamic_scissors_irrelevant(1)
.depth_stencil_simple_depth()
.fragment_shader(fs_entry, ())
.fragment_shader(fs.main_entry_point(), ())
.blend_alpha_blending()
.cull_mode_disabled()
.render_pass(sub_pass.clone())
.build(device.clone())
.unwrap());
println!("{:?}", gp.descriptor(0, 0).unwrap().ty);
println!("{:?}", gp.descriptor(0, 1).unwrap().ty);
println!("{:?}", gp.descriptor(0, 2).unwrap().ty); // TODO: Why does this exist?
// println!("{:?}", gp.descriptor(0, 0).unwrap().ty);
// println!("{:?}", gp.descriptor(0, 1).unwrap().ty);
// println!("{:?}", gp.descriptor(0, 2).unwrap().ty); // TODO: Why does this exist?
gp
}
@@ -327,43 +332,37 @@ impl TextShader {
}
impl Drawcall for TextShader {
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder, fb_index: usize, game_objects: Vec<&GameObject>, game_data: &GameData, dynamic_state: &DynamicState) {
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>, fb_index: usize, game_objects: Vec<&GameObject>, game_data: &GameData) {
for i in 0..game_objects.len() {
let game_object = &game_objects[i];
let mesh = &game_data.meshes_text[game_object.mesh_index];
let push_constants = game_object.get_push_constants();
builder.draw_indexed(
self.pipeline.clone(),
dynamic_state,
vec![mesh.vertex_buffer.clone()],
mesh.index_buffer.clone(),
game_object.descriptor_sets[fb_index].clone(),
push_constants).unwrap();
builder.bind_pipeline_graphics(self.pipeline.clone())
.bind_descriptor_sets(PipelineBindPoint::Graphics, self.pipeline.layout().clone(), 0, game_object.descriptor_sets[fb_index].clone())
.bind_vertex_buffers(0, mesh.vertex_buffer.clone())
.bind_index_buffer(mesh.index_buffer.clone())
.push_constants(self.pipeline.layout().clone(), 0, game_object.get_push_constants())
.draw_indexed(mesh.index_buffer.len() as u32, 1, 0, 0, 0).unwrap();
}
}
fn create_descriptor_sets(self: &Self, textures: &Vec<TextureHandle>, renderer: &VulkanRenderer) -> Vec<Vec<DS>> {
let descriptor_set_layout = self.get_pipeline().descriptor_set_layout(0).unwrap().clone();
let descriptor_set_layout = self.get_pipeline().layout().descriptor_set_layouts().get(0).unwrap().clone();
renderer.uniform_buffers.iter().map(|uniform_buffer| {
let descriptor_set: Arc<(dyn vulkano::descriptor::DescriptorSet + std::marker::Send + std::marker::Sync + 'static)>;
let builder = PersistentDescriptorSet::start(descriptor_set_layout.clone());
let diffuse_index = match textures.len() {
0 => 0,
1 => textures[0],
_ => panic!("Expected only diffuse map for text shader!"),
};
let diffuse = &renderer.game_data.textures[diffuse_index];
let diffuse_view = ImageView::new(diffuse.image.clone()).unwrap();
descriptor_set = Arc::new(builder
.add_buffer(uniform_buffer.clone()).unwrap()
.add_sampled_image(diffuse.image.clone(), diffuse.sampler.clone()).unwrap()
.add_sampled_image(diffuse.image.clone(), diffuse.sampler.clone()).unwrap() // TODO: delet this
.build().unwrap());
let mut builder = PersistentDescriptorSet::start(descriptor_set_layout.clone());
builder.add_buffer(uniform_buffer.clone()).unwrap()
.add_sampled_image(diffuse_view.clone(), diffuse.sampler.clone()).unwrap();
vec![descriptor_set]
vec![Arc::new(builder.build().unwrap())]
}).collect()
}