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

back in the saddle, upgrading dependencies

Browse Source
This commit is contained in:
mitchellhansen
2020-07-26 00:47:24 -07:00
parent 626eac4e86
commit ea52a20fce
10 changed files with 317 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/canvas/canvas_state.rs
View File

@@ -15,7 +15,6 @@ use std::path::PathBuf;
use image::GenericImageView;
use std::iter::FromIterator;
use vulkano::swapchain::Capabilities;
use winit::Window;
use vulkano::pipeline::viewport::Viewport;
use vulkano::descriptor::descriptor::DescriptorDescTy::TexelBuffer;
use crate::canvas::canvas_frame::CanvasFrame;
@@ -35,6 +34,7 @@ use crate::canvas::managed::shader::generic_shader::GenericShader;
use crate::VertexTypes;
use crate::util::vertex::{TextVertex3D, TextureVertex3D, ImageVertex3D, ColorVertex3D, CanvasFrameAllocation};
use shade_runner::Input;
use winit::window::Window;
/// Canvas state is used for storage of texture and image buffers in addition to vertex buffers
@@ -380,7 +380,7 @@ impl CanvasState {
fn get_solid_color_descriptor_set(&self, kernel: Arc<GenericShader>) -> Box<dyn DescriptorSet + Send + Sync> {
let o: Box<dyn DescriptorSet + Send + Sync> = Box::new(
PersistentDescriptorSet::start(
kernel.clone().get_pipeline().clone(), 0,
kernel.clone().get_pipeline().clone().descriptor_set_layout(0).unwrap().clone(),
).build().unwrap());
o
}
@@ -458,10 +458,10 @@ impl CanvasState {
/// Pushes the draw commands to the command buffer. Requires the framebuffers and
/// image number to be passed in as they are taken care of by the vkprocessor
pub fn draw_commands(&mut self,
mut command_buffer: AutoCommandBufferBuilder,
mut command_buffer: &mut AutoCommandBufferBuilder,
framebuffers: Vec<Arc<dyn FramebufferAbstract + Send + Sync>>,
image_num: usize,
allocated_buffers: CanvasFrameAllocation) -> AutoCommandBufferBuilder {
allocated_buffers: CanvasFrameAllocation) {
// Specify the color to clear the framebuffer with i.e. blue
let clear_values = vec!(
@@ -478,7 +478,7 @@ impl CanvasState {
reference: None,
};
let mut command_buffer = command_buffer.begin_render_pass(
command_buffer = command_buffer.begin_render_pass(
framebuffers[image_num].clone(), false, clear_values.clone(),
).unwrap();
@@ -547,10 +547,10 @@ impl CanvasState {
// Text
let mut shader = self.shader_buffers.get(
self.get_shader_handle(String::from("simple_text"))
.unwrap().clone().get_handle() as usize
).unwrap();
// let mut shader = self.shader_buffers.get(
// self.get_shader_handle(String::from("simple_text"))
// .unwrap().clone().get_handle() as usize
// ).unwrap();
//
// self.dynamic_state = DynamicState {
// line_width: None,
@@ -597,18 +597,18 @@ impl CanvasState {
// }),
// };
if !allocated_buffers.text_vertex_buffer.is_empty() {
command_buffer = command_buffer.draw(
shader.get_pipeline().clone(),
&self.dynamic_state.clone(),
allocated_buffers.text_vertex_buffer.clone(),
(), (),
).unwrap();
}
// if !allocated_buffers.text_vertex_buffer.is_empty() {
// command_buffer = command_buffer.draw(
// shader.get_pipeline().clone(),
// &self.dynamic_state.clone(),
// allocated_buffers.text_vertex_buffer.clone(),
// (), (),
// ).unwrap();
// }
command_buffer
.end_render_pass()
.unwrap()
.unwrap();
}
}

11
src/canvas/managed/gpu_buffers.rs
View File

@@ -2,7 +2,7 @@ use vulkano::image::{ImmutableImage, AttachmentImage};
use std::sync::Arc;
use vulkano::format::{Format, R8Unorm};
use vulkano::sampler::Sampler;
use vulkano::descriptor::DescriptorSet;
use vulkano::descriptor::{DescriptorSet, PipelineLayoutAbstract};
use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
use vulkano::buffer::{CpuAccessibleBuffer, BufferAccess};
use vulkano::pipeline::GraphicsPipelineAbstract;
@@ -25,7 +25,7 @@ impl CanvasTexture {
sampler: Arc<Sampler>) -> Box<dyn DescriptorSet + Send + Sync> {
let o: Box<dyn DescriptorSet + Send + Sync> = Box::new(
PersistentDescriptorSet::start(
pipeline.clone(), 0,
pipeline.clone().descriptor_set_layout(0).unwrap().clone(),
)
.add_sampled_image(self.buffer.clone(), sampler.clone()).unwrap()
.build().unwrap());
@@ -46,7 +46,7 @@ impl CanvasImage {
-> Box<dyn DescriptorSet + Send + Sync> {
let o: Box<dyn DescriptorSet + Send + Sync> = Box::new(
PersistentDescriptorSet::start(
pipeline.clone(), 0,
pipeline.clone().descriptor_set_layout(0).unwrap().clone()
)
.add_image(self.buffer.clone()).unwrap()
.build().unwrap());
@@ -65,12 +65,13 @@ pub struct CanvasFont {
}
impl CanvasFont {
pub fn get_descriptor_set(pipeline: Arc<dyn GraphicsPipelineAbstract + Sync + Send>)
pub fn get_descriptor_set(&self, pipeline: Arc<dyn GraphicsPipelineAbstract + Sync + Send>)
-> Box<dyn DescriptorSet + Send + Sync> {
let o: Box<dyn DescriptorSet + Send + Sync> = Box::new(
PersistentDescriptorSet::start(
pipeline.clone(), 0,
pipeline.clone().descriptor_set_layout(0).unwrap().clone()
)
.add_buffer(self.buffer.clone()).unwrap()
.build().unwrap());
o
}

6
src/compute/compu_state.rs
View File

@@ -93,9 +93,8 @@ impl CompuState {
pub fn compute_commands(&mut self,
compute_frame: CompuFrame,
mut command_buffer: AutoCommandBufferBuilder,
canvas: &CanvasState)
-> AutoCommandBufferBuilder {
mut command_buffer: &mut AutoCommandBufferBuilder,
canvas: &CanvasState) {
// i = (Buffer, Kernel)
for i in compute_frame.pure_compute {
@@ -167,7 +166,6 @@ impl CompuState {
output_buffer.get_input_buffer()).unwrap();
}
command_buffer
}
}

11
src/compute/managed/compu_buffer.rs
View File

@@ -8,6 +8,7 @@ use image::ImageBuffer;
use image::Rgba;
use shade_runner::Layout;
use crate::compute::managed::handles::CompuBufferHandle;
use vulkano::descriptor::PipelineLayoutAbstract;
#[derive(Clone)]
@@ -30,13 +31,13 @@ impl CompuBuffers {
let input_buffer = {
let mut buff = data.iter();
let data_iter = (0..data_length).map(|n| *(buff.next().unwrap()));
CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), data_iter).unwrap()
CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), false, data_iter).unwrap()
};
let output_buffer = {
let mut buff = data.iter();
let data_iter = (0..data_length).map(|n| *(buff.next().unwrap()));
CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), data_iter).unwrap()
CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), false, data_iter).unwrap()
};
// Settings buffer which holds i32's
@@ -48,7 +49,7 @@ impl CompuBuffers {
(0..2).map(|n| *(buff.next().unwrap()));
CpuAccessibleBuffer::from_iter(device.clone(),
BufferUsage::all(),
data_iter).unwrap()
false, data_iter).unwrap()
};
CompuBuffers {
@@ -66,12 +67,12 @@ impl CompuBuffers {
}
pub fn get_descriptor_set(&self, compute_pipeline: std::sync::Arc<ComputePipeline<PipelineLayout<Layout>>>)
-> Arc<PersistentDescriptorSet<std::sync::Arc<ComputePipeline<PipelineLayout<Layout>>>, ((((),
-> Arc<PersistentDescriptorSet<((((),
PersistentDescriptorSetBuf<std::sync::Arc<vulkano::buffer::cpu_access::CpuAccessibleBuffer<[u8]>>>),
PersistentDescriptorSetBuf<std::sync::Arc<vulkano::buffer::cpu_access::CpuAccessibleBuffer<[u8]>>>),
PersistentDescriptorSetBuf<std::sync::Arc<vulkano::buffer::cpu_access::CpuAccessibleBuffer<[u32]>>>)>> {
Arc::new(PersistentDescriptorSet::start(compute_pipeline.clone(), 0)
Arc::new(PersistentDescriptorSet::start(compute_pipeline.clone().descriptor_set_layout(0).unwrap().clone())
.add_buffer(self.io_buffers.get(0).unwrap().clone()).unwrap()
.add_buffer(self.io_buffers.get(1).unwrap().clone()).unwrap()
.add_buffer(self.settings_buffer.clone()).unwrap()

5
src/compute/managed/compu_kernel.rs
View File

@@ -50,7 +50,8 @@ impl CompuKernel {
let mut options = CompileOptions::new().ok_or(CompileError::CreateCompiler).unwrap();
let shader = sr::load_compute_with_options(compute_path.clone(), options)
let shader = sr::load_compute(compute_path.clone(), Some(options))
.expect("Failed to compile");
let entry = sr::parse_compute(&shader)
@@ -106,7 +107,7 @@ impl CompuKernel {
self.compute_kernel_path = CompuKernel::get_path(filename);
self.shader =
sr::load_compute_with_options(self.compute_kernel_path.clone(), options)
sr::load_compute(self.compute_kernel_path.clone(), Some(options))
.expect("Failed to compile");
self.entry =

257
src/main.rs
View File

@@ -15,8 +15,6 @@ use vulkano::sync;
use crate::util::timer::Timer;
use vulkano::instance::Instance;
use vulkano::sync::GpuFuture;
use winit::{EventsLoop, WindowBuilder, WindowEvent, Event, DeviceEvent, VirtualKeyCode, ElementState};
use winit::dpi::LogicalSize;
use vulkano_win::VkSurfaceBuild;
use crate::util::load_raw;
@@ -32,6 +30,12 @@ use crate::drawables::sprite::Sprite;
use crate::drawables::rect::Rect;
use crate::drawables::compu_sprite::CompuSprite;
use crate::drawables::text::Text;
use winit::window::{WindowBuilder};
use winit::dpi::LogicalSize;
use winit::event_loop::EventLoop;
use winit::event::{Event, WindowEvent, DeviceEvent, VirtualKeyCode, ElementState};
use winit::platform::unix::WindowBuilderExtUnix;
pub mod util;
pub mod vkprocessor;
@@ -39,162 +43,157 @@ pub mod drawables;
pub mod canvas;
pub mod compute;
pub fn main() {
hprof::start_frame();
let q1 = hprof::enter("setup");
let instance = {
let extensions = vulkano_win::required_extensions();
Instance::new(None, &extensions, None).unwrap()
};
let _callback = DebugCallback::errors_and_warnings(&instance, |msg| {
println!("Debug callback: {:?}", msg.description);
}).ok();
let mut events_loop = EventsLoop::new();
let mut surface = WindowBuilder::new()
.with_dimensions(LogicalSize::from((800, 800)))
.build_vk_surface(&events_loop, instance.clone()).unwrap();
let mut window = surface.window();
let mut processor = vkprocessor::VkProcessor::new(&instance, &surface);
{
let g = hprof::enter("vulkan preload");
processor.create_swapchain(&surface);
let mut processor = vkprocessor::VkProcessor::new(instance.clone());
processor.preload_kernels();
processor.preload_shaders();
processor.preload_textures();
processor.preload_fonts();
}
let q2 = hprof::enter("Game Objects");
let mut timer = Timer::new();
let mut frame_future : Box<dyn GpuFuture> =
Box::new(sync::now(processor.device.clone())) as Box<dyn GpuFuture>;
let step_size: f32 = 0.005;
let mut elapsed_time: f32;
let mut delta_time: f32;
let mut accumulator_time: f32 = 0.0;
let mut current_time: f32 = timer.elap_time();
let image_data = load_raw(String::from("funky-bird.jpg"));
let image_dimensions_f : (f32, f32) = ((image_data.1).0 as f32, (image_data.1).1 as f32);
let image_dimensions_u : (u32, u32) = image_data.1;
let compu_sprite1 : CompuSprite =
CompuSprite::new((0.0, -0.5), (0.4, 0.4), 0, image_dimensions_f,
// Swap image to render the result to. Must match dimensions
processor.new_swap_image(image_dimensions_u));
let compute_buffer : Arc<CompuBufferHandle> =
processor.new_compute_buffer(image_data.0, image_data.1, 4);
let compute_kernel : Arc<CompuKernelHandle> =
processor.get_kernel_handle(String::from("simple-edge.compute"))
.expect("Can't find that kernel");
// Get the handles for the assets
let funky_handle : Arc<CanvasTextureHandle> =
processor.get_texture_handle(String::from("funky-bird.jpg")).unwrap();
let sfml_handle : Arc<CanvasTextureHandle> =
processor.get_texture_handle(String::from("sfml.png")).unwrap();
let font_handle : Arc<CanvasFontHandle> =
processor.get_font_handle(String::from("sansation.ttf")).unwrap();
let funky_sprite = Sprite::new((0.0, 0.5), (0.5, 0.5), 0, funky_handle.clone());
let sfml_sprite = Sprite::new((0.0, -0.5), (0.5, 0.5), 1, sfml_handle.clone());
let rect = Rect::new((-0.5, -0.5), (0.5, 0.5), 1);
//let sfml_sprite = Sprite::new((0.0, -0.5), (0.5, 0.5), 1, sfml_handle.clone());
let text_sprite = Text::new((-0.1,-0.1), (10.0, 10.0), 1);
//let test_polygon = Poly::new_with_color((-0.5, -0.5), (0.5, 0.5), 1, (1.0,0.0,0.0,0.0));
drop(q2);
drop(q1);
let l = hprof::enter("Loop");
let mut exit = false;
let mut count = 0;
while let true = processor.is_open() {
// Take care of our timing
{
elapsed_time = timer.elap_time();
delta_time = elapsed_time - current_time;
current_time = elapsed_time;
if delta_time > 0.02 {
delta_time = 0.02;
let g = hprof::enter("vulkan preload");
processor.create_swapchain();
processor.preload_kernels();
processor.preload_shaders();
processor.preload_textures();
processor.preload_fonts();
}
let q2 = hprof::enter("Game Objects");
let mut timer = Timer::new();
let mut frame_future: Box<dyn GpuFuture> =
Box::new(sync::now(processor.device.clone())) as Box<dyn GpuFuture>;
let step_size: f32 = 0.005;
let mut elapsed_time: f32;
let mut delta_time: f32;
let mut accumulator_time: f32 = 0.0;
let mut current_time: f32 = timer.elap_time();
let image_data = load_raw(String::from("funky-bird.jpg"));
let image_dimensions_f: (f32, f32) = ((image_data.1).0 as f32, (image_data.1).1 as f32);
let image_dimensions_u: (u32, u32) = image_data.1;
let compu_sprite1: CompuSprite =
CompuSprite::new((0.0, -0.5), (0.4, 0.4), 0, image_dimensions_f,
// Swap image to render the result to. Must match dimensions
processor.new_swap_image(image_dimensions_u));
let compute_buffer: Arc<CompuBufferHandle> =
processor.new_compute_buffer(image_data.0, image_data.1, 4);
let compute_kernel: Arc<CompuKernelHandle> =
processor.get_kernel_handle(String::from("simple-edge.compute"))
.expect("Can't find that kernel");
// Get the handles for the assets
let funky_handle: Arc<CanvasTextureHandle> =
processor.get_texture_handle(String::from("funky-bird.jpg")).unwrap();
let sfml_handle: Arc<CanvasTextureHandle> =
processor.get_texture_handle(String::from("sfml.png")).unwrap();
//let font_handle : Arc<CanvasFontHandle> =
// processor.get_font_handle(String::from("sansation.ttf")).unwrap();
let funky_sprite = Sprite::new((0.0, 0.5), (0.5, 0.5), 0, funky_handle.clone());
let sfml_sprite = Sprite::new((0.0, -0.5), (0.5, 0.5), 1, sfml_handle.clone());
let rect = Rect::new((-0.5, -0.5), (0.5, 0.5), 1);
//let sfml_sprite = Sprite::new((0.0, -0.5), (0.5, 0.5), 1, sfml_handle.clone());
let text_sprite = Text::new((-0.1, -0.1), (10.0, 10.0), 1);
//let test_polygon = Poly::new_with_color((-0.5, -0.5), (0.5, 0.5), 1, (1.0,0.0,0.0,0.0));
drop(q2);
drop(q1);
let l = hprof::enter("Loop");
let mut exit = false;
let mut count = 0;
while let true = processor.is_open() {
// Take care of our timing
{
elapsed_time = timer.elap_time();
delta_time = elapsed_time - current_time;
current_time = elapsed_time;
if delta_time > 0.02 {
delta_time = 0.02;
}
accumulator_time += delta_time;
}
accumulator_time += delta_time;
}
while (accumulator_time - step_size) >= step_size {
accumulator_time -= step_size;
}
while (accumulator_time - step_size) >= step_size {
accumulator_time -= step_size;
}
// Events loop is borrowed from the surface
events_loop.poll_events(|event| {
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>
{
exit = true;
}
Event::WindowEvent { event: WindowEvent::Resized(_), .. } => {
processor.recreate_swapchain(&surface);
}
Event::DeviceEvent { event: DeviceEvent::Key(keyboard_input), .. } => {
match keyboard_input.virtual_keycode.unwrap() {
VirtualKeyCode::A => {
if keyboard_input.state == ElementState::Pressed {
// processor.save_edges_image();
}
// Events loop is borrowed from the surface
processor.event_loop().clone().run(move |event, _, control_flow| {
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>
{
exit = true;
}
Event::WindowEvent { event: WindowEvent::Resized(_), .. } => {
processor.swapchain_recreate_needed = true;
}
Event::DeviceEvent { event: DeviceEvent::Key(keyboard_input), .. } => {
match keyboard_input.virtual_keycode.unwrap() {
VirtualKeyCode::A => {
if keyboard_input.state == ElementState::Pressed {
// processor.save_edges_image();
}
}
_ => ()
}
_ => ()
}
}
// Event::DeviceEvent { event: DeviceEvent::Button(mouse_input), .. } => {
// mouse_xy.x
// },
_ => ()
_ => ()
}
});
if exit {
break;
}
});
if exit {
break;
}
let mut canvas_frame = CanvasFrame::default();
canvas_frame.draw(&funky_sprite);
canvas_frame.draw(&text_sprite);
let mut canvas_frame = CanvasFrame::default();
canvas_frame.draw(&funky_sprite);
canvas_frame.draw(&text_sprite);
// canvas_frame.draw(&rect);
let mut compu_frame = CompuFrame::new();
//compu_frame.add(compute_buffer.clone(), compute_kernel.clone());
compu_frame.add_with_image_swap(compute_buffer.clone(), compute_kernel.clone(), &compu_sprite1);
let mut compu_frame = CompuFrame::new();
//compu_frame.add(compute_buffer.clone(), compute_kernel.clone());
compu_frame.add_with_image_swap(compute_buffer.clone(), compute_kernel.clone(), &compu_sprite1);
{
let g = hprof::enter("Run");
processor.run(&surface,
canvas_frame,
compu_frame);
{
let g = hprof::enter("Run");
processor.run(canvas_frame,
compu_frame);
}
}
drop(l);
hprof::end_frame();
hprof::profiler().print_timing();
drop(processor);
}
drop(l);
hprof::end_frame();
hprof::profiler().print_timing();
}

86
src/vkprocessor.rs
View File

@@ -5,9 +5,8 @@ use vulkano::sync::{GpuFuture, FlushError, NowFuture};
use vulkano::sync::now;
use vulkano::sync;
use std::sync::Arc;
use vulkano::swapchain::{Swapchain, PresentMode, SurfaceTransform, Surface, SwapchainCreationError, AcquireError, Capabilities};
use vulkano::swapchain::{Swapchain, PresentMode, SurfaceTransform, Surface, SwapchainCreationError, AcquireError, Capabilities, FullscreenExclusive, ColorSpace};
use vulkano::image::swapchain::SwapchainImage;
use winit::Window;
use crate::compute::compu_state::CompuState;
use vulkano::image::ImageUsage;
use crate::compute::compu_frame::CompuFrame;
@@ -21,6 +20,12 @@ use crate::canvas::managed::shader::text_shader::TextShader;
use crate::canvas::managed::handles::{CanvasTextureHandle, CompiledShaderHandle, CanvasFontHandle, CanvasImageHandle};
use crate::compute::managed::handles::{CompuKernelHandle, CompuBufferHandle};
use crate::util::vertex::{VertexTypes, ColorVertex3D, TextVertex3D, TextureVertex3D, ImageVertex3D};
use vulkano_text::DrawText;
use winit::window::{Window, WindowBuilder};
use vulkano::instance::debug::DebugCallback;
use winit::dpi::LogicalSize;
use vulkano_win::VkSurfaceBuild;
use winit::event_loop::EventLoop;
/// VKProcessor holds the vulkan instance information, the swapchain,
@@ -36,7 +41,10 @@ pub struct VkProcessor<'a> {
pub swapchain: Option<Arc<Swapchain<Window>>>,
pub swapchain_images: Option<Vec<Arc<SwapchainImage<Window>>>>,
swapchain_recreate_needed: bool,
pub swapchain_recreate_needed: bool,
pub surface: Arc<Surface<Window>>,
pub event_loop: Arc<EventLoop<()>>,
/// State holding textures, images, and their related vertex buffers
canvas_state: CanvasState,
@@ -49,12 +57,24 @@ pub struct VkProcessor<'a> {
impl<'a> VkProcessor<'a> {
/// Creates a new VkProcessor from an instance and surface
/// This includes the physical device, queues, compute and canvas state
pub fn new(instance: &'a Arc<Instance>, surface: &'a Arc<Surface<Window>>) -> VkProcessor<'a> {
//pub fn new(instance: &'a Arc<Instance>, surface: &'a Arc<Surface<Window>>) -> VkProcessor<'a> {
pub fn new(instance: Arc<Instance>) -> VkProcessor<'a> {
let physical = PhysicalDevice::enumerate(instance).next().unwrap();
let _callback = DebugCallback::errors_and_warnings(&instance, |msg| {
println!("Debug callback: {:?}", msg.description);
}).ok();
let mut events_loop = Arc::new(EventLoop::new());
let mut surface = WindowBuilder::new()
.with_inner_size(LogicalSize::new(800, 800));
// Some weird namespacing issue here
let mut surface = VkSurfaceBuild::build_vk_surface(surface, &events_loop, instance.clone()).unwrap();
let physical = PhysicalDevice::enumerate(&instance).next().unwrap();
let queue_family = physical.queue_families().find(|&q| {
// We take the first queue that supports drawing to our window.
@@ -85,28 +105,35 @@ impl<'a> VkProcessor<'a> {
compute_state: CompuState::new(),
capabilities: capabilities.clone(),
canvas_state: CanvasState::new(queue, device, physical, capabilities),
surface: surface,
event_loop: events_loop,
}
}
/// VKProcessor controls the window. So it will let the main loop know when it is done
pub fn is_open(&mut self) -> bool {
// self.surface
// self.surface
true
}
pub fn event_loop(&mut self) -> Arc<EventLoop<()>> {
self.event_loop()
}
/// Using the surface, we calculate the surface capabilities and create the swapchain and swapchain images
pub fn create_swapchain(&mut self, surface: &'a Arc<Surface<Window>>) {
pub fn create_swapchain(&mut self) {
let (mut swapchain, images) = {
let capabilities = surface.capabilities(self.physical).unwrap();
let capabilities = self.surface.capabilities(self.physical).unwrap();
let usage = capabilities.supported_usage_flags;
let alpha = capabilities.supported_composite_alpha.iter().next().unwrap();
// Choosing the internal format that the images will have.
let format = capabilities.supported_formats[0].0;
// Set the swapchains window dimensions
let initial_dimensions = if let Some(dimensions) = surface.window().get_inner_size() {
let initial_dimensions = if let dimensions = self.surface.window().inner_size() {
// convert to physical pixels
let dimensions: (u32, u32) = dimensions.to_physical(surface.window().get_hidpi_factor()).into();
let dimensions: (u32, u32) = dimensions.to_logical::<u32>(self.surface.window().scale_factor()).into();
[dimensions.0, dimensions.1]
} else {
// The window no longer exists so exit the application.
@@ -114,7 +141,7 @@ impl<'a> VkProcessor<'a> {
};
Swapchain::new(self.device.clone(),
surface.clone(),
self.surface.clone(),
capabilities.min_image_count, // number of attachment images
format,
initial_dimensions,
@@ -123,7 +150,9 @@ impl<'a> VkProcessor<'a> {
&self.queue,
SurfaceTransform::Identity,
alpha,
PresentMode::Immediate, true, None).unwrap()
PresentMode::Immediate,
FullscreenExclusive::Default, true,
ColorSpace::PassThrough).unwrap()
};
self.swapchain = Some(swapchain);
@@ -131,15 +160,16 @@ impl<'a> VkProcessor<'a> {
}
/// On screen resizes, the swapchain and images must be recreated
pub fn recreate_swapchain(&mut self, surface: &'a Arc<Surface<Window>>) {
let dimensions = if let Some(dimensions) = surface.window().get_inner_size() {
let dimensions: (u32, u32) = dimensions.to_physical(surface.window().get_hidpi_factor()).into();
pub fn recreate_swapchain(&mut self) {
let dimensions = if let dimensions = self.surface.window().inner_size() {
let dimensions: (u32, u32) = dimensions.to_logical::<u32>(self.surface.window().scale_factor()).into();
[dimensions.0, dimensions.1]
} else {
return;
};
let (new_swapchain, new_images) = match self.swapchain.clone().unwrap().clone().recreate_with_dimension(dimensions) {
let (new_swapchain, new_images) = match self.swapchain.clone().unwrap().clone()
.recreate_with_dimensions(dimensions) {
Ok(r) => r,
// 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.
@@ -176,7 +206,7 @@ impl<'a> VkProcessor<'a> {
/// A hardcoded list of shaders which can be proloaded from this function
pub fn preload_fonts(&mut self) {
self.canvas_state.load_font(String::from("sansation.ttf"));
//self.canvas_state.load_font(String::from("sansation.ttf"));
}
/// O(n) Lookup for the matching texture string
@@ -224,11 +254,9 @@ impl<'a> VkProcessor<'a> {
/// Run the VKprocessor for a single frame, consuming the Canvas/Compu Frames
pub fn run(&mut self,
surface: &'a Arc<Surface<Window>>,
canvas_frame: CanvasFrame,
compute_frame: CompuFrame,
) {
{
let g = hprof::enter("Waiting at queue");
self.queue.wait();
@@ -241,7 +269,7 @@ impl<'a> VkProcessor<'a> {
// Whenever the window resizes we need to recreate everything dependent on the window size.
// In this example that includes the swapchain, the framebuffers and the dynamic state viewport.
if self.swapchain_recreate_needed {
self.recreate_swapchain(surface);
self.recreate_swapchain();
framebuffers =
self.canvas_state.window_size_dependent_setup(&self.swapchain_images.clone().unwrap().clone());
self.swapchain_recreate_needed = false;
@@ -249,7 +277,7 @@ impl<'a> VkProcessor<'a> {
// This function can block if no image is available. The parameter is an optional timeout
// after which the function call will return an error.
let (image_num, acquire_future) =
let (image_num, suboptimal, acquire_future) =
match vulkano::swapchain::acquire_next_image(
self.swapchain.clone().unwrap().clone(),
None,
@@ -262,6 +290,10 @@ impl<'a> VkProcessor<'a> {
Err(err) => panic!("{:?}", err)
};
if suboptimal {
self.swapchain_recreate_needed = true;
}
drop(g);
let allocated_buffers = {
@@ -271,20 +303,21 @@ impl<'a> VkProcessor<'a> {
self.canvas_state.allocate(canvas_frame)
};
// let mut draw_text = DrawText::new(self.device.clone(), self.queue.clone(), self.swapchain.unwrap().clone(), &self.swapchain_images.images);
let mut command_buffer =
AutoCommandBufferBuilder::primary_one_time_submit(self.device.clone(), self.queue.family()).unwrap();
let g = hprof::enter("Push compute commands to command buffer");
// Add the compute commands
let mut command_buffer = self.compute_state.compute_commands(compute_frame, command_buffer, &self.canvas_state);
self.compute_state.compute_commands(compute_frame, &mut command_buffer, &self.canvas_state);
drop(g);
let g = hprof::enter("Push draw commands to command buffer");
// Add the draw commands
//let mut command_buffer = self.canvas_state.draw_commands(command_buffer, framebuffers, image_num);
let mut command_buffer =
self.canvas_state.draw_commands(command_buffer, framebuffers, image_num, allocated_buffers);
self.canvas_state.draw_commands(&mut command_buffer, framebuffers, image_num, allocated_buffers);
// And build
let command_buffer = command_buffer.build().unwrap();
@@ -292,7 +325,6 @@ impl<'a> VkProcessor<'a> {
// Wait on the previous frame, then execute the command buffer and present the image
{
let g = hprof::enter("Joining on the framebuffer");
let mut future = sync::now(self.device.clone())
.join(acquire_future);