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

sync

Browse Source
master
mitchellhansen 4 years ago
parent 59c44a2f2d
commit f5f0346d5c
2 changed files with 135 additions and 152 deletions
Show Stats Download Patch File Download Diff File

28
src/main.rs
Unescape View File

@ -3,7 +3,6 @@
#![allow(unused_mut)]
extern crate cgmath;
extern crate image;
extern crate nalgebra as na;
@ -35,6 +34,7 @@ use winit::dpi::LogicalSize;
use winit::event_loop::EventLoop;
use winit::event::{Event, WindowEvent, DeviceEvent, VirtualKeyCode, ElementState};
use winit::platform::unix::WindowBuilderExtUnix;
use crate::vkprocessor::VkProcessor;
pub mod util;
@ -43,24 +43,32 @@ 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 mut processor = vkprocessor::VkProcessor::new(instance.clone());
let _callback = DebugCallback::errors_and_warnings(&instance, |msg| {
println!("Debug callback: {:?}", msg.description);
}).ok();
let mut events_loop = 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.clone(), &events_loop, instance.clone()).unwrap();
let mut processor = VkProcessor::new(&instance, surface.clone());
{
let g = hprof::enter("vulkan preload");
processor.create_swapchain();
processor.create_swapchain(surface.clone());
processor.preload_kernels();
processor.preload_shaders();
@ -139,7 +147,7 @@ pub fn main() {
}
// Events loop is borrowed from the surface
processor.event_loop().clone().run(move |event, _, control_flow| {
events_loop.run(move |event, _, control_flow| {
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>
{
@ -181,19 +189,17 @@ pub fn main() {
{
let g = hprof::enter("Run");
processor.run(canvas_frame,
processor.run(&surface.clone(),
canvas_frame,
compu_frame);
}
}
drop(l);
hprof::end_frame();
hprof::profiler().print_timing();
drop(processor);
}
}

49
src/vkprocessor.rs
Unescape View File

@ -32,7 +32,6 @@ use winit::event_loop::EventLoop;
/// and the compute and canvas states
pub struct VkProcessor<'a> {
// Vulkan state fields
pub instance: Arc<Instance>,
pub physical: PhysicalDevice<'a>,
pub device: Arc<Device>,
pub queues: QueuesIter,
@ -43,9 +42,6 @@ pub struct VkProcessor<'a> {
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,
/// State holding
@ -59,22 +55,9 @@ 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: Arc<Instance>) -> VkProcessor<'a> {
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();
pub fn new(instance: &'a Arc<Instance>, surface: Arc<Surface<Window>>) -> VkProcessor<'a> {
let physical = PhysicalDevice::enumerate(&instance).next().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.
@ -93,8 +76,8 @@ impl<'a> VkProcessor<'a> {
let capabilities = surface.capabilities(physical).unwrap();
VkProcessor {
instance: instance.clone(),
physical: physical.clone(),
device: device.clone(),
queue: queue.clone(),
@ -105,8 +88,6 @@ 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,
}
}
@ -116,24 +97,19 @@ impl<'a> VkProcessor<'a> {
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) {
pub fn create_swapchain(&mut self, surface: Arc<Surface<Window>>) {
let (mut swapchain, images) = {
let capabilities = self.surface.capabilities(self.physical).unwrap();
let capabilities = 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 dimensions = self.surface.window().inner_size() {
let initial_dimensions = if let dimensions = surface.window().inner_size() {
// convert to physical pixels
let dimensions: (u32, u32) = dimensions.to_logical::<u32>(self.surface.window().scale_factor()).into();
let dimensions: (u32, u32) = dimensions.to_logical::<u32>(surface.window().scale_factor()).into();
[dimensions.0, dimensions.1]
} else {
// The window no longer exists so exit the application.
@ -141,7 +117,7 @@ impl<'a> VkProcessor<'a> {
};
Swapchain::new(self.device.clone(),
self.surface.clone(),
surface.clone(),
capabilities.min_image_count, // number of attachment images
format,
initial_dimensions,
@ -160,9 +136,9 @@ impl<'a> VkProcessor<'a> {
}
/// On screen resizes, the swapchain and images must be recreated
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();
pub fn recreate_swapchain(&mut self, surface: &'a Arc<Surface<Window>>) {
let dimensions = if let dimensions = surface.window().inner_size() {
let dimensions: (u32, u32) = dimensions.to_logical::<u32>(surface.window().scale_factor()).into();
[dimensions.0, dimensions.1]
} else {
return;
@ -254,6 +230,7 @@ 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,
) {
@ -269,7 +246,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();
self.recreate_swapchain(surface);
framebuffers =
self.canvas_state.window_size_dependent_setup(&self.swapchain_images.clone().unwrap().clone());
self.swapchain_recreate_needed = false;

Write Preview
Loading…
Cancel
Save