trimming... maybe

This commit is contained in:
Alex Janka 2023-10-02 11:22:22 +11:00
parent 772026c04f
commit 361112d2d1
2 changed files with 49 additions and 225 deletions

View file

@ -14,8 +14,33 @@ use winit::window::Window;
// https://github.com/ash-rs/ash/blob/master/examples/src/bin/texture.rs // https://github.com/ash-rs/ash/blob/master/examples/src/bin/texture.rs
const SHADER: &[u8] = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/shaders/shader.spv")); const SHADER: &[u8] = include_bytes!(concat!(env!("CARGO_MANIFEST_DIR"), "/shaders/shader.spv"));
const VERTICES: [Vertex; 3] = [Vertex(-1.0, -1.0), Vertex(3.0, -1.0), Vertex(-1.0, 3.0)];
pub struct WindowData { pub struct WindowData {
inner: VulkanWindowInner,
}
impl WindowData {
pub fn new(factor: u32, window: &Window) -> Self {
Self {
inner: unsafe { VulkanWindowInner::new(factor, window) },
}
}
pub fn resize(&mut self, width: u32, height: u32, factor: u32, window: &Window) {
self.inner.resize(width, height, factor, window);
}
pub fn new_frame(&mut self, buffer: &[[u8; 4]]) {
self.inner.new_frame(buffer);
}
pub fn render(&mut self) {
self.inner.render();
}
}
struct VulkanWindowInner {
instance: Instance, instance: Instance,
device: Device, device: Device,
surface_loader: Surface, surface_loader: Surface,
@ -31,10 +56,6 @@ pub struct WindowData {
draw_command_buffer: vk::CommandBuffer, draw_command_buffer: vk::CommandBuffer,
setup_command_buffer: vk::CommandBuffer, setup_command_buffer: vk::CommandBuffer,
depth_image: vk::Image,
depth_image_view: vk::ImageView,
depth_image_memory: vk::DeviceMemory,
present_complete_semaphore: vk::Semaphore, present_complete_semaphore: vk::Semaphore,
rendering_complete_semaphore: vk::Semaphore, rendering_complete_semaphore: vk::Semaphore,
@ -49,13 +70,9 @@ pub struct WindowData {
graphics_pipelines: Vec<vk::Pipeline>, graphics_pipelines: Vec<vk::Pipeline>,
viewports: [vk::Viewport; 1], viewports: [vk::Viewport; 1],
scissors: [vk::Rect2D; 1], scissors: [vk::Rect2D; 1],
index_buffer: vk::Buffer,
index_buffer_data: [u32; 6],
shader_module: vk::ShaderModule, shader_module: vk::ShaderModule,
vertex_input_buffer_memory: vk::DeviceMemory, vertex_input_buffer_memory: vk::DeviceMemory,
texture_memory: vk::DeviceMemory, texture_memory: vk::DeviceMemory,
index_buffer_memory: vk::DeviceMemory,
tex_image_view: vk::ImageView, tex_image_view: vk::ImageView,
desc_set_layouts: [vk::DescriptorSetLayout; 1], desc_set_layouts: [vk::DescriptorSetLayout; 1],
descriptor_pool: vk::DescriptorPool, descriptor_pool: vk::DescriptorPool,
@ -68,8 +85,8 @@ pub struct WindowData {
texture_image: vk::Image, texture_image: vk::Image,
} }
impl WindowData { impl VulkanWindowInner {
pub unsafe fn new(factor: u32, window: &Window) -> Self { unsafe fn new(factor: u32, window: &Window) -> Self {
let entry = Entry::linked(); let entry = Entry::linked();
let name = std::ffi::CString::new("gameboy").unwrap(); let name = std::ffi::CString::new("gameboy").unwrap();
@ -265,42 +282,6 @@ impl WindowData {
}) })
.collect(); .collect();
let device_memory_properties = instance.get_physical_device_memory_properties(pdevice); let device_memory_properties = instance.get_physical_device_memory_properties(pdevice);
let depth_image_create_info = vk::ImageCreateInfo::default()
.image_type(vk::ImageType::TYPE_2D)
.format(vk::Format::D16_UNORM)
.extent(surface_resolution.into())
.mip_levels(1)
.array_layers(1)
.samples(vk::SampleCountFlags::TYPE_1)
.tiling(vk::ImageTiling::OPTIMAL)
.usage(vk::ImageUsageFlags::DEPTH_STENCIL_ATTACHMENT)
.sharing_mode(vk::SharingMode::EXCLUSIVE);
let depth_image = device.create_image(&depth_image_create_info, None).unwrap();
let depth_image_memory_req = device.get_image_memory_requirements(depth_image);
let depth_image_memory_index = device_memory_properties.memory_types
[..device_memory_properties.memory_type_count as _]
.iter()
.enumerate()
.find(|(index, memory_type)| {
(1 << index) & depth_image_memory_req.memory_type_bits != 0
&& memory_type.property_flags & vk::MemoryPropertyFlags::DEVICE_LOCAL
== vk::MemoryPropertyFlags::DEVICE_LOCAL
})
.map(|(index, _memory_type)| index as _)
.expect("Unable to find suitable memory index for depth image.");
let depth_image_allocate_info = vk::MemoryAllocateInfo::default()
.allocation_size(depth_image_memory_req.size)
.memory_type_index(depth_image_memory_index);
let depth_image_memory = device
.allocate_memory(&depth_image_allocate_info, None)
.unwrap();
device
.bind_image_memory(depth_image, depth_image_memory, 0)
.expect("Unable to bind depth image memory");
let fence_create_info = let fence_create_info =
vk::FenceCreateInfo::default().flags(vk::FenceCreateFlags::SIGNALED); vk::FenceCreateInfo::default().flags(vk::FenceCreateFlags::SIGNALED);
@ -312,57 +293,6 @@ impl WindowData {
.create_fence(&fence_create_info, None) .create_fence(&fence_create_info, None)
.expect("Create fence failed."); .expect("Create fence failed.");
record_submit_commandbuffer(
&device,
setup_command_buffer,
setup_commands_reuse_fence,
present_queue,
&[],
&[],
&[],
|device, setup_command_buffer| {
let layout_transition_barriers = vk::ImageMemoryBarrier::default()
.image(depth_image)
.dst_access_mask(
vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_READ
| vk::AccessFlags::DEPTH_STENCIL_ATTACHMENT_WRITE,
)
.new_layout(vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
.old_layout(vk::ImageLayout::UNDEFINED)
.subresource_range(
vk::ImageSubresourceRange::default()
.aspect_mask(vk::ImageAspectFlags::DEPTH)
.layer_count(1)
.level_count(1),
);
device.cmd_pipeline_barrier(
setup_command_buffer,
vk::PipelineStageFlags::BOTTOM_OF_PIPE,
vk::PipelineStageFlags::LATE_FRAGMENT_TESTS,
vk::DependencyFlags::empty(),
&[],
&[],
&[layout_transition_barriers],
);
},
);
let depth_image_view_info = vk::ImageViewCreateInfo::default()
.subresource_range(
vk::ImageSubresourceRange::default()
.aspect_mask(vk::ImageAspectFlags::DEPTH)
.level_count(1)
.layer_count(1),
)
.image(depth_image)
.format(depth_image_create_info.format)
.view_type(vk::ImageViewType::TYPE_2D);
let depth_image_view = device
.create_image_view(&depth_image_view_info, None)
.unwrap();
let semaphore_create_info = vk::SemaphoreCreateInfo::default(); let semaphore_create_info = vk::SemaphoreCreateInfo::default();
let present_complete_semaphore = device let present_complete_semaphore = device
@ -372,32 +302,18 @@ impl WindowData {
.create_semaphore(&semaphore_create_info, None) .create_semaphore(&semaphore_create_info, None)
.unwrap(); .unwrap();
let renderpass_attachments = [ let renderpass_attachments = [vk::AttachmentDescription {
vk::AttachmentDescription { format: surface_format.format,
format: surface_format.format, samples: vk::SampleCountFlags::TYPE_1,
samples: vk::SampleCountFlags::TYPE_1, load_op: vk::AttachmentLoadOp::CLEAR,
load_op: vk::AttachmentLoadOp::CLEAR, store_op: vk::AttachmentStoreOp::STORE,
store_op: vk::AttachmentStoreOp::STORE, final_layout: vk::ImageLayout::PRESENT_SRC_KHR,
final_layout: vk::ImageLayout::PRESENT_SRC_KHR, ..Default::default()
..Default::default() }];
},
vk::AttachmentDescription {
format: vk::Format::D16_UNORM,
samples: vk::SampleCountFlags::TYPE_1,
load_op: vk::AttachmentLoadOp::CLEAR,
initial_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
final_layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
..Default::default()
},
];
let color_attachment_refs = [vk::AttachmentReference { let color_attachment_refs = [vk::AttachmentReference {
attachment: 0, attachment: 0,
layout: vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL, layout: vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL,
}]; }];
let depth_attachment_ref = vk::AttachmentReference {
attachment: 1,
layout: vk::ImageLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
};
let dependencies = [vk::SubpassDependency { let dependencies = [vk::SubpassDependency {
src_subpass: vk::SUBPASS_EXTERNAL, src_subpass: vk::SUBPASS_EXTERNAL,
src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT, src_stage_mask: vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT,
@ -409,7 +325,6 @@ impl WindowData {
let subpass = vk::SubpassDescription::default() let subpass = vk::SubpassDescription::default()
.color_attachments(&color_attachment_refs) .color_attachments(&color_attachment_refs)
.depth_stencil_attachment(&depth_attachment_ref)
.pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS); .pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS);
let renderpass_create_info = vk::RenderPassCreateInfo::default() let renderpass_create_info = vk::RenderPassCreateInfo::default()
@ -424,7 +339,7 @@ impl WindowData {
let framebuffers: Vec<vk::Framebuffer> = present_image_views let framebuffers: Vec<vk::Framebuffer> = present_image_views
.iter() .iter()
.map(|&present_image_view| { .map(|&present_image_view| {
let framebuffer_attachments = [present_image_view, depth_image_view]; let framebuffer_attachments = [present_image_view];
let frame_buffer_create_info = vk::FramebufferCreateInfo::default() let frame_buffer_create_info = vk::FramebufferCreateInfo::default()
.render_pass(renderpass) .render_pass(renderpass)
.attachments(&framebuffer_attachments) .attachments(&framebuffer_attachments)
@ -437,49 +352,9 @@ impl WindowData {
.unwrap() .unwrap()
}) })
.collect(); .collect();
let index_buffer_data = [0u32, 1, 2, 2, 3, 0];
let index_buffer_info = vk::BufferCreateInfo {
size: std::mem::size_of_val(&index_buffer_data) as u64,
usage: vk::BufferUsageFlags::INDEX_BUFFER,
sharing_mode: vk::SharingMode::EXCLUSIVE,
..Default::default()
};
let index_buffer = device.create_buffer(&index_buffer_info, None).unwrap();
let index_buffer_memory_req = device.get_buffer_memory_requirements(index_buffer);
let index_buffer_memory_index = find_memorytype_index(
&index_buffer_memory_req,
&device_memory_properties,
vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT,
)
.expect("Unable to find suitable memorytype for the index buffer.");
let index_allocate_info = vk::MemoryAllocateInfo {
allocation_size: index_buffer_memory_req.size,
memory_type_index: index_buffer_memory_index,
..Default::default()
};
let index_buffer_memory = device.allocate_memory(&index_allocate_info, None).unwrap();
let index_ptr: *mut std::ffi::c_void = device
.map_memory(
index_buffer_memory,
0,
index_buffer_memory_req.size,
vk::MemoryMapFlags::empty(),
)
.unwrap();
let mut index_slice = Align::new(
index_ptr,
std::mem::align_of::<u32>() as u64,
index_buffer_memory_req.size,
);
index_slice.copy_from_slice(&index_buffer_data);
device.unmap_memory(index_buffer_memory);
device
.bind_buffer_memory(index_buffer, index_buffer_memory, 0)
.unwrap();
let vertices: [Vertex; 3] = [Vertex(-1.0, -1.0), Vertex(3.0, -1.0), Vertex(-1.0, 3.0)];
let vertex_input_buffer_info = vk::BufferCreateInfo { let vertex_input_buffer_info = vk::BufferCreateInfo {
size: std::mem::size_of_val(&vertices) as u64, size: std::mem::size_of_val(&VERTICES) as u64,
usage: vk::BufferUsageFlags::VERTEX_BUFFER, usage: vk::BufferUsageFlags::VERTEX_BUFFER,
sharing_mode: vk::SharingMode::EXCLUSIVE, sharing_mode: vk::SharingMode::EXCLUSIVE,
..Default::default() ..Default::default()
@ -518,7 +393,7 @@ impl WindowData {
std::mem::align_of::<Vertex>() as u64, std::mem::align_of::<Vertex>() as u64,
vertex_input_buffer_memory_req.size, vertex_input_buffer_memory_req.size,
); );
slice.copy_from_slice(&vertices); slice.copy_from_slice(&VERTICES);
device.unmap_memory(vertex_input_buffer_memory); device.unmap_memory(vertex_input_buffer_memory);
device device
.bind_buffer_memory(vertex_input_buffer, vertex_input_buffer_memory, 0) .bind_buffer_memory(vertex_input_buffer, vertex_input_buffer_memory, 0)
@ -838,23 +713,6 @@ impl WindowData {
let multisample_state_info = vk::PipelineMultisampleStateCreateInfo::default() let multisample_state_info = vk::PipelineMultisampleStateCreateInfo::default()
.rasterization_samples(vk::SampleCountFlags::TYPE_1); .rasterization_samples(vk::SampleCountFlags::TYPE_1);
let noop_stencil_state = vk::StencilOpState {
fail_op: vk::StencilOp::KEEP,
pass_op: vk::StencilOp::KEEP,
depth_fail_op: vk::StencilOp::KEEP,
compare_op: vk::CompareOp::ALWAYS,
..Default::default()
};
let depth_state_info = vk::PipelineDepthStencilStateCreateInfo {
depth_test_enable: 1,
depth_write_enable: 1,
depth_compare_op: vk::CompareOp::LESS_OR_EQUAL,
front: noop_stencil_state,
back: noop_stencil_state,
max_depth_bounds: 1.0,
..Default::default()
};
let color_blend_attachment_states = [vk::PipelineColorBlendAttachmentState { let color_blend_attachment_states = [vk::PipelineColorBlendAttachmentState {
blend_enable: 0, blend_enable: 0,
src_color_blend_factor: vk::BlendFactor::SRC_COLOR, src_color_blend_factor: vk::BlendFactor::SRC_COLOR,
@ -880,7 +738,6 @@ impl WindowData {
.viewport_state(&viewport_state_info) .viewport_state(&viewport_state_info)
.rasterization_state(&rasterization_info) .rasterization_state(&rasterization_info)
.multisample_state(&multisample_state_info) .multisample_state(&multisample_state_info)
.depth_stencil_state(&depth_state_info)
.color_blend_state(&color_blend_state) .color_blend_state(&color_blend_state)
.dynamic_state(&dynamic_state_info) .dynamic_state(&dynamic_state_info)
.layout(pipeline_layout) .layout(pipeline_layout)
@ -903,9 +760,6 @@ impl WindowData {
pool, pool,
draw_command_buffer, draw_command_buffer,
setup_command_buffer, setup_command_buffer,
depth_image,
depth_image_view,
depth_image_memory,
present_complete_semaphore, present_complete_semaphore,
rendering_complete_semaphore, rendering_complete_semaphore,
draw_commands_reuse_fence, draw_commands_reuse_fence,
@ -918,12 +772,9 @@ impl WindowData {
graphics_pipelines, graphics_pipelines,
viewports, viewports,
scissors, scissors,
index_buffer,
index_buffer_data,
shader_module, shader_module,
vertex_input_buffer_memory, vertex_input_buffer_memory,
texture_memory, texture_memory,
index_buffer_memory,
tex_image_view, tex_image_view,
desc_set_layouts, desc_set_layouts,
descriptor_pool, descriptor_pool,
@ -936,11 +787,11 @@ impl WindowData {
} }
} }
pub fn resize(&mut self, _width: u32, _height: u32, factor: u32, window: &Window) { fn resize(&mut self, _width: u32, _height: u32, factor: u32, window: &Window) {
*self = unsafe { Self::new(factor, window) }; *self = unsafe { Self::new(factor, window) };
} }
pub fn new_frame(&mut self, buffer: &[[u8; 4]]) { fn new_frame(&mut self, buffer: &[[u8; 4]]) {
unsafe { unsafe {
let image_ptr = self let image_ptr = self
.device .device
@ -1037,7 +888,7 @@ impl WindowData {
} }
} }
pub fn render(&mut self) { fn render(&mut self) {
unsafe { unsafe {
let (present_index, _) = self let (present_index, _) = self
.swapchain_loader .swapchain_loader
@ -1048,19 +899,11 @@ impl WindowData {
vk::Fence::null(), vk::Fence::null(),
) )
.unwrap(); .unwrap();
let clear_values = [ let clear_values = [vk::ClearValue {
vk::ClearValue { color: vk::ClearColorValue {
color: vk::ClearColorValue { float32: [0.0, 0.0, 0.0, 0.0],
float32: [0.0, 0.0, 0.0, 0.0],
},
}, },
vk::ClearValue { }];
depth_stencil: vk::ClearDepthStencilValue {
depth: 1.0,
stencil: 0,
},
},
];
let render_pass_begin_info = vk::RenderPassBeginInfo::default() let render_pass_begin_info = vk::RenderPassBeginInfo::default()
.render_pass(self.renderpass) .render_pass(self.renderpass)
@ -1103,20 +946,7 @@ impl WindowData {
&[self.vertex_input_buffer], &[self.vertex_input_buffer],
&[0], &[0],
); );
device.cmd_bind_index_buffer( device.cmd_draw(draw_command_buffer, VERTICES.len() as u32, 1, 0, 1);
draw_command_buffer,
self.index_buffer,
0,
vk::IndexType::UINT32,
);
device.cmd_draw_indexed(
draw_command_buffer,
self.index_buffer_data.len() as u32,
1,
0,
0,
1,
);
device.cmd_end_render_pass(draw_command_buffer); device.cmd_end_render_pass(draw_command_buffer);
}, },
); );
@ -1135,7 +965,7 @@ impl WindowData {
} }
} }
impl Drop for WindowData { impl Drop for VulkanWindowInner {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
self.device.device_wait_idle().unwrap(); self.device.device_wait_idle().unwrap();
@ -1151,8 +981,6 @@ impl Drop for WindowData {
self.device.free_memory(self.texture_memory, None); self.device.free_memory(self.texture_memory, None);
self.device.destroy_image_view(self.tex_image_view, None); self.device.destroy_image_view(self.tex_image_view, None);
self.device.destroy_image(self.texture_image, None); self.device.destroy_image(self.texture_image, None);
self.device.free_memory(self.index_buffer_memory, None);
self.device.destroy_buffer(self.index_buffer, None);
self.device self.device
.free_memory(self.vertex_input_buffer_memory, None); .free_memory(self.vertex_input_buffer_memory, None);
self.device.destroy_buffer(self.vertex_input_buffer, None); self.device.destroy_buffer(self.vertex_input_buffer, None);
@ -1176,9 +1004,7 @@ impl Drop for WindowData {
.destroy_fence(self.draw_commands_reuse_fence, None); .destroy_fence(self.draw_commands_reuse_fence, None);
self.device self.device
.destroy_fence(self.setup_commands_reuse_fence, None); .destroy_fence(self.setup_commands_reuse_fence, None);
self.device.free_memory(self.depth_image_memory, None);
self.device.destroy_image_view(self.depth_image_view, None);
self.device.destroy_image(self.depth_image, None);
for &image_view in self.present_image_views.iter() { for &image_view in self.present_image_views.iter() {
self.device.destroy_image_view(image_view, None); self.device.destroy_image_view(image_view, None);
} }

View file

@ -114,9 +114,7 @@ impl WindowRenderer {
let real_factor = (window.scale_factor() * factor as f64) as usize; let real_factor = (window.scale_factor() * factor as f64) as usize;
let data = Arc::new(Mutex::new(unsafe { let data = Arc::new(Mutex::new(WindowData::new(real_factor as u32, &window)));
WindowData::new(real_factor as u32, &window)
}));
let info = WindowInfo { let info = WindowInfo {
id: window.id(), id: window.id(),
data: data.clone(), data: data.clone(),