4sides quad

This commit is contained in:
zomseffen 2024-12-16 20:01:39 +01:00
parent 534f1a109a
commit 7fe7015774
13 changed files with 784 additions and 52 deletions

View file

@ -365,6 +365,7 @@ impl App {
self.device.free_command_buffers(self.data.command_pool, &self.data.command_buffers);
self.device.destroy_pipeline(self.data.pipeline_cube, None);
self.device.destroy_pipeline(self.data.pipeline_cuboid, None);
self.device.destroy_pipeline(self.data.pipeline_quad, None);
self.device.destroy_pipeline_layout(self.data.pipeline_layout, None);
self.device.destroy_render_pass(self.data.render_pass, None);
self.data.swapchain_image_views
@ -668,64 +669,93 @@ unsafe fn create_logical_device(
}
unsafe fn create_pipeline(device: &Device, data: &mut app_data::AppData) -> Result<()> {
// set up shaders for cubes
// load the byte data
let vert_cube = include_bytes!("../shaders/vert_cube.spv");
let geo_cube = include_bytes!("../shaders/geo_cube.spv");
let frag_cube = include_bytes!("../shaders/frag_cube.spv");
// create the shaders
let vert_shader_module_cube = create_shader_module(device, &vert_cube[..])?;
let geo_shader_module_cube = create_shader_module(device, &geo_cube[..])?;
let frag_shader_module_cube = create_shader_module(device, &frag_cube[..])?;
//create the shader stage for the vertex shader
let vert_stage_cube = vk::PipelineShaderStageCreateInfo::builder()
.stage(vk::ShaderStageFlags::VERTEX)
.module(vert_shader_module_cube)
.name(b"main\0");
//create the shader stage for the geometry shader
let geo_stage_cube = vk::PipelineShaderStageCreateInfo::builder()
.stage(vk::ShaderStageFlags::GEOMETRY)
.module(geo_shader_module_cube)
.name(b"main\0");
//create the shader stage for the fragment shader
let frag_stage_cube = vk::PipelineShaderStageCreateInfo::builder()
.stage(vk::ShaderStageFlags::FRAGMENT)
.module(frag_shader_module_cube)
.name(b"main\0");
// create the binding description for the cube vertex
let binding_descriptions_cube = &[vertex::Vertex::binding_description()];
let attribute_descriptions_cube = vertex::Vertex::attribute_descriptions();
let vertex_input_state_cube = vk::PipelineVertexInputStateCreateInfo::builder()
.vertex_binding_descriptions(binding_descriptions_cube)
.vertex_attribute_descriptions(&attribute_descriptions_cube);
// set up shaders for cuboids
// load the byte data
let vert_cuboid = include_bytes!("../shaders/vert_cuboid.spv");
let geo_cuboid = include_bytes!("../shaders/geo_cuboid.spv");
let frag_cuboid = include_bytes!("../shaders/frag_cuboid.spv");
// create the shaders
let vert_shader_module_cuboid = create_shader_module(device, &vert_cuboid[..])?;
let geo_shader_module_cuboid = create_shader_module(device, &geo_cuboid[..])?;
let frag_shader_module_cuboid = create_shader_module(device, &frag_cuboid[..])?;
//create the shader stage for the vertex shader
let vert_stage_cuboid = vk::PipelineShaderStageCreateInfo::builder()
.stage(vk::ShaderStageFlags::VERTEX)
.module(vert_shader_module_cuboid)
.name(b"main\0");
//create the shader stage for the geometry shader
let geo_stage_cuboid = vk::PipelineShaderStageCreateInfo::builder()
.stage(vk::ShaderStageFlags::GEOMETRY)
.module(geo_shader_module_cuboid)
.name(b"main\0");
//create the shader stage for the fragment shader
let frag_stage_cuboid = vk::PipelineShaderStageCreateInfo::builder()
.stage(vk::ShaderStageFlags::FRAGMENT)
.module(frag_shader_module_cuboid)
.name(b"main\0");
// create the binding description for the sized vertex
let binding_descriptions_cuboid = &[vertex::SizedVertex::binding_description()];
let attribute_descriptions_cuboid = vertex::SizedVertex::attribute_descriptions();
let vertex_input_state_cuboid = vk::PipelineVertexInputStateCreateInfo::builder()
.vertex_binding_descriptions(binding_descriptions_cuboid)
.vertex_attribute_descriptions(&attribute_descriptions_cuboid);
// set up shaders for quads/raytracing
// load the byte data
let vert_quad = include_bytes!("../shaders/vert_rt_quad.spv");
let frag_quad = include_bytes!("../shaders/frag_rt_quad.spv");
// create the shaders
let vert_shader_module_quad = create_shader_module(device, &vert_quad[..])?;
let frag_shader_module_quad = create_shader_module(device, &frag_quad[..])?;
//create the shader stage for the vertex shader
let vert_stage_quad = vk::PipelineShaderStageCreateInfo::builder()
.stage(vk::ShaderStageFlags::VERTEX)
.module(vert_shader_module_quad)
.name(b"main\0");
//create the shader stage for the fragment shader
let frag_stage_quad = vk::PipelineShaderStageCreateInfo::builder()
.stage(vk::ShaderStageFlags::FRAGMENT)
.module(frag_shader_module_quad)
.name(b"main\0");
// create the binding description for the quad vertex
let binding_descriptions_quad = &[vertex::RTVertex::binding_description()];
let attribute_descriptions_quad = vertex::RTVertex::attribute_descriptions();
let vertex_input_state_quad = vk::PipelineVertexInputStateCreateInfo::builder()
.vertex_binding_descriptions(binding_descriptions_quad)
.vertex_attribute_descriptions(&attribute_descriptions_quad);
// define input assembly and object type. This is altered when using geometry shader
let mut topology = vk::PrimitiveTopology::TRIANGLE_LIST;
if data.use_geometry_shader {
topology = vk::PrimitiveTopology::POINT_LIST;
@ -736,6 +766,7 @@ unsafe fn create_pipeline(device: &Device, data: &mut app_data::AppData) -> Resu
.topology(topology)
.primitive_restart_enable(false);
// define viewport and other transformations when projecting onto the screen
let viewport = vk::Viewport::builder()
.x(0.0)
.y(0.0)
@ -793,12 +824,13 @@ unsafe fn create_pipeline(device: &Device, data: &mut app_data::AppData) -> Resu
.attachments(attachments)
.blend_constants([0.0, 0.0, 0.0, 0.0]);
// define the work pipeline
let set_layouts = &[data.descriptor_set_layout];
let layout_info = vk::PipelineLayoutCreateInfo::builder()
.set_layouts(set_layouts);
data.pipeline_layout = device.create_pipeline_layout(&layout_info, None)?;
// define stages for the cubes pipeline
let stages_cube = &[vert_stage_cube, frag_stage_cube];
let stages_geom_cube = &[vert_stage_cube, geo_stage_cube,frag_stage_cube];
@ -820,7 +852,7 @@ unsafe fn create_pipeline(device: &Device, data: &mut app_data::AppData) -> Resu
else {
info_cube = info_cube.stages(stages_cube);
}
// define stages for the cuboid pipeline
let stages_cuboid = &[vert_stage_cuboid, frag_stage_cuboid];
let stages_geom_cuboid = &[vert_stage_cuboid, geo_stage_cuboid,frag_stage_cuboid];
@ -842,11 +874,30 @@ unsafe fn create_pipeline(device: &Device, data: &mut app_data::AppData) -> Resu
else {
info_cuboid = info_cuboid.stages(stages_cuboid);
}
// define stages for the quad/rt pipeline
let stages_quad = &[vert_stage_quad, frag_stage_quad];
let pipelines = device.create_graphics_pipelines(vk::PipelineCache::null(), &[info_cube, info_cuboid], None)?.0;
let mut info_quad = vk::GraphicsPipelineCreateInfo::builder()
.vertex_input_state(&vertex_input_state_quad)
.input_assembly_state(&input_assembly_state)
.viewport_state(&viewport_state)
.rasterization_state(&rasterization_state)
.multisample_state(&multisample_state)
.depth_stencil_state(&depth_stencil_state)
.color_blend_state(&color_blend_state)
.layout(data.pipeline_layout)
.render_pass(data.render_pass)
.subpass(0);
info_quad = info_quad.stages(stages_quad);
// create the pipeline
let pipelines = device.create_graphics_pipelines(vk::PipelineCache::null(), &[info_cube, info_cuboid, info_quad], None)?.0;
data.pipeline_cube = pipelines[0];
data.pipeline_cuboid = pipelines[1];
data.pipeline_quad = pipelines[2];
device.destroy_shader_module(vert_shader_module_cube, None);
device.destroy_shader_module(geo_shader_module_cube, None);
@ -856,6 +907,9 @@ unsafe fn create_pipeline(device: &Device, data: &mut app_data::AppData) -> Resu
device.destroy_shader_module(geo_shader_module_cuboid, None);
device.destroy_shader_module(frag_shader_module_cuboid, None);
device.destroy_shader_module(vert_shader_module_quad, None);
device.destroy_shader_module(frag_shader_module_quad, None);
Ok(())
}