316 lines
11 KiB
Rust
316 lines
11 KiB
Rust
use std::sync::Arc;
|
|
use vulkano::buffer::{Buffer, BufferCreateInfo, BufferUsage, Subbuffer};
|
|
use vulkano::command_buffer::{CommandBufferExecFuture, PrimaryAutoCommandBuffer};
|
|
use vulkano::device::{DeviceExtensions};
|
|
use vulkano::image::{Image};
|
|
use vulkano::image::view::ImageView;
|
|
use vulkano::instance::{Instance, InstanceCreateFlags, InstanceCreateInfo};
|
|
use vulkano::memory::allocator::{AllocationCreateInfo, MemoryTypeFilter};
|
|
use vulkano::render_pass::{Framebuffer, FramebufferCreateInfo, RenderPass};
|
|
use vulkano::shader::ShaderModule;
|
|
use vulkano::swapchain::{PresentFuture, Surface, SwapchainAcquireFuture, SwapchainCreateInfo, SwapchainPresentInfo};
|
|
use vulkano::{swapchain, sync, Validated, VulkanError, VulkanLibrary};
|
|
use vulkano::sync::future::{FenceSignalFuture, JoinFuture};
|
|
use vulkano::sync::GpuFuture;
|
|
use winit::application::ApplicationHandler;
|
|
use winit::event::{WindowEvent};
|
|
use winit::event_loop::ActiveEventLoop;
|
|
use winit::platform::x11::WindowAttributesExtX11;
|
|
use winit::window::{Window, WindowId};
|
|
use crate::util::{MyVertex, VulkanoWrapper};
|
|
|
|
#[derive(Default)]
|
|
pub(crate) struct App {
|
|
window: Option<Window>,
|
|
wrapper: Option<Arc<VulkanoWrapper>>,
|
|
|
|
vs: Option<Arc<ShaderModule>>,
|
|
fs: Option<Arc<ShaderModule>>,
|
|
|
|
command_buffers: Option<Vec<Arc<PrimaryAutoCommandBuffer>>>,
|
|
queue: Option<Arc<vulkano::device::Queue>>,
|
|
|
|
vertex_buffer: Option<Subbuffer<[MyVertex]>>,
|
|
pipeline: Option<Arc<vulkano::pipeline::GraphicsPipeline>>,
|
|
|
|
framebuffers: Option<Vec<Arc<Framebuffer>>>,
|
|
|
|
fences: Option<Vec<Option<Arc<FenceSignalFuture<PresentFuture<CommandBufferExecFuture<JoinFuture<Box<dyn GpuFuture>, SwapchainAcquireFuture>>>>>>>>,
|
|
previous_fence_i: usize,
|
|
|
|
window_resized: bool,
|
|
recreate_swapchain: bool,
|
|
}
|
|
|
|
|
|
fn get_framebuffers(
|
|
images: &[Arc<Image>],
|
|
render_pass: &Arc<RenderPass>,
|
|
) -> Vec<Arc<Framebuffer>> {
|
|
images
|
|
.iter()
|
|
.map(|image| {
|
|
let view = ImageView::new_default(image.clone()).unwrap();
|
|
Framebuffer::new(
|
|
render_pass.clone(),
|
|
FramebufferCreateInfo {
|
|
attachments: vec![view],
|
|
..Default::default()
|
|
},
|
|
)
|
|
.unwrap()
|
|
})
|
|
.collect::<Vec<_>>()
|
|
}
|
|
|
|
impl ApplicationHandler for App {
|
|
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
|
|
println!("Application resumed");
|
|
|
|
self.window = Some(event_loop.create_window(
|
|
Window::default_attributes()
|
|
.with_base_size(winit::dpi::LogicalSize::new(1024.0, 768.0))
|
|
.with_title("Hello, world!"),
|
|
).unwrap());
|
|
|
|
let window = self.window.as_ref().unwrap();
|
|
|
|
let library = VulkanLibrary::new().expect("failed to load Vulkan library");
|
|
|
|
let required_extensions = Surface::required_extensions(&event_loop).unwrap();
|
|
|
|
let instance = Instance::new(
|
|
library,
|
|
InstanceCreateInfo {
|
|
flags: InstanceCreateFlags::ENUMERATE_PORTABILITY,
|
|
enabled_extensions: required_extensions,
|
|
..Default::default()
|
|
},
|
|
).expect("failed to create instance");
|
|
|
|
self.wrapper = Some(Arc::new(VulkanoWrapper::new(instance, window, DeviceExtensions {
|
|
khr_swapchain: true,
|
|
..DeviceExtensions::empty()
|
|
})));
|
|
|
|
let wrapper = if let Some(wrapper) = self.wrapper.as_ref() {wrapper} else {panic!("wrapper has disappeared")};
|
|
|
|
self.framebuffers = Some(get_framebuffers(&wrapper.images, &wrapper.render_pass));
|
|
self.queue = Some(wrapper.queues.first().unwrap().clone());
|
|
|
|
let vertex1 = MyVertex {
|
|
position: [-0.5, -0.5],
|
|
};
|
|
let vertex2 = MyVertex {
|
|
position: [0.0, 0.5],
|
|
};
|
|
let vertex3 = MyVertex {
|
|
position: [0.5, -0.25],
|
|
};
|
|
|
|
self.vertex_buffer = Some(Buffer::from_iter(
|
|
wrapper.memory_allocator.clone(),
|
|
BufferCreateInfo {
|
|
usage: BufferUsage::VERTEX_BUFFER,
|
|
..Default::default()
|
|
},
|
|
AllocationCreateInfo {
|
|
memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
|
|
| MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
|
|
..Default::default()
|
|
},
|
|
vec![vertex1, vertex2, vertex3],
|
|
).unwrap());
|
|
|
|
self.vs = Some(vs::load(wrapper.device.clone()).expect("failed to create shader module"));
|
|
self.fs = Some(fs::load(wrapper.device.clone()).expect("failed to create shader module"));
|
|
|
|
self.pipeline = Some(wrapper.get_pipeline(
|
|
self.vs.clone().unwrap(),
|
|
self.fs.clone().unwrap(),
|
|
wrapper.render_pass.clone(),
|
|
wrapper.viewport.read().unwrap().clone(),
|
|
));
|
|
|
|
self.command_buffers = Some(wrapper.get_command_buffers(
|
|
&self.queue.clone().unwrap(),
|
|
&self.pipeline.clone().unwrap(),
|
|
&self.framebuffers.clone().unwrap(),
|
|
&self.vertex_buffer.clone().unwrap(),
|
|
));
|
|
|
|
let frames_in_flight = wrapper.images.len();
|
|
self.fences = Some(vec![None; frames_in_flight]);
|
|
}
|
|
|
|
fn window_event(&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
|
|
match event {
|
|
WindowEvent::CloseRequested => {
|
|
println!("The close button was pressed; stopping");
|
|
event_loop.exit();
|
|
},
|
|
WindowEvent::RedrawRequested => {
|
|
println!("{}", self.previous_fence_i);
|
|
// Redraw the application.
|
|
//
|
|
// It's preferable for applications that do not render continuously to render in
|
|
// this event rather than in AboutToWait, since rendering in here allows
|
|
// the program to gracefully handle redraws requested by the OS.
|
|
|
|
// Draw.
|
|
let wrapper = if let Some(wrapper) = self.wrapper.clone() {wrapper} else {panic!("wrapper has disappeared")};
|
|
let queue = self.queue.clone().unwrap();
|
|
let swapchain = wrapper.swapchain.read().unwrap().clone();
|
|
|
|
let (image_i, suboptimal, acquire_future) =
|
|
match swapchain::acquire_next_image(swapchain.clone(), None)
|
|
.map_err(Validated::unwrap)
|
|
{
|
|
Ok(r) => r,
|
|
Err(VulkanError::OutOfDate) => {
|
|
self.recreate_swapchain = true;
|
|
return;
|
|
}
|
|
Err(e) => panic!("failed to acquire next image: {e}"),
|
|
};
|
|
|
|
if suboptimal {
|
|
self.recreate_swapchain = true;
|
|
}
|
|
|
|
let fences = self.fences.as_mut().unwrap();
|
|
|
|
if let Some(image_fence) = &fences[image_i as usize] {
|
|
image_fence.wait(None).unwrap();
|
|
}
|
|
|
|
let previous_future = match fences[self.previous_fence_i].clone() {
|
|
// Create a `NowFuture`.
|
|
None => {
|
|
let mut now = sync::now(wrapper.device.clone());
|
|
now.cleanup_finished();
|
|
|
|
now.boxed()
|
|
}
|
|
// Use the existing `FenceSignalFuture`.
|
|
Some(fence) => fence.boxed(),
|
|
};
|
|
|
|
let future = previous_future
|
|
.join(acquire_future)
|
|
.then_execute(queue.clone(), self.command_buffers.clone().unwrap()[image_i as usize].clone())
|
|
.unwrap()
|
|
.then_swapchain_present(
|
|
queue.clone(),
|
|
SwapchainPresentInfo::swapchain_image_index(swapchain.clone(), image_i),
|
|
)
|
|
.then_signal_fence_and_flush();
|
|
|
|
fences[image_i as usize] = match future.map_err(Validated::unwrap) {
|
|
Ok(value) => Some(Arc::new(value)),
|
|
Err(VulkanError::OutOfDate) => {
|
|
self.recreate_swapchain = true;
|
|
None
|
|
}
|
|
Err(e) => {
|
|
println!("failed to flush future: {e}");
|
|
None
|
|
}
|
|
};
|
|
|
|
self.previous_fence_i = image_i as usize;
|
|
|
|
// Queue a RedrawRequested event.
|
|
//
|
|
// You only need to call this if you've determined that you need to redraw in
|
|
// applications which do not always need to. Applications that redraw continuously
|
|
// can render here instead.
|
|
//self.window.as_ref().unwrap().request_redraw();
|
|
},
|
|
WindowEvent::Resized(_) => {
|
|
self.window_resized = true;
|
|
},
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
|
|
if self.recreate_swapchain {
|
|
self.recreate_swapchain = false;
|
|
|
|
let new_dimensions = if let Some(window) = &self.window {
|
|
window.inner_size()
|
|
} else {
|
|
panic!("window is None");
|
|
};
|
|
|
|
let wrapper = if let Some(wrapper) = self.wrapper.clone() {wrapper} else {panic!("wrapper has disappeared")};
|
|
|
|
|
|
let (new_swapchain, new_images) = wrapper.swapchain.read().unwrap()
|
|
.recreate(SwapchainCreateInfo {
|
|
// Here, `image_extend` will correspond to the window dimensions.
|
|
image_extent: new_dimensions.into(),
|
|
..wrapper.swapchain.read().unwrap().create_info()
|
|
})
|
|
.expect("failed to recreate swapchain: {e}");
|
|
*wrapper.swapchain.write().unwrap() = new_swapchain;
|
|
let new_framebuffers = get_framebuffers(&new_images, &wrapper.render_pass);
|
|
|
|
self.framebuffers = Some(new_framebuffers);
|
|
|
|
if self.window_resized {
|
|
self.window_resized = false;
|
|
let mut viewport = wrapper.viewport.write().unwrap();
|
|
|
|
viewport.extent[0] = new_dimensions.width as f32;
|
|
self.pipeline = Some(wrapper.get_pipeline(
|
|
self.vs.clone().unwrap(),
|
|
self.fs.clone().unwrap(),
|
|
wrapper.render_pass.clone(),
|
|
viewport.clone(),
|
|
));
|
|
|
|
self.command_buffers = Some(wrapper.get_command_buffers(
|
|
&self.queue.clone().unwrap(),
|
|
&self.pipeline.clone().unwrap(),
|
|
&self.framebuffers.clone().unwrap(),
|
|
&self.vertex_buffer.clone().unwrap(),
|
|
));
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
mod vs {
|
|
vulkano_shaders::shader! {
|
|
ty: "vertex",
|
|
src: "
|
|
#version 460
|
|
|
|
layout(location = 0) in vec2 position;
|
|
|
|
void main() {
|
|
gl_Position = vec4(position, 0.0, 1.0);
|
|
}
|
|
",
|
|
}
|
|
}
|
|
|
|
mod fs {
|
|
vulkano_shaders::shader! {
|
|
ty: "fragment",
|
|
src: "
|
|
#version 460
|
|
|
|
layout(location = 0) out vec4 f_color;
|
|
|
|
void main() {
|
|
f_color = vec4(1.0, 0.0, 0.0, 1.0);
|
|
}
|
|
",
|
|
}
|
|
}
|