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

update to vulkano 0.24

Browse Source
This commit is contained in:
Asuro
2021-08-01 04:16:17 +02:00
parent 02ba2bb95a
commit 0a41daf4eb
9 changed files with 118 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
Cargo.toml
View File

@@ -6,18 +6,19 @@ edition = "2018"
default-run = "rust-engine" default-run = "rust-engine"
[dependencies] [dependencies]
vulkano-shaders = "0.20" vulkano-shaders = "0.24"
vulkano = "0.20" vulkano = "0.24"
vulkano-win = "0.20" vulkano-win = "0.24"
cgmath = "0.17.0" cgmath = "0.18.0"
winit = "0.24" winit = "0.25"
image = "0.23.6" image = "0.23"
serde = "1.0.114" serde = "1.0"
serde_json = "1.0.59" serde_json = "1.0"
serde_derive = "1.0.114" serde_derive = "1.0"
toml = "0.5.6" toml = "0.5"
gilrs = "0.7.4" gilrs = "0.7"
gltf = "0.15.2" gltf = "0.15"
gfx_glyph = "0.17"
[[bin]] [[bin]]
name = "converter" name = "converter"

BIN
build/debug.rdbg
View File

Binary file not shown.

7
src/config.rs
View File

@@ -1,7 +1,8 @@
use std::fs; use std::{convert::TryInto, fs};
use serde_derive::{Deserialize, Serialize}; use serde_derive::{Deserialize, Serialize};
use toml; use toml;
use vulkano::image::SampleCount;
#[derive(Debug, Serialize, Deserialize, Clone, Copy)] #[derive(Debug, Serialize, Deserialize, Clone, Copy)]
pub struct LogConfigInput { pub struct LogConfigInput {
@@ -32,4 +33,8 @@ impl RenderConfig {
pub fn from_file(path: &str) -> Self { pub fn from_file(path: &str) -> Self {
toml::from_slice(&fs::read(path).expect("Failed to read render config!")).expect("Failed to parse render config!") toml::from_slice(&fs::read(path).expect("Failed to read render config!")).expect("Failed to parse render config!")
} }
pub fn get_msaa(&self) -> Option<SampleCount> {
self.msaa_samples.try_into().ok()
}
} }

2
src/game/mod.rs
View File

@@ -66,8 +66,6 @@ impl Game for TestGame {
if self.input.button_down("print_framerate") { if self.input.button_down("print_framerate") {
println!("{:.0} ms / {:.0} FPS", frame_time * 1000.0, 1.0 / frame_time); println!("{:.0} ms / {:.0} FPS", frame_time * 1000.0, 1.0 / frame_time);
print_quat_as_euler(self.player.camera.rotation);
println!();
} }
if self.input.button_just_pressed("test") { if self.input.button_just_pressed("test") {

1
src/game/player.rs
View File

@@ -187,6 +187,7 @@ impl Updatable for Player {
let mesh = &renderer.game_data.meshes[game_object.mesh_index]; let mesh = &renderer.game_data.meshes[game_object.mesh_index];
if let Some(dist) = intersection_distance(self.camera.position, ray_direction, mesh, game_object) { if let Some(dist) = intersection_distance(self.camera.position, ray_direction, mesh, game_object) {
game_object.is_selected = !game_object.is_selected; game_object.is_selected = !game_object.is_selected;
println!("distance: {}", dist);
} }
} }
} }

29
src/vulkan/framebuffers.rs
View File

@@ -3,9 +3,10 @@ use std::sync::Arc;
use vulkano::command_buffer::DynamicState; use vulkano::command_buffer::DynamicState;
use vulkano::device::Device; use vulkano::device::Device;
use vulkano::format::Format; use vulkano::format::Format;
use vulkano::framebuffer::{Framebuffer, FramebufferAbstract, RenderPassAbstract}; use vulkano::image::view::ImageView;
use vulkano::image::{AttachmentImage, ImageUsage, SwapchainImage}; use vulkano::image::{AttachmentImage, ImageUsage, SampleCount, SwapchainImage};
use vulkano::pipeline::viewport::Viewport; use vulkano::pipeline::viewport::Viewport;
use vulkano::render_pass::{Framebuffer, FramebufferAbstract, RenderPass};
use winit::window::Window; use winit::window::Window;
use vulkano::swapchain::Swapchain; use vulkano::swapchain::Swapchain;
@@ -13,8 +14,8 @@ use vulkano::swapchain::Swapchain;
pub fn create_framebuffers(device: Arc<Device>, pub fn create_framebuffers(device: Arc<Device>,
swapchain: &Arc<Swapchain<Window>>, swapchain: &Arc<Swapchain<Window>>,
images: &[Arc<SwapchainImage<Window>>], images: &[Arc<SwapchainImage<Window>>],
msaa_sample_count: u32, msaa_samples: Option<SampleCount>,
render_pass: Arc<dyn RenderPassAbstract + Send + Sync>, render_pass: Arc<RenderPass>,
dynamic_state: &mut DynamicState) dynamic_state: &mut DynamicState)
-> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> { -> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> {
@@ -28,13 +29,13 @@ pub fn create_framebuffers(device: Arc<Device>,
}; };
dynamic_state.viewports = Some(vec!(viewport)); dynamic_state.viewports = Some(vec!(viewport));
let depth_image = if msaa_sample_count > 0 { let depth_image = if let Some(msaa_sample_count) = msaa_samples {
AttachmentImage::multisampled_with_usage(device.clone(), dim_array, msaa_sample_count, Format::D16Unorm, ImageUsage { depth_stencil_attachment: true, ..ImageUsage::none() }).unwrap() AttachmentImage::multisampled_with_usage(device.clone(), dim_array, msaa_sample_count, Format::D16Unorm, ImageUsage { depth_stencil_attachment: true, ..ImageUsage::none() }).unwrap()
} else { } else {
AttachmentImage::with_usage(device.clone(), dim_array, Format::D16Unorm, ImageUsage { depth_stencil_attachment: true, ..ImageUsage::none() }).unwrap() AttachmentImage::with_usage(device.clone(), dim_array, Format::D16Unorm, ImageUsage { depth_stencil_attachment: true, ..ImageUsage::none() }).unwrap()
}; };
let msaa_buffers = if msaa_sample_count > 0 { let msaa_buffers = if let Some(msaa_sample_count) = msaa_samples {
Some(create_msaa_buffers(device.clone(), dim_array, swapchain, msaa_sample_count)) Some(create_msaa_buffers(device.clone(), dim_array, swapchain, msaa_sample_count))
} else { } else {
None None
@@ -44,18 +45,22 @@ pub fn create_framebuffers(device: Arc<Device>,
for i in 0..images.len() { for i in 0..images.len() {
let image_buffer = &images[i]; let image_buffer = &images[i];
let image_view = ImageView::new(image_buffer.clone()).unwrap();
let depth_view = ImageView::new(depth_image.clone()).unwrap();
if let Some(msaa_buffers_exist) = &msaa_buffers { if let Some(msaa_buffers_exist) = &msaa_buffers {
let msaa_view = ImageView::new((&msaa_buffers_exist[i]).clone()).unwrap();
framebuffers.push(Arc::new(Framebuffer::start(render_pass.clone()) framebuffers.push(Arc::new(Framebuffer::start(render_pass.clone())
.add(image_buffer.clone()).unwrap() .add(image_view).unwrap()
.add((&msaa_buffers_exist[i]).clone()).unwrap() .add(msaa_view).unwrap()
.add(depth_image.clone()).unwrap() .add(depth_view).unwrap()
.build().unwrap() .build().unwrap()
) as Arc<dyn FramebufferAbstract + Send + Sync>); ) as Arc<dyn FramebufferAbstract + Send + Sync>);
} else { } else {
framebuffers.push(Arc::new(Framebuffer::start(render_pass.clone()) framebuffers.push(Arc::new(Framebuffer::start(render_pass.clone())
.add(image_buffer.clone()).unwrap() .add(image_view).unwrap()
.add(depth_image.clone()).unwrap() .add(depth_view).unwrap()
.build().unwrap() .build().unwrap()
) as Arc<dyn FramebufferAbstract + Send + Sync>); ) as Arc<dyn FramebufferAbstract + Send + Sync>);
} }
@@ -64,7 +69,7 @@ pub fn create_framebuffers(device: Arc<Device>,
framebuffers framebuffers
} }
fn create_msaa_buffers(device: Arc<Device>, dimensions: [u32; 2], swapchain: &Arc<Swapchain<Window>>, sample_count: u32) -> Vec<Arc<AttachmentImage>> { fn create_msaa_buffers(device: Arc<Device>, dimensions: [u32; 2], swapchain: &Arc<Swapchain<Window>>, sample_count: SampleCount) -> Vec<Arc<AttachmentImage>> {
let mut msaa_attachments = vec![]; let mut msaa_attachments = vec![];
for _ in 0..swapchain.num_images() { for _ in 0..swapchain.num_images() {
msaa_attachments.push(AttachmentImage::transient_multisampled(device.clone(), dimensions, sample_count, swapchain.format()).unwrap()); msaa_attachments.push(AttachmentImage::transient_multisampled(device.clone(), dimensions, sample_count, swapchain.format()).unwrap());

85
src/vulkan/mod.rs
View File

@@ -1,16 +1,16 @@
use std::sync::Arc; use std::{sync::Arc};
use std::time::SystemTime; use std::time::SystemTime;
use cgmath::{Matrix4, SquareMatrix}; use cgmath::{Matrix4, SquareMatrix};
use dds::get_block_size; use dds::get_block_size;
use vulkano::{buffer::{BufferUsage, CpuAccessibleBuffer}, command_buffer::{CommandBuffer, SubpassContents}, image::{ImageLayout, ImageUsage, MipmapsCount, immutable::SubImage}}; use vulkano::command_buffer::CommandBufferUsage::{MultipleSubmit, SimultaneousUse};
use vulkano::command_buffer::{AutoCommandBuffer, AutoCommandBufferBuilder, DynamicState}; use vulkano::{buffer::{BufferUsage, CpuAccessibleBuffer}, command_buffer::{PrimaryAutoCommandBuffer, SubpassContents}, image::{ImageDimensions, ImageLayout, ImageUsage, MipmapsCount, immutable::SubImage}, render_pass::{FramebufferAbstract, RenderPass}};
use vulkano::command_buffer::{AutoCommandBufferBuilder, PrimaryCommandBuffer, DynamicState};
use vulkano::descriptor::DescriptorSet; use vulkano::descriptor::DescriptorSet;
use vulkano::device::{Device, DeviceExtensions, Queue}; use vulkano::device::{Device, Features, Queue};
use vulkano::format::{ClearValue, Format}; use vulkano::format::{ClearValue, Format};
use vulkano::framebuffer::{RenderPassAbstract, FramebufferAbstract}; use vulkano::image::{ImageCreateFlags, ImmutableImage};
use vulkano::image::{Dimensions, ImmutableImage}; use vulkano::instance::{ApplicationInfo, Instance, PhysicalDevice, Version};
use vulkano::instance::{ApplicationInfo, Instance, InstanceExtensions, PhysicalDevice, Version};
use vulkano::instance::debug::{DebugCallback, MessageSeverity, MessageType}; use vulkano::instance::debug::{DebugCallback, MessageSeverity, MessageType};
use vulkano::sampler::{Filter, MipmapMode, Sampler, SamplerAddressMode}; use vulkano::sampler::{Filter, MipmapMode, Sampler, SamplerAddressMode};
use vulkano::swapchain::{AcquireError, FullscreenExclusive, PresentMode, Surface, SurfaceTransform, Swapchain, SwapchainCreationError}; use vulkano::swapchain::{AcquireError, FullscreenExclusive, PresentMode, Surface, SurfaceTransform, Swapchain, SwapchainCreationError};
@@ -28,7 +28,7 @@ use pipelines::line_vs::ty::LinePushConstants;
use pipelines::DefaultShader; use pipelines::DefaultShader;
use pipelines::vs; use pipelines::vs;
use crate::config::RenderConfig; use crate::{config::RenderConfig};
use crate::vulkan::gameobject::{GameObject, GameObjectHandle}; use crate::vulkan::gameobject::{GameObject, GameObjectHandle};
pub mod pipelines; pub mod pipelines;
@@ -82,7 +82,7 @@ pub struct MeshHandle {
pub(crate) type TextureHandle = usize; pub(crate) type TextureHandle = usize;
pub struct Texture { pub struct Texture {
pub image: Arc<ImmutableImage<Format>>, pub image: Arc<ImmutableImage>,
pub sampler: Arc<Sampler> pub sampler: Arc<Sampler>
} }
@@ -109,7 +109,7 @@ pub struct VulkanRenderer {
pub pipelines: Vec<Box<dyn Drawcall>>, pub pipelines: Vec<Box<dyn Drawcall>>,
pub surface: Arc<Surface<Window>>, pub surface: Arc<Surface<Window>>,
pub swapchain: Arc<Swapchain<Window>>, pub swapchain: Arc<Swapchain<Window>>,
pub render_pass: Arc<dyn RenderPassAbstract + Send + Sync>, pub render_pass: Arc<RenderPass>,
pub queue: Arc<Queue>, pub queue: Arc<Queue>,
pub recreate_swapchain: bool, pub recreate_swapchain: bool,
pub debug_callback: Option<DebugCallback>, pub debug_callback: Option<DebugCallback>,
@@ -141,7 +141,7 @@ impl VulkanRenderer {
// Create basic vulkan instance with layers and info // Create basic vulkan instance with layers and info
let instance = { let instance = {
let extensions = InstanceExtensions { let extensions = vulkano::instance::InstanceExtensions {
ext_debug_utils: true, ext_debug_utils: true,
..vulkano_win::required_extensions() ..vulkano_win::required_extensions()
}; };
@@ -164,9 +164,9 @@ impl VulkanRenderer {
} }
}); });
Instance::new(Some(&app_info), &extensions, VALIDATION_LAYERS.iter().cloned()).expect("failed to create Vulkan instance") Instance::new(Some(&app_info), Version::V1_2, &extensions, VALIDATION_LAYERS.iter().cloned()).expect("failed to create Vulkan instance")
} else { } else {
Instance::new(Some(&app_info), &extensions, None).expect("failed to create Vulkan instance") Instance::new(Some(&app_info), Version::V1_2, &extensions, None).expect("failed to create Vulkan instance")
} }
}; };
@@ -198,14 +198,12 @@ impl VulkanRenderer {
let layer_str = msg.layer_prefix; let layer_str = msg.layer_prefix;
println!("[{}][{}]: {}", type_str, layer_str, msg.description); println!("[{}][{:?}]: {}", type_str, layer_str, msg.description);
}).ok(); }).ok();
} }
// TODO: Just get the first physical device we find, it's fiiiine... // TODO: Just get the first physical device we find, it's fiiiine...
let physical = PhysicalDevice::enumerate(&instance).next().unwrap(); let physical = PhysicalDevice::enumerate(&instance).next().unwrap();
println!("Using device: {} (type: {:?})", physical.name(), physical.ty());
let events_loop = EventLoop::new(); let events_loop = EventLoop::new();
let surface = WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap(); let surface = WindowBuilder::new().build_vk_surface(&events_loop, instance.clone()).unwrap();
let window = surface.window(); let window = surface.window();
@@ -218,8 +216,8 @@ impl VulkanRenderer {
}).unwrap(); }).unwrap();
// Queue // Queue
let device_ext = DeviceExtensions { khr_swapchain: true, ..DeviceExtensions::none() }; let device_ext = vulkano::device::DeviceExtensions { khr_swapchain: true, ..vulkano::device::DeviceExtensions::none() };
let (device, mut queues) = Device::new(physical, physical.supported_features(), &device_ext, let (device, mut queues) = Device::new(physical, &Features::none(), &device_ext,
[(queue_family, 0.5)].iter().cloned()).unwrap(); [(queue_family, 0.5)].iter().cloned()).unwrap();
let queue = queues.next().unwrap(); let queue = queues.next().unwrap();
@@ -232,9 +230,19 @@ impl VulkanRenderer {
let inner_size = window.inner_size(); let inner_size = window.inner_size();
data.dimensions = [inner_size.width, inner_size.height]; data.dimensions = [inner_size.width, inner_size.height];
Swapchain::new(device.clone(), surface.clone(), caps.min_image_count, format, Swapchain::start(device.clone(), surface.clone())
data.dimensions, 1, usage, &queue, SurfaceTransform::Identity, alpha, .num_images(caps.min_image_count)
PresentMode::Fifo, FullscreenExclusive::Default, true, color_space).unwrap() .format(format)
.dimensions(data.dimensions)
.usage(usage)
.sharing_mode(&queue)
.transform(SurfaceTransform::Identity)
.composite_alpha(alpha)
.present_mode(PresentMode::Fifo)
.fullscreen_exclusive(FullscreenExclusive::Default)
.clipped(true)
.color_space(color_space)
.build().unwrap()
}; };
// Render pass // Render pass
@@ -255,7 +263,7 @@ impl VulkanRenderer {
// The render pass we created above only describes the layout of our framebuffers. Before we // The render pass we created above only describes the layout of our framebuffers. Before we
// can draw we also need to create the actual framebuffers. // can draw we also need to create the actual framebuffers.
let framebuffers = framebuffers::create_framebuffers(device.clone(), &swapchain, &images, render_config.msaa_samples, render_pass.clone(), &mut dynamic_state); let framebuffers = framebuffers::create_framebuffers(device.clone(), &swapchain, &images, render_config.get_msaa(), render_pass.clone(), &mut dynamic_state);
let mut uniform_buffers = Vec::new(); let mut uniform_buffers = Vec::new();
let uniform_buffer = vs::ty::ObjectUniformData { let uniform_buffer = vs::ty::ObjectUniformData {
@@ -296,10 +304,10 @@ impl VulkanRenderer {
}, events_loop) }, events_loop)
} }
fn create_command_buffer(self: &mut Self, fb_index: usize, uniform_buffer_data: vs::ty::ObjectUniformData) -> Arc<AutoCommandBuffer> { fn create_command_buffer(self: &mut Self, fb_index: usize, uniform_buffer_data: vs::ty::ObjectUniformData) -> Arc<PrimaryAutoCommandBuffer> {
// General setup // General setup
let mut builder = AutoCommandBufferBuilder::primary_simultaneous_use(self.device.clone(), self.queue.family()).unwrap(); let mut builder = AutoCommandBufferBuilder::primary(self.device.clone(), self.queue.family(), SimultaneousUse).unwrap();
builder.update_buffer(self.uniform_buffers[fb_index].clone(), uniform_buffer_data).unwrap(); builder.update_buffer(self.uniform_buffers[fb_index].clone(), Arc::new(uniform_buffer_data)).unwrap();
if self.render_config.msaa_samples > 0 { if self.render_config.msaa_samples > 0 {
builder.begin_render_pass(self.framebuffers[fb_index].clone(), SubpassContents::Inline, vec![ClearValue::None, ClearValue::Float([0.0, 0.0, 0.0, 1.0]), ClearValue::Depth(1.0)]).unwrap(); builder.begin_render_pass(self.framebuffers[fb_index].clone(), SubpassContents::Inline, vec![ClearValue::None, ClearValue::Float([0.0, 0.0, 0.0, 1.0]), ClearValue::Depth(1.0)]).unwrap();
} else { } else {
@@ -328,7 +336,7 @@ impl VulkanRenderer {
let inner_size = window.inner_size(); let inner_size = window.inner_size();
self.game_data.dimensions = [inner_size.width, inner_size.height]; self.game_data.dimensions = [inner_size.width, inner_size.height];
let (new_swapchain, new_images) = match self.swapchain.recreate_with_dimensions(self.game_data.dimensions) { let (new_swapchain, new_images) = match self.swapchain.recreate().dimensions(self.game_data.dimensions).build() {
Ok(r) => r, Ok(r) => r,
// This error tends to happen when the user is manually resizing the window. // This error tends to happen when the user is manually resizing the window.
// Simply restarting the loop is the easiest way to fix this issue. // Simply restarting the loop is the easiest way to fix this issue.
@@ -349,7 +357,7 @@ impl VulkanRenderer {
self.swapchain = new_swapchain; self.swapchain = new_swapchain;
// Because framebuffers contains an Arc on the old swapchain, we need to // Because framebuffers contains an Arc on the old swapchain, we need to
// recreate framebuffers as well. // recreate framebuffers as well.
self.framebuffers = framebuffers::create_framebuffers(self.device.clone(), &self.swapchain, &new_images, self.render_config.msaa_samples, self.render_pass.clone(), &mut self.dynamic_state); self.framebuffers = framebuffers::create_framebuffers(self.device.clone(), &self.swapchain, &new_images, self.render_config.get_msaa(), self.render_pass.clone(), &mut self.dynamic_state);
self.recreate_swapchain = false; self.recreate_swapchain = false;
} }
@@ -428,7 +436,7 @@ impl VulkanRenderer {
} }
pub fn upload_texture(self: &mut Self, bytes: &[u8], width: u32, height: u32, format: Format, device: Arc<Device>) { pub fn upload_texture(self: &mut Self, bytes: &[u8], width: u32, height: u32, format: Format, device: Arc<Device>) {
let dimensions = Dimensions::Dim2d { width, height }; let dimensions = ImageDimensions::Dim2d { width, height, array_layers: 1 };
let usage = ImageUsage { let usage = ImageUsage {
transfer_destination: true, transfer_destination: true,
@@ -439,12 +447,13 @@ impl VulkanRenderer {
let layout = ImageLayout::ShaderReadOnlyOptimal; let layout = ImageLayout::ShaderReadOnlyOptimal;
let (image_view, initializer) = ImmutableImage::uninitialized( let (immutable_image, initializer) = ImmutableImage::uninitialized(
device.clone(), device.clone(),
dimensions, dimensions,
format, format,
MipmapsCount::Log2, MipmapsCount::Log2,
usage, usage,
ImageCreateFlags::default(),
layout, layout,
device.active_queue_families(), device.active_queue_families(),
).unwrap(); ).unwrap();
@@ -452,20 +461,21 @@ impl VulkanRenderer {
let init = SubImage::new( let init = SubImage::new(
Arc::new(initializer), Arc::new(initializer),
0, 0,
image_view.mipmap_levels(), immutable_image.mipmap_levels(),
0, 0,
1, 1,
ImageLayout::ShaderReadOnlyOptimal, ImageLayout::ShaderReadOnlyOptimal,
); );
let mut cbb = AutoCommandBufferBuilder::new(device.clone(), self.queue.family()).unwrap(); // TODO: do we need multiple submit?
let mut cbb = AutoCommandBufferBuilder::primary(device.clone(), self.queue.family(), MultipleSubmit).unwrap();
let mut offset = 0; let mut offset = 0;
let block_bytes = get_block_size(format).expect(&format!("Unknown texture format {:?}!", format)); let block_bytes = get_block_size(format).expect(&format!("Unknown texture format {:?}!", format));
for i in 0..image_view.mipmap_levels() { for i in 0..immutable_image.mipmap_levels() {
let mip_size = dimensions.to_image_dimensions().mipmap_dimensions(i).unwrap().width_height_depth(); let mip_size = dimensions.mipmap_dimensions(i).unwrap().width_height_depth();
let mip_byte_size = ( let mip_byte_size = (
(u32::max(4, mip_size[0]) / 4) (u32::max(4, mip_size[0]) / 4)
@@ -485,10 +495,9 @@ impl VulkanRenderer {
[0, 0, 0], [0, 0, 0],
mip_size, mip_size,
0, 0,
dimensions.array_layers_with_cube(), dimensions.array_layers(),
i, i,
) ).unwrap();
.unwrap();
offset += mip_byte_size; offset += mip_byte_size;
} }
@@ -504,9 +513,9 @@ impl VulkanRenderer {
let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear, let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
MipmapMode::Linear, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat, MipmapMode::Linear, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, (image_view.mipmap_levels() - 1) as f32).unwrap(); SamplerAddressMode::Repeat, 0.0, 1.0, 0.0, (immutable_image.mipmap_levels() - 1) as f32).unwrap();
self.game_data.textures.push(Texture { image: image_view, sampler }); self.game_data.textures.push(Texture { image: immutable_image, sampler });
} }
pub fn add_game_object(self: &mut Self, mut game_object: GameObject, pipeline_index: usize) -> GameObjectHandle { pub fn add_game_object(self: &mut Self, mut game_object: GameObject, pipeline_index: usize) -> GameObjectHandle {

63
src/vulkan/pipelines.rs
View File

@@ -1,24 +1,21 @@
use std::{convert::TryInto, io::{self, ErrorKind, Read, Write}, path::PathBuf, sync::Arc}; use std::{convert::TryInto, io::{self, ErrorKind, Read, Write}, path::PathBuf, sync::Arc};
use vulkano::{command_buffer::AutoCommandBufferBuilder, descriptor::{descriptor::ShaderStages, descriptor_set::PersistentDescriptorSet}, pipeline::shader::ShaderModule}; use vulkano::{command_buffer::{AutoCommandBufferBuilder, PrimaryAutoCommandBuffer}, descriptor::{descriptor_set::PersistentDescriptorSet}, image::view::ImageView, pipeline::{shader::{ShaderModule}}, render_pass::{RenderPass, Subpass}};
use vulkano::command_buffer::DynamicState; use vulkano::command_buffer::DynamicState;
use vulkano::device::Device; use vulkano::device::Device;
use vulkano::framebuffer::RenderPassAbstract;
use vulkano::framebuffer::Subpass;
use vulkano::pipeline::GraphicsPipeline; use vulkano::pipeline::GraphicsPipeline;
use vulkano::pipeline::GraphicsPipelineAbstract; use vulkano::pipeline::GraphicsPipelineAbstract;
use vulkano::pipeline::shader::GraphicsShaderType;
use crate::GameObject; use crate::GameObject;
use crate::vulkan::{LinePoint, Vertex}; use crate::vulkan::{LinePoint, Vertex};
use crate::vulkan::GameData; use crate::vulkan::GameData;
use crate::VulkanRenderer; use crate::VulkanRenderer;
type RP = Arc<dyn RenderPassAbstract + Send + Sync>; type RP = Arc<RenderPass>;
type GP = Arc<dyn GraphicsPipelineAbstract + Send + Sync>; type GP = Arc<dyn GraphicsPipelineAbstract + Send + Sync>;
pub trait Drawcall { pub trait Drawcall {
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder, fb_index: usize, game_data: &GameData, dynamic_state: &DynamicState); fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>, fb_index: usize, game_data: &GameData, dynamic_state: &DynamicState);
fn create_descriptor_set(self: &Self, game_object: &mut GameObject, renderer: &VulkanRenderer); fn create_descriptor_set(self: &Self, game_object: &mut GameObject, renderer: &VulkanRenderer);
fn recreate_pipeline(self: &mut Self, device: Arc<Device>, render_pass: RP); fn recreate_pipeline(self: &mut Self, device: Arc<Device>, render_pass: RP);
fn get_pipeline(self: &Self) -> &GP; fn get_pipeline(self: &Self) -> &GP;
@@ -101,42 +98,42 @@ impl DefaultShader {
compile_shaders().unwrap(); compile_shaders().unwrap();
} }
unsafe { // 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"); // static ENTRY_NAME: [u8; 5usize] = [109u8, 97u8, 105u8, 110u8, 0];
let fs_layout = fs::Layout(ShaderStages { // let entry_name_c = std::ffi::CStr::from_ptr(ENTRY_NAME.as_ptr() as *const _);
fragment: true,
..ShaderStages::none()
});
let fs_entry = fs_module.graphics_entry_point(entry_name_c, fs::MainInput, fs::MainOutput, fs_layout, GraphicsShaderType::Fragment);
let vs_module = shader_module_from_file(device.clone(), "shaders/triangle.vert.spv"); // let fs_module = shader_module_from_file(device.clone(), "shaders/triangle.frag.spv");
let vs_layout = vs::Layout(ShaderStages { // let fs_entry = fs_module.graphics_entry_point(entry_name_c, yeet, &[], ref_shader.main_entry_point().input().clone(), ref_shader.main_entry_point().output().clone(), GraphicsShaderType::Fragment);
vertex: true,
..ShaderStages::none() // let vs_module = shader_module_from_file(device.clone(), "shaders/triangle.vert.spv");
}); // let vs_layout = vs::Layout(ShaderStages {
let vs_entry = vs_module.graphics_entry_point(entry_name_c, vs::MainInput, vs::MainOutput, vs_layout, GraphicsShaderType::Vertex); // vertex: true,
// ..ShaderStages::none()
// });
// let vs_entry = vs_module.graphics_entry_point(entry_name_c, vs_layout, &[], vs::MainInput, vs::MainOutput, GraphicsShaderType::Vertex);
let fs = fs::Shader::load(device.clone()).unwrap();
let vs = vs::Shader::load(device.clone()).unwrap();
Arc::new(GraphicsPipeline::start() Arc::new(GraphicsPipeline::start()
.vertex_input_single_buffer::<Vertex>() .vertex_input_single_buffer::<Vertex>()
.vertex_shader(vs_entry, ()) .vertex_shader(vs.main_entry_point(), ())
.triangle_list() .triangle_list()
.viewports_dynamic_scissors_irrelevant(1) .viewports_dynamic_scissors_irrelevant(1)
.depth_stencil_simple_depth() .depth_stencil_simple_depth()
.fragment_shader(fs_entry, ()) .fragment_shader(fs.main_entry_point(), ())
.blend_alpha_blending() .blend_alpha_blending()
.cull_mode_back() .cull_mode_back()
.render_pass(sub_pass.clone()) .render_pass(sub_pass.clone())
.build(device.clone()) .build(device.clone())
.unwrap()) .unwrap())
} // }
} }
} }
impl Drawcall for DefaultShader { impl Drawcall for DefaultShader {
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder, fb_index: usize, game_data: &GameData, dynamic_state: &DynamicState) { fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>, fb_index: usize, game_data: &GameData, dynamic_state: &DynamicState) {
for i in 0..game_data.game_objects.len() { for i in 0..game_data.game_objects.len() {
let game_object = &game_data.game_objects[i]; let game_object = &game_data.game_objects[i];
let mesh = &game_data.meshes[game_object.mesh_index]; let mesh = &game_data.meshes[game_object.mesh_index];
@@ -148,12 +145,13 @@ impl Drawcall for DefaultShader {
vec![mesh.vertex_buffer.clone()], vec![mesh.vertex_buffer.clone()],
mesh.index_buffer.clone(), mesh.index_buffer.clone(),
game_object.descriptor_sets[fb_index].clone(), game_object.descriptor_sets[fb_index].clone(),
push_constants).unwrap(); push_constants,
vec![]).unwrap();
} }
} }
fn create_descriptor_set(self: &Self, game_object: &mut GameObject, renderer: &VulkanRenderer) { fn create_descriptor_set(self: &Self, game_object: &mut GameObject, renderer: &VulkanRenderer) {
let descriptor_set_layout = self.get_pipeline().descriptor_set_layout(0).unwrap().clone(); let descriptor_set_layout = self.get_pipeline().layout().descriptor_set_layout(0).unwrap().clone();
println!("Diff: {:?}, Norm: {:?}", game_object.texture_index, game_object.normal_map_index); println!("Diff: {:?}, Norm: {:?}", game_object.texture_index, game_object.normal_map_index);
@@ -162,12 +160,14 @@ impl Drawcall for DefaultShader {
let builder = PersistentDescriptorSet::start(descriptor_set_layout.clone()); let builder = PersistentDescriptorSet::start(descriptor_set_layout.clone());
let diffuse = &renderer.game_data.textures[game_object.texture_index]; let diffuse = &renderer.game_data.textures[game_object.texture_index];
let diffuse_view = ImageView::new(diffuse.image.clone()).unwrap();
let normal_map = &renderer.game_data.textures[game_object.normal_map_index]; let normal_map = &renderer.game_data.textures[game_object.normal_map_index];
let normal_view = ImageView::new(normal_map.image.clone()).unwrap();
descriptor_set = Arc::new(builder descriptor_set = Arc::new(builder
.add_buffer(uniform_buffer.clone()).unwrap() .add_buffer(uniform_buffer.clone()).unwrap()
.add_sampled_image(diffuse.image.clone(), diffuse.sampler.clone()).unwrap() .add_sampled_image(diffuse_view, diffuse.sampler.clone()).unwrap()
.add_sampled_image(normal_map.image.clone(), normal_map.sampler.clone()).unwrap() .add_sampled_image(normal_view, normal_map.sampler.clone()).unwrap()
.build().unwrap()); .build().unwrap());
descriptor_set descriptor_set
@@ -230,12 +230,13 @@ impl LineShader {
} }
impl Drawcall for LineShader { impl Drawcall for LineShader {
fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder, _fb_index: usize, game_data: &GameData, dynamic_state: &DynamicState) { fn draw(self: &Self, builder: &mut AutoCommandBufferBuilder<PrimaryAutoCommandBuffer>, _fb_index: usize, game_data: &GameData, dynamic_state: &DynamicState) {
builder.draw(self.pipeline.clone(), builder.draw(self.pipeline.clone(),
&dynamic_state, &dynamic_state,
vec![self.vertex_buffer.clone()], vec![self.vertex_buffer.clone()],
(), (),
game_data.line_push_constants.clone()).unwrap(); game_data.line_push_constants.clone(),
vec![]).unwrap();
} }
fn create_descriptor_set(self: &Self, _game_object: &mut GameObject, _renderer: &VulkanRenderer) { fn create_descriptor_set(self: &Self, _game_object: &mut GameObject, _renderer: &VulkanRenderer) {

4
src/vulkan/renderpass.rs
View File

@@ -1,10 +1,10 @@
use crate::RenderConfig; use crate::RenderConfig;
use std::sync::Arc; use std::sync::Arc;
use vulkano::framebuffer::RenderPassAbstract;
use vulkano::format::Format; use vulkano::format::Format;
use vulkano::device::Device; use vulkano::device::Device;
use vulkano::render_pass::RenderPass;
pub fn create_render_pass(device: Arc<Device>, render_config: &RenderConfig, swapchain_format: Format) -> Arc<dyn RenderPassAbstract + Send + Sync> { pub fn create_render_pass(device: Arc<Device>, render_config: &RenderConfig, swapchain_format: Format) -> Arc<RenderPass> {
if render_config.msaa_samples > 0 { if render_config.msaa_samples > 0 {
Arc::new(vulkano::single_pass_renderpass!( Arc::new(vulkano::single_pass_renderpass!(
device.clone(), device.clone(),