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

finished updating dependencies

Browse Source
This commit is contained in:
mitchellhansen
2020-07-27 23:04:49 -07:00
parent f5f0346d5c
commit 5916b0d947
3 changed files with 92 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/canvas/canvas_state.rs
View File

@@ -256,7 +256,6 @@ impl CanvasState {
/// Takes physical and capabilities as we don't store that in Canvas
pub fn load_shader<T: 'static, V>(&mut self,
filename: String,
physical: PhysicalDevice,
capabilities: Capabilities) -> Option<Arc<CompiledShaderHandle>>
where T: CompiledShader, V: Vertex {
let handle = Arc::new(CompiledShaderHandle {

155
src/main.rs
View File

@@ -4,38 +4,37 @@
extern crate cgmath;
extern crate hprof;
extern crate image;
extern crate nalgebra as na;
extern crate rand;
extern crate time;
extern crate hprof;
use vulkano::sync;
use crate::util::timer::Timer;
use vulkano::instance::Instance;
use vulkano::sync::GpuFuture;
use vulkano_win::VkSurfaceBuild;
use crate::util::load_raw;
use std::sync::Arc;
use vulkano::instance::debug::DebugCallback;
use crate::compute::compu_frame::CompuFrame;
use crate::canvas::canvas_frame::{CanvasFrame, Drawable};
use std::sync::Arc;
use crate::canvas::managed::handles::{CanvasTextureHandle, Handle, CanvasFontHandle};
use crate::util::vertex::{VertexTypes, TextureVertex3D};
use crate::compute::managed::handles::{CompuBufferHandle, CompuKernelHandle};
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 vulkano::instance::Instance;
use vulkano::sync;
use vulkano::sync::GpuFuture;
use vulkano_win::VkSurfaceBuild;
use winit::dpi::LogicalSize;
use winit::event_loop::EventLoop;
use winit::event::{Event, WindowEvent, DeviceEvent, VirtualKeyCode, ElementState};
use winit::event::{DeviceEvent, ElementState, Event, VirtualKeyCode, WindowEvent};
use winit::event_loop::{EventLoop, ControlFlow};
use winit::platform::unix::WindowBuilderExtUnix;
use crate::vkprocessor::VkProcessor;
use winit::window::WindowBuilder;
use crate::canvas::canvas_frame::{CanvasFrame, Drawable};
use crate::canvas::managed::handles::{CanvasFontHandle, CanvasTextureHandle, Handle};
use crate::compute::compu_frame::CompuFrame;
use crate::compute::managed::handles::{CompuBufferHandle, CompuKernelHandle};
use crate::drawables::compu_sprite::CompuSprite;
use crate::drawables::rect::Rect;
use crate::drawables::sprite::Sprite;
use crate::drawables::text::Text;
use crate::util::load_raw;
use crate::util::timer::Timer;
use crate::util::vertex::{TextureVertex3D, VertexTypes};
use crate::vkprocessor::VkProcessor;
pub mod util;
pub mod vkprocessor;
@@ -60,15 +59,14 @@ pub fn main() {
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();
.with_inner_size(LogicalSize::new(800, 800))
.build_vk_surface(&events_loop, instance.clone()).unwrap();
let mut processor = VkProcessor::new(&instance, surface.clone());
let mut processor = VkProcessor::new(instance.clone(), surface.clone());
{
let g = hprof::enter("vulkan preload");
processor.create_swapchain(surface.clone());
processor.create_swapchain(instance.clone(), surface.clone());
processor.preload_kernels();
processor.preload_shaders();
@@ -129,77 +127,72 @@ pub fn main() {
let mut count = 0;
while let true = processor.is_open() {
// 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;
// }
//
// while (accumulator_time - step_size) >= step_size {
// accumulator_time -= step_size;
// }
// 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;
// Events loop is borrowed from the surface
events_loop.run(move |event, _, control_flow| {
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>
{
*control_flow = ControlFlow::Exit
}
Event::WindowEvent { event: WindowEvent::Resized(_), .. } => {
processor.swapchain_recreate_needed = true;
}
accumulator_time += delta_time;
}
Event::MainEventsCleared => {
let mut canvas_frame = CanvasFrame::default();
canvas_frame.draw(&funky_sprite);
canvas_frame.draw(&text_sprite);
// canvas_frame.draw(&rect);
while (accumulator_time - step_size) >= step_size {
accumulator_time -= step_size;
}
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);
// Events loop is borrowed from the surface
events_loop.run(move |event, _, control_flow| {
match event {
Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>
{
exit = true;
}
Event::WindowEvent { event: WindowEvent::Resized(_), .. } => {
processor.swapchain_recreate_needed = true;
{
let g = hprof::enter("Run");
processor.run(&surface.clone(),
canvas_frame,
compu_frame);
}
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::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;
_ => ()
}
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 g = hprof::enter("Run");
processor.run(&surface.clone(),
canvas_frame,
compu_frame);
}
}
});
drop(l);
hprof::end_frame();
hprof::profiler().print_timing();
}

34
src/vkprocessor.rs
View File

@@ -30,9 +30,9 @@ use winit::event_loop::EventLoop;
/// VKProcessor holds the vulkan instance information, the swapchain,
/// and the compute and canvas states
pub struct VkProcessor<'a> {
pub struct VkProcessor {
// Vulkan state fields
pub physical: PhysicalDevice<'a>,
//pub physical: PhysicalDevice<'a>,
pub device: Arc<Device>,
pub queues: QueuesIter,
pub queue: Arc<Queue>,
@@ -52,12 +52,12 @@ pub struct VkProcessor<'a> {
}
impl<'a> VkProcessor<'a> {
impl VkProcessor {
/// 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: Arc<Surface<Window>>) -> VkProcessor<'a> {
pub fn new(instance: Arc<Instance>, surface: Arc<Surface<Window>>) -> VkProcessor {
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.
@@ -78,7 +78,7 @@ impl<'a> VkProcessor<'a> {
VkProcessor {
physical: physical.clone(),
//physical: physical.clone(),
device: device.clone(),
queue: queue.clone(),
queues: queues,
@@ -98,13 +98,15 @@ impl<'a> VkProcessor<'a> {
}
/// Using the surface, we calculate the surface capabilities and create the swapchain and swapchain images
pub fn create_swapchain(&mut self, surface: Arc<Surface<Window>>) {
pub fn create_swapchain(&mut self, instance: Arc<Instance>, surface: Arc<Surface<Window>>) {
let (mut swapchain, images) = {
let capabilities = surface.capabilities(self.physical).unwrap();
let physical = PhysicalDevice::enumerate(&instance).next().unwrap();
let capabilities = surface.capabilities(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;
let colorspace = capabilities.supported_formats[0].1;
// Set the swapchains window dimensions
let initial_dimensions = if let dimensions = surface.window().inner_size() {
@@ -122,13 +124,13 @@ impl<'a> VkProcessor<'a> {
format,
initial_dimensions,
1, // Layers
usage,
ImageUsage::color_attachment(),
&self.queue,
SurfaceTransform::Identity,
alpha,
PresentMode::Immediate,
FullscreenExclusive::Default, true,
ColorSpace::PassThrough).unwrap()
colorspace).unwrap()
};
self.swapchain = Some(swapchain);
@@ -136,7 +138,7 @@ 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>>) {
pub fn recreate_swapchain(&mut self, surface: &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]
@@ -174,10 +176,10 @@ impl<'a> VkProcessor<'a> {
/// A hardcoded list of shaders which can be preloaded from this function
pub fn preload_shaders(&mut self) {
self.canvas_state.load_shader::<GenericShader, ColorVertex3D>(String::from("color-passthrough"), self.physical.clone(), self.capabilities.clone());
self.canvas_state.load_shader::<GenericShader, TextureVertex3D>(String::from("simple_texture"), self.physical.clone(), self.capabilities.clone());
self.canvas_state.load_shader::<GenericShader, ImageVertex3D>(String::from("simple_image"), self.physical.clone(), self.capabilities.clone());
self.canvas_state.load_shader::<TextShader, ColorVertex3D>(String::from("simple_text"), self.physical.clone(), self.capabilities.clone());
self.canvas_state.load_shader::<GenericShader, ColorVertex3D>(String::from("color-passthrough"), self.capabilities.clone());
self.canvas_state.load_shader::<GenericShader, TextureVertex3D>(String::from("simple_texture"), self.capabilities.clone());
self.canvas_state.load_shader::<GenericShader, ImageVertex3D>(String::from("simple_image"), self.capabilities.clone());
self.canvas_state.load_shader::<TextShader, ColorVertex3D>(String::from("simple_text"), self.capabilities.clone());
}
/// A hardcoded list of shaders which can be proloaded from this function
@@ -230,7 +232,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>>,
surface: &Arc<Surface<Window>>,
canvas_frame: CanvasFrame,
compute_frame: CompuFrame,
) {