diff --git a/vulkan-rs/src/acceleration_structure.rs b/vulkan-rs/src/acceleration_structure.rs index 285b6da..e6de45e 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( + pub fn add_instance<'a>( mut self, - blas: &Arc, + blas: &AccelerationStructure<'a>, transform: Option>, instance_flags: impl Into, ) -> Self { @@ -70,10 +70,10 @@ impl AccelerationStructureBuilder { self } - pub fn add_vertices( + pub fn add_vertices<'a, T: ReprC + Send + Sync + 'static>( mut self, - vertex_buffer: &Arc>, - transform: Option>>, + vertex_buffer: &Arc>, + transform: Option>>, flags: impl Into, ) -> Self { match &mut self.data { @@ -122,11 +122,11 @@ impl AccelerationStructureBuilder { self } - pub fn build( + pub fn build<'a>( self, - device: Arc, + device: &Device, recorder: &mut CommandBufferRecorder<'_>, - ) -> Result> { + ) -> Result> { let build_flags = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR | VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR; @@ -140,7 +140,7 @@ impl AccelerationStructureBuilder { | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, ) .set_memory_usage(MemoryUsage::CpuToGpu) - .build(device.clone())?; + .build(device)?; let device_address: VkDeviceOrHostAddressConstKHR = instances_buffer.device_address().into(); @@ -239,8 +239,8 @@ impl AccelerationStructureBuilder { } }; - let acceleration_structure = Arc::new(AccelerationStructure { - device: device.clone(), + let acceleration_structure = AccelerationStructure { + device, acceleration_structure, @@ -258,7 +258,7 @@ impl AccelerationStructureBuilder { generation_data, build_flags, - }); + }; acceleration_structure.generate( recorder, @@ -270,21 +270,21 @@ impl AccelerationStructureBuilder { } } -pub struct AccelerationStructure { - device: Arc, +pub struct AccelerationStructure<'a> { + device: &'a Device, acceleration_structure: VkAccelerationStructureKHR, - result_buffer: Arc>, - scratch_buffer: Mutex>>, + result_buffer: Buffer<'a, RawBuffer>, + scratch_buffer: Mutex>, update_scratch_buffer_size: VkDeviceSize, - generation_data: AccelerationStructureGenerationData, + generation_data: AccelerationStructureGenerationData<'a>, build_flags: VkBuildAccelerationStructureFlagBitsKHR, } -impl AccelerationStructure { +impl<'a> AccelerationStructure<'a> { pub fn bottom_level() -> AccelerationStructureBuilder { AccelerationStructureBuilder { flags: 0.into(), @@ -303,7 +303,7 @@ impl AccelerationStructure { } } - pub fn result_buffer(&self) -> &Arc> { + pub fn result_buffer(&self) -> &Buffer<'a, RawBuffer> { &self.result_buffer } @@ -390,10 +390,10 @@ impl AccelerationStructure { #[inline] fn create_scratch_buffer( - device: &Arc, + 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, @@ -401,11 +401,11 @@ impl AccelerationStructure { .set_memory_usage(MemoryUsage::GpuOnly) .set_size(size) .force_alignment(alignment) - .build(device.clone()) + .build(device) } } -impl Drop for AccelerationStructure { +impl<'a> Drop for AccelerationStructure<'a> { fn drop(&mut self) { self.device .destroy_acceleration_structure(self.acceleration_structure, None); @@ -418,11 +418,11 @@ impl_vk_handle!( acceleration_structure ); -enum AccelerationStructureGenerationData { +enum AccelerationStructureGenerationData<'a> { TopLevel( Vec, VkAccelerationStructureGeometryKHR, - Arc>, + Buffer<'a, VkAccelerationStructureInstanceKHR>, ), BottomLevel( Vec, @@ -430,26 +430,26 @@ enum AccelerationStructureGenerationData { ), } -impl +impl<'a> From<( Vec, VkAccelerationStructureGeometryKHR, - Arc>, - )> for AccelerationStructureGenerationData + Buffer<'a, VkAccelerationStructureInstanceKHR>, + )> for AccelerationStructureGenerationData<'a> { fn from( (instances, geometry, buffer): ( Vec, VkAccelerationStructureGeometryKHR, - Arc>, + Buffer<'a, VkAccelerationStructureInstanceKHR>, ), ) -> Self { Self::TopLevel(instances, geometry, buffer) } } -impl From<(Vec, Vec)> - for AccelerationStructureGenerationData +impl<'a> From<(Vec, Vec)> + for AccelerationStructureGenerationData<'a> { fn from( (geometries, primitive_counts): (Vec, Vec), diff --git a/vulkan-rs/src/buffer.rs b/vulkan-rs/src/buffer.rs index 8096ede..d311e31 100644 --- a/vulkan-rs/src/buffer.rs +++ b/vulkan-rs/src/buffer.rs @@ -4,7 +4,6 @@ use anyhow::Result; use std; use std::mem; -use std::sync::Arc; pub struct BufferBuilder<'a, T: ReprC> { flags: VkBufferCreateFlagBits, @@ -62,7 +61,7 @@ impl<'a, T: ReprC> BufferBuilder<'a, T> { } impl<'a, T: ReprC + Clone + Send + Sync + 'static> BufferBuilder<'a, T> { - pub fn build(self, device: Arc) -> Result>> { + pub fn build(self, device: &'a Device) -> Result> { let size = match self.data { Some(data) => data.len() as VkDeviceSize, None => self.size, @@ -90,18 +89,18 @@ impl<'a, T: ReprC + Clone + Send + Sync + 'static> BufferBuilder<'a, T> { memory_requirements.alignment = alignment; Memory::forced_requirements( - &device, + device, memory_requirements, buffer, MemoryUsage::into_vma(self.memory_usage), )? } None => { - Memory::buffer_memory(&device, buffer, MemoryUsage::into_vma(self.memory_usage))? + Memory::buffer_memory(device, buffer, MemoryUsage::into_vma(self.memory_usage))? } }; - let buffer = Arc::new(Buffer { + let buffer = Buffer { device, buffer, memory, @@ -111,7 +110,7 @@ impl<'a, T: ReprC + Clone + Send + Sync + 'static> BufferBuilder<'a, T> { _sharing_mode: self.sharing_mode, size, - }); + }; if let Some(data) = self.data { buffer.fill(data)?; @@ -122,11 +121,11 @@ impl<'a, T: ReprC + Clone + Send + Sync + 'static> BufferBuilder<'a, T> { } #[derive(Debug)] -pub struct Buffer { - device: Arc, +pub struct Buffer<'a, T: ReprC> { + device: &'a Device, buffer: VkBuffer, - memory: Arc>, + memory: Memory<'a, T>, _usage: VkBufferUsageFlagBits, @@ -134,7 +133,7 @@ pub struct Buffer { size: VkDeviceSize, } -impl Buffer { +impl<'a, T: ReprC + Clone + Send + Sync + 'static> Buffer<'a, T> { pub fn fill(&self, data: &[T]) -> Result<()> { let mut buffer_map = self.map(data.len() as VkDeviceSize)?; @@ -152,19 +151,19 @@ impl Buffer { } pub fn into_device_local( - self: &Arc>, + &self, buffer_recorder: &mut CommandBufferRecorder<'_>, 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() .set_memory_usage(MemoryUsage::GpuOnly) .set_usage(new_usage) .set_size(self.size) - .build(self.device.clone())?; + .build(self.device)?; // copy complete buffer buffer_recorder.copy_buffer( @@ -190,8 +189,8 @@ impl Buffer { } } -impl Buffer { - pub fn builder<'a>() -> BufferBuilder<'a, T> { +impl<'a, T: ReprC> Buffer<'a, T> { + pub fn builder() -> BufferBuilder<'a, T> { BufferBuilder { flags: 0u32.into(), usage: 0u32.into(), @@ -217,72 +216,28 @@ impl Buffer { } } -impl VulkanDevice for Buffer { - fn device(&self) -> &Arc { +impl<'a, T: ReprC> VulkanDevice for Buffer<'a, T> { + fn device(&self) -> &Device { &self.device } } impl_vk_handle_t!(Buffer[ReprC], VkBuffer, buffer); -impl VkHandle for Buffer { +impl<'a, T: ReprC> VkHandle for Buffer<'a, T> { fn vk_handle(&self) -> VkDeviceMemory { self.memory.vk_handle() } } -impl<'a, T: ReprC> VkHandle for &'a Buffer { +impl<'a, T: ReprC> VkHandle for &'a Buffer<'a, T> { fn vk_handle(&self) -> VkDeviceMemory { self.memory.vk_handle() } } -impl VkHandle for Arc> { - fn vk_handle(&self) -> VkDeviceMemory { - self.memory.vk_handle() - } -} - -impl<'a, T: ReprC> VkHandle for &'a Arc> { - fn vk_handle(&self) -> VkDeviceMemory { - self.memory.vk_handle() - } -} - -impl Drop for Buffer { +impl<'a, T: ReprC> Drop for Buffer<'a, T> { fn drop(&mut self) { self.device.destroy_buffer(self.buffer); } } - -// use crate::{ffi::*, handle_ffi_result}; - -impl FFIBufferTrait for Buffer { - fn byte_size(&self) -> VkDeviceSize { - self.byte_size() - } -} - -pub trait FFIBufferTrait { - fn byte_size(&self) -> VkDeviceSize; -} - -pub struct FFIBuffer { - trait_obj: Box, -} - -impl FFIBuffer { - fn byte_size(&self) -> VkDeviceSize { - self.trait_obj.byte_size() - } -} - -#[no_mangle] -pub extern "C" fn create_buffer(_device: *const Device) -> *const FFIBuffer { - todo!() -} - -#[no_mangle] -pub extern "C" fn byte_size(buffer: *const FFIBuffer) -> VkDeviceSize { - unsafe { &*buffer }.byte_size() -} diff --git a/vulkan-rs/src/commandbuffer.rs b/vulkan-rs/src/commandbuffer.rs index 31d615d..11b8fb3 100644 --- a/vulkan-rs/src/commandbuffer.rs +++ b/vulkan-rs/src/commandbuffer.rs @@ -9,7 +9,7 @@ use anyhow::Result; use std::any::Any; use std::sync::{ atomic::{AtomicUsize, Ordering::SeqCst}, - Arc, Mutex, MutexGuard, + Mutex, MutexGuard, }; pub struct QueryEnable { @@ -29,11 +29,11 @@ impl CommandBufferBuilder { self } - pub fn build( + pub fn build<'a>( self, - device: Arc, - queue: Arc>, - ) -> Result> { + device: &'a Device, + queue: &'a Mutex>, + ) -> Result>> { let command_pool = self .pool_builder .set_queue_family_index( @@ -42,7 +42,7 @@ impl CommandBufferBuilder { .map_err(|_| anyhow::Error::msg("Failed locking vulkan queue"))? .family_index(), ) - .build(device.clone())?; + .build(device)?; let command_buffer_ci = VkCommandBufferAllocateInfo::new(command_pool.vk_handle(), self.buffer_level, 1); @@ -62,30 +62,30 @@ impl CommandBufferBuilder { } #[derive(Debug)] -pub struct CommandBuffer { - device: Arc, - pool: Arc, +pub struct CommandBuffer<'a> { + device: &'a Device, + pool: CommandPool<'a>, buffer: VkCommandBuffer, calls: Arc, - stored_handles: Mutex>>, + stored_handles: Mutex>, } #[derive(Debug)] pub struct CommandBufferRecorder<'a> { - device: Arc, + device: &'a Device, sub_pass: u32, pipeline: Option>, calls: Arc, buffer: VkCommandBuffer, - handles_lock: MutexGuard<'a, Vec>>, + handles_lock: MutexGuard<'a, Vec<&'a (dyn Any + Send + Sync)>>, } impl_vk_handle!(CommandBuffer, VkCommandBuffer, buffer); -impl CommandBuffer { +impl<'a> CommandBuffer<'a> { pub fn new_primary() -> CommandBufferBuilder { CommandBufferBuilder { buffer_level: VK_COMMAND_BUFFER_LEVEL_PRIMARY, @@ -572,14 +572,14 @@ impl<'a> CommandBufferRecorder<'a> { pub fn set_image_layout( &mut self, - image: &Arc, + image: &Image<'a>, 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.clone()); + self.handles_lock.push(image); self.pipeline_barrier( CommandBuffer::access_to_stage(src_access), @@ -760,8 +760,8 @@ impl<'a> CommandBufferRecorder<'a> { pub fn blit_image( &mut self, - src_image: &Arc, - dst_image: &Arc, + src_image: &Image<'a>, + dst_image: &Image<'a>, src_layout: VkImageLayout, dst_layout: VkImageLayout, regions: &[VkImageBlit], @@ -769,8 +769,8 @@ impl<'a> CommandBufferRecorder<'a> { ) { self.calls.fetch_add(1, SeqCst); - self.handles_lock.push(src_image.clone()); - self.handles_lock.push(dst_image.clone()); + self.handles_lock.push(src_image); + self.handles_lock.push(dst_image); self.device.cmd_blit_image( self.buffer, @@ -785,15 +785,15 @@ impl<'a> CommandBufferRecorder<'a> { pub fn copy_buffer_to_image( &mut self, - src_buffer: &Arc>, - dst_image: &Arc, + src_buffer: &Arc>, + dst_image: &Image<'a>, image_layout: VkImageLayout, regions: &[VkBufferImageCopy], ) { self.calls.fetch_add(1, SeqCst); self.handles_lock.push(src_buffer.clone()); - self.handles_lock.push(dst_image.clone()); + self.handles_lock.push(dst_image); self.device.cmd_copy_buffer_to_image( self.buffer, diff --git a/vulkan-rs/src/commandpool.rs b/vulkan-rs/src/commandpool.rs index cb01f64..bd8701a 100644 --- a/vulkan-rs/src/commandpool.rs +++ b/vulkan-rs/src/commandpool.rs @@ -22,7 +22,7 @@ impl CommandPoolBuilder { self } - pub(crate) fn build(self, device: Arc) -> Result> { + pub(crate) fn build<'a>(self, device: &'a Device) -> Result>> { let command_pool_ci = VkCommandPoolCreateInfo::new(self.flags, self.queue_family_index); let command_pool = device.create_command_pool(&command_pool_ci)?; @@ -35,12 +35,12 @@ impl CommandPoolBuilder { } #[derive(Debug)] -pub(crate) struct CommandPool { - device: Arc, +pub(crate) struct CommandPool<'a> { + device: &'a Device, command_pool: VkCommandPool, } -impl CommandPool { +impl<'a> CommandPool<'a> { pub(crate) fn builder() -> CommandPoolBuilder { CommandPoolBuilder { flags: VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT @@ -50,39 +50,16 @@ impl CommandPool { } } -impl VulkanDevice for CommandPool { - fn device(&self) -> &Arc { +impl<'a> VulkanDevice for CommandPool<'a> { + fn device(&self) -> &Device { &self.device } } impl_vk_handle!(CommandPool, VkCommandPool, command_pool); -impl Drop for CommandPool { +impl<'a> Drop for CommandPool<'a> { fn drop(&mut self) { self.device.destroy_command_pool(self.command_pool); } } - -// use crate::{ffi::*, handle_ffi_result}; - -// #[no_mangle] -// pub extern "C" fn create_command_pool( -// flags: VkCommandPoolCreateFlagBits, -// queue_family_index: u32, -// device: *const Device, -// ) -> *const CommandPool { -// let device = unsafe { Arc::from_raw(device) }; - -// let pool_res = CommandPool::builder() -// .set_flags(flags) -// .set_queue_family_index(queue_family_index) -// .build(device); - -// handle_ffi_result!(pool_res) -// } - -// #[no_mangle] -// pub extern "C" fn destroy_command_pool(command_pool: *const CommandPool) { -// let _pool = unsafe { Arc::from_raw(command_pool) }; -// } diff --git a/vulkan-rs/src/descriptorpool.rs b/vulkan-rs/src/descriptorpool.rs index 06e970f..4369a50 100644 --- a/vulkan-rs/src/descriptorpool.rs +++ b/vulkan-rs/src/descriptorpool.rs @@ -2,15 +2,13 @@ use crate::prelude::*; use anyhow::Result; -use std::sync::Arc; - -pub struct DescriptorPoolBuilder { - layout: Option>, +pub struct DescriptorPoolBuilder<'a> { + layout: Option<&'a DescriptorSetLayout<'a>>, descriptor_count: u32, flags: VkDescriptorPoolCreateFlagBits, } -impl DescriptorPoolBuilder { +impl<'a> DescriptorPoolBuilder<'a> { pub fn set_flags(mut self, flags: impl Into) -> Self { self.flags |= flags.into(); @@ -23,13 +21,13 @@ impl DescriptorPoolBuilder { self } - pub fn set_layout(mut self, layout: Arc) -> Self { + pub fn set_layout(mut self, layout: &'a DescriptorSetLayout<'a>) -> Self { self.layout = Some(layout); self } - pub fn build(self, device: Arc) -> Result> { + pub fn build(self, device: &'a Device) -> Result> { if cfg!(debug_assertions) { if self.layout.is_none() { panic!("no layout set!"); @@ -60,23 +58,23 @@ impl DescriptorPoolBuilder { let descriptor_pool = device.create_descriptor_pool(&descriptor_pool_ci)?; - Ok(Arc::new(DescriptorPool { + Ok(DescriptorPool { device, descriptor_pool, descriptor_set_layout: layout, - })) + }) } } #[derive(Debug)] -pub struct DescriptorPool { - device: Arc, +pub struct DescriptorPool<'a> { + device: &'a Device, descriptor_pool: VkDescriptorPool, - pub(crate) descriptor_set_layout: Arc, + pub(crate) descriptor_set_layout: &'a DescriptorSetLayout<'a>, } -impl DescriptorPool { - pub fn builder() -> DescriptorPoolBuilder { +impl<'a> DescriptorPool<'a> { + pub fn builder() -> DescriptorPoolBuilder<'a> { DescriptorPoolBuilder { layout: None, descriptor_count: 1, @@ -89,83 +87,33 @@ impl DescriptorPool { .reset_descriptor_pool(self.descriptor_pool, VK_DESCRIPTOR_POOL_RESET_NULL_BIT) } - pub fn prepare_set(self: &Arc) -> DescriptorSetBuilder { - DescriptorSet::builder(self.device.clone(), self.clone()) + pub fn prepare_set(&self) -> DescriptorSetBuilder<'a> { + DescriptorSet::builder(self.device, self) } } -impl VulkanDevice for DescriptorPool { - fn device(&self) -> &Arc { +impl<'a> VulkanDevice for DescriptorPool<'a> { + fn device(&self) -> &Device { &self.device } } impl_vk_handle!(DescriptorPool, VkDescriptorPool, descriptor_pool); -impl VkHandle for DescriptorPool { +impl<'a> VkHandle for DescriptorPool<'a> { fn vk_handle(&self) -> VkDescriptorSetLayout { self.descriptor_set_layout.vk_handle() } } -impl<'a> VkHandle for &'a DescriptorPool { +impl<'a> VkHandle for &'a DescriptorPool<'a> { fn vk_handle(&self) -> VkDescriptorSetLayout { self.descriptor_set_layout.vk_handle() } } -impl VkHandle for Arc { - fn vk_handle(&self) -> VkDescriptorSetLayout { - self.descriptor_set_layout.vk_handle() - } -} - -impl<'a> VkHandle for &'a Arc { - fn vk_handle(&self) -> VkDescriptorSetLayout { - self.descriptor_set_layout.vk_handle() - } -} - -impl Drop for DescriptorPool { +impl<'a> Drop for DescriptorPool<'a> { fn drop(&mut self) { self.device.destroy_descriptor_pool(self.descriptor_pool); } } - -use crate::{ffi::*, handle_ffi_result}; - -#[no_mangle] -pub extern "C" fn create_descriptor_pool( - flags: VkDescriptorPoolCreateFlagBits, - descriptor_set_layout: *const DescriptorSetLayout, - device: *const Device, -) -> *const DescriptorPool { - let device = unsafe { Arc::from_raw(device) }; - let layout = unsafe { Arc::from_raw(descriptor_set_layout) }; - - let pool_res = DescriptorPool::builder() - .set_flags(flags) - .set_layout(layout) - .build(device); - - handle_ffi_result!(pool_res) -} - -#[no_mangle] -pub extern "C" fn reset_descriptor_pool(descriptor_pool: *const DescriptorPool) -> bool { - let pool = unsafe { Arc::from_raw(descriptor_pool) }; - - match pool.reset() { - Ok(_) => true, - Err(err) => { - update_last_error(err); - - false - } - } -} - -#[no_mangle] -pub extern "C" fn destroy_descriptor_pool(descriptor_pool: *const DescriptorPool) { - let _pool = unsafe { Arc::from_raw(descriptor_pool) }; -} diff --git a/vulkan-rs/src/descriptorset.rs b/vulkan-rs/src/descriptorset.rs index 942e381..cb9cec0 100644 --- a/vulkan-rs/src/descriptorset.rs +++ b/vulkan-rs/src/descriptorset.rs @@ -5,14 +5,14 @@ use anyhow::Result; use std::any::Any; use std::collections::HashMap; use std::slice; -use std::sync::{Arc, Mutex}; +use std::sync::Mutex; #[derive(Debug)] -pub struct DescriptorWrite { +pub struct DescriptorWrite<'a> { binding: u32, descriptor_type: VkDescriptorType, inner: InnerWrite, - handles: Vec>, + handles: Vec<&'a (dyn Any + Send + Sync)>, } #[derive(Debug)] @@ -27,10 +27,10 @@ enum InnerWrite { ), } -impl DescriptorWrite { +impl<'a> DescriptorWrite<'a> { pub fn uniform_buffers( binding: u32, - buffers: &[&Arc>], + buffers: &[&Buffer<'a, T>], ) -> Self { DescriptorWrite { binding, @@ -47,14 +47,14 @@ impl DescriptorWrite { ), handles: buffers .iter() - .map(|b| (*b).clone() as Arc) + .map(|b| (*b) as &'a (dyn Any + Send + Sync)) .collect(), } } pub fn storage_buffers( binding: u32, - buffers: &[&Arc>], + buffers: &[&Buffer<'a, T>], ) -> Self { DescriptorWrite { binding, @@ -71,12 +71,12 @@ impl DescriptorWrite { ), handles: buffers .iter() - .map(|b| (*b).clone() as Arc) + .map(|b| (*b) as &'a (dyn Any + Send + Sync)) .collect(), } } - pub fn combined_samplers(binding: u32, images: &[&Arc]) -> Self { + pub fn combined_samplers(binding: u32, images: &[&'a Image<'a>]) -> Self { DescriptorWrite { binding, descriptor_type: VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, @@ -96,12 +96,12 @@ impl DescriptorWrite { ), handles: images .iter() - .map(|i| (*i).clone() as Arc) + .map(|i| (*i).clone() as &'a (dyn Any + Send + Sync)) .collect(), } } - pub fn storage_images(binding: u32, images: &[&Arc]) -> Self { + pub fn storage_images(binding: u32, images: &[&'a Image<'a>]) -> Self { DescriptorWrite { binding, descriptor_type: VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, @@ -117,12 +117,12 @@ impl DescriptorWrite { ), handles: images .iter() - .map(|i| (*i).clone() as Arc) + .map(|i| (*i).clone() as &'a (dyn Any + Send + Sync)) .collect(), } } - pub fn input_attachments(binding: u32, images: &[&Arc]) -> Self { + pub fn input_attachments(binding: u32, images: &[&'a Image<'a>]) -> Self { DescriptorWrite { binding, descriptor_type: VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, @@ -138,14 +138,14 @@ impl DescriptorWrite { ), handles: images .iter() - .map(|i| (*i).clone() as Arc) + .map(|i| (*i) as &'a (dyn Any + Send + Sync)) .collect(), } } pub fn acceleration_structures( binding: u32, - acceleration_structures: &[&Arc], + acceleration_structures: &[&AccelerationStructure<'a>], ) -> Self { let vk_as: Vec = acceleration_structures .iter() @@ -161,7 +161,7 @@ impl DescriptorWrite { )), handles: acceleration_structures .iter() - .map(|a| (*a).clone() as Arc) + .map(|a| (*a) as &'a (dyn Any + Send + Sync)) .collect(), }; @@ -198,21 +198,21 @@ impl DescriptorWrite { } } -pub struct DescriptorSetBuilder { - device: Arc, - descriptor_pool: Arc, +pub struct DescriptorSetBuilder<'a> { + device: &'a Device, + descriptor_pool: &'a DescriptorPool<'a>, variable_desc_counts: Vec, variable_descriptor_count: VkDescriptorSetVariableDescriptorCountAllocateInfoEXT, } -impl DescriptorSetBuilder { +impl<'a> DescriptorSetBuilder<'a> { pub fn set_variable_descriptor_counts(mut self, descriptor_counts: &[u32]) -> Self { self.variable_desc_counts = descriptor_counts.to_vec(); self } - pub fn allocate(mut self) -> Result> { + pub fn allocate(mut self) -> Result> { let layout = self.descriptor_pool.vk_handle(); let mut descriptor_set_ci = VkDescriptorSetAllocateInfo::new( @@ -228,30 +228,30 @@ impl DescriptorSetBuilder { let descriptor_set = self.device.allocate_descriptor_sets(&descriptor_set_ci)?[0]; - Ok(Arc::new(DescriptorSet { + Ok(DescriptorSet { device: self.device, pool: self.descriptor_pool, descriptor_set, handles: Mutex::new(HashMap::new()), - })) + }) } } #[derive(Debug)] -pub struct DescriptorSet { - device: Arc, - pool: Arc, +pub struct DescriptorSet<'a> { + device: &'a Device, + pool: &'a DescriptorPool<'a>, descriptor_set: VkDescriptorSet, - handles: Mutex>>>, + handles: Mutex>>, } -impl DescriptorSet { +impl<'a> DescriptorSet<'a> { pub(crate) fn builder( - device: Arc, - descriptor_pool: Arc, - ) -> DescriptorSetBuilder { + device: &'a Device, + descriptor_pool: &'a DescriptorPool<'a>, + ) -> DescriptorSetBuilder<'a> { DescriptorSetBuilder { device, descriptor_pool, @@ -263,7 +263,7 @@ impl DescriptorSet { } // TODO: add update function for VkCopyDescriptorSet - pub fn update(&self, writes: &[DescriptorWrite]) -> Result<()> { + pub fn update(&self, writes: &[DescriptorWrite<'a>]) -> Result<()> { debug_assert!(!writes.is_empty()); #[cfg(debug_assertions)] @@ -307,39 +307,27 @@ impl DescriptorSet { } } -impl VulkanDevice for DescriptorSet { - fn device(&self) -> &Arc { +impl<'a> VulkanDevice for DescriptorSet<'a> { + fn device(&self) -> &Device { &self.device } } impl_vk_handle!(DescriptorSet, VkDescriptorSet, descriptor_set); -impl VkHandle for DescriptorSet { +impl<'a> VkHandle for DescriptorSet<'a> { fn vk_handle(&self) -> VkDescriptorSetLayout { self.pool.vk_handle() } } -impl<'a> VkHandle for &'a DescriptorSet { +impl<'a> VkHandle for &'a DescriptorSet<'a> { fn vk_handle(&self) -> VkDescriptorSetLayout { self.pool.vk_handle() } } -impl VkHandle for Arc { - fn vk_handle(&self) -> VkDescriptorSetLayout { - self.pool.vk_handle() - } -} - -impl<'a> VkHandle for &'a Arc { - fn vk_handle(&self) -> VkDescriptorSetLayout { - self.pool.vk_handle() - } -} - -impl Drop for DescriptorSet { +impl<'a> Drop for DescriptorSet<'a> { fn drop(&mut self) { if let Err(error) = self .device @@ -355,8 +343,6 @@ mod test { use crate::prelude::*; use anyhow::Result; - use std::sync::Arc; - #[test] fn create_multiple_sets_from_one_pool() -> Result<()> { const DESCRIPTOR_COUNT: u32 = 2; @@ -370,14 +356,14 @@ mod test { VK_SHADER_STAGE_FRAGMENT_BIT, 0, ) - .build(device.clone())?; + .build(&device)?; let descriptor_pool = DescriptorPool::builder() - .set_layout(descriptor_layout.clone()) + .set_layout(&descriptor_layout) .set_descriptor_set_count(DESCRIPTOR_COUNT) - .build(device.clone())?; + .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/descriptorsetlayout.rs b/vulkan-rs/src/descriptorsetlayout.rs index e91e8f9..0a25d58 100644 --- a/vulkan-rs/src/descriptorsetlayout.rs +++ b/vulkan-rs/src/descriptorsetlayout.rs @@ -48,7 +48,7 @@ impl DescriptorSetLayoutBuilder { self } - pub fn build(self, device: Arc) -> Result> { + pub fn build<'a>(self, device: &'a Device) -> Result>> { let mut descriptor_set_ci = VkDescriptorSetLayoutCreateInfo::new(self.flags, &self.layout_bindings); let binding_flags_ci = @@ -98,15 +98,15 @@ impl DescriptorSetLayoutBuilder { } #[derive(Debug)] -pub struct DescriptorSetLayout { - device: Arc, +pub struct DescriptorSetLayout<'a> { + device: &'a Device, descriptor_set_layout: VkDescriptorSetLayout, pool_sizes: Vec, bindings: Vec, } -impl DescriptorSetLayout { +impl<'a> DescriptorSetLayout<'a> { pub fn builder() -> DescriptorSetLayoutBuilder { DescriptorSetLayoutBuilder { layout_bindings: Vec::new(), @@ -124,8 +124,8 @@ impl DescriptorSetLayout { } } -impl VulkanDevice for DescriptorSetLayout { - fn device(&self) -> &Arc { +impl<'a> VulkanDevice for DescriptorSetLayout<'a> { + fn device(&self) -> &Device { &self.device } } @@ -136,7 +136,7 @@ impl_vk_handle!( descriptor_set_layout ); -impl Drop for DescriptorSetLayout { +impl<'a> Drop for DescriptorSetLayout<'a> { fn drop(&mut self) { self.device .destroy_descriptor_set_layout(self.descriptor_set_layout); diff --git a/vulkan-rs/src/device.rs b/vulkan-rs/src/device.rs index b6cfbc9..a08842a 100644 --- a/vulkan-rs/src/device.rs +++ b/vulkan-rs/src/device.rs @@ -53,7 +53,7 @@ pub struct Device { enabled_extensions: DeviceExtensions, - physical_device: Arc, + physical_device: PhysicalDevice, device: VkDevice, memory_allocator: Allocator, @@ -65,9 +65,9 @@ impl Device { pub fn preinitialized( device: VkDevice, proc_addr: PFN_vkGetDeviceProcAddr, - physical_device: Arc, + physical_device: PhysicalDevice, extensions: &[VkString], - ) -> Result> { + ) -> Result { let device_functions = DeviceFunctions::load(|name| { proc_addr(device, name.as_ptr()) as *const std::ffi::c_void }); @@ -133,7 +133,7 @@ impl Device { physical_device.instance().api_version(), )?; - Ok(Arc::new(Device { + Ok(Device { memory_allocator, device_functions, @@ -151,15 +151,15 @@ impl Device { device, sampler_manager: SamplerManager::new(), - })) + }) } pub fn new( - physical_device: Arc, + physical_device: PhysicalDevice, mut extensions: DeviceExtensions, queue_infos: &[VkDeviceQueueCreateInfo], requested_device_features: DeviceFeatures, - ) -> Result> { + ) -> Result { // buffer device address is required in the current library implementation extensions.buffer_device_address = true; @@ -285,7 +285,7 @@ impl Device { physical_device.instance().api_version(), )?; - Ok(Arc::new(Device { + Ok(Device { memory_allocator, device_functions, @@ -303,7 +303,7 @@ impl Device { device, sampler_manager: SamplerManager::new(), - })) + }) } fn verify_vma_vk_functions(fns: &VmaVulkanFunctions) -> Result<()> { @@ -348,26 +348,22 @@ impl Device { Ok(()) } - pub fn get_queue( - self: &Arc, - queue_family_index: u32, - queue_index: u32, - ) -> Arc> { + pub fn get_queue<'a>(&'a self, queue_family_index: u32, queue_index: u32) -> Mutex> { Queue::new( - self.clone(), + self, self.get_device_queue(queue_family_index, queue_index), queue_family_index, queue_index, ) } - pub fn physical_device(&self) -> &Arc { + pub fn physical_device(&self) -> &PhysicalDevice { &self.physical_device } - pub fn wait_for_fences( + pub fn wait_for_fences<'a>( &self, - fences: &[&Arc], + fences: &[&Fence<'a>], wait_all: bool, timeout: Duration, ) -> Result<()> { @@ -879,7 +875,7 @@ impl Device { pub(crate) fn create_sampler_from_manager( &self, create_info: VkSamplerCreateInfo, - ) -> Result> { + ) -> Result { self.sampler_manager .lock() .unwrap() diff --git a/vulkan-rs/src/fence.rs b/vulkan-rs/src/fence.rs index 13f7207..e6b7619 100644 --- a/vulkan-rs/src/fence.rs +++ b/vulkan-rs/src/fence.rs @@ -15,7 +15,7 @@ impl FenceBuilder { self } - pub fn build(self, device: Arc) -> Result> { + pub fn build<'a>(self, device: &'a Device) -> Result>> { let flag: VkFenceCreateFlagBits = if self.signaled { VK_FENCE_CREATE_SIGNALED_BIT.into() } else { @@ -31,12 +31,12 @@ impl FenceBuilder { } #[derive(Debug)] -pub struct Fence { - device: Arc, +pub struct Fence<'a> { + device: &'a Device, fence: VkFence, } -impl Fence { +impl<'a> Fence<'a> { pub fn builder() -> FenceBuilder { FenceBuilder { signaled: false } } @@ -50,39 +50,16 @@ impl Fence { } } -impl VulkanDevice for Fence { - fn device(&self) -> &Arc { +impl<'a> VulkanDevice for Fence<'a> { + fn device(&self) -> &Device { &self.device } } impl_vk_handle!(Fence, VkFence, fence); -impl Drop for Fence { +impl<'a> Drop for Fence<'a> { fn drop(&mut self) { self.device.destroy_fence(self.fence); } } - -use crate::{ffi::*, handle_ffi_result}; - -#[no_mangle] -pub extern "C" fn create_fence(signaled: bool, device: *const Device) -> *const Fence { - let device = unsafe { Arc::from_raw(device) }; - - let fence_res = Fence::builder().set_signaled(signaled).build(device); - - handle_ffi_result!(fence_res) -} - -#[no_mangle] -pub extern "C" fn reset_fence(fence: *const Fence) -> bool { - let fence = unsafe { Arc::from_raw(fence) }; - - fence.reset() -} - -#[no_mangle] -pub extern "C" fn destroy_fence(fence: *const Fence) { - let _fence = unsafe { Arc::from_raw(fence) }; -} diff --git a/vulkan-rs/src/ffi.rs b/vulkan-rs/src/ffi.rs deleted file mode 100644 index cc4ffc3..0000000 --- a/vulkan-rs/src/ffi.rs +++ /dev/null @@ -1,70 +0,0 @@ -use std::cell::RefCell; -use std::os::raw::{c_char, c_int}; - -#[macro_export] -macro_rules! handle_ffi_result { - ($result: expr) => { - match $result { - Ok(value) => Arc::into_raw(value), - Err(error) => { - update_last_error(error); - - std::ptr::null() - } - } - }; -} - -thread_local! { - static LAST_ERROR:RefCell>> = RefCell::new(None); -} - -pub(crate) fn update_last_error(err: anyhow::Error) { - LAST_ERROR.with(|prev| { - *prev.borrow_mut() = Some(Box::new(format!("{:?}", err))); - }); -} - -pub(crate) fn take_last_error() -> Option> { - LAST_ERROR.with(|prev| prev.borrow_mut().take()) -} - -#[no_mangle] -pub extern "C" fn last_error_length() -> c_int { - LAST_ERROR.with(|prev| match *prev.borrow() { - Some(ref err) => err.to_string().len() as c_int + 1, - None => 0, - }) -} - -#[no_mangle] -pub unsafe extern "C" fn last_error_message(buffer: *mut c_char, length: c_int) -> c_int { - if buffer.is_null() { - return -1; - } - - let last_error = match take_last_error() { - Some(err) => err, - None => return 0, - }; - - let error_message = last_error.to_string(); - - let buffer = std::slice::from_raw_parts_mut(buffer as *mut u8, length as usize); - - if error_message.len() >= buffer.len() { - return -1; - } - - std::ptr::copy_nonoverlapping( - error_message.as_ptr(), - buffer.as_mut_ptr(), - error_message.len(), - ); - - // Add a trailing null so people using the string as a `char *` don't - // accidentally read into garbage. - buffer[error_message.len()] = 0; - - error_message.len() as c_int -} diff --git a/vulkan-rs/src/framebuffer.rs b/vulkan-rs/src/framebuffer.rs index ff320d3..d9a2448 100644 --- a/vulkan-rs/src/framebuffer.rs +++ b/vulkan-rs/src/framebuffer.rs @@ -6,7 +6,7 @@ use std::sync::Arc; pub struct FramebufferBuilder<'a> { render_pass: Option<&'a Arc>, - attachments: Vec<&'a Arc>, + attachments: Vec<&'a Image<'a>>, width: u32, height: u32, layers: u32, @@ -19,7 +19,7 @@ impl<'a> FramebufferBuilder<'a> { self } - pub fn add_attachment(mut self, image: &'a Arc) -> Self { + pub fn add_attachment(mut self, image: &'a Image<'a>) -> Self { self.attachments.push(image); self @@ -43,7 +43,7 @@ impl<'a> FramebufferBuilder<'a> { self } - pub fn build(mut self, device: Arc) -> Result> { + pub fn build(mut self, device: Arc) -> Result> { if self.attachments.is_empty() { panic!("no attachments added!"); } @@ -80,29 +80,29 @@ impl<'a> FramebufferBuilder<'a> { let framebuffer = device.create_framebuffer(&framebuffer_ci)?; - Ok(Arc::new(Framebuffer { + Ok(Framebuffer { device, framebuffer, images, width: self.width, height: self.height, - })) + }) } } #[derive(Debug)] -pub struct Framebuffer { +pub struct Framebuffer<'a> { device: Arc, framebuffer: VkFramebuffer, - images: Vec>, + images: Vec<&'a Image<'a>>, width: u32, height: u32, } -impl Framebuffer { - pub fn builder<'a>() -> FramebufferBuilder<'a> { +impl<'a> Framebuffer<'a> { + pub fn builder() -> FramebufferBuilder<'a> { FramebufferBuilder { render_pass: None, attachments: Vec::new(), @@ -120,11 +120,11 @@ impl Framebuffer { self.height } - pub fn attachments(&self) -> &[Arc] { + pub fn attachments(&self) -> &[&'a Image<'a>] { &self.images } - pub fn image(&self, index: usize) -> &Arc { + pub fn image(&self, index: usize) -> &Image<'a> { &self.images[index] } @@ -133,15 +133,15 @@ impl Framebuffer { } } -impl VulkanDevice for Framebuffer { - fn device(&self) -> &Arc { +impl<'a> VulkanDevice for Framebuffer<'a> { + fn device(&self) -> &Device { &self.device } } impl_vk_handle!(Framebuffer, VkFramebuffer, framebuffer); -impl Drop for Framebuffer { +impl<'a> Drop for Framebuffer<'a> { 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 4920f8d..1adbe32 100644 --- a/vulkan-rs/src/image.rs +++ b/vulkan-rs/src/image.rs @@ -9,20 +9,20 @@ use std::path::Path; use std::sync::{Arc, Mutex}; use std::time::Duration; -enum ImageSourceType { +enum ImageSourceType<'a> { Empty, Raw(Vec), - Array(Vec>), + Array(Vec>), } -struct ImageCreateInfo { +struct ImageCreateInfo<'a> { vk_image_create_info: VkImageCreateInfo, - source_type: ImageSourceType, + source_type: ImageSourceType<'a>, } -impl ImageCreateInfo { - fn default(source_type: ImageSourceType) -> Self { +impl<'a> ImageCreateInfo<'a> { + fn default(source_type: ImageSourceType<'a>) -> Self { ImageCreateInfo { vk_image_create_info: VkImageCreateInfo::new( 0, @@ -62,25 +62,25 @@ struct PreinitializedImage { assume_layout: bool, } -enum ImageBuilderInternalType { +enum ImageBuilderInternalType<'a> { PreinitializedImage(PreinitializedImage), - NewImage(ImageCreateInfo), + NewImage(ImageCreateInfo<'a>), } /// Implements the builder pattern for Image -pub struct ImageBuilder { +pub struct ImageBuilder<'a> { file_name: Option, - builder_type: ImageBuilderInternalType, + builder_type: ImageBuilderInternalType<'a>, components: VkComponentMapping, view_type: VkImageViewType, subresource_range: VkImageSubresourceRange, - sampler: Option>, + sampler: Option, } -impl ImageBuilder { +impl<'a> ImageBuilder<'a> { /// Sets up the ImageBuilder for further use - fn new(internal_type: ImageBuilderInternalType) -> Self { + fn new(internal_type: ImageBuilderInternalType<'a>) -> Self { ImageBuilder { file_name: None, builder_type: internal_type, @@ -98,7 +98,7 @@ impl ImageBuilder { } } - pub fn build(self, device: &Arc, queue: &Arc>) -> Result> { + pub fn build(self, device: &'a Device, queue: &'a Mutex>) -> Result> { let mut image_view_ci = self.vk_image_view_create_info(); match self.builder_type { @@ -107,9 +107,9 @@ impl ImageBuilder { let image_view = device.create_image_view(&image_view_ci)?; - let image = Arc::new(Image { - device: device.clone(), - queue: queue.clone(), + let image = Image { + device, + queue, image: preinitialized_image.image, image_view, @@ -130,7 +130,7 @@ impl ImageBuilder { levels: 1, sample_count: preinitialized_image.sample_count, usage: preinitialized_image.usage, - }); + }; // TODO: check necessity if !preinitialized_image.assume_layout { @@ -308,7 +308,7 @@ impl ImageBuilder { self } - pub fn attach_sampler(mut self, sampler: Arc) -> Self { + pub fn attach_sampler(mut self, sampler: Sampler) -> Self { self.sampler = Some(sampler); if let ImageBuilderInternalType::NewImage(ref mut info) = self.builder_type { @@ -384,13 +384,13 @@ impl ImageBuilder { } fn create_from_source( - device: &Arc, - queue: &Arc>, - info: &ImageCreateInfo, - sampler: Option>, + device: &Device, + queue: &Mutex>, + info: &ImageCreateInfo<'a>, + sampler: Option, mut view_ci: VkImageViewCreateInfo, file_name: Option, - ) -> Result> { + ) -> Result> { let format = view_ci.format; let (image, memory) = Self::create_texture(device, &info.vk_image_create_info)?; @@ -399,7 +399,7 @@ impl ImageBuilder { let image_view = device.create_image_view(&view_ci)?; - Ok(Arc::new(Image { + Ok(Image { device: device.clone(), queue: queue.clone(), @@ -422,13 +422,13 @@ impl ImageBuilder { levels: info.vk_image_create_info.mipLevels, sample_count: info.vk_image_create_info.samples, usage: info.vk_image_create_info.usage, - })) + }) } fn create_texture( - device: &Arc, + device: &Device, image_ci: &VkImageCreateInfo, - ) -> Result<(VkImage, Arc>)> { + ) -> Result<(VkImage, Memory<'a, RawBuffer>)> { let image = Self::create_image(device, image_ci)?; let memory = Memory::image_memory( device, @@ -439,7 +439,7 @@ impl ImageBuilder { Ok((image, memory)) } - fn create_image(device: &Arc, image_ci: &VkImageCreateInfo) -> Result { + fn create_image(device: &Device, image_ci: &VkImageCreateInfo) -> Result { debug_assert_ne!(image_ci.extent.width, 0); debug_assert_ne!(image_ci.extent.height, 0); @@ -447,18 +447,18 @@ impl ImageBuilder { } fn optimize_fill( - device: &Arc, - queue: &Arc>, + device: &Device, + queue: &Mutex>, data: &[RawBuffer], - image: &Arc, + image: &Image<'a>, ) -> Result<()> { let staging_buffer = Buffer::builder() .set_usage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT) .set_memory_usage(MemoryUsage::CpuToGpu) .set_data(data) - .build(device.clone())?; + .build(device)?; - copy_buffer_to_image(device, queue, &staging_buffer, image)?; + copy_buffer_to_image(image, device, queue, &staging_buffer)?; Ok(()) } @@ -469,12 +469,12 @@ impl ImageBuilder { /// handles VkImage, VkSampler, VkDeviceSize and VkImageView internally /// just as you set it up to #[derive(Debug)] -pub struct Image { +pub struct Image<'a> { // device handle - device: Arc, + device: &'a Device, // queue handle - queue: Arc>, + queue: &'a Mutex>, file_name: Option, @@ -486,8 +486,8 @@ pub struct Image { image_view: VkImageView, // optional handles - _memory: Option>>, - sampler: Option>, + _memory: Option>, + sampler: Option, // image information format: VkFormat, @@ -502,7 +502,7 @@ pub struct Image { usage: VkImageUsageFlagBits, } -impl Image { +impl<'a> Image<'a> { /// Creates an `ImageBuilder` where you can define the image for your needs /// /// For example, this is used to wrap swapchain images @@ -519,7 +519,7 @@ impl Image { layout: VkImageLayout, usage: impl Into, assume_layout: bool, - ) -> ImageBuilder { + ) -> ImageBuilder<'a> { ImageBuilder::new(ImageBuilderInternalType::PreinitializedImage( PreinitializedImage { image, @@ -545,7 +545,7 @@ impl Image { /// * `source` - The color information for the image /// * `width` - The target width of the image /// * `height` - The target height of the image - pub fn from_raw(source: Vec, width: u32, height: u32) -> ImageBuilder { + pub fn from_raw(source: Vec, width: u32, height: u32) -> ImageBuilder<'a> { let mut create_info = ImageCreateInfo::default(ImageSourceType::Raw(source)); create_info.vk_image_create_info.extent.width = width; create_info.vk_image_create_info.extent.height = height; @@ -563,7 +563,7 @@ impl Image { /// # Arguments /// /// * `file` - The path to the file - pub fn from_file(file: AssetPath) -> Result { + pub fn from_file(file: AssetPath) -> Result> { let texture = match image::open(&file.full_path()) { Ok(i) => i.to_rgba8(), Err(err) => return Err(anyhow::Error::new(err).context(file.full_path())), @@ -591,7 +591,7 @@ impl Image { /// # Arguments /// /// * `slice` - Slice of bytes - pub fn from_slice(data: &[u8]) -> Result { + pub fn from_slice(data: &[u8]) -> Result> { let texture = image::load_from_memory(data)?.to_rgba8(); let (width, height) = texture.dimensions(); @@ -607,7 +607,7 @@ impl Image { /// # Arguments /// /// * `array` - Source images - pub fn from_array(array: Vec>) -> ImageBuilder { + pub fn from_array(array: Vec>) -> ImageBuilder<'a> { debug_assert!(array.is_empty(), "images array must not be empty"); let width = array[0].width(); @@ -652,7 +652,7 @@ impl Image { height: u32, usage: impl Into, sample_count: VkSampleCountFlags, - ) -> ImageBuilder { + ) -> ImageBuilder<'a> { let mut create_info = ImageCreateInfo::default(ImageSourceType::Empty); create_info.vk_image_create_info.samples = sample_count.into(); create_info.vk_image_create_info.extent.width = width; @@ -664,7 +664,7 @@ impl Image { } pub fn check_configuration( - device: &Arc, + device: &Device, tiling: VkImageTiling, format: VkFormat, usage: impl Into, @@ -677,11 +677,11 @@ impl Image { } } - pub fn device(&self) -> &Arc { + pub fn device(&self) -> &Device { &self.device } - pub fn queue(&self) -> &Arc> { + pub fn queue(&self) -> &Mutex> { &self.queue } @@ -689,7 +689,7 @@ impl Image { self.file_name.as_ref() } - pub fn convert_layout(self: &Arc, target_layout: VkImageLayout) -> Result<()> { + pub fn convert_layout(&self, target_layout: VkImageLayout) -> Result<()> { into_layout(self, target_layout) } @@ -697,7 +697,7 @@ impl Image { self.format } - pub fn sampler(&self) -> &Option> { + pub fn sampler(&self) -> &Option { &self.sampler } @@ -788,7 +788,7 @@ impl Image { } } - pub fn to_file(self: &Arc, path: impl AsRef) -> Result<()> { + pub fn to_file(&self, path: impl AsRef) -> Result<()> { // check if image is created with correct usage flag that allows transfering data from it if (self.usage | VK_IMAGE_USAGE_TRANSFER_SRC_BIT) == 0 { return Err(anyhow::anyhow!( @@ -815,9 +815,9 @@ impl Image { } pub fn copy_image_to_buffer( - self: &Arc, + &self, extra_buffer_flags: impl Into>, - ) -> Result>> { + ) -> Result> { let usage = match extra_buffer_flags.into() { Some(flags) => VK_BUFFER_USAGE_TRANSFER_DST_BIT | flags, None => VK_BUFFER_USAGE_TRANSFER_DST_BIT.into(), @@ -885,13 +885,13 @@ impl Image { Ok(buffer) } - pub fn copy_buffer_to_image(self: &Arc, buffer: &Arc>) -> Result<()> { - copy_buffer_to_image(&self.device, &self.queue, &buffer, self) + pub fn copy_buffer_to_image(&self, buffer: &Arc>) -> Result<()> { + copy_buffer_to_image(self, &self.device, &self.queue, &buffer) } } -impl VulkanDevice for Image { - fn device(&self) -> &Arc { +impl<'a> VulkanDevice for Image<'a> { + fn device(&self) -> &Device { &self.device } } @@ -899,7 +899,7 @@ impl VulkanDevice for Image { impl_vk_handle!(Image, VkImage, image); impl_vk_handle!(Image, VkImageView, image_view); -impl Drop for Image { +impl<'a> Drop for Image<'a> { fn drop(&mut self) { self.device.destroy_image_view(self.image_view); @@ -909,10 +909,9 @@ impl Drop for Image { } } -fn into_layout(image: &Arc, layout: VkImageLayout) -> Result<()> { +fn into_layout<'a>(image: &Image<'a>, layout: VkImageLayout) -> Result<()> { // create a new command buffer - let command_buffer = - CommandBuffer::new_primary().build(image.device.clone(), image.queue.clone())?; + let command_buffer = CommandBuffer::new_primary().build(image.device, image.queue)?; { // begin recording into this command buffer @@ -950,11 +949,11 @@ fn into_layout(image: &Arc, layout: VkImageLayout) -> Result<()> { Ok(()) } -fn copy_buffer_to_image( - device: &Arc, - queue: &Arc>, - buffer: &Arc>, - image: &Arc, +fn copy_buffer_to_image<'a, T: ReprC + Send + Sync + 'static>( + image: &Image<'a>, + device: &Device, + queue: &Mutex>, + buffer: &Buffer<'a, T>, ) -> Result<()> where T: Copy, @@ -1045,11 +1044,11 @@ where Ok(()) } -fn copy_images_to_imagearray( - device: &Arc, - queue: &Arc>, - image_array: &Arc, - images: &[Arc], +fn copy_images_to_imagearray<'a>( + device: &Device, + queue: &Mutex>, + image_array: &Image<'a>, + images: &[Image<'a>], ) -> Result<()> { // create a new command buffer let command_buffer = CommandBuffer::new_primary().build(device.clone(), queue.clone())?; @@ -1119,10 +1118,10 @@ fn copy_images_to_imagearray( Ok(()) } -fn copy_image_to_image( +fn copy_image_to_image<'a>( buffer_recorder: &mut CommandBufferRecorder<'_>, - src_image: &Arc, - dst_image: &Arc, + src_image: &Image<'a>, + dst_image: &Image<'a>, mip_level: u32, dst_layer: u32, ) { @@ -1181,9 +1180,9 @@ fn copy_image_to_image( ); } -fn blit_mip_maps( +fn blit_mip_maps<'a>( buffer_recorder: &mut CommandBufferRecorder<'_>, - image: &Arc, + image: &Image<'a>, target_image_layout: VkImageLayout, ) { let mut mip_width = image.width(); diff --git a/vulkan-rs/src/instance.rs b/vulkan-rs/src/instance.rs index 4ed5226..10fe524 100644 --- a/vulkan-rs/src/instance.rs +++ b/vulkan-rs/src/instance.rs @@ -6,7 +6,6 @@ use std::collections::HashSet; use std::fmt; use std::mem::MaybeUninit; use std::ptr; -use std::sync::Arc; use std::os::raw::c_char; use std::os::raw::c_void; @@ -104,7 +103,7 @@ impl Instance { proc_addr: PFN_vkGetInstanceProcAddr, extensions: &[VkString], api_version: Option, - ) -> Result> { + ) -> Result { let static_functions = StaticFunctions { _lib: None, vkGetInstanceProcAddr: proc_addr, @@ -122,7 +121,7 @@ impl Instance { let instance_extensions = InstanceExtensions::from_list(extensions); - let instance = Arc::new(Instance { + let instance = Instance { _static_functions: static_functions, _entry_functions: None, instance_functions, @@ -138,7 +137,7 @@ impl Instance { debug_report: None, api_version: api_version.unwrap_or(VK_MAKE_VERSION(1, 0, 0)), - }); + }; Ok(instance) } @@ -147,7 +146,7 @@ impl Instance { app_info: VkApplicationInfo<'_>, debug_info: VulkanDebugInfo, mut extensions: InstanceExtensions, - ) -> Result> { + ) -> Result { // required in physical device extensions.physical_device_properties2 = true; @@ -267,7 +266,7 @@ impl Instance { } } - Ok(Arc::new(instance)) + Ok(instance) } pub(crate) fn api_version(&self) -> u32 { diff --git a/vulkan-rs/src/lib.rs b/vulkan-rs/src/lib.rs index b361aad..52a563f 100644 --- a/vulkan-rs/src/lib.rs +++ b/vulkan-rs/src/lib.rs @@ -39,8 +39,6 @@ pub mod shadermodule; pub mod surface; pub mod swapchain; -pub mod ffi; - mod sampler_manager; mod single_submit; @@ -56,13 +54,11 @@ pub trait VkHandle { } pub trait VulkanDevice { - fn device(&self) -> &std::sync::Arc; + fn device(&self) -> &device::Device; } -pub fn create_vk_handles() -> anyhow::Result<( - std::sync::Arc, - std::sync::Arc>, -)> { +pub fn create_vk_handles<'a>( +) -> anyhow::Result<(prelude::Device, std::sync::Mutex>)> { use crate::prelude::*; let instance = Instance::new( diff --git a/vulkan-rs/src/macros.rs b/vulkan-rs/src/macros.rs index 6c969c5..e3045f0 100644 --- a/vulkan-rs/src/macros.rs +++ b/vulkan-rs/src/macros.rs @@ -1,49 +1,25 @@ macro_rules! impl_vk_handle { - ($struct_name:ident $(<$( $const:ident $name:ident: $type:ident, )*>)?, $target_name:ident, $value:ident) => { - impl$(<$( $const $name: $type, )*>)? VkHandle<$target_name> for $struct_name$(<$($name,)?>)? { + ($struct_name:ident $(<$( $lt:lifetime $(,)? )* $( $const:ident $name:ident: $type:ident, )*>)?, $target_name:ident, $value:ident) => { + impl$(<$( $const $name: $type, )*>)? VkHandle<$target_name> for $struct_name$(<$($lt, )* $($name,)?>)? { fn vk_handle(&self) -> $target_name { self.$value } } - impl<'a $($(, $const $name: $type)*)?> VkHandle<$target_name> for &'a $struct_name$(<$($name,)?>)? { - fn vk_handle(&self) -> $target_name { - self.$value - } - } - - impl$(<$( $const $name: $type, )*>)? VkHandle<$target_name> for Arc<$struct_name$(<$($name,)?>)?> { - fn vk_handle(&self) -> $target_name { - self.$value - } - } - - impl<'a $($(, $const $name: $type)*)?> VkHandle<$target_name> for &'a Arc<$struct_name$(<$($name,)?>)?> { + impl<'x $($(, $const $name: $type)*)?> VkHandle<$target_name> for &'x $struct_name$(<$($lt, )* $($name,)?>)? { fn vk_handle(&self) -> $target_name { self.$value } } }; - ($struct_name:ident $(<$( $name:ident: $type:ident, )*>)?, $target_name:ident, $value:ident) => { - impl$(<$( $name: $type, )*>)? VkHandle<$target_name> for $struct_name$(<$($name,)?>)? { + ($struct_name:ident $(<$( $lt:lifetime $(,)? )* $( $name:ident: $type:ident, )*>)?, $target_name:ident, $value:ident) => { + impl$(<$( $lt, )* $( $name: $type, )*>)? VkHandle<$target_name> for $struct_name$(<$($lt, )* $($name,)?>)? { fn vk_handle(&self) -> $target_name { self.$value } } - impl<'a $($(, $name: $type)*)?> VkHandle<$target_name> for &'a $struct_name$(<$($name,)?>)? { - fn vk_handle(&self) -> $target_name { - self.$value - } - } - - impl$(<$( $name: $type, )*>)? VkHandle<$target_name> for Arc<$struct_name$(<$($name,)?>)?> { - fn vk_handle(&self) -> $target_name { - self.$value - } - } - - impl<'a $($(, $name: $type)*)?> VkHandle<$target_name> for &'a Arc<$struct_name$(<$($name,)?>)?> { + impl<'x $($(, $lt, )* $(, $name: $type)*)?> VkHandle<$target_name> for &'x $struct_name$(<$($lt, )* $($name,)?>)? { fn vk_handle(&self) -> $target_name { self.$value } @@ -64,18 +40,6 @@ macro_rules! impl_vk_handle_t { self.$value } } - - impl VkHandle<$target_name> for Arc<$struct_name> { - fn vk_handle(&self) -> $target_name { - self.$value - } - } - - impl<'a, T $(: $($t,)* )?> VkHandle<$target_name> for &'a Arc<$struct_name> { - fn vk_handle(&self) -> $target_name { - self.$value - } - } }; } diff --git a/vulkan-rs/src/memory.rs b/vulkan-rs/src/memory.rs index 4a31077..52df3c1 100644 --- a/vulkan-rs/src/memory.rs +++ b/vulkan-rs/src/memory.rs @@ -6,7 +6,6 @@ use utilities::impl_reprc; use vma_rs::prelude::*; use std::marker::PhantomData; -use std::sync::Arc; impl_reprc!( #[derive(Debug, Copy)] @@ -45,45 +44,42 @@ impl Into for MemoryUsage { } #[derive(Debug)] -pub struct Memory { - device: Arc, +pub struct Memory<'a, T: ReprC> { + device: &'a Device, allocation: Allocation, data_type: PhantomData, } -impl Memory { +impl<'a, T: ReprC> Memory<'a, T> { pub(crate) fn forced_requirements( - device: &Arc, + device: &'a Device, memory_requirements: VkMemoryRequirements, buffer: VkBuffer, memory_usage: VmaMemoryUsage, - ) -> Result>> { + ) -> Result> { let mut memory = Self::create_and_bind(device, memory_requirements, memory_usage, ())?; - - if let Some(mut_memory) = Arc::get_mut(&mut memory) { - mut_memory.allocation.bind_buffer_memory(buffer)?; - } + memory.allocation.bind_buffer_memory(buffer)?; Ok(memory) } pub(crate) fn buffer_memory( - device: &Arc, + device: &'a Device, buffer: VkBuffer, memory_usage: VmaMemoryUsage, - ) -> Result>> { + ) -> Result> { let memory_requirements = device.buffer_memory_requirements(buffer); Self::create_and_bind(device, memory_requirements, memory_usage, buffer) } pub(crate) fn image_memory( - device: &Arc, + device: &Device, image: VkImage, memory_usage: VmaMemoryUsage, - ) -> Result>> { + ) -> Result> { let memory_requirements = device.image_memory_requirements(image); Self::create_and_bind(device, memory_requirements, memory_usage, image) @@ -94,22 +90,22 @@ impl Memory { } } -trait MemoryBinder { +trait MemoryBinder<'a, T, K: ReprC> { fn create_and_bind( - device: &Arc, + device: &Device, memory_requirements: VkMemoryRequirements, memory_usage: VmaMemoryUsage, argument: T, - ) -> Result>>; + ) -> Result>; } -impl MemoryBinder<(), K> for Memory { +impl<'a, K: ReprC> MemoryBinder<'a, (), K> for Memory<'a, K> { fn create_and_bind( - device: &Arc, + device: &Device, memory_requirements: VkMemoryRequirements, memory_usage: VmaMemoryUsage, _: (), - ) -> Result>> { + ) -> Result> { let allocation = device .allocator() .allocate() @@ -117,23 +113,23 @@ impl MemoryBinder<(), K> for Memory { .set_memory_type_bits(memory_requirements.memoryTypeBits.into()) .build(&memory_requirements)?; - Ok(Arc::new(Memory { - device: device.clone(), + Ok(Memory { + device, allocation, data_type: PhantomData, - })) + }) } } -impl MemoryBinder for Memory { +impl<'a, K: ReprC> MemoryBinder<'a, VkImage, K> for Memory<'a, K> { fn create_and_bind( - device: &Arc, + device: &Device, memory_requirements: VkMemoryRequirements, memory_usage: VmaMemoryUsage, image: VkImage, - ) -> Result>> { + ) -> Result> { let allocation = device .allocator() .allocate() @@ -141,23 +137,23 @@ impl MemoryBinder for Memory { .set_memory_type_bits(memory_requirements.memoryTypeBits.into()) .build(image)?; - Ok(Arc::new(Memory { - device: device.clone(), + Ok(Memory { + device, allocation, data_type: PhantomData, - })) + }) } } -impl MemoryBinder for Memory { +impl<'a, K: ReprC> MemoryBinder<'a, VkBuffer, K> for Memory<'a, K> { fn create_and_bind( - device: &Arc, + device: &Device, memory_requirements: VkMemoryRequirements, memory_usage: VmaMemoryUsage, buffer: VkBuffer, - ) -> Result>> { + ) -> Result> { let allocation = device .allocator() .allocate() @@ -165,23 +161,23 @@ impl MemoryBinder for Memory { .set_memory_type_bits(memory_requirements.memoryTypeBits.into()) .build(buffer)?; - Ok(Arc::new(Memory { - device: device.clone(), + Ok(Memory { + device, allocation, data_type: PhantomData, - })) + }) } } -impl VulkanDevice for Memory { - fn device(&self) -> &Arc { +impl<'a, T: ReprC> VulkanDevice for Memory<'a, T> { + fn device(&self) -> &Device { &self.device } } -impl Memory { +impl<'a, T: ReprC + Clone> Memory<'a, T> { pub fn map(&self, length: VkDeviceSize) -> Result> { self.allocation.map(length) } diff --git a/vulkan-rs/src/physicaldevice.rs b/vulkan-rs/src/physicaldevice.rs index 0028ded..f2ce0eb 100644 --- a/vulkan-rs/src/physicaldevice.rs +++ b/vulkan-rs/src/physicaldevice.rs @@ -2,11 +2,11 @@ use crate::prelude::*; use anyhow::Result; -use std::{ptr, sync::Arc}; +use std::ptr; #[derive(Debug)] pub struct PhysicalDevice { - instance: Arc, + instance: Instance, physical_device: VkPhysicalDevice, properties: VkPhysicalDeviceProperties, features: VkPhysicalDeviceFeatures, @@ -26,7 +26,7 @@ pub struct PhysicalDevice { } impl PhysicalDevice { - pub fn new(instance: Arc) -> Result> { + pub fn new(instance: Instance) -> Result { let physical_devices = instance.enumerate_physical_devices()?; let (mut physical_device, mut device_properties) = PhysicalDevice::find_phys_dev( @@ -57,19 +57,19 @@ impl PhysicalDevice { } pub fn from_raw( - instance: Arc, + instance: Instance, physical_device: VkPhysicalDevice, - ) -> Result> { + ) -> Result { let properties = instance.physical_device_properties(physical_device); Self::internal_new(instance, physical_device, properties) } fn internal_new( - instance: Arc, + instance: Instance, physical_device: VkPhysicalDevice, properties: VkPhysicalDeviceProperties, - ) -> Result> { + ) -> Result { let device_features = instance.physical_device_features(physical_device); let device_memory_properties = instance.physical_device_memory_properties(physical_device); @@ -134,7 +134,7 @@ impl PhysicalDevice { patch ); - Ok(Arc::new(PhysicalDevice { + Ok(PhysicalDevice { instance, physical_device, properties, @@ -151,13 +151,13 @@ impl PhysicalDevice { descriptor_indexing_features, buffer_device_address_features, - })) + }) } } // getter impl PhysicalDevice { - pub fn instance(&self) -> &Arc { + pub fn instance(&self) -> &Instance { &self.instance } @@ -305,7 +305,7 @@ impl_vk_handle!(PhysicalDevice, VkPhysicalDevice, physical_device); // private impl PhysicalDevice { fn find_phys_dev( - instance: &Arc, + instance: &Instance, physical_devices: &[VkPhysicalDevice], device_type: VkPhysicalDeviceType, ) -> (Option, Option) { @@ -321,7 +321,7 @@ impl PhysicalDevice { } fn query_extensions( - instance: &Arc, + instance: &Instance, physical_device: VkPhysicalDevice, ) -> Result> { let extensions = instance.enumerate_device_extensions(physical_device)?; diff --git a/vulkan-rs/src/pipeline.rs b/vulkan-rs/src/pipeline.rs index 462244f..f17cd61 100644 --- a/vulkan-rs/src/pipeline.rs +++ b/vulkan-rs/src/pipeline.rs @@ -84,7 +84,7 @@ impl Pipeline { } impl VulkanDevice for Pipeline { - fn device(&self) -> &Arc { + fn device(&self) -> &Device { &self.device } } diff --git a/vulkan-rs/src/pipelinecache.rs b/vulkan-rs/src/pipelinecache.rs index cbd0798..f637999 100644 --- a/vulkan-rs/src/pipelinecache.rs +++ b/vulkan-rs/src/pipelinecache.rs @@ -38,7 +38,7 @@ impl PipelineCache { } impl VulkanDevice for PipelineCache { - fn device(&self) -> &Arc { + fn device(&self) -> &Device { &self.device } } diff --git a/vulkan-rs/src/pipelinelayout.rs b/vulkan-rs/src/pipelinelayout.rs index 3443e94..ec13b95 100644 --- a/vulkan-rs/src/pipelinelayout.rs +++ b/vulkan-rs/src/pipelinelayout.rs @@ -59,7 +59,7 @@ impl PipelineLayout { } impl VulkanDevice for PipelineLayout { - fn device(&self) -> &Arc { + fn device(&self) -> &Device { &self.device } } diff --git a/vulkan-rs/src/pipelines/ray_tracing_pipeline.rs b/vulkan-rs/src/pipelines/ray_tracing_pipeline.rs index 5fc0108..e650331 100644 --- a/vulkan-rs/src/pipelines/ray_tracing_pipeline.rs +++ b/vulkan-rs/src/pipelines/ray_tracing_pipeline.rs @@ -245,7 +245,7 @@ impl<'a> RayTracingPipelineBuilder<'a> { mut self, device: Arc, pipeline_layout: &Arc, - ) -> Result<(Arc, ShaderBindingTable)> { + ) -> Result<(Arc, ShaderBindingTable<'a>)> { let shader_stages: Vec = self .shader_modules .iter() diff --git a/vulkan-rs/src/pipelines/shader_binding_table.rs b/vulkan-rs/src/pipelines/shader_binding_table.rs index 1f883a3..68d4b5d 100644 --- a/vulkan-rs/src/pipelines/shader_binding_table.rs +++ b/vulkan-rs/src/pipelines/shader_binding_table.rs @@ -14,8 +14,8 @@ pub(crate) struct ShaderBindingTableBuilder { hit_group_entries: Vec, } -pub struct ShaderBindingTable { - _sbt_buffer: Arc>, +pub struct ShaderBindingTable<'a> { + _sbt_buffer: Buffer<'a, RawBuffer>, raygen_shader_binding_table: VkStridedDeviceAddressRegionKHR, miss_shader_binding_table: VkStridedDeviceAddressRegionKHR, @@ -23,7 +23,7 @@ pub struct ShaderBindingTable { callable_shader_binding_table: VkStridedDeviceAddressRegionKHR, } -impl ShaderBindingTable { +impl<'a> ShaderBindingTable<'a> { pub fn raygen_shader_binding_table(&self) -> &VkStridedDeviceAddressRegionKHR { &self.raygen_shader_binding_table } @@ -41,7 +41,7 @@ impl ShaderBindingTable { } fn create( - sbt_buffer: Arc>, + sbt_buffer: Buffer<'a, RawBuffer>, ray_gen_entry_size: VkDeviceSize, ray_gen_entry_count: VkDeviceSize, miss_offset: VkDeviceSize, @@ -128,11 +128,11 @@ impl ShaderBindingTableBuilder { self } - pub(crate) fn build( + pub(crate) fn build<'a>( &mut self, device: &Arc, pipeline: &Arc, - ) -> Result { + ) -> Result> { let ray_tracing_properties = device.physical_device().ray_tracing_properties(); let prog_id_size = ray_tracing_properties.shaderGroupHandleSize; @@ -208,7 +208,7 @@ impl ShaderBindingTableBuilder { .collect::>() .as_slice(), ) - .build(device.clone())?; + .build(device)?; Ok(ShaderBindingTable::create( sbt_buffer, diff --git a/vulkan-rs/src/querypool.rs b/vulkan-rs/src/querypool.rs index fc0aff7..abbe169 100644 --- a/vulkan-rs/src/querypool.rs +++ b/vulkan-rs/src/querypool.rs @@ -52,7 +52,7 @@ impl QueryPool { } impl VulkanDevice for QueryPool { - fn device(&self) -> &Arc { + fn device(&self) -> &Device { &self.device } } diff --git a/vulkan-rs/src/queue.rs b/vulkan-rs/src/queue.rs index e309c08..044f9d6 100644 --- a/vulkan-rs/src/queue.rs +++ b/vulkan-rs/src/queue.rs @@ -15,17 +15,17 @@ pub struct QueueRequestInfo { } #[derive(Debug)] -pub struct Queue { - device: Arc, +pub struct Queue<'a> { + device: &'a Device, queue: VkQueue, family_index: u32, queue_index: u32, } -impl Queue { - pub fn create_presentable_request_info( - physical_device: &Arc, - surface: &Arc, +impl<'a> Queue<'a> { + pub fn create_presentable_request_info<'b>( + physical_device: &PhysicalDevice, + surface: &Surface<'b>, queue_type: impl Into, ) -> Result { let index = @@ -41,7 +41,7 @@ impl Queue { } pub fn create_non_presentable_request_info( - physical_device: &Arc, + physical_device: &PhysicalDevice, queue_type: impl Into, ) -> Result { let index = Self::find_non_presentable_queue_index(physical_device, queue_type.into())?; @@ -56,17 +56,17 @@ impl Queue { } pub fn new( - device: Arc, + device: &'a Device, queue: VkQueue, family_index: u32, queue_index: u32, - ) -> Arc> { - Arc::new(Mutex::new(Queue { + ) -> Mutex> { + Mutex::new(Queue { device, queue, family_index, queue_index, - })) + }) } pub fn family_index(&self) -> u32 { @@ -78,7 +78,7 @@ impl Queue { } /// really expensiv call, since its locks the queue until it is idle - pub fn submit(&self, fence: Option<&Arc>, submits: &[SubmitInfo]) -> Result<()> { + pub fn submit(&self, fence: Option<&Fence<'a>>, submits: &[SubmitInfo]) -> Result<()> { let submit_infos: Vec = submits.iter().map(|s| s.as_vk_submit()).collect(); let fence = match fence { @@ -93,7 +93,7 @@ impl Queue { pub fn minimal_submit( &self, time_out: Duration, - command_buffers: &[Arc], + command_buffers: &[Arc>], ) -> Result<()> { let mut submit = SubmitInfo::default(); @@ -101,7 +101,7 @@ impl Queue { submit = submit.add_command_buffer(command_buffer); } - let fence = Fence::builder().build(self.device.clone())?; + let fence = Fence::builder().build(self.device)?; self.submit(Some(&fence), slice::from_ref(&submit))?; @@ -113,9 +113,9 @@ impl Queue { pub fn present( &self, - swapchains: &[&Arc], + swapchains: &[&Swapchain<'a>], image_indices: &[u32], - wait_semaphores: &[&Arc], + wait_semaphores: &[&Semaphore<'a>], ) -> Result> { let wait_semaphores: Vec = wait_semaphores.iter().map(|sem| sem.vk_handle()).collect(); @@ -140,18 +140,18 @@ impl Queue { } } -impl VulkanDevice for Queue { - fn device(&self) -> &Arc { +impl<'a> VulkanDevice for Queue<'a> { + fn device(&self) -> &Device { &self.device } } impl_vk_handle!(Queue, VkQueue, queue); -impl Queue { +impl<'a> Queue<'a> { fn find_presentable_queue_index( - physical_device: &Arc, - surface: &Arc, + physical_device: &PhysicalDevice, + surface: &Surface<'a>, flags: VkQueueFlagBits, ) -> Result { let surface = surface.vk_handle(); @@ -179,7 +179,7 @@ impl Queue { } fn find_non_presentable_queue_index( - physical_device: &Arc, + physical_device: &PhysicalDevice, flags: VkQueueFlagBits, ) -> Result { let vk_physical_device = physical_device.vk_handle(); diff --git a/vulkan-rs/src/render_target/mod.rs b/vulkan-rs/src/render_target/mod.rs index 5479232..7896def 100644 --- a/vulkan-rs/src/render_target/mod.rs +++ b/vulkan-rs/src/render_target/mod.rs @@ -9,24 +9,24 @@ pub mod sub_pass; use sub_pass::{AttachmentInfo, AttachmentInfoUsage, SubPass}; pub struct RenderTargetBuilder<'a> { - old_render_target: Option<&'a RenderTarget>, - sub_passes: Vec, + old_render_target: Option<&'a RenderTarget<'a>>, + sub_passes: Vec>, } impl<'a> RenderTargetBuilder<'a> { - pub fn add_sub_pass(mut self, sub_pass: SubPass) -> Self { + pub fn add_sub_pass(mut self, sub_pass: SubPass<'a>) -> Self { self.sub_passes.push(sub_pass); self } - pub fn preserve_old_render_pass(mut self, render_target: &'a RenderTarget) -> Self { + pub fn preserve_old_render_pass(mut self, render_target: &'a RenderTarget<'a>) -> Self { self.old_render_target = Some(render_target); self } - pub fn build(self, device: &Arc) -> Result { + pub fn build(self, device: &Arc) -> Result> { #[cfg(debug_assertions)] { // sub passes must not be empty @@ -187,8 +187,8 @@ impl<'a> RenderTargetBuilder<'a> { fn create_framebuffers( render_pass: &Arc, - sub_passes: &[SubPass], - ) -> Result>> { + sub_passes: &[SubPass<'a>], + ) -> Result>> { let extent = sub_passes[0].extent(); (0..Self::max_images(sub_passes)) @@ -211,7 +211,7 @@ impl<'a> RenderTargetBuilder<'a> { } #[inline] - fn max_images(sub_passes: &[SubPass]) -> usize { + fn max_images(sub_passes: &[SubPass<'a>]) -> usize { let mut max_images = 0; for sub_pass in sub_passes.iter() { @@ -221,7 +221,7 @@ impl<'a> RenderTargetBuilder<'a> { max_images } - fn verify_setups(old_sub_passes: &[SubPass], new_sub_passes: &[SubPass]) -> bool { + fn verify_setups(old_sub_passes: &[SubPass<'a>], new_sub_passes: &[SubPass<'a>]) -> bool { if old_sub_passes.len() != new_sub_passes.len() { return false; } @@ -238,7 +238,7 @@ impl<'a> RenderTargetBuilder<'a> { #[inline] fn map_attachment<'b, F>(&'b self, mut f: F) where - F: FnMut(&'b AttachmentInfo) -> (), + F: FnMut(&'b AttachmentInfo<'a>) -> (), { for sub_pass in self.sub_passes.iter() { for attachment in sub_pass.attachments().iter() { @@ -260,21 +260,21 @@ struct SubPassAttachmentReferences { } #[derive(Debug)] -pub struct RenderTarget { +pub struct RenderTarget<'a> { render_pass: Arc, - framebuffers: Vec>, + framebuffers: Vec>, clear_values: Vec, extent: VkExtent2D, - sub_passes: Vec, + sub_passes: Vec>, current_subpass: AtomicU32, framebuffer_index: AtomicUsize, } -impl RenderTarget { - pub fn builder<'a>() -> RenderTargetBuilder<'a> { +impl<'a> RenderTarget<'a> { + pub fn builder() -> RenderTargetBuilder<'a> { RenderTargetBuilder { old_render_target: None, sub_passes: Vec::new(), @@ -285,11 +285,11 @@ impl RenderTarget { &self.render_pass } - pub fn framebuffer(&self, index: usize) -> &Arc { + pub fn framebuffer(&self, index: usize) -> &Framebuffer<'a> { &self.framebuffers[index] } - pub fn sub_pass(&self, index: usize) -> &SubPass { + pub fn sub_pass(&self, index: usize) -> &SubPass<'a> { &self.sub_passes[index] } @@ -353,48 +353,14 @@ impl RenderTarget { #[cfg(test)] mod test { - use crate::prelude::*; + use crate::{create_vk_handles, prelude::*}; use anyhow::Result; - use std::sync::{Arc, Mutex}; - - fn create_vk_handles() -> Result<(Arc, Arc>)> { - let instance = Instance::new( - VkApplicationInfo::new( - &VkString::new("Test"), - 1, - &VkString::new("no name"), - 1, - VK_MAKE_VERSION(1, 3, 0), - ), - VulkanDebugInfo::default(), - InstanceExtensions::default(), - )?; - - let physical_device = PhysicalDevice::new(instance)?; - - let queue_info = Queue::create_non_presentable_request_info( - &physical_device, - VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_TRANSFER_BIT, - )?; - - let device = Device::new( - physical_device, - DeviceExtensions::default(), - &[queue_info.queue_create_info], - DeviceFeatures::default(), - )?; - - let queue = device.get_queue(queue_info.queue_family_index, queue_info.queue_index); - - Ok((device, queue)) - } - #[test] fn test_render_target() { let (device, queue) = create_vk_handles().unwrap(); - let target_images: Vec> = (0..2) + let target_images: Vec> = (0..2) .map(|_| { let image = Image::empty( 1920, @@ -409,7 +375,7 @@ mod test { Ok(image) }) - .collect::>>>() + .collect::>>>() .unwrap(); RenderTarget::builder() diff --git a/vulkan-rs/src/render_target/sub_pass.rs b/vulkan-rs/src/render_target/sub_pass.rs index 551b2fb..fefb9ef 100644 --- a/vulkan-rs/src/render_target/sub_pass.rs +++ b/vulkan-rs/src/render_target/sub_pass.rs @@ -1,6 +1,6 @@ use crate::prelude::*; use anyhow::Result; -use std::sync::{Arc, Mutex}; +use std::sync::Mutex; pub enum ClearValue { Color([f32; 4]), @@ -54,14 +54,14 @@ impl CustomTarget { } } - fn to_attachment_info( + fn to_attachment_info<'a>( &self, - device: &Arc, - queue: &Arc>, + device: &Device, + queue: &Mutex>, width: u32, height: u32, sample_count: VkSampleCountFlags, - ) -> Result { + ) -> Result> { let clear_operation = SubPassBuilder::clear_op(if self.use_as_input { false } else { @@ -168,25 +168,25 @@ impl CustomTarget { } } -pub enum ResolveTarget { +pub enum ResolveTarget<'a> { CustomTarget(CustomTarget), - PreparedTargets((Vec>, bool)), + PreparedTargets((Vec<&'a Image<'a>>, bool)), } -impl From for ResolveTarget { +impl<'a> From for ResolveTarget<'a> { fn from(custom_target: CustomTarget) -> Self { Self::CustomTarget(custom_target) } } -impl From<(Vec>, bool)> for ResolveTarget { - fn from((prepared_targets, clear_on_load): (Vec>, bool)) -> Self { +impl<'a> From<(Vec<&'a Image<'a>>, bool)> for ResolveTarget<'a> { + fn from((prepared_targets, clear_on_load): (Vec<&'a Image<'a>>, bool)) -> Self { Self::PreparedTargets((prepared_targets, clear_on_load)) } } -impl<'a> From<(&'a Vec>, bool)> for ResolveTarget { - fn from((prepared_targets, clear_on_load): (&'a Vec>, bool)) -> Self { +impl<'a> From<(&'a Vec<&'a Image<'a>>, bool)> for ResolveTarget<'a> { + fn from((prepared_targets, clear_on_load): (&'a Vec<&'a Image<'a>>, bool)) -> Self { Self::PreparedTargets((prepared_targets.clone(), clear_on_load)) } } @@ -202,15 +202,15 @@ pub struct SubPassBuilder<'a> { height: u32, sample_count: VkSampleCountFlags, - queue: Option>>, + queue: Option<&'a Mutex>>, target_infos: Vec, input_info: Option, // (images, index, clear_color, clear_on_load) - prepared_targets: Option<(&'a [Arc], usize, [f32; 4], bool)>, - resolve_targets: Vec, + prepared_targets: Option<(&'a [&'a Image<'a>], usize, [f32; 4], bool)>, + resolve_targets: Vec>, output_usage: VkAccessFlagBits, } @@ -242,7 +242,7 @@ impl<'a> SubPassBuilder<'a> { pub fn set_prepared_targets( mut self, - prepared_targets: &'a [Arc], + prepared_targets: &'a [&'a Image<'a>], target_index: usize, clear_color: impl Into<[f32; 4]>, clear_on_load: bool, @@ -257,19 +257,19 @@ impl<'a> SubPassBuilder<'a> { self } - pub fn add_resolve_targets(mut self, resolve_target: impl Into) -> Self { + pub fn add_resolve_targets(mut self, resolve_target: impl Into>) -> Self { self.resolve_targets.push(resolve_target.into()); self } - pub fn use_queue(mut self, queue: Arc>) -> Self { + pub fn use_queue(mut self, queue: &'a Mutex>) -> Self { self.queue = Some(queue); self } - pub fn build(self, device: &Arc) -> Result { + pub fn build(self, device: &Device) -> Result> { Ok(SubPass { extent: VkExtent2D { width: self.width, @@ -284,7 +284,7 @@ impl<'a> SubPassBuilder<'a> { } #[inline] - fn create_images(self, device: &Arc) -> Result> { + fn create_images(self, device: &Device) -> Result>> { // check for correct sample count let checked_sample_count = device.max_supported_sample_count(self.sample_count); @@ -405,16 +405,16 @@ pub enum AttachmentInfoUsage { } #[derive(Debug)] -pub struct AttachmentInfo { - images: Vec>, +pub struct AttachmentInfo<'a> { + images: Vec<&'a Image<'a>>, pub(crate) clear_value: VkClearValue, pub(crate) layout: VkImageLayout, pub(crate) description: VkAttachmentDescription, pub(crate) usage: AttachmentInfoUsage, } -impl AttachmentInfo { - pub fn image(&self, mut index: usize) -> &Arc { +impl<'a> AttachmentInfo<'a> { + pub fn image(&self, mut index: usize) -> &Image<'a> { debug_assert!(!self.images.is_empty()); if index >= self.images.len() { @@ -433,17 +433,17 @@ impl AttachmentInfo { } #[derive(Debug)] -pub struct SubPass { +pub struct SubPass<'a> { extent: VkExtent2D, input_info: Option, - attachments: Vec, + attachments: Vec>, output_usage: VkAccessFlagBits, } -impl SubPass { - pub fn builder<'a>(width: u32, height: u32) -> SubPassBuilder<'a> { +impl<'a> SubPass<'a> { + pub fn builder(width: u32, height: u32) -> SubPassBuilder<'a> { SubPassBuilder { width, height, @@ -475,7 +475,7 @@ impl SubPass { self.extent } - pub fn attachments(&self) -> &[AttachmentInfo] { + pub fn attachments(&self) -> &[AttachmentInfo<'a>] { &self.attachments } diff --git a/vulkan-rs/src/renderpass.rs b/vulkan-rs/src/renderpass.rs index ec1d254..1fc2df4 100644 --- a/vulkan-rs/src/renderpass.rs +++ b/vulkan-rs/src/renderpass.rs @@ -34,7 +34,7 @@ impl RenderPass { } impl VulkanDevice for RenderPass { - fn device(&self) -> &Arc { + fn device(&self) -> &Device { &self.device } } diff --git a/vulkan-rs/src/sampler_manager.rs b/vulkan-rs/src/sampler_manager.rs index be878ad..03e7e82 100644 --- a/vulkan-rs/src/sampler_manager.rs +++ b/vulkan-rs/src/sampler_manager.rs @@ -78,7 +78,7 @@ impl SamplerBuilder { self } - pub fn build(self, device: &Device) -> Result> { + pub fn build(self, device: &Device) -> Result { device.create_sampler_from_manager(self.create_info) } } diff --git a/vulkan-rs/src/semaphore.rs b/vulkan-rs/src/semaphore.rs index a0c3377..5654d8e 100644 --- a/vulkan-rs/src/semaphore.rs +++ b/vulkan-rs/src/semaphore.rs @@ -2,48 +2,32 @@ use crate::prelude::*; use anyhow::Result; -use std::sync::Arc; - #[derive(Debug)] -pub struct Semaphore { - device: Arc, +pub struct Semaphore<'a> { + device: &'a Device, semaphore: VkSemaphore, } -impl Semaphore { - pub fn new(device: Arc) -> Result> { +impl<'a> Semaphore<'a> { + pub fn new(device: &'a Device) -> Result> { let semaphore_ci = VkSemaphoreCreateInfo::new(VK_SEMAPHORE_CREATE_NULL_BIT); let semaphore = device.create_semaphore(&semaphore_ci)?; - Ok(Arc::new(Semaphore { device, semaphore })) + Ok(Semaphore { device, semaphore }) } } -impl VulkanDevice for Semaphore { - fn device(&self) -> &Arc { +impl<'a> VulkanDevice for Semaphore<'a> { + fn device(&self) -> &Device { &self.device } } impl_vk_handle!(Semaphore, VkSemaphore, semaphore); -impl Drop for Semaphore { +impl<'a> Drop for Semaphore<'a> { fn drop(&mut self) { self.device.destroy_semaphore(self.semaphore); } } - -use crate::{ffi::*, handle_ffi_result}; - -#[no_mangle] -pub extern "C" fn create_semaphore(device: *const Device) -> *const Semaphore { - let device = unsafe { Arc::from_raw(device) }; - - handle_ffi_result!(Semaphore::new(device)) -} - -#[no_mangle] -pub extern "C" fn destroy_semaphore(semaphore: *const Semaphore) { - let _semaphore = unsafe { Arc::from_raw(semaphore) }; -} diff --git a/vulkan-rs/src/shadermodule.rs b/vulkan-rs/src/shadermodule.rs index c878050..b456b73 100644 --- a/vulkan-rs/src/shadermodule.rs +++ b/vulkan-rs/src/shadermodule.rs @@ -144,7 +144,7 @@ impl_pipeline_stage_info!(ray_generation, RayGeneration); impl_pipeline_stage_info!(miss, Miss); impl VulkanDevice for ShaderModule { - fn device(&self) -> &Arc { + fn device(&self) -> &Device { &self.device } } diff --git a/vulkan-rs/src/single_submit/mod.rs b/vulkan-rs/src/single_submit/mod.rs index e720990..6fb3006 100644 --- a/vulkan-rs/src/single_submit/mod.rs +++ b/vulkan-rs/src/single_submit/mod.rs @@ -1,15 +1,15 @@ use crate::prelude::*; use anyhow::Result; -use std::sync::{Arc, Mutex}; +use std::sync::Mutex; use std::time::Duration; pub struct SingleSubmit<'a, F, T> where F: FnOnce(&mut CommandBufferRecorder<'_>) -> Result, { - command_buffer: &'a Arc, - queue: &'a Arc>, + command_buffer: &'a CommandBuffer<'a>, + queue: &'a Mutex>, f: F, timeout: Option, @@ -20,8 +20,8 @@ where F: FnOnce(&mut CommandBufferRecorder<'_>) -> Result, { pub fn builder( - command_buffer: &'a Arc, - queue: &'a Arc>, + command_buffer: &'a CommandBuffer<'a>, + queue: &'a Mutex>, f: F, ) -> Self { SingleSubmit { diff --git a/vulkan-rs/src/surface.rs b/vulkan-rs/src/surface.rs index 80674ed..cf85f82 100644 --- a/vulkan-rs/src/surface.rs +++ b/vulkan-rs/src/surface.rs @@ -7,17 +7,14 @@ use std::sync::Arc; const UNORM_FORMATS: [VkFormat; 2] = [VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM]; #[derive(Debug)] -pub struct Surface { - instance: Arc, +pub struct Surface<'a> { + instance: &'a Instance, surface: VkSurfaceKHR, } -impl Surface { - pub fn from_vk_surface(surface: VkSurfaceKHR, instance: &Arc) -> Arc { - Arc::new(Surface { - instance: instance.clone(), - surface, - }) +impl<'a> Surface<'a> { + pub fn from_vk_surface(surface: VkSurfaceKHR, instance: &'a Instance) -> Self { + Self { instance, surface } } pub fn capabilities(&self, device: &Arc) -> Result { @@ -67,9 +64,19 @@ impl Surface { } } -impl_vk_handle!(Surface, VkSurfaceKHR, surface); +impl<'a> VkHandle for Surface<'a> { + fn vk_handle(&self) -> VkSurfaceKHR { + self.surface + } +} -impl Drop for Surface { +impl<'a> VkHandle for &'a Surface<'a> { + fn vk_handle(&self) -> VkSurfaceKHR { + self.surface + } +} + +impl<'a> Drop for Surface<'a> { fn drop(&mut self) { self.instance.destroy_surface(self.surface) } diff --git a/vulkan-rs/src/swapchain.rs b/vulkan-rs/src/swapchain.rs index 4f5c860..2472b7a 100644 --- a/vulkan-rs/src/swapchain.rs +++ b/vulkan-rs/src/swapchain.rs @@ -5,52 +5,52 @@ use anyhow::Result; use std::cmp; use std::sync::{ atomic::{AtomicU32, Ordering::SeqCst}, - Arc, Mutex, + Mutex, }; pub enum NextImageSynchronization<'a> { - Semaphore(&'a Arc), - Fence(&'a Arc), + Semaphore(&'a Semaphore<'a>), + Fence(&'a Fence<'a>), } -impl<'a> From<&'a Arc> for NextImageSynchronization<'a> { - fn from(value: &'a Arc) -> Self { +impl<'a> From<&'a Semaphore<'a>> for NextImageSynchronization<'a> { + fn from(value: &'a Semaphore<'a>) -> Self { Self::Semaphore(value) } } -impl<'a> From<&'a Arc> for NextImageSynchronization<'a> { - fn from(value: &'a Arc) -> Self { +impl<'a> From<&'a Fence<'a>> for NextImageSynchronization<'a> { + fn from(value: &'a Fence<'a>) -> Self { Self::Fence(value) } } #[derive(Debug)] -pub struct Swapchain { - width: AtomicU32, - height: AtomicU32, - index: AtomicU32, +pub struct Swapchain<'a> { + width: u32, + height: u32, + index: u32, - device: Arc, - surface: Arc, + device: &'a Device, + surface: Surface<'a>, - create_info: Mutex, - swapchain: Mutex, + create_info: VkSwapchainCreateInfoKHR, + swapchain: VkSwapchainKHR, usage: VkImageUsageFlagBits, raw: bool, } -impl Swapchain { +impl<'a> Swapchain<'a> { pub fn new( - device: Arc, - surface: &Arc, + device: &'a Device, + surface: Surface<'a>, vsync: bool, image_count: u32, image_usage: impl Into, prefered_format: VkFormat, array_layers: u32, - ) -> Result> { + ) -> Result> { let surface_caps = surface.capabilities(&device)?; let extent = if surface_caps.currentExtent.width == u32::max_value() { @@ -112,57 +112,54 @@ impl Swapchain { let swapchain = device.create_swapchain(&swapchain_ci)?; - Ok(Arc::new(Swapchain { + Ok(Swapchain { width: AtomicU32::new(extent.width), height: AtomicU32::new(extent.height), usage: swapchain_ci.imageUsage, index: AtomicU32::new(0), device, - surface: surface.clone(), + surface, create_info: Mutex::new(swapchain_ci), swapchain: Mutex::new(swapchain), raw: false, - })) + }) } - pub fn from_ci( - device: Arc, - swapchain_ci: &VkSwapchainCreateInfoKHR, - ) -> Result> { - Ok(Arc::new(Swapchain { - width: AtomicU32::new(swapchain_ci.imageExtent.width), - height: AtomicU32::new(swapchain_ci.imageExtent.height), + pub fn from_ci(device: &Device, swapchain_ci: &VkSwapchainCreateInfoKHR) -> Result { + Ok(Swapchain { + width: swapchain_ci.imageExtent.width, + height: swapchain_ci.imageExtent.height, usage: swapchain_ci.imageUsage, - index: AtomicU32::new(0), + index: 0, surface: Surface::from_vk_surface( swapchain_ci.surface, device.physical_device().instance(), ), - create_info: Mutex::new(swapchain_ci.clone()), + create_info: swapchain_ci.clone(), - swapchain: Mutex::new(device.create_swapchain(swapchain_ci)?), + swapchain: device.create_swapchain(swapchain_ci)?, device, raw: false, - })) + }) } pub fn from_raw( - device: Arc, + device: &'a Device, swapchain_ci: &VkSwapchainCreateInfoKHR, swapchain: VkSwapchainKHR, - ) -> Arc { - Arc::new(Swapchain { - width: AtomicU32::new(swapchain_ci.imageExtent.width), - height: AtomicU32::new(swapchain_ci.imageExtent.height), + ) -> Self { + Swapchain { + width: swapchain_ci.imageExtent.width, + height: swapchain_ci.imageExtent.height, usage: swapchain_ci.imageUsage, - index: AtomicU32::new(0), + index: 0, surface: Surface::from_vk_surface( swapchain_ci.surface, @@ -170,12 +167,11 @@ impl Swapchain { ), device, - create_info: Mutex::new(swapchain_ci.clone()), - - swapchain: Mutex::new(swapchain), + create_info: swapchain_ci.clone(), + swapchain, raw: true, - }) + } } pub fn recreate(&self) -> Result<()> { @@ -217,10 +213,10 @@ impl Swapchain { Ok(()) } - pub fn acquire_next_image<'a>( + pub fn acquire_next_image<'b>( &self, time_out: u64, - synchro: impl Into>, + synchro: impl Into>, ) -> Result> { let synchro = synchro.into(); @@ -264,9 +260,9 @@ impl Swapchain { pub fn wrap_images( &self, images: &[VkImage], - queue: &Arc>, + queue: &Mutex>, assume_layout: bool, - ) -> Result>> { + ) -> Result>> { let format = self.format(); let tiling = VK_IMAGE_TILING_OPTIMAL; @@ -290,7 +286,7 @@ impl Swapchain { self.usage, assume_layout, ) - .attach_sampler(Sampler::nearest_sampler().build(&self.device)?) + .attach_sampler(Sampler::nearest_sampler().build(self.device)?) .build(&self.device, queue)?, ); } @@ -299,55 +295,42 @@ impl Swapchain { } pub fn width(&self) -> u32 { - self.width.load(SeqCst) + self.width } pub fn height(&self) -> u32 { - self.height.load(SeqCst) + self.height } pub fn format(&self) -> VkFormat { - self.create_info.lock().unwrap().imageFormat + self.create_info.imageFormat } #[inline] fn destroy(&self) { - self.device - .destroy_swapchain(*self.swapchain.lock().unwrap()) + self.device.destroy_swapchain(self.swapchain) } } -impl VulkanDevice for Swapchain { - fn device(&self) -> &Arc { +impl<'a> VulkanDevice for Swapchain<'a> { + fn device(&self) -> &Device { &self.device } } -impl VkHandle for Swapchain { +impl<'a> VkHandle for Swapchain<'a> { fn vk_handle(&self) -> VkSwapchainKHR { - *self.swapchain.lock().unwrap() + self.swapchain } } -impl<'a> VkHandle for &'a Swapchain { +impl<'a> VkHandle for &'a Swapchain<'a> { fn vk_handle(&self) -> VkSwapchainKHR { - *self.swapchain.lock().unwrap() + self.swapchain } } -impl VkHandle for Arc { - fn vk_handle(&self) -> VkSwapchainKHR { - *self.swapchain.lock().unwrap() - } -} - -impl<'a> VkHandle for &'a Arc { - fn vk_handle(&self) -> VkSwapchainKHR { - *self.swapchain.lock().unwrap() - } -} - -impl Drop for Swapchain { +impl<'a> Drop for Swapchain<'a> { fn drop(&mut self) { if !self.raw { self.destroy();