hodasemi/vulkan_lib
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Wiki Activity Actions

First try to convert to lifetimes

Browse source
This commit is contained in:
hodasemi 2024-03-28 18:28:52 +01:00
parent 4d476c4263
commit 39c4fa2342
33 changed files with 489 additions and 826 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
vulkan-rs/src/acceleration_structure.rs
View file

@ -37,9 +37,9 @@ pub struct AccelerationStructureBuilder {
}
impl AccelerationStructureBuilder {
pub fn add_instance(
pub fn add_instance<'a>(
mut self,
blas: &Arc<AccelerationStructure>,
blas: &AccelerationStructure<'a>,
transform: Option<Matrix4<f32>>,
instance_flags: impl Into<VkGeometryInstanceFlagBitsKHR>,
) -> Self {
@ -70,10 +70,10 @@ impl AccelerationStructureBuilder {
self
}
pub fn add_vertices<T: ReprC + Send + Sync + 'static>(
pub fn add_vertices<'a, T: ReprC + Send + Sync + 'static>(
mut self,
vertex_buffer: &Arc<Buffer<T>>,
transform: Option<Arc<Buffer<Transform>>>,
vertex_buffer: &Arc<Buffer<'a, T>>,
transform: Option<Arc<Buffer<'a, Transform>>>,
flags: impl Into<VkGeometryFlagBitsKHR>,
) -> Self {
match &mut self.data {
@ -122,11 +122,11 @@ impl AccelerationStructureBuilder {
self
}
pub fn build(
pub fn build<'a>(
self,
device: Arc<Device>,
device: &Device,
recorder: &mut CommandBufferRecorder<'_>,
) -> Result<Arc<AccelerationStructure>> {
) -> Result<AccelerationStructure<'a>> {
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<Device>,
pub struct AccelerationStructure<'a> {
device: &'a Device,
acceleration_structure: VkAccelerationStructureKHR,
result_buffer: Arc<Buffer<RawBuffer>>,
scratch_buffer: Mutex<Arc<Buffer<RawBuffer>>>,
result_buffer: Buffer<'a, RawBuffer>,
scratch_buffer: Mutex<Buffer<'a, RawBuffer>>,
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<Buffer<RawBuffer>> {
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: &Device,
size: VkDeviceSize,
alignment: VkDeviceSize,
) -> Result<Arc<Buffer<RawBuffer>>> {
) -> Result<Buffer<'a, RawBuffer>> {
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<VkAccelerationStructureInstanceKHR>,
VkAccelerationStructureGeometryKHR,
Arc<Buffer<VkAccelerationStructureInstanceKHR>>,
Buffer<'a, VkAccelerationStructureInstanceKHR>,
),
BottomLevel(
Vec<VkAccelerationStructureGeometryKHR>,
@ -430,26 +430,26 @@ enum AccelerationStructureGenerationData {
),
}
impl
impl<'a>
From<(
Vec<VkAccelerationStructureInstanceKHR>,
VkAccelerationStructureGeometryKHR,
Arc<Buffer<VkAccelerationStructureInstanceKHR>>,
)> for AccelerationStructureGenerationData
Buffer<'a, VkAccelerationStructureInstanceKHR>,
)> for AccelerationStructureGenerationData<'a>
{
fn from(
(instances, geometry, buffer): (
Vec<VkAccelerationStructureInstanceKHR>,
VkAccelerationStructureGeometryKHR,
Arc<Buffer<VkAccelerationStructureInstanceKHR>>,
Buffer<'a, VkAccelerationStructureInstanceKHR>,
),
) -> Self {
Self::TopLevel(instances, geometry, buffer)
}
}
impl From<(Vec<VkAccelerationStructureGeometryKHR>, Vec<u32>)>
for AccelerationStructureGenerationData
impl<'a> From<(Vec<VkAccelerationStructureGeometryKHR>, Vec<u32>)>
for AccelerationStructureGenerationData<'a>
{
fn from(
(geometries, primitive_counts): (Vec<VkAccelerationStructureGeometryKHR>, Vec<u32>),

83
vulkan-rs/src/buffer.rs
View file

@ -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<Device>) -> Result<Arc<Buffer<T>>> {
pub fn build(self, device: &'a Device) -> Result<Buffer<'a, T>> {
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<T: ReprC> {
device: Arc<Device>,
pub struct Buffer<'a, T: ReprC> {
device: &'a Device,
buffer: VkBuffer,
memory: Arc<Memory<T>>,
memory: Memory<'a, T>,
_usage: VkBufferUsageFlagBits,
@ -134,7 +133,7 @@ pub struct Buffer<T: ReprC> {
size: VkDeviceSize,
}
impl<T: ReprC + Clone + Send + Sync + 'static> Buffer<T> {
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<T: ReprC + Clone + Send + Sync + 'static> Buffer<T> {
}
pub fn into_device_local(
self: &Arc<Buffer<T>>,
&self,
buffer_recorder: &mut CommandBufferRecorder<'_>,
access_mask: impl Into<VkAccessFlagBits>,
stage: impl Into<VkPipelineStageFlagBits>,
usage: impl Into<VkBufferUsageFlagBits>,
) -> Result<Arc<Buffer<T>>> {
) -> Result<Buffer<'a, T>> {
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<T: ReprC + Clone + Send + Sync + 'static> Buffer<T> {
}
}
impl<T: ReprC> Buffer<T> {
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<T: ReprC> Buffer<T> {
}
}
impl<T: ReprC> VulkanDevice for Buffer<T> {
fn device(&self) -> &Arc<Device> {
impl<'a, T: ReprC> VulkanDevice for Buffer<'a, T> {
fn device(&self) -> &Device {
&self.device
}
}
impl_vk_handle_t!(Buffer[ReprC], VkBuffer, buffer);
impl<T: ReprC> VkHandle<VkDeviceMemory> for Buffer<T> {
impl<'a, T: ReprC> VkHandle<VkDeviceMemory> for Buffer<'a, T> {
fn vk_handle(&self) -> VkDeviceMemory {
self.memory.vk_handle()
}
}
impl<'a, T: ReprC> VkHandle<VkDeviceMemory> for &'a Buffer<T> {
impl<'a, T: ReprC> VkHandle<VkDeviceMemory> for &'a Buffer<'a, T> {
fn vk_handle(&self) -> VkDeviceMemory {
self.memory.vk_handle()
}
}
impl<T: ReprC> VkHandle<VkDeviceMemory> for Arc<Buffer<T>> {
fn vk_handle(&self) -> VkDeviceMemory {
self.memory.vk_handle()
}
}
impl<'a, T: ReprC> VkHandle<VkDeviceMemory> for &'a Arc<Buffer<T>> {
fn vk_handle(&self) -> VkDeviceMemory {
self.memory.vk_handle()
}
}
impl<T: ReprC> Drop for Buffer<T> {
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<T: ReprC> FFIBufferTrait for Buffer<T> {
fn byte_size(&self) -> VkDeviceSize {
self.byte_size()
}
}
pub trait FFIBufferTrait {
fn byte_size(&self) -> VkDeviceSize;
}
pub struct FFIBuffer {
trait_obj: Box<dyn FFIBufferTrait>,
}
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()
}

44
vulkan-rs/src/commandbuffer.rs
View file

@ -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<Device>,
queue: Arc<Mutex<Queue>>,
) -> Result<Arc<CommandBuffer>> {
device: &'a Device,
queue: &'a Mutex<Queue<'a>>,
) -> Result<Arc<CommandBuffer<'a>>> {
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<Device>,
pool: Arc<CommandPool>,
pub struct CommandBuffer<'a> {
device: &'a Device,
pool: CommandPool<'a>,
buffer: VkCommandBuffer,
calls: Arc<AtomicUsize>,
stored_handles: Mutex<Vec<Arc<dyn Any + Send + Sync>>>,
stored_handles: Mutex<Vec<&'a (dyn Any + Send + Sync)>>,
}
#[derive(Debug)]
pub struct CommandBufferRecorder<'a> {
device: Arc<Device>,
device: &'a Device,
sub_pass: u32,
pipeline: Option<Arc<Pipeline>>,
calls: Arc<AtomicUsize>,
buffer: VkCommandBuffer,
handles_lock: MutexGuard<'a, Vec<Arc<dyn Any + Send + Sync>>>,
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: &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<Image>,
dst_image: &Arc<Image>,
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<T: ReprC + Send + Sync + 'static>(
&mut self,
src_buffer: &Arc<Buffer<T>>,
dst_image: &Arc<Image>,
src_buffer: &Arc<Buffer<'a, T>>,
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,

37
vulkan-rs/src/commandpool.rs
View file

@ -22,7 +22,7 @@ impl CommandPoolBuilder {
self
}
pub(crate) fn build(self, device: Arc<Device>) -> Result<Arc<CommandPool>> {
pub(crate) fn build<'a>(self, device: &'a Device) -> Result<Arc<CommandPool<'a>>> {
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<Device>,
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<Device> {
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) };
// }

90
vulkan-rs/src/descriptorpool.rs
View file

@ -2,15 +2,13 @@ use crate::prelude::*;
use anyhow::Result;
use std::sync::Arc;
pub struct DescriptorPoolBuilder {
layout: Option<Arc<DescriptorSetLayout>>,
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<VkDescriptorPoolCreateFlagBits>) -> Self {
self.flags |= flags.into();
@ -23,13 +21,13 @@ impl DescriptorPoolBuilder {
self
}
pub fn set_layout(mut self, layout: Arc<DescriptorSetLayout>) -> Self {
pub fn set_layout(mut self, layout: &'a DescriptorSetLayout<'a>) -> Self {
self.layout = Some(layout);
self
}
pub fn build(self, device: Arc<Device>) -> Result<Arc<DescriptorPool>> {
pub fn build(self, device: &'a Device) -> Result<DescriptorPool<'a>> {
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<Device>,
pub struct DescriptorPool<'a> {
device: &'a Device,
descriptor_pool: VkDescriptorPool,
pub(crate) descriptor_set_layout: Arc<DescriptorSetLayout>,
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<Self>) -> 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<Device> {
impl<'a> VulkanDevice for DescriptorPool<'a> {
fn device(&self) -> &Device {
&self.device
}
}
impl_vk_handle!(DescriptorPool, VkDescriptorPool, descriptor_pool);
impl VkHandle<VkDescriptorSetLayout> for DescriptorPool {
impl<'a> VkHandle<VkDescriptorSetLayout> for DescriptorPool<'a> {
fn vk_handle(&self) -> VkDescriptorSetLayout {
self.descriptor_set_layout.vk_handle()
}
}
impl<'a> VkHandle<VkDescriptorSetLayout> for &'a DescriptorPool {
impl<'a> VkHandle<VkDescriptorSetLayout> for &'a DescriptorPool<'a> {
fn vk_handle(&self) -> VkDescriptorSetLayout {
self.descriptor_set_layout.vk_handle()
}
}
impl VkHandle<VkDescriptorSetLayout> for Arc<DescriptorPool> {
fn vk_handle(&self) -> VkDescriptorSetLayout {
self.descriptor_set_layout.vk_handle()
}
}
impl<'a> VkHandle<VkDescriptorSetLayout> for &'a Arc<DescriptorPool> {
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) };
}

96
vulkan-rs/src/descriptorset.rs
View file

@ -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<Arc<dyn Any + Send + Sync>>,
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<T: ReprC + Send + Sync + 'static>(
binding: u32,
buffers: &[&Arc<Buffer<T>>],
buffers: &[&Buffer<'a, T>],
) -> Self {
DescriptorWrite {
binding,
@ -47,14 +47,14 @@ impl DescriptorWrite {
),
handles: buffers
.iter()
.map(|b| (*b).clone() as Arc<dyn Any + Send + Sync>)
.map(|b| (*b) as &'a (dyn Any + Send + Sync))
.collect(),
}
}
pub fn storage_buffers<T: ReprC + Send + Sync + 'static>(
binding: u32,
buffers: &[&Arc<Buffer<T>>],
buffers: &[&Buffer<'a, T>],
) -> Self {
DescriptorWrite {
binding,
@ -71,12 +71,12 @@ impl DescriptorWrite {
),
handles: buffers
.iter()
.map(|b| (*b).clone() as Arc<dyn Any + Send + Sync>)
.map(|b| (*b) as &'a (dyn Any + Send + Sync))
.collect(),
}
}
pub fn combined_samplers(binding: u32, images: &[&Arc<Image>]) -> 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<dyn Any + Send + Sync>)
.map(|i| (*i).clone() as &'a (dyn Any + Send + Sync))
.collect(),
}
}
pub fn storage_images(binding: u32, images: &[&Arc<Image>]) -> 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<dyn Any + Send + Sync>)
.map(|i| (*i).clone() as &'a (dyn Any + Send + Sync))
.collect(),
}
}
pub fn input_attachments(binding: u32, images: &[&Arc<Image>]) -> 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<dyn Any + Send + Sync>)
.map(|i| (*i) as &'a (dyn Any + Send + Sync))
.collect(),
}
}
pub fn acceleration_structures(
binding: u32,
acceleration_structures: &[&Arc<AccelerationStructure>],
acceleration_structures: &[&AccelerationStructure<'a>],
) -> Self {
let vk_as: Vec<VkAccelerationStructureKHR> = acceleration_structures
.iter()
@ -161,7 +161,7 @@ impl DescriptorWrite {
)),
handles: acceleration_structures
.iter()
.map(|a| (*a).clone() as Arc<dyn Any + Send + Sync>)
.map(|a| (*a) as &'a (dyn Any + Send + Sync))
.collect(),
};
@ -198,21 +198,21 @@ impl DescriptorWrite {
}
}
pub struct DescriptorSetBuilder {
device: Arc<Device>,
descriptor_pool: Arc<DescriptorPool>,
pub struct DescriptorSetBuilder<'a> {
device: &'a Device,
descriptor_pool: &'a DescriptorPool<'a>,
variable_desc_counts: Vec<u32>,
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<Arc<DescriptorSet>> {
pub fn allocate(mut self) -> Result<DescriptorSet<'a>> {
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<Device>,
pool: Arc<DescriptorPool>,
pub struct DescriptorSet<'a> {
device: &'a Device,
pool: &'a DescriptorPool<'a>,
descriptor_set: VkDescriptorSet,
handles: Mutex<HashMap<u32, Vec<Arc<dyn Any + Send + Sync>>>>,
handles: Mutex<HashMap<u32, Vec<&'a (dyn Any + Send + Sync)>>>,
}
impl DescriptorSet {
impl<'a> DescriptorSet<'a> {
pub(crate) fn builder(
device: Arc<Device>,
descriptor_pool: Arc<DescriptorPool>,
) -> 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<Device> {
impl<'a> VulkanDevice for DescriptorSet<'a> {
fn device(&self) -> &Device {
&self.device
}
}
impl_vk_handle!(DescriptorSet, VkDescriptorSet, descriptor_set);
impl VkHandle<VkDescriptorSetLayout> for DescriptorSet {
impl<'a> VkHandle<VkDescriptorSetLayout> for DescriptorSet<'a> {
fn vk_handle(&self) -> VkDescriptorSetLayout {
self.pool.vk_handle()
}
}
impl<'a> VkHandle<VkDescriptorSetLayout> for &'a DescriptorSet {
impl<'a> VkHandle<VkDescriptorSetLayout> for &'a DescriptorSet<'a> {
fn vk_handle(&self) -> VkDescriptorSetLayout {
self.pool.vk_handle()
}
}
impl VkHandle<VkDescriptorSetLayout> for Arc<DescriptorSet> {
fn vk_handle(&self) -> VkDescriptorSetLayout {
self.pool.vk_handle()
}
}
impl<'a> VkHandle<VkDescriptorSetLayout> for &'a Arc<DescriptorSet> {
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<Arc<DescriptorSet>> = (0..DESCRIPTOR_COUNT)
let descriptors: Vec<DescriptorSet<'_>> = (0..DESCRIPTOR_COUNT)
.map(|_| {
let set = descriptor_pool.prepare_set().allocate();

14
vulkan-rs/src/descriptorsetlayout.rs
View file

@ -48,7 +48,7 @@ impl DescriptorSetLayoutBuilder {
self
}
pub fn build(self, device: Arc<Device>) -> Result<Arc<DescriptorSetLayout>> {
pub fn build<'a>(self, device: &'a Device) -> Result<Arc<DescriptorSetLayout<'a>>> {
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<Device>,
pub struct DescriptorSetLayout<'a> {
device: &'a Device,
descriptor_set_layout: VkDescriptorSetLayout,
pool_sizes: Vec<VkDescriptorPoolSize>,
bindings: Vec<DescriptorLayoutBinding>,
}
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<Device> {
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);

34
vulkan-rs/src/device.rs
View file

@ -53,7 +53,7 @@ pub struct Device {
enabled_extensions: DeviceExtensions,
physical_device: Arc<PhysicalDevice>,
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<PhysicalDevice>,
physical_device: PhysicalDevice,
extensions: &[VkString],
) -> Result<Arc<Device>> {
) -> Result<Device> {
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<PhysicalDevice>,
physical_device: PhysicalDevice,
mut extensions: DeviceExtensions,
queue_infos: &[VkDeviceQueueCreateInfo],
requested_device_features: DeviceFeatures,
) -> Result<Arc<Device>> {
) -> Result<Device> {
// 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<Self>,
queue_family_index: u32,
queue_index: u32,
) -> Arc<Mutex<Queue>> {
pub fn get_queue<'a>(&'a self, queue_family_index: u32, queue_index: u32) -> Mutex<Queue<'a>> {
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<PhysicalDevice> {
pub fn physical_device(&self) -> &PhysicalDevice {
&self.physical_device
}
pub fn wait_for_fences(
pub fn wait_for_fences<'a>(
&self,
fences: &[&Arc<Fence>],
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<Arc<Sampler>> {
) -> Result<Sampler> {
self.sampler_manager
.lock()
.unwrap()

37
vulkan-rs/src/fence.rs
View file

@ -15,7 +15,7 @@ impl FenceBuilder {
self
}
pub fn build(self, device: Arc<Device>) -> Result<Arc<Fence>> {
pub fn build<'a>(self, device: &'a Device) -> Result<Arc<Fence<'a>>> {
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<Device>,
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<Device> {
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) };
}

70
vulkan-rs/src/ffi.rs
View file

@ -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<Option<Box<String>>> = 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<Box<String>> {
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
}

28
vulkan-rs/src/framebuffer.rs
View file

@ -6,7 +6,7 @@ use std::sync::Arc;
pub struct FramebufferBuilder<'a> {
render_pass: Option<&'a Arc<RenderPass>>,
attachments: Vec<&'a Arc<Image>>,
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<Image>) -> 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<Device>) -> Result<Arc<Framebuffer>> {
pub fn build(mut self, device: Arc<Device>) -> Result<Framebuffer<'a>> {
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<Device>,
framebuffer: VkFramebuffer,
images: Vec<Arc<Image>>,
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<Image>] {
pub fn attachments(&self) -> &[&'a Image<'a>] {
&self.images
}
pub fn image(&self, index: usize) -> &Arc<Image> {
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<Device> {
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);
}

153
vulkan-rs/src/image.rs
View file

@ -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<u8>),
Array(Vec<Arc<Image>>),
Array(Vec<Image<'a>>),
}
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<AssetPath>,
builder_type: ImageBuilderInternalType,
builder_type: ImageBuilderInternalType<'a>,
components: VkComponentMapping,
view_type: VkImageViewType,
subresource_range: VkImageSubresourceRange,
sampler: Option<Arc<Sampler>>,
sampler: Option<Sampler>,
}
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<Device>, queue: &Arc<Mutex<Queue>>) -> Result<Arc<Image>> {
pub fn build(self, device: &'a Device, queue: &'a Mutex<Queue<'a>>) -> Result<Image<'a>> {
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<Sampler>) -> 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<Device>,
queue: &Arc<Mutex<Queue>>,
info: &ImageCreateInfo,
sampler: Option<Arc<Sampler>>,
device: &Device,
queue: &Mutex<Queue<'a>>,
info: &ImageCreateInfo<'a>,
sampler: Option<Sampler>,
mut view_ci: VkImageViewCreateInfo,
file_name: Option<AssetPath>,
) -> Result<Arc<Image>> {
) -> Result<Image<'a>> {
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: &Device,
image_ci: &VkImageCreateInfo,
) -> Result<(VkImage, Arc<Memory<RawBuffer>>)> {
) -> 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<Device>, image_ci: &VkImageCreateInfo) -> Result<VkImage> {
fn create_image(device: &Device, image_ci: &VkImageCreateInfo) -> Result<VkImage> {
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<Device>,
queue: &Arc<Mutex<Queue>>,
device: &Device,
queue: &Mutex<Queue<'a>>,
data: &[RawBuffer],
image: &Arc<Image>,
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>,
device: &'a Device,
// queue handle
queue: Arc<Mutex<Queue>>,
queue: &'a Mutex<Queue<'a>>,
file_name: Option<AssetPath>,
@ -486,8 +486,8 @@ pub struct Image {
image_view: VkImageView,
// optional handles
_memory: Option<Arc<Memory<RawBuffer>>>,
sampler: Option<Arc<Sampler>>,
_memory: Option<Memory<'a, RawBuffer>>,
sampler: Option<Sampler>,
// 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<VkImageUsageFlagBits>,
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<u8>, width: u32, height: u32) -> ImageBuilder {
pub fn from_raw(source: Vec<u8>, 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<ImageBuilder> {
pub fn from_file(file: AssetPath) -> Result<ImageBuilder<'a>> {
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<ImageBuilder> {
pub fn from_slice(data: &[u8]) -> Result<ImageBuilder<'a>> {
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<Arc<Image>>) -> ImageBuilder {
pub fn from_array(array: Vec<Image<'a>>) -> 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<VkImageUsageFlagBits>,
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: &Device,
tiling: VkImageTiling,
format: VkFormat,
usage: impl Into<VkImageUsageFlagBits>,
@ -677,11 +677,11 @@ impl Image {
}
}
pub fn device(&self) -> &Arc<Device> {
pub fn device(&self) -> &Device {
&self.device
}
pub fn queue(&self) -> &Arc<Mutex<Queue>> {
pub fn queue(&self) -> &Mutex<Queue<'a>> {
&self.queue
}
@ -689,7 +689,7 @@ impl Image {
self.file_name.as_ref()
}
pub fn convert_layout(self: &Arc<Self>, 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<Arc<Sampler>> {
pub fn sampler(&self) -> &Option<Sampler> {
&self.sampler
}
@ -788,7 +788,7 @@ impl Image {
}
}
pub fn to_file(self: &Arc<Image>, path: impl AsRef<Path>) -> Result<()> {
pub fn to_file(&self, path: impl AsRef<Path>) -> 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<Image>,
&self,
extra_buffer_flags: impl Into<Option<VkBufferUsageFlagBits>>,
) -> Result<Arc<Buffer<RawBuffer>>> {
) -> Result<Buffer<'a, RawBuffer>> {
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<Image>, buffer: &Arc<Buffer<RawBuffer>>) -> Result<()> {
copy_buffer_to_image(&self.device, &self.queue, &buffer, self)
pub fn copy_buffer_to_image(&self, buffer: &Arc<Buffer<'a, RawBuffer>>) -> Result<()> {
copy_buffer_to_image(self, &self.device, &self.queue, &buffer)
}
}
impl VulkanDevice for Image {
fn device(&self) -> &Arc<Device> {
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<Image>, 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<Image>, layout: VkImageLayout) -> Result<()> {
Ok(())
}
fn copy_buffer_to_image<T: ReprC + Send + Sync + 'static>(
device: &Arc<Device>,
queue: &Arc<Mutex<Queue>>,
buffer: &Arc<Buffer<T>>,
image: &Arc<Image>,
fn copy_buffer_to_image<'a, T: ReprC + Send + Sync + 'static>(
image: &Image<'a>,
device: &Device,
queue: &Mutex<Queue<'a>>,
buffer: &Buffer<'a, T>,
) -> Result<()>
where
T: Copy,
@ -1045,11 +1044,11 @@ where
Ok(())
}
fn copy_images_to_imagearray(
device: &Arc<Device>,
queue: &Arc<Mutex<Queue>>,
image_array: &Arc<Image>,
images: &[Arc<Image>],
fn copy_images_to_imagearray<'a>(
device: &Device,
queue: &Mutex<Queue<'a>>,
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<Image>,
dst_image: &Arc<Image>,
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: &Image<'a>,
target_image_layout: VkImageLayout,
) {
let mut mip_width = image.width();

11
vulkan-rs/src/instance.rs
View file

@ -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<u32>,
) -> Result<Arc<Instance>> {
) -> Result<Instance> {
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<Arc<Instance>> {
) -> Result<Instance> {
// 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 {

10
vulkan-rs/src/lib.rs
View file

@ -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<T> {
}
pub trait VulkanDevice {
fn device(&self) -> &std::sync::Arc<device::Device>;
fn device(&self) -> &device::Device;
}
pub fn create_vk_handles() -> anyhow::Result<(
std::sync::Arc<prelude::Device>,
std::sync::Arc<std::sync::Mutex<prelude::Queue>>,
)> {
pub fn create_vk_handles<'a>(
) -> anyhow::Result<(prelude::Device, std::sync::Mutex<prelude::Queue<'a>>)> {
use crate::prelude::*;
let instance = Instance::new(

48
vulkan-rs/src/macros.rs
View file

@ -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<T $(: $($t,)* )?> VkHandle<$target_name> for Arc<$struct_name<T>> {
fn vk_handle(&self) -> $target_name {
self.$value
}
}
impl<'a, T $(: $($t,)* )?> VkHandle<$target_name> for &'a Arc<$struct_name<T>> {
fn vk_handle(&self) -> $target_name {
self.$value
}
}
};
}

72
vulkan-rs/src/memory.rs
View file

@ -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<VmaMemoryUsage> for MemoryUsage {
}
#[derive(Debug)]
pub struct Memory<T: ReprC> {
device: Arc<Device>,
pub struct Memory<'a, T: ReprC> {
device: &'a Device,
allocation: Allocation,
data_type: PhantomData<T>,
}
impl<T: ReprC> Memory<T> {
impl<'a, T: ReprC> Memory<'a, T> {
pub(crate) fn forced_requirements(
device: &Arc<Device>,
device: &'a Device,
memory_requirements: VkMemoryRequirements,
buffer: VkBuffer,
memory_usage: VmaMemoryUsage,
) -> Result<Arc<Memory<T>>> {
) -> Result<Memory<'a, T>> {
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>,
device: &'a Device,
buffer: VkBuffer,
memory_usage: VmaMemoryUsage,
) -> Result<Arc<Memory<T>>> {
) -> Result<Memory<'a, T>> {
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: &Device,
image: VkImage,
memory_usage: VmaMemoryUsage,
) -> Result<Arc<Memory<T>>> {
) -> Result<Memory<'a, T>> {
let memory_requirements = device.image_memory_requirements(image);
Self::create_and_bind(device, memory_requirements, memory_usage, image)
@ -94,22 +90,22 @@ impl<T: ReprC> Memory<T> {
}
}
trait MemoryBinder<T, K: ReprC> {
trait MemoryBinder<'a, T, K: ReprC> {
fn create_and_bind(
device: &Arc<Device>,
device: &Device,
memory_requirements: VkMemoryRequirements,
memory_usage: VmaMemoryUsage,
argument: T,
) -> Result<Arc<Memory<K>>>;
) -> Result<Memory<'a, K>>;
}
impl<K: ReprC> MemoryBinder<(), K> for Memory<K> {
impl<'a, K: ReprC> MemoryBinder<'a, (), K> for Memory<'a, K> {
fn create_and_bind(
device: &Arc<Device>,
device: &Device,
memory_requirements: VkMemoryRequirements,
memory_usage: VmaMemoryUsage,
_: (),
) -> Result<Arc<Memory<K>>> {
) -> Result<Memory<'a, K>> {
let allocation = device
.allocator()
.allocate()
@ -117,23 +113,23 @@ impl<K: ReprC> MemoryBinder<(), K> for Memory<K> {
.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<K: ReprC> MemoryBinder<VkImage, K> for Memory<K> {
impl<'a, K: ReprC> MemoryBinder<'a, VkImage, K> for Memory<'a, K> {
fn create_and_bind(
device: &Arc<Device>,
device: &Device,
memory_requirements: VkMemoryRequirements,
memory_usage: VmaMemoryUsage,
image: VkImage,
) -> Result<Arc<Memory<K>>> {
) -> Result<Memory<'a, K>> {
let allocation = device
.allocator()
.allocate()
@ -141,23 +137,23 @@ impl<K: ReprC> MemoryBinder<VkImage, K> for Memory<K> {
.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<K: ReprC> MemoryBinder<VkBuffer, K> for Memory<K> {
impl<'a, K: ReprC> MemoryBinder<'a, VkBuffer, K> for Memory<'a, K> {
fn create_and_bind(
device: &Arc<Device>,
device: &Device,
memory_requirements: VkMemoryRequirements,
memory_usage: VmaMemoryUsage,
buffer: VkBuffer,
) -> Result<Arc<Memory<K>>> {
) -> Result<Memory<'a, K>> {
let allocation = device
.allocator()
.allocate()
@ -165,23 +161,23 @@ impl<K: ReprC> MemoryBinder<VkBuffer, K> for Memory<K> {
.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<T: ReprC> VulkanDevice for Memory<T> {
fn device(&self) -> &Arc<Device> {
impl<'a, T: ReprC> VulkanDevice for Memory<'a, T> {
fn device(&self) -> &Device {
&self.device
}
}
impl<T: ReprC + Clone> Memory<T> {
impl<'a, T: ReprC + Clone> Memory<'a, T> {
pub fn map(&self, length: VkDeviceSize) -> Result<VkMappedMemory<'_, T>> {
self.allocation.map(length)
}

24
vulkan-rs/src/physicaldevice.rs
View file

@ -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: Instance,
physical_device: VkPhysicalDevice,
properties: VkPhysicalDeviceProperties,
features: VkPhysicalDeviceFeatures,
@ -26,7 +26,7 @@ pub struct PhysicalDevice {
}
impl PhysicalDevice {
pub fn new(instance: Arc<Instance>) -> Result<Arc<PhysicalDevice>> {
pub fn new(instance: Instance) -> Result<PhysicalDevice> {
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: Instance,
physical_device: VkPhysicalDevice,
) -> Result<Arc<PhysicalDevice>> {
) -> Result<PhysicalDevice> {
let properties = instance.physical_device_properties(physical_device);
Self::internal_new(instance, physical_device, properties)
}
fn internal_new(
instance: Arc<Instance>,
instance: Instance,
physical_device: VkPhysicalDevice,
properties: VkPhysicalDeviceProperties,
) -> Result<Arc<PhysicalDevice>> {
) -> Result<PhysicalDevice> {
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<Instance> {
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: &Instance,
physical_devices: &[VkPhysicalDevice],
device_type: VkPhysicalDeviceType,
) -> (Option<VkPhysicalDevice>, Option<VkPhysicalDeviceProperties>) {
@ -321,7 +321,7 @@ impl PhysicalDevice {
}
fn query_extensions(
instance: &Arc<Instance>,
instance: &Instance,
physical_device: VkPhysicalDevice,
) -> Result<Vec<VkString>> {
let extensions = instance.enumerate_device_extensions(physical_device)?;

2
vulkan-rs/src/pipeline.rs
View file

@ -84,7 +84,7 @@ impl Pipeline {
}
impl VulkanDevice for Pipeline {
fn device(&self) -> &Arc<Device> {
fn device(&self) -> &Device {
&self.device
}
}

2
vulkan-rs/src/pipelinecache.rs
View file

@ -38,7 +38,7 @@ impl PipelineCache {
}
impl VulkanDevice for PipelineCache {
fn device(&self) -> &Arc<Device> {
fn device(&self) -> &Device {
&self.device
}
}

2
vulkan-rs/src/pipelinelayout.rs
View file

@ -59,7 +59,7 @@ impl PipelineLayout {
}
impl VulkanDevice for PipelineLayout {
fn device(&self) -> &Arc<Device> {
fn device(&self) -> &Device {
&self.device
}
}

2
vulkan-rs/src/pipelines/ray_tracing_pipeline.rs
View file

@ -245,7 +245,7 @@ impl<'a> RayTracingPipelineBuilder<'a> {
mut self,
device: Arc<Device>,
pipeline_layout: &Arc<PipelineLayout>,
) -> Result<(Arc<Pipeline>, ShaderBindingTable)> {
) -> Result<(Arc<Pipeline>, ShaderBindingTable<'a>)> {
let shader_stages: Vec<VkPipelineShaderStageCreateInfo> = self
.shader_modules
.iter()

14
vulkan-rs/src/pipelines/shader_binding_table.rs
View file

@ -14,8 +14,8 @@ pub(crate) struct ShaderBindingTableBuilder {
hit_group_entries: Vec<ShaderBindingTableEntry>,
}
pub struct ShaderBindingTable {
_sbt_buffer: Arc<Buffer<RawBuffer>>,
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<Buffer<RawBuffer>>,
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<Device>,
pipeline: &Arc<Pipeline>,
) -> Result<ShaderBindingTable> {
) -> Result<ShaderBindingTable<'a>> {
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::<Vec<RawBuffer>>()
.as_slice(),
)
.build(device.clone())?;
.build(device)?;
Ok(ShaderBindingTable::create(
sbt_buffer,

2
vulkan-rs/src/querypool.rs
View file

@ -52,7 +52,7 @@ impl QueryPool {
}
impl VulkanDevice for QueryPool {
fn device(&self) -> &Arc<Device> {
fn device(&self) -> &Device {
&self.device
}
}

44
vulkan-rs/src/queue.rs
View file

@ -15,17 +15,17 @@ pub struct QueueRequestInfo {
}
#[derive(Debug)]
pub struct Queue {
device: Arc<Device>,
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<PhysicalDevice>,
surface: &Arc<Surface>,
impl<'a> Queue<'a> {
pub fn create_presentable_request_info<'b>(
physical_device: &PhysicalDevice,
surface: &Surface<'b>,
queue_type: impl Into<VkQueueFlagBits>,
) -> Result<QueueRequestInfo> {
let index =
@ -41,7 +41,7 @@ impl Queue {
}
pub fn create_non_presentable_request_info(
physical_device: &Arc<PhysicalDevice>,
physical_device: &PhysicalDevice,
queue_type: impl Into<VkQueueFlagBits>,
) -> Result<QueueRequestInfo> {
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>,
device: &'a Device,
queue: VkQueue,
family_index: u32,
queue_index: u32,
) -> Arc<Mutex<Queue>> {
Arc::new(Mutex::new(Queue {
) -> Mutex<Queue<'a>> {
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<Fence>>, submits: &[SubmitInfo]) -> Result<()> {
pub fn submit(&self, fence: Option<&Fence<'a>>, submits: &[SubmitInfo]) -> Result<()> {
let submit_infos: Vec<VkSubmitInfo> = 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<CommandBuffer>],
command_buffers: &[Arc<CommandBuffer<'a>>],
) -> 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<Swapchain>],
swapchains: &[&Swapchain<'a>],
image_indices: &[u32],
wait_semaphores: &[&Arc<Semaphore>],
wait_semaphores: &[&Semaphore<'a>],
) -> Result<OutOfDate<()>> {
let wait_semaphores: Vec<VkSemaphore> =
wait_semaphores.iter().map(|sem| sem.vk_handle()).collect();
@ -140,18 +140,18 @@ impl Queue {
}
}
impl VulkanDevice for Queue {
fn device(&self) -> &Arc<Device> {
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<PhysicalDevice>,
surface: &Arc<Surface>,
physical_device: &PhysicalDevice,
surface: &Surface<'a>,
flags: VkQueueFlagBits,
) -> Result<u32> {
let surface = surface.vk_handle();
@ -179,7 +179,7 @@ impl Queue {
}
fn find_non_presentable_queue_index(
physical_device: &Arc<PhysicalDevice>,
physical_device: &PhysicalDevice,
flags: VkQueueFlagBits,
) -> Result<u32> {
let vk_physical_device = physical_device.vk_handle();

74
vulkan-rs/src/render_target/mod.rs
View file

@ -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<SubPass>,
old_render_target: Option<&'a RenderTarget<'a>>,
sub_passes: Vec<SubPass<'a>>,
}
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<Device>) -> Result<RenderTarget> {
pub fn build(self, device: &Arc<Device>) -> Result<RenderTarget<'a>> {
#[cfg(debug_assertions)]
{
// sub passes must not be empty
@ -187,8 +187,8 @@ impl<'a> RenderTargetBuilder<'a> {
fn create_framebuffers(
render_pass: &Arc<RenderPass>,
sub_passes: &[SubPass],
) -> Result<Vec<Arc<Framebuffer>>> {
sub_passes: &[SubPass<'a>],
) -> Result<Vec<Framebuffer<'a>>> {
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<RenderPass>,
framebuffers: Vec<Arc<Framebuffer>>,
framebuffers: Vec<Framebuffer<'a>>,
clear_values: Vec<VkClearValue>,
extent: VkExtent2D,
sub_passes: Vec<SubPass>,
sub_passes: Vec<SubPass<'a>>,
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<Framebuffer> {
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<Device>, Arc<Mutex<Queue>>)> {
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<Arc<Image>> = (0..2)
let target_images: Vec<Image<'_>> = (0..2)
.map(|_| {
let image = Image::empty(
1920,
@ -409,7 +375,7 @@ mod test {
Ok(image)
})
.collect::<Result<Vec<Arc<Image>>>>()
.collect::<Result<Vec<Image<'_>>>>()
.unwrap();
RenderTarget::builder()

58
vulkan-rs/src/render_target/sub_pass.rs
View file

@ -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<Device>,
queue: &Arc<Mutex<Queue>>,
device: &Device,
queue: &Mutex<Queue<'a>>,
width: u32,
height: u32,
sample_count: VkSampleCountFlags,
) -> Result<AttachmentInfo> {
) -> Result<AttachmentInfo<'a>> {
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<Arc<Image>>, bool)),
PreparedTargets((Vec<&'a Image<'a>>, bool)),
}
impl From<CustomTarget> for ResolveTarget {
impl<'a> From<CustomTarget> for ResolveTarget<'a> {
fn from(custom_target: CustomTarget) -> Self {
Self::CustomTarget(custom_target)
}
}
impl From<(Vec<Arc<Image>>, bool)> for ResolveTarget {
fn from((prepared_targets, clear_on_load): (Vec<Arc<Image>>, 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<Arc<Image>>, bool)> for ResolveTarget {
fn from((prepared_targets, clear_on_load): (&'a Vec<Arc<Image>>, 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<Arc<Mutex<Queue>>>,
queue: Option<&'a Mutex<Queue<'a>>>,
target_infos: Vec<CustomTarget>,
input_info: Option<InputAttachmentInfo>,
// (images, index, clear_color, clear_on_load)
prepared_targets: Option<(&'a [Arc<Image>], usize, [f32; 4], bool)>,
resolve_targets: Vec<ResolveTarget>,
prepared_targets: Option<(&'a [&'a Image<'a>], usize, [f32; 4], bool)>,
resolve_targets: Vec<ResolveTarget<'a>>,
output_usage: VkAccessFlagBits,
}
@ -242,7 +242,7 @@ impl<'a> SubPassBuilder<'a> {
pub fn set_prepared_targets(
mut self,
prepared_targets: &'a [Arc<Image>],
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<ResolveTarget>) -> Self {
pub fn add_resolve_targets(mut self, resolve_target: impl Into<ResolveTarget<'a>>) -> Self {
self.resolve_targets.push(resolve_target.into());
self
}
pub fn use_queue(mut self, queue: Arc<Mutex<Queue>>) -> Self {
pub fn use_queue(mut self, queue: &'a Mutex<Queue<'a>>) -> Self {
self.queue = Some(queue);
self
}
pub fn build(self, device: &Arc<Device>) -> Result<SubPass> {
pub fn build(self, device: &Device) -> Result<SubPass<'a>> {
Ok(SubPass {
extent: VkExtent2D {
width: self.width,
@ -284,7 +284,7 @@ impl<'a> SubPassBuilder<'a> {
}
#[inline]
fn create_images(self, device: &Arc<Device>) -> Result<Vec<AttachmentInfo>> {
fn create_images(self, device: &Device) -> Result<Vec<AttachmentInfo<'a>>> {
// 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<Arc<Image>>,
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<Image> {
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<InputAttachmentInfo>,
attachments: Vec<AttachmentInfo>,
attachments: Vec<AttachmentInfo<'a>>,
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
}

2
vulkan-rs/src/renderpass.rs
View file

@ -34,7 +34,7 @@ impl RenderPass {
}
impl VulkanDevice for RenderPass {
fn device(&self) -> &Arc<Device> {
fn device(&self) -> &Device {
&self.device
}
}

2
vulkan-rs/src/sampler_manager.rs
View file

@ -78,7 +78,7 @@ impl SamplerBuilder {
self
}
pub fn build(self, device: &Device) -> Result<Arc<Sampler>> {
pub fn build(self, device: &Device) -> Result<Sampler> {
device.create_sampler_from_manager(self.create_info)
}
}

32
vulkan-rs/src/semaphore.rs
View file

@ -2,48 +2,32 @@ use crate::prelude::*;
use anyhow::Result;
use std::sync::Arc;
#[derive(Debug)]
pub struct Semaphore {
device: Arc<Device>,
pub struct Semaphore<'a> {
device: &'a Device,
semaphore: VkSemaphore,
}
impl Semaphore {
pub fn new(device: Arc<Device>) -> Result<Arc<Semaphore>> {
impl<'a> Semaphore<'a> {
pub fn new(device: &'a Device) -> Result<Semaphore<'a>> {
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<Device> {
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) };
}

2
vulkan-rs/src/shadermodule.rs
View file

@ -144,7 +144,7 @@ impl_pipeline_stage_info!(ray_generation, RayGeneration);
impl_pipeline_stage_info!(miss, Miss);
impl<ShaderModuleType: ShaderType> VulkanDevice for ShaderModule<ShaderModuleType> {
fn device(&self) -> &Arc<Device> {
fn device(&self) -> &Device {
&self.device
}
}

10
vulkan-rs/src/single_submit/mod.rs
View file

@ -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<T>,
{
command_buffer: &'a Arc<CommandBuffer>,
queue: &'a Arc<Mutex<Queue>>,
command_buffer: &'a CommandBuffer<'a>,
queue: &'a Mutex<Queue<'a>>,
f: F,
timeout: Option<Duration>,
@ -20,8 +20,8 @@ where
F: FnOnce(&mut CommandBufferRecorder<'_>) -> Result<T>,
{
pub fn builder(
command_buffer: &'a Arc<CommandBuffer>,
queue: &'a Arc<Mutex<Queue>>,
command_buffer: &'a CommandBuffer<'a>,
queue: &'a Mutex<Queue<'a>>,
f: F,
) -> Self {
SingleSubmit {

27
vulkan-rs/src/surface.rs
View file

@ -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<Instance>,
pub struct Surface<'a> {
instance: &'a Instance,
surface: VkSurfaceKHR,
}
impl Surface {
pub fn from_vk_surface(surface: VkSurfaceKHR, instance: &Arc<Instance>) -> Arc<Surface> {
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<Device>) -> Result<VkSurfaceCapabilitiesKHR> {
@ -67,9 +64,19 @@ impl Surface {
}
}
impl_vk_handle!(Surface, VkSurfaceKHR, surface);
impl<'a> VkHandle<VkSurfaceKHR> for Surface<'a> {
fn vk_handle(&self) -> VkSurfaceKHR {
self.surface
}
}
impl Drop for Surface {
impl<'a> VkHandle<VkSurfaceKHR> 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)
}

127
vulkan-rs/src/swapchain.rs
View file

@ -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<Semaphore>),
Fence(&'a Arc<Fence>),
Semaphore(&'a Semaphore<'a>),
Fence(&'a Fence<'a>),
}
impl<'a> From<&'a Arc<Semaphore>> for NextImageSynchronization<'a> {
fn from(value: &'a Arc<Semaphore>) -> 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<Fence>> for NextImageSynchronization<'a> {
fn from(value: &'a Arc<Fence>) -> 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<Device>,
surface: Arc<Surface>,
device: &'a Device,
surface: Surface<'a>,
create_info: Mutex<VkSwapchainCreateInfoKHR>,
swapchain: Mutex<VkSwapchainKHR>,
create_info: VkSwapchainCreateInfoKHR,
swapchain: VkSwapchainKHR,
usage: VkImageUsageFlagBits,
raw: bool,
}
impl Swapchain {
impl<'a> Swapchain<'a> {
pub fn new(
device: Arc<Device>,
surface: &Arc<Surface>,
device: &'a Device,
surface: Surface<'a>,
vsync: bool,
image_count: u32,
image_usage: impl Into<VkImageUsageFlagBits>,
prefered_format: VkFormat,
array_layers: u32,
) -> Result<Arc<Swapchain>> {
) -> Result<Swapchain<'a>> {
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<Device>,
swapchain_ci: &VkSwapchainCreateInfoKHR,
) -> Result<Arc<Self>> {
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<Self> {
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>,
device: &'a Device,
swapchain_ci: &VkSwapchainCreateInfoKHR,
swapchain: VkSwapchainKHR,
) -> Arc<Self> {
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<NextImageSynchronization<'a>>,
synchro: impl Into<NextImageSynchronization<'b>>,
) -> Result<OutOfDate<u32>> {
let synchro = synchro.into();
@ -264,9 +260,9 @@ impl Swapchain {
pub fn wrap_images(
&self,
images: &[VkImage],
queue: &Arc<Mutex<Queue>>,
queue: &Mutex<Queue<'a>>,
assume_layout: bool,
) -> Result<Vec<Arc<Image>>> {
) -> Result<Vec<Image<'a>>> {
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<Device> {
impl<'a> VulkanDevice for Swapchain<'a> {
fn device(&self) -> &Device {
&self.device
}
}
impl VkHandle<VkSwapchainKHR> for Swapchain {
impl<'a> VkHandle<VkSwapchainKHR> for Swapchain<'a> {
fn vk_handle(&self) -> VkSwapchainKHR {
*self.swapchain.lock().unwrap()
self.swapchain
}
}
impl<'a> VkHandle<VkSwapchainKHR> for &'a Swapchain {
impl<'a> VkHandle<VkSwapchainKHR> for &'a Swapchain<'a> {
fn vk_handle(&self) -> VkSwapchainKHR {
*self.swapchain.lock().unwrap()
self.swapchain
}
}
impl VkHandle<VkSwapchainKHR> for Arc<Swapchain> {
fn vk_handle(&self) -> VkSwapchainKHR {
*self.swapchain.lock().unwrap()
}
}
impl<'a> VkHandle<VkSwapchainKHR> for &'a Arc<Swapchain> {
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();