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

Toggle msaa

Browse Source
This commit is contained in:
Till
2020-12-04 17:13:45 +01:00
parent befa69c55e
commit 33768a6730
1 changed files with 95 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
src/vulkan/mod.rs
View File

@@ -15,7 +15,7 @@ use vulkano::instance::{ApplicationInfo, Instance, InstanceExtensions, PhysicalD
use vulkano::instance::debug::{DebugCallback, MessageSeverity, MessageType};
use vulkano::pipeline::viewport::Viewport;
use vulkano::sampler::{Filter, MipmapMode, Sampler, SamplerAddressMode};
use vulkano::swapchain::{AcquireError, ColorSpace, FullscreenExclusive, PresentMode, Surface, SurfaceTransform, Swapchain, SwapchainCreationError};
use vulkano::swapchain::{AcquireError, FullscreenExclusive, PresentMode, Surface, SurfaceTransform, Swapchain, SwapchainCreationError};
use vulkano::swapchain;
use vulkano::sync::{FlushError, GpuFuture};
use vulkano::sync;
@@ -228,17 +228,18 @@ impl VulkanRenderer {
let caps = surface.capabilities(physical).unwrap();
let usage = caps.supported_usage_flags;
let alpha = caps.supported_composite_alpha.iter().next().unwrap();
let format = caps.supported_formats[0].0;
let (format, color_space) = caps.supported_formats[2];
let inner_size = window.inner_size();
data.dimensions = [inner_size.width, inner_size.height];
Swapchain::new(device.clone(), surface.clone(), caps.min_image_count, format,
data.dimensions, 1, usage, &queue, SurfaceTransform::Identity, alpha,
PresentMode::Fifo, FullscreenExclusive::Default, true, ColorSpace::SrgbNonLinear).unwrap()
PresentMode::Fifo, FullscreenExclusive::Default, true, color_space).unwrap()
};
// Render pass
let render_pass = Arc::new(vulkano::single_pass_renderpass!(
let render_pass: Arc<dyn RenderPassAbstract + Send + Sync> = if render_config.msaa_samples > 0 {
Arc::new(vulkano::single_pass_renderpass!(
device.clone(),
attachments: {
color: {
@@ -267,7 +268,32 @@ impl VulkanRenderer {
depth_stencil: {depth},
resolve: [color]
}
).unwrap());
).unwrap())
} else {
Arc::new(vulkano::single_pass_renderpass!(
device.clone(),
attachments: {
color: {
load: Clear,
store: Store,
format: swapchain.format(),
samples: 1,
},
depth: {
load: Clear,
store: Store,
format: Format::D16Unorm,
samples: 1,
initial_layout: ImageLayout::Undefined,
final_layout: ImageLayout::DepthStencilAttachmentOptimal,
}
},
pass: {
color: [color],
depth_stencil: {depth}
}
).unwrap())
};
let sampler = Sampler::new(device.clone(), Filter::Linear, Filter::Linear,
MipmapMode::Nearest, SamplerAddressMode::Repeat, SamplerAddressMode::Repeat,
@@ -284,11 +310,15 @@ impl VulkanRenderer {
// Otherwise we would have to recreate the whole pipeline.
let mut dynamic_state = DynamicState { line_width: None, viewports: None, scissors: None, compare_mask: None, write_mask: None, reference: None };
let msaa_attachments = Self::create_msaa_buffers(device.clone(), data.dimensions, &swapchain, render_config.msaa_samples);
let msaa_attachments = if render_config.msaa_samples > 0 {
Some(Self::create_msaa_buffers(device.clone(), data.dimensions, &swapchain, render_config.msaa_samples))
} else {
None
};
// 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.
let framebuffers = window_size_dependent_setup(device.clone(), &images, &msaa_attachments, render_config.msaa_samples, render_pass.clone(), &mut dynamic_state);
let framebuffers = window_size_dependent_setup(device.clone(), &images, msaa_attachments, render_config.msaa_samples, render_pass.clone(), &mut dynamic_state);
let mut uniform_buffers = Vec::new();
let uniform_buffer = vs::ty::ObjectUniformData {
@@ -330,7 +360,11 @@ impl VulkanRenderer {
// General setup
let mut builder = AutoCommandBufferBuilder::primary_simultaneous_use(self.device.clone(), self.queue.family()).unwrap();
builder.update_buffer(self.uniform_buffers[fb_index].clone(), uniform_buffer_data).unwrap();
if self.msaa_sample_count > 0 {
builder.begin_render_pass(self.framebuffers[fb_index].clone(), false, vec![ClearValue::None, ClearValue::Float([0.0, 0.0, 0.0, 1.0]), ClearValue::Depth(1.0)]).unwrap();
} else {
builder.begin_render_pass(self.framebuffers[fb_index].clone(), false, vec![ClearValue::Float([0.0, 0.0, 0.0, 1.0]), ClearValue::Depth(1.0)]).unwrap();
}
// Draw meshes etc.
for pipeline in &self.pipelines {
@@ -371,12 +405,16 @@ impl VulkanRenderer {
Err(err) => panic!("{:?}", err),
};
let msaa_buffers = Self::create_msaa_buffers(self.device.clone(), self.game_data.dimensions, &new_swapchain, self.msaa_sample_count);
let msaa_buffers = if self.msaa_sample_count > 0 {
Some(Self::create_msaa_buffers(self.device.clone(), self.game_data.dimensions, &new_swapchain, self.msaa_sample_count))
} else {
None
};
self.swapchain = new_swapchain;
// Because framebuffers contains an Arc on the old swapchain, we need to
// recreate framebuffers as well.
self.framebuffers = window_size_dependent_setup(self.device.clone(), &new_images, &msaa_buffers, self.msaa_sample_count, self.render_pass.clone(), &mut self.dynamic_state);
self.framebuffers = window_size_dependent_setup(self.device.clone(), &new_images, msaa_buffers, self.msaa_sample_count, self.render_pass.clone(), &mut self.dynamic_state);
self.recreate_swapchain = false;
}
@@ -549,7 +587,7 @@ pub fn start_event_loop(mut renderer: VulkanRenderer, mut game: Box<dyn Game>, e
}
/// This method is called once during initialization, then again whenever the window is resized
fn window_size_dependent_setup(device: Arc<Device>, images: &[Arc<SwapchainImage<Window>>], msaa_buffers: &[Arc<AttachmentImage>], msaa_sample_count: u32, render_pass: Arc<dyn RenderPassAbstract + Send + Sync>, dynamic_state: &mut DynamicState) -> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> {
fn window_size_dependent_setup(device: Arc<Device>, images: &[Arc<SwapchainImage<Window>>], msaa_buffers: Option<Vec<Arc<AttachmentImage>>>, msaa_sample_count: u32, render_pass: Arc<dyn RenderPassAbstract + Send + Sync>, dynamic_state: &mut DynamicState) -> Vec<Arc<dyn FramebufferAbstract + Send + Sync>> {
let dimensions = images[0].dimensions();
let dim_array = [dimensions.width() as f32, dimensions.height() as f32];
let dim_array_u32 = [dimensions.width() as u32, dimensions.height() as u32];
@@ -561,20 +599,32 @@ fn window_size_dependent_setup(device: Arc<Device>, images: &[Arc<SwapchainImage
};
dynamic_state.viewports = Some(vec!(viewport));
let depth_image = AttachmentImage::multisampled_with_usage(device.clone(), dim_array_u32, msaa_sample_count, Format::D16Unorm, ImageUsage { depth_stencil_attachment: true, ..ImageUsage::none() }).unwrap();
let depth_image = if let Some(msaa_buffers_exist) = &msaa_buffers {
AttachmentImage::multisampled_with_usage(device.clone(), dim_array_u32, msaa_sample_count, Format::D16Unorm, ImageUsage { depth_stencil_attachment: true, ..ImageUsage::none() }).unwrap()
} else {
AttachmentImage::with_usage(device.clone(), dim_array_u32, Format::D16Unorm, ImageUsage { depth_stencil_attachment: true, ..ImageUsage::none() }).unwrap()
};
let mut framebuffers = vec![];
for i in 0..images.len() {
let image_buffer = &images[i];
let msaa_buffer = &msaa_buffers[i];
if let Some(msaa_buffers_exist) = &msaa_buffers {
framebuffers.push(Arc::new(Framebuffer::start(render_pass.clone())
.add(image_buffer.clone()).unwrap()
.add((&msaa_buffers_exist[i]).clone()).unwrap()
.add(depth_image.clone()).unwrap()
.build().unwrap()
) as Arc<dyn FramebufferAbstract + Send + Sync>);
} else {
framebuffers.push(Arc::new(Framebuffer::start(render_pass.clone())
.add(image_buffer.clone()).unwrap()
.add(msaa_buffer.clone()).unwrap()
.add(depth_image.clone()).unwrap()
.build().unwrap()
) as Arc<dyn FramebufferAbstract + Send + Sync>);
}
}
framebuffers
}