From 913d25cd829b9f2ee7a77f5687a829e64d0cd842 Mon Sep 17 00:00:00 2001 From: hodasemi Date: Fri, 29 Mar 2024 08:43:44 +0100 Subject: [PATCH] Refine more lifetimes --- vulkan-rs/src/acceleration_structure.rs | 55 +-- vulkan-rs/src/buffer.rs | 14 +- vulkan-rs/src/commandbuffer.rs | 358 ++++++++---------- vulkan-rs/src/descriptorpool.rs | 12 +- vulkan-rs/src/descriptorset.rs | 98 ++--- vulkan-rs/src/framebuffer.rs | 34 +- vulkan-rs/src/image.rs | 28 +- .../src/pipelines/shader_binding_table.rs | 8 +- vulkan-rs/src/render_target/mod.rs | 60 +-- vulkan-rs/src/render_target/sub_pass.rs | 30 +- vulkan-rs/src/single_submit/mod.rs | 18 +- 11 files changed, 328 insertions(+), 387 deletions(-) diff --git a/vulkan-rs/src/acceleration_structure.rs b/vulkan-rs/src/acceleration_structure.rs index 0e18daa..cf98a45 100644 --- a/vulkan-rs/src/acceleration_structure.rs +++ b/vulkan-rs/src/acceleration_structure.rs @@ -37,9 +37,9 @@ pub struct AccelerationStructureBuilder { } impl AccelerationStructureBuilder { - pub fn add_instance<'a>( + pub fn add_instance<'device>( mut self, - blas: &AccelerationStructure<'a>, + blas: &AccelerationStructure<'device>, transform: Option>, instance_flags: impl Into, ) -> Self { @@ -122,11 +122,11 @@ impl AccelerationStructureBuilder { self } - pub fn build<'a>( + pub fn build<'device, 'pipeline, 'cbuffer>( self, - device: &'a Device, - recorder: &mut CommandBufferRecorder<'_, '_>, - ) -> Result> { + device: &'device Device, + recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>, + ) -> Result> { let build_flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR | VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR; @@ -270,21 +270,21 @@ impl AccelerationStructureBuilder { } } -pub struct AccelerationStructure<'a> { - device: &'a Device, +pub struct AccelerationStructure<'device> { + device: &'device Device, acceleration_structure: VkAccelerationStructureKHR, - result_buffer: Buffer<'a, RawBuffer>, - scratch_buffer: Mutex>, + result_buffer: Buffer<'device, RawBuffer>, + scratch_buffer: Mutex>, update_scratch_buffer_size: VkDeviceSize, - generation_data: AccelerationStructureGenerationData<'a>, + generation_data: AccelerationStructureGenerationData<'device>, build_flags: VkBuildAccelerationStructureFlagBitsKHR, } -impl<'a> AccelerationStructure<'a> { +impl<'device> AccelerationStructure<'device> { pub fn bottom_level() -> AccelerationStructureBuilder { AccelerationStructureBuilder { flags: 0.into(), @@ -303,7 +303,7 @@ impl<'a> AccelerationStructure<'a> { } } - pub fn result_buffer(&self) -> &Buffer<'a, RawBuffer> { + pub fn result_buffer(&self) -> &Buffer<'device, RawBuffer> { &self.result_buffer } @@ -313,7 +313,10 @@ impl<'a> AccelerationStructure<'a> { ) } - pub fn update(&self, buffer_recorder: &mut CommandBufferRecorder<'_, '_>) -> Result<()> { + pub fn update<'pipeline, 'cbuffer>( + &self, + buffer_recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>, + ) -> Result<()> { *self.scratch_buffer.lock().unwrap() = Self::create_scratch_buffer( &self.device, self.update_scratch_buffer_size, @@ -330,9 +333,9 @@ impl<'a> AccelerationStructure<'a> { ) } - fn generate( + fn generate<'pipeline, 'cbuffer>( &self, - buffer_recorder: &mut CommandBufferRecorder<'_, '_>, + buffer_recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>, src: VkAccelerationStructureKHR, mode: VkBuildAccelerationStructureModeKHR, ) -> Result<()> { @@ -390,10 +393,10 @@ impl<'a> AccelerationStructure<'a> { #[inline] fn create_scratch_buffer( - device: &'a Device, + device: &'device Device, size: VkDeviceSize, alignment: VkDeviceSize, - ) -> Result> { + ) -> Result> { Buffer::builder() .set_usage( VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, @@ -418,11 +421,11 @@ impl_vk_handle!( acceleration_structure ); -enum AccelerationStructureGenerationData<'a> { +enum AccelerationStructureGenerationData<'device> { TopLevel( Vec, VkAccelerationStructureGeometryKHR, - Buffer<'a, VkAccelerationStructureInstanceKHR>, + Buffer<'device, VkAccelerationStructureInstanceKHR>, ), BottomLevel( Vec, @@ -430,26 +433,26 @@ enum AccelerationStructureGenerationData<'a> { ), } -impl<'a> +impl<'device> From<( Vec, VkAccelerationStructureGeometryKHR, - Buffer<'a, VkAccelerationStructureInstanceKHR>, - )> for AccelerationStructureGenerationData<'a> + Buffer<'device, VkAccelerationStructureInstanceKHR>, + )> for AccelerationStructureGenerationData<'device> { fn from( (instances, geometry, buffer): ( Vec, VkAccelerationStructureGeometryKHR, - Buffer<'a, VkAccelerationStructureInstanceKHR>, + Buffer<'device, VkAccelerationStructureInstanceKHR>, ), ) -> Self { Self::TopLevel(instances, geometry, buffer) } } -impl<'a> From<(Vec, Vec)> - for AccelerationStructureGenerationData<'a> +impl<'device> From<(Vec, Vec)> + for AccelerationStructureGenerationData<'device> { fn from( (geometries, primitive_counts): (Vec, Vec), diff --git a/vulkan-rs/src/buffer.rs b/vulkan-rs/src/buffer.rs index ab2095a..da15cb8 100644 --- a/vulkan-rs/src/buffer.rs +++ b/vulkan-rs/src/buffer.rs @@ -121,11 +121,11 @@ impl<'a, T: ReprC + Clone + Send + Sync + 'static> BufferBuilder<'a, T> { } #[derive(Debug)] -pub struct Buffer<'a, T: ReprC> { - device: &'a Device, +pub struct Buffer<'device, T: ReprC> { + device: &'device Device, buffer: VkBuffer, - memory: Memory<'a, T>, + memory: Memory<'device, T>, _usage: VkBufferUsageFlagBits, @@ -133,7 +133,7 @@ pub struct Buffer<'a, T: ReprC> { size: VkDeviceSize, } -impl<'a, T: ReprC + Clone + Send + Sync + 'static> Buffer<'a, T> { +impl<'device, T: ReprC + Clone + Send + Sync + 'static> Buffer<'device, T> { pub fn fill(&self, data: &[T]) -> Result<()> { let mut buffer_map = self.map(data.len() as VkDeviceSize)?; @@ -150,13 +150,13 @@ impl<'a, T: ReprC + Clone + Send + Sync + 'static> Buffer<'a, T> { self.memory.map(self.size) } - pub fn into_device_local<'b>( + pub fn into_device_local<'pipeline, 'cbuffer>( &self, - buffer_recorder: &mut CommandBufferRecorder<'a, 'b>, + buffer_recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>, access_mask: impl Into, stage: impl Into, usage: impl Into, - ) -> Result> { + ) -> Result> { let new_usage = usage.into() | VK_BUFFER_USAGE_TRANSFER_DST_BIT; let device_local_buffer = Buffer::builder() diff --git a/vulkan-rs/src/commandbuffer.rs b/vulkan-rs/src/commandbuffer.rs index 7f632e4..8828d95 100644 --- a/vulkan-rs/src/commandbuffer.rs +++ b/vulkan-rs/src/commandbuffer.rs @@ -6,7 +6,6 @@ use crate::prelude::*; use anyhow::Result; -use std::any::Any; use std::sync::Mutex; pub struct QueryEnable { @@ -53,36 +52,33 @@ impl CommandBufferBuilder { buffer: command_buffer, calls: 0, - stored_handles: Vec::new(), }) } } #[derive(Debug)] -pub struct CommandBuffer<'a> { - device: &'a Device, - pool: CommandPool<'a>, +pub struct CommandBuffer<'device> { + device: &'device Device, + pool: CommandPool<'device>, buffer: VkCommandBuffer, calls: usize, - stored_handles: Vec<&'a (dyn Any + Send + Sync)>, } #[derive(Debug)] -pub struct CommandBufferRecorder<'a, 'b> { - device: &'a Device, +pub struct CommandBufferRecorder<'device, 'pipeline, 'cbuffer> { + device: &'device Device, sub_pass: u32, - pipeline: Option<&'a Pipeline<'a>>, + pipeline: Option<&'pipeline Pipeline<'device>>, - calls: &'b mut usize, + calls: &'cbuffer mut usize, buffer: VkCommandBuffer, - handles_lock: &'b mut Vec<&'a (dyn Any + Send + Sync)>, } impl_vk_handle!(CommandBuffer<'a>, VkCommandBuffer, buffer); -impl<'a> CommandBuffer<'a> { +impl<'device> CommandBuffer<'device> { pub fn new_primary() -> CommandBufferBuilder { CommandBufferBuilder { buffer_level: VK_COMMAND_BUFFER_LEVEL_PRIMARY, @@ -105,17 +101,12 @@ impl<'a> CommandBuffer<'a> { self.calls } - pub fn begin<'b>( - &'a mut self, + pub fn begin<'pipeline, 'cbuffer>( + &'cbuffer mut self, begin_info: VkCommandBufferBeginInfo, - ) -> Result> - where - 'b: 'a, - 'a: 'b, - { + ) -> Result> { self.device.begin_command_buffer(self.buffer, &begin_info)?; - self.stored_handles.clear(); self.calls = 0; Ok(CommandBufferRecorder { @@ -125,7 +116,6 @@ impl<'a> CommandBuffer<'a> { calls: &mut self.calls, buffer: self.buffer, - handles_lock: &mut self.stored_handles, }) } @@ -162,10 +152,10 @@ impl<'a> CommandBuffer<'a> { } } - pub fn inheritance_info( - render_pass: Option<&RenderPass<'a>>, + pub fn inheritance_info<'image>( + render_pass: Option<&RenderPass<'device>>, sub_pass: Option, - framebuffer: Option<&Framebuffer<'a>>, + framebuffer: Option<&Framebuffer<'device, 'image>>, query_enable: Option, ) -> VkCommandBufferInheritanceInfo { let mut info = VkCommandBufferInheritanceInfo::new( @@ -188,9 +178,12 @@ impl<'a> CommandBuffer<'a> { } } -impl<'a, 'b> CommandBufferRecorder<'a, 'b> { +impl<'handle, 'me, 'device, 'pipeline, 'cbuffer> CommandBufferRecorder<'device, 'pipeline, 'cbuffer> +where + 'handle: 'me, +{ pub fn pipeline_barrier( - &mut self, + &'me mut self, src_stage_mask: impl Into, dst_stage_mask: impl Into, dependency_flags: impl Into, @@ -212,7 +205,7 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn memory_barrier( - &mut self, + &'me mut self, src_access_mask: impl Into, src_stage: VkPipelineStageFlags, dst_access_mask: impl Into, @@ -229,17 +222,13 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn buffer_barrier( - &'a mut self, - buffer: &'b Buffer<'a, T>, + &'me mut self, + buffer: &'handle Buffer<'device, T>, src_access_mask: impl Into, src_stage: impl Into, dst_access_mask: impl Into, dst_stage: impl Into, - ) where - 'b: 'a, - { - self.handles_lock.push(buffer); - + ) { self.pipeline_barrier( src_stage, dst_stage, @@ -259,18 +248,18 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn image_barrier( - &mut self, - image: &Image<'a>, + &'me mut self, + image: &'handle Image<'device>, old_image_layout: VkImageLayout, src_stage: impl Into, new_image_layout: VkImageLayout, dst_stage: impl Into, - ) { + ) where + 'handle: 'me, + { let src_access_mask = Image::src_layout_to_access(old_image_layout); let dst_access_mask = Image::dst_layout_to_access(new_image_layout); - self.handles_lock.push(image); - self.pipeline_barrier( src_stage, dst_stage, @@ -293,16 +282,14 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn image_barrier_auto_stage( - &mut self, - image: &Image<'a>, + &'me mut self, + image: &'handle Image<'device>, old_image_layout: VkImageLayout, new_image_layout: VkImageLayout, ) { let src_access_mask = Image::src_layout_to_access(old_image_layout); let dst_access_mask = Image::dst_layout_to_access(new_image_layout); - self.handles_lock.push(image); - self.pipeline_barrier( CommandBuffer::access_to_stage(src_access_mask), CommandBuffer::access_to_stage(dst_access_mask), @@ -325,7 +312,7 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn begin_render_pass( - &mut self, + &'me mut self, renderpass_begin_info: VkRenderPassBeginInfo, subpass_contents: VkSubpassContents, ) { @@ -335,16 +322,13 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { .cmd_begin_render_pass(self.buffer, &renderpass_begin_info, subpass_contents); } - pub fn begin_render_pass_full( - &mut self, - render_pass: &RenderPass<'a>, - framebuffer: &Framebuffer<'a>, + pub fn begin_render_pass_full<'image>( + &'me mut self, + render_pass: &'handle RenderPass<'device>, + framebuffer: &'handle Framebuffer<'device, 'image>, clear_values: &[VkClearValue], subpass_contents: VkSubpassContents, ) { - self.handles_lock.push(render_pass.clone()); - self.handles_lock.push(framebuffer.clone()); - self.sub_pass = 0; let render_pass_begin_info = VkRenderPassBeginInfo::new( @@ -364,18 +348,16 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { .cmd_begin_render_pass(self.buffer, &render_pass_begin_info, subpass_contents); } - pub fn next_subpass(&mut self, subpass_contents: VkSubpassContents) { + pub fn next_subpass(&'me mut self, subpass_contents: VkSubpassContents) { self.sub_pass += 1; self.device.cmd_next_subpass(self.buffer, subpass_contents); } - pub fn end_render_pass(&self) { + pub fn end_render_pass(&'me self) { self.device.cmd_end_render_pass(self.buffer); } - pub fn bind_pipeline(&mut self, pipeline: &Pipeline<'a>) -> Result<()> { - self.handles_lock.push(pipeline); - + pub fn bind_pipeline(&'me mut self, pipeline: &'pipeline Pipeline<'device>) -> Result<()> { match pipeline.pipeline_type() { PipelineType::Graphics => { debug_assert_eq!(self.sub_pass, pipeline.sub_pass()); @@ -398,12 +380,15 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { ), } - self.pipeline = Some(pipeline.clone()); + self.pipeline = Some(pipeline); Ok(()) } - pub fn execute_commands(&self, command_buffers: &[&impl VkHandle]) { + pub fn execute_commands( + &'me mut self, + command_buffers: &[&'handle impl VkHandle], + ) { *self.calls += 1; let buffers: Vec = @@ -413,7 +398,10 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { .cmd_execute_commands(self.buffer, buffers.as_slice()); } - pub fn bind_descriptor_sets_minimal(&mut self, descriptor_sets: &[&DescriptorSet<'a>]) { + pub fn bind_descriptor_sets_minimal<'a>( + &'me mut self, + descriptor_sets: &[&'handle DescriptorSet<'device, 'a>], + ) { *self.calls += 1; let (pipeline_bind_point, vk_layout) = { @@ -433,11 +421,7 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { let vk_descriptor_sets: Vec = descriptor_sets .iter() - .map(|ds: &&DescriptorSet<'a>| { - self.handles_lock.push((*ds).clone()); - - ds.vk_handle() - }) + .map(|ds: &&DescriptorSet<'device, 'a>| ds.vk_handle()) .collect(); self.device.cmd_bind_descriptor_sets( @@ -450,28 +434,25 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { ); } - pub fn bind_vertex_buffer(&mut self, buffer: &Buffer<'a, T>) { + pub fn bind_vertex_buffer( + &'me mut self, + buffer: &'handle Buffer<'device, T>, + ) { *self.calls += 1; - self.handles_lock.push(buffer); - self.device .cmd_bind_vertex_buffers(self.buffer, 0, &[buffer.vk_handle()], &[0]); } pub fn bind_vertex_buffers_minimal( - &mut self, - buffers: &[&Buffer<'a, T>], + &'me mut self, + buffers: &[&'handle Buffer<'device, T>], ) { *self.calls += 1; let vk_buffers: Vec = buffers .iter() - .map(|b: &&Buffer<'a, T>| { - self.handles_lock.push((*b).clone()); - - b.vk_handle() - }) + .map(|b: &&Buffer<'device, T>| b.vk_handle()) .collect(); let offsets = vec![0; vk_buffers.len()]; @@ -485,29 +466,27 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn bind_index_buffer( - &mut self, - buffer: &Buffer<'a, T>, + &'me mut self, + buffer: &'handle Buffer<'device, T>, offset: VkDeviceSize, index_type: VkIndexType, ) { *self.calls += 1; - self.handles_lock.push(buffer); - self.device .cmd_bind_index_buffer(self.buffer, buffer.vk_handle(), offset, index_type); } - pub fn set_viewport(&self, viewports: &[VkViewport]) { + pub fn set_viewport(&'me self, viewports: &[VkViewport]) { self.device.cmd_set_viewport(self.buffer, 0, viewports); } - pub fn set_scissor(&self, scissors: &[VkRect2D]) { + pub fn set_scissor(&'me self, scissors: &[VkRect2D]) { self.device.cmd_set_scissor(self.buffer, 0, scissors); } pub fn draw( - &self, + &'me mut self, vertex_count: u32, instance_count: u32, first_vertex: u32, @@ -524,14 +503,14 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { ); } - pub fn draw_complete_single_instance(&self, vertex_count: u32) { + pub fn draw_complete_single_instance(&'me mut self, vertex_count: u32) { *self.calls += 1; self.device.cmd_draw(self.buffer, vertex_count, 1, 0, 0); } pub fn draw_indexed( - &self, + &'me mut self, index_count: u32, instance_count: u32, first_index: u32, @@ -550,14 +529,18 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { ); } - pub fn draw_indexed_complete_single_instance(&self, index_count: u32) { + pub fn draw_indexed_complete_single_instance(&'me mut self, index_count: u32) { *self.calls += 1; self.device .cmd_draw_indexed(self.buffer, index_count, 1, 0, 0, 0); } - pub fn push_constants(&self, stage_flags: impl Into, data: &U) { + pub fn push_constants( + &'me mut self, + stage_flags: impl Into, + data: &U, + ) { *self.calls += 1; let pipeline = match &self.pipeline { @@ -572,16 +555,14 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn set_image_layout( - &mut self, - image: &Image<'a>, + &'me mut self, + image: &'handle Image<'device>, new_image_layout: VkImageLayout, subresource_range: VkImageSubresourceRange, ) { let src_access = Image::src_layout_to_access(image.image_layout()); let dst_access = Image::dst_layout_to_access(new_image_layout); - self.handles_lock.push(image); - self.pipeline_barrier( CommandBuffer::access_to_stage(src_access), CommandBuffer::access_to_stage(dst_access), @@ -603,12 +584,14 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { image.set_image_layout(new_image_layout); } - pub fn set_full_image_layout(&mut self, image: &Image<'a>, new_image_layout: VkImageLayout) { + pub fn set_full_image_layout( + &'me mut self, + image: &'handle Image<'device>, + new_image_layout: VkImageLayout, + ) { let src_access = Image::src_layout_to_access(image.image_layout()); let dst_access = Image::dst_layout_to_access(new_image_layout); - self.handles_lock.push(image); - self.pipeline_barrier( CommandBuffer::access_to_stage(src_access), CommandBuffer::access_to_stage(dst_access), @@ -631,63 +614,60 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } // TODO: - pub fn set_line_width(&self) { + pub fn set_line_width(&'me self) { unimplemented!(); } - pub fn set_depth_bias(&self) { + pub fn set_depth_bias(&'me self) { unimplemented!(); } - pub fn set_blend_constants(&self) { + pub fn set_blend_constants(&'me self) { unimplemented!(); } - pub fn set_depth_bounds(&self) { + pub fn set_depth_bounds(&'me self) { unimplemented!(); } - pub fn set_stencil_compare_mask(&self) { + pub fn set_stencil_compare_mask(&'me self) { unimplemented!(); } - pub fn set_stencil_write_mask(&self) { + pub fn set_stencil_write_mask(&'me self) { unimplemented!(); } - pub fn set_stencil_reference(&self) { + pub fn set_stencil_reference(&'me self) { unimplemented!(); } - pub fn draw_indirect(&self) { + pub fn draw_indirect(&'me self) { unimplemented!(); } - pub fn draw_indexed_indirect(&self) { + pub fn draw_indexed_indirect(&'me self) { unimplemented!(); } - pub fn dispatch(&self, x: u32, y: u32, z: u32) { + pub fn dispatch(&'me mut self, x: u32, y: u32, z: u32) { *self.calls += 1; self.device.cmd_dispatch(self.buffer, x, y, z); } - pub fn dispatch_indirect(&self) { + pub fn dispatch_indirect(&'me self) { unimplemented!(); } pub fn copy_buffer( - &mut self, - src_buffer: &Buffer<'a, T>, - dst_buffer: &Buffer<'a, U>, + &'me mut self, + src_buffer: &'handle Buffer<'device, T>, + dst_buffer: &'handle Buffer<'device, U>, regions: &[VkBufferCopy], ) { *self.calls += 1; - self.handles_lock.push(src_buffer); - self.handles_lock.push(dst_buffer); - self.device.cmd_copy_buffer( self.buffer, src_buffer.vk_handle(), @@ -697,18 +677,15 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn copy_image( - &mut self, - src_image: &Image<'a>, - dst_image: &Image<'a>, + &'me mut self, + src_image: &'handle Image<'device>, + dst_image: &'handle Image<'device>, src_layout: VkImageLayout, dst_layout: VkImageLayout, regions: &[VkImageCopy], ) { *self.calls += 1; - self.handles_lock.push(src_image); - self.handles_lock.push(dst_image); - self.device.cmd_copy_image( self.buffer, src_image.vk_handle(), @@ -720,14 +697,11 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn blit_complete( - &mut self, - src_image: &Image<'a>, - dst_image: &Image<'a>, + &'me mut self, + src_image: &'handle Image<'device>, + dst_image: &'handle Image<'device>, filter: VkFilter, ) { - self.handles_lock.push(src_image); - self.handles_lock.push(dst_image); - let image_blit = VkImageBlit { srcSubresource: src_image.full_resource_layers(), srcOffsets: [ @@ -760,9 +734,9 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn blit_image( - &mut self, - src_image: &Image<'a>, - dst_image: &Image<'a>, + &'me mut self, + src_image: &'handle Image<'device>, + dst_image: &'handle Image<'device>, src_layout: VkImageLayout, dst_layout: VkImageLayout, regions: &[VkImageBlit], @@ -770,9 +744,6 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { ) { *self.calls += 1; - self.handles_lock.push(src_image); - self.handles_lock.push(dst_image); - self.device.cmd_blit_image( self.buffer, src_image.vk_handle(), @@ -785,17 +756,14 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn copy_buffer_to_image( - &mut self, - src_buffer: &Buffer<'a, T>, - dst_image: &Image<'a>, + &'me mut self, + src_buffer: &'handle Buffer<'device, T>, + dst_image: &'handle Image<'device>, image_layout: VkImageLayout, regions: &[VkBufferImageCopy], ) { *self.calls += 1; - self.handles_lock.push(src_buffer); - self.handles_lock.push(dst_image); - self.device.cmd_copy_buffer_to_image( self.buffer, src_buffer.vk_handle(), @@ -806,17 +774,14 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn copy_image_to_buffer( - &mut self, - src_image: &Image<'a>, + &'me mut self, + src_image: &'handle Image<'device>, image_layout: VkImageLayout, - dst_buffer: &Buffer<'a, T>, + dst_buffer: &'handle Buffer<'device, T>, regions: &[VkBufferImageCopy], ) { *self.calls += 1; - self.handles_lock.push(src_image); - self.handles_lock.push(dst_buffer); - self.device.cmd_copy_image_to_buffer( self.buffer, src_image.vk_handle(), @@ -826,19 +791,21 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { ) } - pub fn update_buffer(&self) { + pub fn update_buffer(&'me self) { unimplemented!(); } - pub fn fill_buffer(&self) { + pub fn fill_buffer(&'me self) { unimplemented!(); } - pub fn clear_color_image(&mut self, image: &Image<'a>, clear_color: VkClearColorValue) { + pub fn clear_color_image( + &'me mut self, + image: &Image<'device>, + clear_color: VkClearColorValue, + ) { *self.calls += 1; - self.handles_lock.push(image); - self.device.cmd_clear_color_image( self.buffer, image.vk_handle(), @@ -848,25 +815,22 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { ); } - pub fn clear_depth_stencil_image(&self) { + pub fn clear_depth_stencil_image(&'me self) { unimplemented!(); } - pub fn clear_attachments(&self) { + pub fn clear_attachments(&'me self) { unimplemented!(); } pub fn resolve_image( - &mut self, - src_image: &Image<'a>, - dst_image: &Image<'a>, + &'me mut self, + src_image: &'handle Image<'device>, + dst_image: &'handle Image<'device>, regions: &[VkImageResolve], ) { *self.calls += 1; - self.handles_lock.push(src_image); - self.handles_lock.push(dst_image); - self.device.cmd_resolve_image( self.buffer, src_image.vk_handle(), @@ -877,61 +841,61 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { ); } - pub fn set_event(&self) { + pub fn set_event(&'me self) { unimplemented!(); } - pub fn reset_event(&self) { + pub fn reset_event(&'me self) { unimplemented!(); } - pub fn wait_events(&self) { + pub fn wait_events(&'me self) { unimplemented!(); } - pub fn begin_query(&self) { + pub fn begin_query(&'me self) { unimplemented!(); } - pub fn end_query(&self) { + pub fn end_query(&'me self) { unimplemented!(); } - pub fn reset_query_pool(&self) { + pub fn reset_query_pool(&'me self) { unimplemented!(); } pub fn write_timestamp( - &mut self, - query_pool: &QueryPool, + &'me mut self, + query_pool: &'handle QueryPool, query: u32, pipeline_stage: impl Into, ) { *self.calls += 1; - self.handles_lock.push(query_pool); - self.device .cmd_write_timestamp(self.buffer, pipeline_stage, query_pool.vk_handle(), query); } - pub fn copy_query_pool_results(&self) { + pub fn copy_query_pool_results(&'me self) { unimplemented!(); } } -impl<'a, 'b> CommandBufferRecorder<'a, 'b> { +impl<'me, 'handle, 'device, 'pipeline, 'cbuffer> CommandBufferRecorder<'device, 'pipeline, 'cbuffer> +where + 'handle: 'me, +{ pub fn build_acceleration_structure_indirect( - &mut self, + &'me mut self, infos: &[VkAccelerationStructureBuildGeometryInfoKHR], - indirect_buffers: &[Buffer<'a, impl ReprC + Send + Sync + 'static>], + indirect_buffers: &[Buffer<'device, impl ReprC + Send + Sync + 'static>], indirect_strides: &[u32], max_primitive_counts: &[&u32], ) { let mut device_addresses: Vec = Vec::with_capacity(indirect_buffers.len()); for indirect_buffer in indirect_buffers.iter() { - self.handles_lock.push(indirect_buffer); device_addresses.push(indirect_buffer.device_address().into()); } @@ -945,7 +909,7 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn build_acceleration_structures( - &self, + &'me self, infos: &[VkAccelerationStructureBuildGeometryInfoKHR], range_infos: &[&[VkAccelerationStructureBuildRangeInfoKHR]], ) { @@ -954,14 +918,11 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn copy_acceleration_structure( - &mut self, - src: &AccelerationStructure<'a>, - dst: &AccelerationStructure<'a>, + &'me mut self, + src: &'handle AccelerationStructure<'device>, + dst: &'handle AccelerationStructure<'device>, mode: VkCopyAccelerationStructureModeKHR, ) { - self.handles_lock.push(src); - self.handles_lock.push(dst); - let info = VkCopyAccelerationStructureInfoKHR::new(src.vk_handle(), dst.vk_handle(), mode); self.device @@ -969,13 +930,11 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn copy_acceleration_structure_to_memory( - &mut self, - src: &AccelerationStructure<'a>, + &'me mut self, + src: &'handle AccelerationStructure<'device>, dst: VkDeviceOrHostAddressKHR, mode: VkCopyAccelerationStructureModeKHR, ) { - self.handles_lock.push(src); - let info = VkCopyAccelerationStructureToMemoryInfoKHR::new(src.vk_handle(), dst, mode); self.device @@ -983,13 +942,11 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn copy_memory_to_acceleration_structure( - &mut self, + &'me mut self, src: VkDeviceOrHostAddressConstKHR, - dst: &AccelerationStructure<'a>, + dst: &'handle AccelerationStructure<'device>, mode: VkCopyAccelerationStructureModeKHR, ) { - self.handles_lock.push(dst); - let info = VkCopyMemoryToAccelerationStructureInfoKHR::new(src, dst.vk_handle(), mode); self.device @@ -997,12 +954,10 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn trace_rays_indirect( - &mut self, - sbt: ShaderBindingTable<'a>, - buffer: Buffer<'a, impl ReprC + Send + Sync + 'static>, + &'me mut self, + sbt: &'handle ShaderBindingTable<'device>, + buffer: &'handle Buffer<'device, impl ReprC + Send + Sync + 'static>, ) { - self.handles_lock.push(&buffer); - self.device.cmd_trace_rays_indirect( self.buffer, sbt.raygen_shader_binding_table(), @@ -1013,7 +968,13 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { ) } - pub fn trace_rays(&self, sbt: &ShaderBindingTable<'a>, width: u32, height: u32, depth: u32) { + pub fn trace_rays( + &'me self, + sbt: &'handle ShaderBindingTable<'device>, + width: u32, + height: u32, + depth: u32, + ) { self.device.cmd_trace_rays( self.buffer, sbt.raygen_shader_binding_table(), @@ -1027,20 +988,15 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } pub fn write_acceleration_structure_properties( - &mut self, - acceleration_structures: &[&AccelerationStructure<'a>], + &'me mut self, + acceleration_structures: &[&'handle AccelerationStructure<'device>], query_type: VkQueryType, - query_pool: &QueryPool, + query_pool: &'handle QueryPool, first_query: u32, ) { - self.handles_lock.push(query_pool); - let as_handles: Vec = acceleration_structures .iter() - .map(|a| { - self.handles_lock.push((*a).clone()); - a.vk_handle() - }) + .map(|a| a.vk_handle()) .collect(); self.device.cmd_write_acceleration_structure_properties( @@ -1053,20 +1009,20 @@ impl<'a, 'b> CommandBufferRecorder<'a, 'b> { } } -impl<'a> VulkanDevice for CommandBuffer<'a> { - fn device(&self) -> &Device { +impl<'device> VulkanDevice for CommandBuffer<'device> { + fn device(&self) -> &'device Device { &self.device } } -impl<'a> Drop for CommandBuffer<'a> { +impl<'device> Drop for CommandBuffer<'device> { fn drop(&mut self) { self.device .free_command_buffers(self.pool.vk_handle(), &[self.buffer]); } } -impl<'a, 'b> Drop for CommandBufferRecorder<'a, 'b> { +impl<'device, 'pipeline, 'cbuffer> Drop for CommandBufferRecorder<'device, 'pipeline, 'cbuffer> { fn drop(&mut self) { self.device.end_command_buffer(self.buffer).unwrap() } diff --git a/vulkan-rs/src/descriptorpool.rs b/vulkan-rs/src/descriptorpool.rs index c98cc78..98c129a 100644 --- a/vulkan-rs/src/descriptorpool.rs +++ b/vulkan-rs/src/descriptorpool.rs @@ -67,14 +67,14 @@ impl<'a> DescriptorPoolBuilder<'a> { } #[derive(Debug)] -pub struct DescriptorPool<'a> { - device: &'a Device, +pub struct DescriptorPool<'device> { + device: &'device Device, descriptor_pool: VkDescriptorPool, - pub(crate) descriptor_set_layout: &'a DescriptorSetLayout<'a>, + pub(crate) descriptor_set_layout: &'device DescriptorSetLayout<'device>, } -impl<'a> DescriptorPool<'a> { - pub fn builder() -> DescriptorPoolBuilder<'a> { +impl<'device> DescriptorPool<'device> { + pub fn builder() -> DescriptorPoolBuilder<'device> { DescriptorPoolBuilder { layout: None, descriptor_count: 1, @@ -87,7 +87,7 @@ impl<'a> DescriptorPool<'a> { .reset_descriptor_pool(self.descriptor_pool, VK_DESCRIPTOR_POOL_RESET_NULL_BIT) } - pub fn prepare_set(&self) -> DescriptorSetBuilder<'a> { + pub fn prepare_set(&'device self) -> DescriptorSetBuilder<'device> { DescriptorSet::builder(self.device, self) } } diff --git a/vulkan-rs/src/descriptorset.rs b/vulkan-rs/src/descriptorset.rs index 4504a1d..f561fe8 100644 --- a/vulkan-rs/src/descriptorset.rs +++ b/vulkan-rs/src/descriptorset.rs @@ -2,17 +2,15 @@ use crate::prelude::*; use anyhow::Result; -use std::any::Any; -use std::collections::HashMap; +use std::marker::PhantomData; use std::slice; -use std::sync::Mutex; #[derive(Debug)] -pub struct DescriptorWrite<'a> { +pub struct DescriptorWrite<'handle> { + lifetime: &'handle PhantomData<()>, binding: u32, descriptor_type: VkDescriptorType, inner: InnerWrite, - handles: Vec<&'a (dyn Any + Send + Sync)>, } #[derive(Debug)] @@ -27,10 +25,10 @@ enum InnerWrite { ), } -impl<'a> DescriptorWrite<'a> { +impl<'device, 'handle> DescriptorWrite<'handle> { pub fn uniform_buffers( binding: u32, - buffers: &[&Buffer<'a, T>], + buffers: &[&'handle Buffer<'device, T>], ) -> Self { DescriptorWrite { binding, @@ -45,16 +43,13 @@ impl<'a> DescriptorWrite<'a> { }) .collect(), ), - handles: buffers - .iter() - .map(|b| (*b) as &'a (dyn Any + Send + Sync)) - .collect(), + lifetime: &PhantomData, } } pub fn storage_buffers( binding: u32, - buffers: &[&Buffer<'a, T>], + buffers: &[&'handle Buffer<'device, T>], ) -> Self { DescriptorWrite { binding, @@ -69,14 +64,11 @@ impl<'a> DescriptorWrite<'a> { }) .collect(), ), - handles: buffers - .iter() - .map(|b| (*b) as &'a (dyn Any + Send + Sync)) - .collect(), + lifetime: &PhantomData, } } - pub fn combined_samplers(binding: u32, images: &[&'a Image<'a>]) -> Self { + pub fn combined_samplers(binding: u32, images: &[&'handle Image<'device>]) -> Self { DescriptorWrite { binding, descriptor_type: VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, @@ -94,14 +86,11 @@ impl<'a> DescriptorWrite<'a> { }) .collect(), ), - handles: images - .iter() - .map(|i| (*i).clone() as &'a (dyn Any + Send + Sync)) - .collect(), + lifetime: &PhantomData, } } - pub fn storage_images(binding: u32, images: &[&'a Image<'a>]) -> Self { + pub fn storage_images(binding: u32, images: &[&'handle Image<'device>]) -> Self { DescriptorWrite { binding, descriptor_type: VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, @@ -115,14 +104,11 @@ impl<'a> DescriptorWrite<'a> { }) .collect(), ), - handles: images - .iter() - .map(|i| (*i).clone() as &'a (dyn Any + Send + Sync)) - .collect(), + lifetime: &PhantomData, } } - pub fn input_attachments(binding: u32, images: &[&'a Image<'a>]) -> Self { + pub fn input_attachments(binding: u32, images: &[&'handle Image<'device>]) -> Self { DescriptorWrite { binding, descriptor_type: VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, @@ -136,16 +122,13 @@ impl<'a> DescriptorWrite<'a> { }) .collect(), ), - handles: images - .iter() - .map(|i| (*i) as &'a (dyn Any + Send + Sync)) - .collect(), + lifetime: &PhantomData, } } pub fn acceleration_structures( binding: u32, - acceleration_structures: &[&AccelerationStructure<'a>], + acceleration_structures: &[&'handle AccelerationStructure<'device>], ) -> Self { let vk_as: Vec = acceleration_structures .iter() @@ -159,10 +142,7 @@ impl<'a> DescriptorWrite<'a> { VkWriteDescriptorSetAccelerationStructureKHR::default(), vk_as, )), - handles: acceleration_structures - .iter() - .map(|a| (*a) as &'a (dyn Any + Send + Sync)) - .collect(), + lifetime: &PhantomData, }; if let InnerWrite::AS((vk_write_as, vk_as)) = &mut write.inner { @@ -212,7 +192,7 @@ impl<'a> DescriptorSetBuilder<'a> { self } - pub fn allocate(mut self) -> Result> { + pub fn allocate<'handle>(mut self) -> Result> { let layout = self.descriptor_pool.vk_handle(); let mut descriptor_set_ci = VkDescriptorSetAllocateInfo::new( @@ -233,25 +213,25 @@ impl<'a> DescriptorSetBuilder<'a> { pool: self.descriptor_pool, descriptor_set, - handles: Mutex::new(HashMap::new()), + lifetimes: &PhantomData, }) } } #[derive(Debug)] -pub struct DescriptorSet<'a> { - device: &'a Device, - pool: &'a DescriptorPool<'a>, +pub struct DescriptorSet<'device, 'handle> { + device: &'device Device, + pool: &'device DescriptorPool<'device>, descriptor_set: VkDescriptorSet, - handles: Mutex>>, + lifetimes: &'handle PhantomData<()>, } -impl<'a> DescriptorSet<'a> { +impl<'device, 'handle> DescriptorSet<'device, 'handle> { pub(crate) fn builder( - device: &'a Device, - descriptor_pool: &'a DescriptorPool<'a>, - ) -> DescriptorSetBuilder<'a> { + device: &'device Device, + descriptor_pool: &'device DescriptorPool<'device>, + ) -> DescriptorSetBuilder<'device> { DescriptorSetBuilder { device, descriptor_pool, @@ -263,7 +243,7 @@ impl<'a> DescriptorSet<'a> { } // TODO: add update function for VkCopyDescriptorSet - pub fn update(&self, writes: &[DescriptorWrite<'a>]) -> Result<()> { + pub fn update(&self, writes: &[DescriptorWrite<'handle>]) -> Result<()> { debug_assert!(!writes.is_empty()); #[cfg(debug_assertions)] @@ -278,7 +258,6 @@ impl<'a> DescriptorSet<'a> { } let mut vk_writes = Vec::new(); - let mut handles_lock = self.handles.lock().unwrap(); for write in writes { let mut write_desc = VkWriteDescriptorSet::new( @@ -291,13 +270,6 @@ impl<'a> DescriptorSet<'a> { write.vk_write(&mut write_desc); vk_writes.push(write_desc); - - match handles_lock.get_mut(&write.binding) { - Some(val) => *val = write.handles.clone(), - None => { - handles_lock.insert(write.binding, write.handles.clone()); - } - } } self.device @@ -307,27 +279,31 @@ impl<'a> DescriptorSet<'a> { } } -impl<'a> VulkanDevice for DescriptorSet<'a> { +impl<'device, 'handle> VulkanDevice for DescriptorSet<'device, 'handle> { fn device(&self) -> &Device { &self.device } } -impl_vk_handle!(DescriptorSet<'a>, VkDescriptorSet, descriptor_set); +impl_vk_handle!( + DescriptorSet<'device, 'handle>, + VkDescriptorSet, + descriptor_set +); -impl<'a> VkHandle for DescriptorSet<'a> { +impl<'device, 'handle> VkHandle for DescriptorSet<'device, 'handle> { fn vk_handle(&self) -> VkDescriptorSetLayout { self.pool.vk_handle() } } -impl<'a> VkHandle for &'a DescriptorSet<'a> { +impl<'a, 'device, 'handle> VkHandle for &'a DescriptorSet<'device, 'handle> { fn vk_handle(&self) -> VkDescriptorSetLayout { self.pool.vk_handle() } } -impl<'a> Drop for DescriptorSet<'a> { +impl<'device, 'handle> Drop for DescriptorSet<'device, 'handle> { fn drop(&mut self) { if let Err(error) = self .device @@ -363,7 +339,7 @@ mod test { .set_descriptor_set_count(DESCRIPTOR_COUNT) .build(&device)?; - let descriptors: Vec> = (0..DESCRIPTOR_COUNT) + let descriptors: Vec> = (0..DESCRIPTOR_COUNT) .map(|_| { let set = descriptor_pool.prepare_set().allocate(); diff --git a/vulkan-rs/src/framebuffer.rs b/vulkan-rs/src/framebuffer.rs index 56ccafa..f262161 100644 --- a/vulkan-rs/src/framebuffer.rs +++ b/vulkan-rs/src/framebuffer.rs @@ -2,22 +2,22 @@ use crate::prelude::*; use anyhow::Result; -pub struct FramebufferBuilder<'a, 'b> { - render_pass: Option<&'b RenderPass<'a>>, - attachments: Vec<&'a Image<'a>>, +pub struct FramebufferBuilder<'device, 'renderpass, 'image> { + render_pass: Option<&'renderpass RenderPass<'device>>, + attachments: Vec<&'image Image<'device>>, width: u32, height: u32, layers: u32, } -impl<'a, 'b> FramebufferBuilder<'a, 'b> { - pub fn set_render_pass(mut self, render_pass: &'b RenderPass<'a>) -> Self { +impl<'device, 'renderpass, 'image> FramebufferBuilder<'device, 'renderpass, 'image> { + pub fn set_render_pass(mut self, render_pass: &'renderpass RenderPass<'device>) -> Self { self.render_pass = Some(render_pass); self } - pub fn add_attachment(mut self, image: &'a Image<'a>) -> Self { + pub fn add_attachment(mut self, image: &'image Image<'device>) -> Self { self.attachments.push(image); self @@ -41,7 +41,7 @@ impl<'a, 'b> FramebufferBuilder<'a, 'b> { self } - pub fn build(mut self, device: &'a Device) -> Result> { + pub fn build(mut self, device: &'device Device) -> Result> { if self.attachments.is_empty() { panic!("no attachments added!"); } @@ -90,17 +90,17 @@ impl<'a, 'b> FramebufferBuilder<'a, 'b> { } #[derive(Debug)] -pub struct Framebuffer<'a> { - device: &'a Device, +pub struct Framebuffer<'device, 'image> { + device: &'device Device, framebuffer: VkFramebuffer, - images: Vec<&'a Image<'a>>, + images: Vec<&'image Image<'device>>, width: u32, height: u32, } -impl<'a> Framebuffer<'a> { - pub fn builder<'b>() -> FramebufferBuilder<'a, 'b> { +impl<'device, 'image> Framebuffer<'device, 'image> { + pub fn builder<'renderpass>() -> FramebufferBuilder<'device, 'renderpass, 'image> { FramebufferBuilder { render_pass: None, attachments: Vec::new(), @@ -118,11 +118,11 @@ impl<'a> Framebuffer<'a> { self.height } - pub fn attachments(&self) -> &[&'a Image<'a>] { + pub fn attachments(&self) -> &[&'image Image<'device>] { &self.images } - pub fn image(&self, index: usize) -> &Image<'a> { + pub fn image(&self, index: usize) -> &Image<'device> { &self.images[index] } @@ -131,15 +131,15 @@ impl<'a> Framebuffer<'a> { } } -impl<'a> VulkanDevice for Framebuffer<'a> { +impl<'device, 'image> VulkanDevice for Framebuffer<'device, 'image> { fn device(&self) -> &Device { &self.device } } -impl_vk_handle!(Framebuffer<'a>, VkFramebuffer, framebuffer); +impl_vk_handle!(Framebuffer<'device, 'image>, VkFramebuffer, framebuffer); -impl<'a> Drop for Framebuffer<'a> { +impl<'device, 'image> Drop for Framebuffer<'device, 'image> { fn drop(&mut self) { self.device.destroy_framebuffer(self.framebuffer); } diff --git a/vulkan-rs/src/image.rs b/vulkan-rs/src/image.rs index 0aa4312..241ddd0 100644 --- a/vulkan-rs/src/image.rs +++ b/vulkan-rs/src/image.rs @@ -385,7 +385,7 @@ impl<'a> ImageBuilder<'a> { fn create_from_source( device: &'a Device, - queue: &Mutex>, + queue: &'a Mutex>, info: &ImageCreateInfo<'a>, sampler: Option>, mut view_ci: VkImageViewCreateInfo, @@ -400,8 +400,8 @@ impl<'a> ImageBuilder<'a> { let image_view = device.create_image_view(&view_ci)?; Ok(Image { - device: device.clone(), - queue: queue.clone(), + device, + queue, image, image_view, @@ -448,7 +448,7 @@ impl<'a> ImageBuilder<'a> { fn optimize_fill( device: &'a Device, - queue: &Mutex>, + queue: &'a Mutex>, data: &[RawBuffer], image: &Image<'a>, ) -> Result<()> { @@ -952,14 +952,14 @@ fn into_layout<'a>(image: &Image<'a>, layout: VkImageLayout) -> Result<()> { fn copy_buffer_to_image<'a, T: ReprC + Send + Sync + 'static>( image: &Image<'a>, device: &'a Device, - queue: &Mutex>, + queue: &'a Mutex>, buffer: &Buffer<'a, T>, ) -> Result<()> where T: Copy, { // create a new command buffer - let mut command_buffer = CommandBuffer::new_primary().build(device.clone(), queue.clone())?; + let mut command_buffer = CommandBuffer::new_primary().build(device, queue)?; { // begin recording into this command buffer @@ -1046,7 +1046,7 @@ where fn copy_images_to_imagearray<'a>( device: &'a Device, - queue: &Mutex>, + queue: &'a Mutex>, image_array: &Image<'a>, images: &[Image<'a>], ) -> Result<()> { @@ -1118,10 +1118,10 @@ fn copy_images_to_imagearray<'a>( Ok(()) } -fn copy_image_to_image<'a>( - buffer_recorder: &mut CommandBufferRecorder<'_, '_>, - src_image: &Image<'a>, - dst_image: &Image<'a>, +fn copy_image_to_image<'device, 'pipeline, 'cbuffer>( + buffer_recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>, + src_image: &Image<'device>, + dst_image: &Image<'device>, mip_level: u32, dst_layer: u32, ) { @@ -1180,9 +1180,9 @@ fn copy_image_to_image<'a>( ); } -fn blit_mip_maps<'a>( - buffer_recorder: &mut CommandBufferRecorder<'_, '_>, - image: &Image<'a>, +fn blit_mip_maps<'device, 'pipeline, 'cbuffer>( + buffer_recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>, + image: &Image<'device>, target_image_layout: VkImageLayout, ) { let mut mip_width = image.width(); diff --git a/vulkan-rs/src/pipelines/shader_binding_table.rs b/vulkan-rs/src/pipelines/shader_binding_table.rs index d0ff611..5af670c 100644 --- a/vulkan-rs/src/pipelines/shader_binding_table.rs +++ b/vulkan-rs/src/pipelines/shader_binding_table.rs @@ -12,8 +12,8 @@ pub(crate) struct ShaderBindingTableBuilder { hit_group_entries: Vec, } -pub struct ShaderBindingTable<'a> { - _sbt_buffer: Buffer<'a, RawBuffer>, +pub struct ShaderBindingTable<'device> { + _sbt_buffer: Buffer<'device, RawBuffer>, raygen_shader_binding_table: VkStridedDeviceAddressRegionKHR, miss_shader_binding_table: VkStridedDeviceAddressRegionKHR, @@ -21,7 +21,7 @@ pub struct ShaderBindingTable<'a> { callable_shader_binding_table: VkStridedDeviceAddressRegionKHR, } -impl<'a> ShaderBindingTable<'a> { +impl<'device> ShaderBindingTable<'device> { pub fn raygen_shader_binding_table(&self) -> &VkStridedDeviceAddressRegionKHR { &self.raygen_shader_binding_table } @@ -39,7 +39,7 @@ impl<'a> ShaderBindingTable<'a> { } fn create( - sbt_buffer: Buffer<'a, RawBuffer>, + sbt_buffer: Buffer<'device, RawBuffer>, ray_gen_entry_size: VkDeviceSize, ray_gen_entry_count: VkDeviceSize, miss_offset: VkDeviceSize, diff --git a/vulkan-rs/src/render_target/mod.rs b/vulkan-rs/src/render_target/mod.rs index 9ea7b7a..04c7c65 100644 --- a/vulkan-rs/src/render_target/mod.rs +++ b/vulkan-rs/src/render_target/mod.rs @@ -5,25 +5,28 @@ use std::sync::atomic::{AtomicU32, AtomicUsize, Ordering::SeqCst}; pub mod sub_pass; use sub_pass::{AttachmentInfo, AttachmentInfoUsage, SubPass}; -pub struct RenderTargetBuilder<'a> { - old_render_target: Option>, - sub_passes: Vec>, +pub struct RenderTargetBuilder<'device, 'image> { + old_render_target: Option>, + sub_passes: Vec>, } -impl<'a> RenderTargetBuilder<'a> { - pub fn add_sub_pass(mut self, sub_pass: SubPass<'a>) -> Self { +impl<'device, 'image> RenderTargetBuilder<'device, 'image> { + pub fn add_sub_pass(mut self, sub_pass: SubPass<'device>) -> Self { self.sub_passes.push(sub_pass); self } - pub fn preserve_old_render_pass(mut self, render_target: RenderTarget<'a>) -> Self { + pub fn preserve_old_render_pass( + mut self, + render_target: RenderTarget<'device, 'image>, + ) -> Self { self.old_render_target = Some(render_target); self } - pub fn build(self, device: &'a Device) -> Result> { + pub fn build(self, device: &'device Device) -> Result> { #[cfg(debug_assertions)] { // sub passes must not be empty @@ -182,10 +185,10 @@ impl<'a> RenderTargetBuilder<'a> { }) } - fn create_framebuffers<'b>( - render_pass: &'b RenderPass<'a>, - sub_passes: &'b [SubPass<'a>], - ) -> Result>> { + fn create_framebuffers<'handle>( + render_pass: &'handle RenderPass<'device>, + sub_passes: &'handle [SubPass<'device>], + ) -> Result>> { let extent = sub_passes[0].extent(); (0..Self::max_images(sub_passes)) @@ -208,7 +211,7 @@ impl<'a> RenderTargetBuilder<'a> { } #[inline] - fn max_images(sub_passes: &[SubPass<'a>]) -> usize { + fn max_images(sub_passes: &[SubPass<'device>]) -> usize { let mut max_images = 0; for sub_pass in sub_passes.iter() { @@ -218,7 +221,10 @@ impl<'a> RenderTargetBuilder<'a> { max_images } - fn verify_setups(old_sub_passes: &[SubPass<'a>], new_sub_passes: &[SubPass<'a>]) -> bool { + fn verify_setups( + old_sub_passes: &[SubPass<'device>], + new_sub_passes: &[SubPass<'device>], + ) -> bool { if old_sub_passes.len() != new_sub_passes.len() { return false; } @@ -233,9 +239,9 @@ impl<'a> RenderTargetBuilder<'a> { } #[inline] - fn map_attachment<'b, F>(&'b self, mut f: F) + fn map_attachment<'handle, F>(&'handle self, mut f: F) where - F: FnMut(&'b AttachmentInfo<'a>) -> (), + F: FnMut(&'handle AttachmentInfo<'device>) -> (), { for sub_pass in self.sub_passes.iter() { for attachment in sub_pass.attachments().iter() { @@ -257,36 +263,36 @@ struct SubPassAttachmentReferences { } #[derive(Debug)] -pub struct RenderTarget<'a> { - render_pass: RenderPass<'a>, - framebuffers: Vec>, +pub struct RenderTarget<'device, 'image> { + render_pass: RenderPass<'device>, + framebuffers: Vec>, clear_values: Vec, extent: VkExtent2D, - sub_passes: Vec>, + sub_passes: Vec>, current_subpass: AtomicU32, framebuffer_index: AtomicUsize, } -impl<'a> RenderTarget<'a> { - pub fn builder() -> RenderTargetBuilder<'a> { +impl<'device, 'image> RenderTarget<'device, 'image> { + pub fn builder() -> RenderTargetBuilder<'device, 'image> { RenderTargetBuilder { old_render_target: None, sub_passes: Vec::new(), } } - pub fn render_pass(&self) -> &RenderPass<'a> { + pub fn render_pass(&self) -> &RenderPass<'device> { &self.render_pass } - pub fn framebuffer(&self, index: usize) -> &Framebuffer<'a> { + pub fn framebuffer(&self, index: usize) -> &Framebuffer<'device, 'image> { &self.framebuffers[index] } - pub fn sub_pass(&self, index: usize) -> &SubPass<'a> { + pub fn sub_pass(&self, index: usize) -> &SubPass<'device> { &self.sub_passes[index] } @@ -309,7 +315,7 @@ impl<'a> RenderTarget<'a> { pub fn begin( &self, - buffer_recorder: &mut CommandBufferRecorder<'_, '_>, + buffer_recorder: &mut CommandBufferRecorder<'device, '_, '_>, subpass_content: VkSubpassContents, framebuffer_index: usize, ) { @@ -331,14 +337,14 @@ impl<'a> RenderTarget<'a> { pub fn next_subpass( &self, - buffer_recorder: &mut CommandBufferRecorder<'_, '_>, + buffer_recorder: &mut CommandBufferRecorder<'device, '_, '_>, subpass_content: VkSubpassContents, ) { buffer_recorder.next_subpass(subpass_content); self.current_subpass.fetch_add(1, SeqCst); } - pub fn end(&self, buffer_recorder: &mut CommandBufferRecorder<'_, '_>) { + pub fn end(&self, buffer_recorder: &mut CommandBufferRecorder<'device, '_, '_>) { debug_assert_eq!( self.current_subpass.load(SeqCst) as usize, self.sub_passes.len() - 1 diff --git a/vulkan-rs/src/render_target/sub_pass.rs b/vulkan-rs/src/render_target/sub_pass.rs index 8990c5f..badf096 100644 --- a/vulkan-rs/src/render_target/sub_pass.rs +++ b/vulkan-rs/src/render_target/sub_pass.rs @@ -411,12 +411,12 @@ pub enum AttachmentInfoUsage { } #[derive(Debug)] -pub enum AttachmentInfoImages<'a> { - Owned(Vec>), - Ref(Vec<&'a Image<'a>>), +pub enum AttachmentInfoImages<'device> { + Owned(Vec>), + Ref(Vec<&'device Image<'device>>), } -impl<'a> AttachmentInfoImages<'a> { +impl<'device> AttachmentInfoImages<'device> { fn len(&self) -> usize { match self { AttachmentInfoImages::Owned(v) => v.len(), @@ -432,20 +432,20 @@ impl<'a> AttachmentInfoImages<'a> { } } -impl<'a> From>> for AttachmentInfoImages<'a> { - fn from(value: Vec>) -> Self { +impl<'device> From>> for AttachmentInfoImages<'device> { + fn from(value: Vec>) -> Self { Self::Owned(value) } } -impl<'a> From>> for AttachmentInfoImages<'a> { - fn from(value: Vec<&'a Image<'a>>) -> Self { +impl<'device> From>> for AttachmentInfoImages<'device> { + fn from(value: Vec<&'device Image<'device>>) -> Self { Self::Ref(value) } } -impl<'a> Index for AttachmentInfoImages<'a> { - type Output = Image<'a>; +impl<'device> Index for AttachmentInfoImages<'device> { + type Output = Image<'device>; fn index(&self, index: usize) -> &Self::Output { match self { @@ -484,17 +484,17 @@ impl<'a> AttachmentInfo<'a> { } #[derive(Debug)] -pub struct SubPass<'a> { +pub struct SubPass<'device> { extent: VkExtent2D, input_info: Option, - attachments: Vec>, + attachments: Vec>, output_usage: VkAccessFlagBits, } -impl<'a> SubPass<'a> { - pub fn builder<'b>(width: u32, height: u32) -> SubPassBuilder<'a, 'b> { +impl<'device> SubPass<'device> { + pub fn builder<'b>(width: u32, height: u32) -> SubPassBuilder<'device, 'b> { SubPassBuilder { width, height, @@ -526,7 +526,7 @@ impl<'a> SubPass<'a> { self.extent } - pub fn attachments(&self) -> &[AttachmentInfo<'a>] { + pub fn attachments(&self) -> &[AttachmentInfo<'device>] { &self.attachments } diff --git a/vulkan-rs/src/single_submit/mod.rs b/vulkan-rs/src/single_submit/mod.rs index 802a100..0541255 100644 --- a/vulkan-rs/src/single_submit/mod.rs +++ b/vulkan-rs/src/single_submit/mod.rs @@ -4,24 +4,24 @@ use anyhow::Result; use std::sync::Mutex; use std::time::Duration; -pub struct SingleSubmit<'a, F, T> +pub struct SingleSubmit<'device, 'a, F, T> where - F: FnOnce(&mut CommandBufferRecorder<'_, '_>) -> Result, + F: FnOnce(&mut CommandBufferRecorder<'device, '_, '_>) -> Result, { - command_buffer: &'a mut CommandBuffer<'a>, - queue: &'a Mutex>, + command_buffer: &'a mut CommandBuffer<'device>, + queue: &'a Mutex>, f: F, timeout: Option, } -impl<'a, F, T> SingleSubmit<'a, F, T> +impl<'device, 'a, F, T> SingleSubmit<'device, 'a, F, T> where - F: FnOnce(&mut CommandBufferRecorder<'_, '_>) -> Result, + F: FnOnce(&mut CommandBufferRecorder<'device, '_, '_>) -> Result, { pub fn builder( - command_buffer: &'a mut CommandBuffer<'a>, - queue: &'a Mutex>, + command_buffer: &'a mut CommandBuffer<'device>, + queue: &'a Mutex>, f: F, ) -> Self { SingleSubmit { @@ -39,7 +39,7 @@ where self } - pub fn submit(mut self) -> Result { + pub fn submit(self) -> Result { let result = { let mut buffer_recorder = self.command_buffer.begin(VkCommandBufferBeginInfo::new( VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,