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

Compare commits

merge into: hodasemi:master
Branches Tags
hodasemi:master
hodasemi:lifetime-test
...
pull from: hodasemi:lifetime-test
Branches Tags
hodasemi:master
hodasemi:lifetime-test

4 commits
master ... lifetime-t

Author SHA1 Message Date
hodasemi
913d25cd82 Refine more lifetimes 2024-03-29 08:43:44 +01:00
hodasemi
c9b4dfc164 Add more lifetime fixes 2024-03-29 07:01:22 +01:00
hodasemi
5b42c076b3 Second step 2024-03-28 21:30:06 +01:00
hodasemi
39c4fa2342 First try to convert to lifetimes 2024-03-28 18:28:52 +01:00
34 changed files with 967 additions and 1354 deletions
Show stats Expand all files Collapse all files

75
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<'device>(
mut self,
blas: &Arc<AccelerationStructure>,
blas: &AccelerationStructure<'device>,
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<'device, 'pipeline, 'cbuffer>(
self,
device: Arc<Device>,
recorder: &mut CommandBufferRecorder<'_>,
) -> Result<Arc<AccelerationStructure>> {
device: &'device Device,
recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>,
) -> Result<AccelerationStructure<'device>> {
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<'device> {
device: &'device Device,
acceleration_structure: VkAccelerationStructureKHR,
result_buffer: Arc<Buffer<RawBuffer>>,
scratch_buffer: Mutex<Arc<Buffer<RawBuffer>>>,
result_buffer: Buffer<'device, RawBuffer>,
scratch_buffer: Mutex<Buffer<'device, RawBuffer>>,
update_scratch_buffer_size: VkDeviceSize,
generation_data: AccelerationStructureGenerationData,
generation_data: AccelerationStructureGenerationData<'device>,
build_flags: VkBuildAccelerationStructureFlagBitsKHR,
}
impl AccelerationStructure {
impl<'device> AccelerationStructure<'device> {
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<'device, RawBuffer> {
&self.result_buffer
}
@ -313,7 +313,10 @@ impl AccelerationStructure {
)
}
pub fn update(&self, buffer_recorder: &mut CommandBufferRecorder<'_>) -> Result<()> {
pub fn update<'pipeline, 'cbuffer>(
&self,
buffer_recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>,
) -> Result<()> {
*self.scratch_buffer.lock().unwrap() = Self::create_scratch_buffer(
&self.device,
self.update_scratch_buffer_size,
@ -330,9 +333,9 @@ impl AccelerationStructure {
)
}
fn generate(
fn generate<'pipeline, 'cbuffer>(
&self,
buffer_recorder: &mut CommandBufferRecorder<'_>,
buffer_recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>,
src: VkAccelerationStructureKHR,
mode: VkBuildAccelerationStructureModeKHR,
) -> Result<()> {
@ -390,10 +393,10 @@ impl AccelerationStructure {
#[inline]
fn create_scratch_buffer(
device: &Arc<Device>,
device: &'device Device,
size: VkDeviceSize,
alignment: VkDeviceSize,
) -> Result<Arc<Buffer<RawBuffer>>> {
) -> Result<Buffer<'device, RawBuffer>> {
Buffer::builder()
.set_usage(
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
@ -401,11 +404,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);
@ -413,16 +416,16 @@ impl Drop for AccelerationStructure {
}
impl_vk_handle!(
AccelerationStructure,
AccelerationStructure<'a>,
VkAccelerationStructureKHR,
acceleration_structure
);
enum AccelerationStructureGenerationData {
enum AccelerationStructureGenerationData<'device> {
TopLevel(
Vec<VkAccelerationStructureInstanceKHR>,
VkAccelerationStructureGeometryKHR,
Arc<Buffer<VkAccelerationStructureInstanceKHR>>,
Buffer<'device, VkAccelerationStructureInstanceKHR>,
),
BottomLevel(
Vec<VkAccelerationStructureGeometryKHR>,
@ -430,26 +433,26 @@ enum AccelerationStructureGenerationData {
),
}
impl
impl<'device>
From<(
Vec<VkAccelerationStructureInstanceKHR>,
VkAccelerationStructureGeometryKHR,
Arc<Buffer<VkAccelerationStructureInstanceKHR>>,
)> for AccelerationStructureGenerationData
Buffer<'device, VkAccelerationStructureInstanceKHR>,
)> for AccelerationStructureGenerationData<'device>
{
fn from(
(instances, geometry, buffer): (
Vec<VkAccelerationStructureInstanceKHR>,
VkAccelerationStructureGeometryKHR,
Arc<Buffer<VkAccelerationStructureInstanceKHR>>,
Buffer<'device, VkAccelerationStructureInstanceKHR>,
),
) -> Self {
Self::TopLevel(instances, geometry, buffer)
}
}
impl From<(Vec<VkAccelerationStructureGeometryKHR>, Vec<u32>)>
for AccelerationStructureGenerationData
impl<'device> From<(Vec<VkAccelerationStructureGeometryKHR>, Vec<u32>)>
for AccelerationStructureGenerationData<'device>
{
fn from(
(geometries, primitive_counts): (Vec<VkAccelerationStructureGeometryKHR>, Vec<u32>),

89
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<'b>(self, device: &'b Device) -> Result<Buffer<'b, 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<'device, T: ReprC> {
device: &'device Device,
buffer: VkBuffer,
memory: Arc<Memory<T>>,
memory: Memory<'device, T>,
_usage: VkBufferUsageFlagBits,
@ -134,7 +133,7 @@ pub struct Buffer<T: ReprC> {
size: VkDeviceSize,
}
impl<T: ReprC + Clone + Send + Sync + 'static> Buffer<T> {
impl<'device, T: ReprC + Clone + Send + Sync + 'static> Buffer<'device, T> {
pub fn fill(&self, data: &[T]) -> Result<()> {
let mut buffer_map = self.map(data.len() as VkDeviceSize)?;
@ -151,20 +150,20 @@ impl<T: ReprC + Clone + Send + Sync + 'static> Buffer<T> {
self.memory.map(self.size)
}
pub fn into_device_local(
self: &Arc<Buffer<T>>,
buffer_recorder: &mut CommandBufferRecorder<'_>,
pub fn into_device_local<'pipeline, 'cbuffer>(
&self,
buffer_recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>,
access_mask: impl Into<VkAccessFlagBits>,
stage: impl Into<VkPipelineStageFlagBits>,
usage: impl Into<VkBufferUsageFlagBits>,
) -> Result<Arc<Buffer<T>>> {
) -> Result<Buffer<'device, 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_vk_handle_t!(Buffer[ReprC]<'b>, 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()
}

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

@ -6,11 +6,7 @@ use crate::prelude::*;
use anyhow::Result;
use std::any::Any;
use std::sync::{
atomic::{AtomicUsize, Ordering::SeqCst},
Arc, Mutex, MutexGuard,
};
use std::sync::Mutex;
pub struct QueryEnable {
pub query_flags: VkQueryControlFlagBits,
@ -29,11 +25,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<CommandBuffer<'a>> {
let command_pool = self
.pool_builder
.set_queue_family_index(
@ -42,50 +38,47 @@ 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);
let command_buffer = device.allocate_command_buffers(&command_buffer_ci)?[0];
Ok(Arc::new(CommandBuffer {
Ok(CommandBuffer {
device,
pool: command_pool,
buffer: command_buffer,
calls: Arc::new(AtomicUsize::new(0)),
stored_handles: Mutex::new(Vec::new()),
}))
calls: 0,
})
}
}
#[derive(Debug)]
pub struct CommandBuffer {
device: Arc<Device>,
pool: Arc<CommandPool>,
pub struct CommandBuffer<'device> {
device: &'device Device,
pool: CommandPool<'device>,
buffer: VkCommandBuffer,
calls: Arc<AtomicUsize>,
stored_handles: Mutex<Vec<Arc<dyn Any + Send + Sync>>>,
calls: usize,
}
#[derive(Debug)]
pub struct CommandBufferRecorder<'a> {
device: Arc<Device>,
pub struct CommandBufferRecorder<'device, 'pipeline, 'cbuffer> {
device: &'device Device,
sub_pass: u32,
pipeline: Option<Arc<Pipeline>>,
pipeline: Option<&'pipeline Pipeline<'device>>,
calls: Arc<AtomicUsize>,
calls: &'cbuffer mut usize,
buffer: VkCommandBuffer,
handles_lock: MutexGuard<'a, Vec<Arc<dyn Any + Send + Sync>>>,
}
impl_vk_handle!(CommandBuffer, VkCommandBuffer, buffer);
impl_vk_handle!(CommandBuffer<'a>, VkCommandBuffer, buffer);
impl CommandBuffer {
impl<'device> CommandBuffer<'device> {
pub fn new_primary() -> CommandBufferBuilder {
CommandBufferBuilder {
buffer_level: VK_COMMAND_BUFFER_LEVEL_PRIMARY,
@ -105,25 +98,24 @@ impl CommandBuffer {
}
pub fn calls(&self) -> usize {
self.calls.load(SeqCst)
self.calls
}
pub fn begin(&self, begin_info: VkCommandBufferBeginInfo) -> Result<CommandBufferRecorder<'_>> {
pub fn begin<'pipeline, 'cbuffer>(
&'cbuffer mut self,
begin_info: VkCommandBufferBeginInfo,
) -> Result<CommandBufferRecorder<'device, 'pipeline, 'cbuffer>> {
self.device.begin_command_buffer(self.buffer, &begin_info)?;
let mut handles_lock = self.stored_handles.lock().unwrap();
handles_lock.clear();
self.calls.store(0, SeqCst);
self.calls = 0;
Ok(CommandBufferRecorder {
device: self.device.clone(),
sub_pass: 0,
pipeline: None,
calls: self.calls.clone(),
calls: &mut self.calls,
buffer: self.buffer,
handles_lock,
})
}
@ -160,10 +152,10 @@ impl CommandBuffer {
}
}
pub fn inheritance_info(
render_pass: Option<&Arc<RenderPass>>,
pub fn inheritance_info<'image>(
render_pass: Option<&RenderPass<'device>>,
sub_pass: Option<u32>,
framebuffer: Option<&Arc<Framebuffer>>,
framebuffer: Option<&Framebuffer<'device, 'image>>,
query_enable: Option<QueryEnable>,
) -> VkCommandBufferInheritanceInfo {
let mut info = VkCommandBufferInheritanceInfo::new(
@ -186,9 +178,12 @@ impl CommandBuffer {
}
}
impl<'a> CommandBufferRecorder<'a> {
impl<'handle, 'me, 'device, 'pipeline, 'cbuffer> CommandBufferRecorder<'device, 'pipeline, 'cbuffer>
where
'handle: 'me,
{
pub fn pipeline_barrier(
&self,
&'me mut self,
src_stage_mask: impl Into<VkPipelineStageFlagBits>,
dst_stage_mask: impl Into<VkPipelineStageFlagBits>,
dependency_flags: impl Into<VkDependencyFlagBits>,
@ -196,7 +191,7 @@ impl<'a> CommandBufferRecorder<'a> {
buffer_memory_barriers: &[VkBufferMemoryBarrier],
image_memory_barriers: &[VkImageMemoryBarrier],
) {
self.calls.fetch_add(1, SeqCst);
*self.calls += 1;
self.device.cmd_pipeline_barrier(
self.buffer,
@ -210,7 +205,7 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn memory_barrier(
&self,
&'me mut self,
src_access_mask: impl Into<VkAccessFlagBits>,
src_stage: VkPipelineStageFlags,
dst_access_mask: impl Into<VkAccessFlagBits>,
@ -227,15 +222,13 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn buffer_barrier<T: ReprC + Send + Sync + 'static>(
&mut self,
buffer: &Arc<Buffer<T>>,
&'me mut self,
buffer: &'handle Buffer<'device, T>,
src_access_mask: impl Into<VkAccessFlagBits>,
src_stage: impl Into<VkPipelineStageFlagBits>,
dst_access_mask: impl Into<VkAccessFlagBits>,
dst_stage: impl Into<VkPipelineStageFlagBits>,
) {
self.handles_lock.push(buffer.clone());
self.pipeline_barrier(
src_stage,
dst_stage,
@ -255,18 +248,18 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn image_barrier(
&mut self,
image: &Arc<Image>,
&'me mut self,
image: &'handle Image<'device>,
old_image_layout: VkImageLayout,
src_stage: impl Into<VkPipelineStageFlagBits>,
new_image_layout: VkImageLayout,
dst_stage: impl Into<VkPipelineStageFlagBits>,
) {
) where
'handle: 'me,
{
let src_access_mask = Image::src_layout_to_access(old_image_layout);
let dst_access_mask = Image::dst_layout_to_access(new_image_layout);
self.handles_lock.push(image.clone());
self.pipeline_barrier(
src_stage,
dst_stage,
@ -289,16 +282,14 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn image_barrier_auto_stage(
&mut self,
image: &Arc<Image>,
&'me mut self,
image: &'handle Image<'device>,
old_image_layout: VkImageLayout,
new_image_layout: VkImageLayout,
) {
let src_access_mask = Image::src_layout_to_access(old_image_layout);
let dst_access_mask = Image::dst_layout_to_access(new_image_layout);
self.handles_lock.push(image.clone());
self.pipeline_barrier(
CommandBuffer::access_to_stage(src_access_mask),
CommandBuffer::access_to_stage(dst_access_mask),
@ -321,7 +312,7 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn begin_render_pass(
&mut self,
&'me mut self,
renderpass_begin_info: VkRenderPassBeginInfo,
subpass_contents: VkSubpassContents,
) {
@ -331,16 +322,13 @@ impl<'a> CommandBufferRecorder<'a> {
.cmd_begin_render_pass(self.buffer, &renderpass_begin_info, subpass_contents);
}
pub fn begin_render_pass_full(
&mut self,
render_pass: &Arc<RenderPass>,
framebuffer: &Arc<Framebuffer>,
pub fn begin_render_pass_full<'image>(
&'me mut self,
render_pass: &'handle RenderPass<'device>,
framebuffer: &'handle Framebuffer<'device, 'image>,
clear_values: &[VkClearValue],
subpass_contents: VkSubpassContents,
) {
self.handles_lock.push(render_pass.clone());
self.handles_lock.push(framebuffer.clone());
self.sub_pass = 0;
let render_pass_begin_info = VkRenderPassBeginInfo::new(
@ -360,18 +348,16 @@ impl<'a> CommandBufferRecorder<'a> {
.cmd_begin_render_pass(self.buffer, &render_pass_begin_info, subpass_contents);
}
pub fn next_subpass(&mut self, subpass_contents: VkSubpassContents) {
pub fn next_subpass(&'me mut self, subpass_contents: VkSubpassContents) {
self.sub_pass += 1;
self.device.cmd_next_subpass(self.buffer, subpass_contents);
}
pub fn end_render_pass(&self) {
pub fn end_render_pass(&'me self) {
self.device.cmd_end_render_pass(self.buffer);
}
pub fn bind_pipeline(&mut self, pipeline: &Arc<Pipeline>) -> Result<()> {
self.handles_lock.push(pipeline.clone());
pub fn bind_pipeline(&'me mut self, pipeline: &'pipeline Pipeline<'device>) -> Result<()> {
match pipeline.pipeline_type() {
PipelineType::Graphics => {
debug_assert_eq!(self.sub_pass, pipeline.sub_pass());
@ -394,13 +380,16 @@ impl<'a> CommandBufferRecorder<'a> {
),
}
self.pipeline = Some(pipeline.clone());
self.pipeline = Some(pipeline);
Ok(())
}
pub fn execute_commands(&self, command_buffers: &[&impl VkHandle<VkCommandBuffer>]) {
self.calls.fetch_add(1, SeqCst);
pub fn execute_commands(
&'me mut self,
command_buffers: &[&'handle impl VkHandle<VkCommandBuffer>],
) {
*self.calls += 1;
let buffers: Vec<VkCommandBuffer> =
command_buffers.iter().map(|cb| cb.vk_handle()).collect();
@ -409,8 +398,11 @@ impl<'a> CommandBufferRecorder<'a> {
.cmd_execute_commands(self.buffer, buffers.as_slice());
}
pub fn bind_descriptor_sets_minimal(&mut self, descriptor_sets: &[&Arc<DescriptorSet>]) {
self.calls.fetch_add(1, SeqCst);
pub fn bind_descriptor_sets_minimal<'a>(
&'me mut self,
descriptor_sets: &[&'handle DescriptorSet<'device, 'a>],
) {
*self.calls += 1;
let (pipeline_bind_point, vk_layout) = {
let pipeline = match &self.pipeline {
@ -429,11 +421,7 @@ impl<'a> CommandBufferRecorder<'a> {
let vk_descriptor_sets: Vec<VkDescriptorSet> = descriptor_sets
.iter()
.map(|ds: &&Arc<DescriptorSet>| {
self.handles_lock.push((*ds).clone());
ds.vk_handle()
})
.map(|ds: &&DescriptorSet<'device, 'a>| ds.vk_handle())
.collect();
self.device.cmd_bind_descriptor_sets(
@ -447,30 +435,24 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn bind_vertex_buffer<T: ReprC + Send + Sync + 'static>(
&mut self,
buffer: &Arc<Buffer<T>>,
&'me mut self,
buffer: &'handle Buffer<'device, T>,
) {
self.calls.fetch_add(1, SeqCst);
self.handles_lock.push(buffer.clone());
*self.calls += 1;
self.device
.cmd_bind_vertex_buffers(self.buffer, 0, &[buffer.vk_handle()], &[0]);
}
pub fn bind_vertex_buffers_minimal<T: ReprC + Send + Sync + 'static>(
&mut self,
buffers: &[&Arc<Buffer<T>>],
&'me mut self,
buffers: &[&'handle Buffer<'device, T>],
) {
self.calls.fetch_add(1, SeqCst);
*self.calls += 1;
let vk_buffers: Vec<VkBuffer> = buffers
.iter()
.map(|b: &&Arc<Buffer<T>>| {
self.handles_lock.push((*b).clone());
b.vk_handle()
})
.map(|b: &&Buffer<'device, T>| b.vk_handle())
.collect();
let offsets = vec![0; vk_buffers.len()];
@ -484,35 +466,33 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn bind_index_buffer<T: ReprC + Send + Sync + 'static>(
&mut self,
buffer: &Arc<Buffer<T>>,
&'me mut self,
buffer: &'handle Buffer<'device, T>,
offset: VkDeviceSize,
index_type: VkIndexType,
) {
self.calls.fetch_add(1, SeqCst);
self.handles_lock.push(buffer.clone());
*self.calls += 1;
self.device
.cmd_bind_index_buffer(self.buffer, buffer.vk_handle(), offset, index_type);
}
pub fn set_viewport(&self, viewports: &[VkViewport]) {
pub fn set_viewport(&'me self, viewports: &[VkViewport]) {
self.device.cmd_set_viewport(self.buffer, 0, viewports);
}
pub fn set_scissor(&self, scissors: &[VkRect2D]) {
pub fn set_scissor(&'me self, scissors: &[VkRect2D]) {
self.device.cmd_set_scissor(self.buffer, 0, scissors);
}
pub fn draw(
&self,
&'me mut self,
vertex_count: u32,
instance_count: u32,
first_vertex: u32,
first_instance: u32,
) {
self.calls.fetch_add(1, SeqCst);
*self.calls += 1;
self.device.cmd_draw(
self.buffer,
@ -523,21 +503,21 @@ impl<'a> CommandBufferRecorder<'a> {
);
}
pub fn draw_complete_single_instance(&self, vertex_count: u32) {
self.calls.fetch_add(1, SeqCst);
pub fn draw_complete_single_instance(&'me mut self, vertex_count: u32) {
*self.calls += 1;
self.device.cmd_draw(self.buffer, vertex_count, 1, 0, 0);
}
pub fn draw_indexed(
&self,
&'me mut self,
index_count: u32,
instance_count: u32,
first_index: u32,
vertex_offset: i32,
first_instance: u32,
) {
self.calls.fetch_add(1, SeqCst);
*self.calls += 1;
self.device.cmd_draw_indexed(
self.buffer,
@ -549,15 +529,19 @@ impl<'a> CommandBufferRecorder<'a> {
);
}
pub fn draw_indexed_complete_single_instance(&self, index_count: u32) {
self.calls.fetch_add(1, SeqCst);
pub fn draw_indexed_complete_single_instance(&'me mut self, index_count: u32) {
*self.calls += 1;
self.device
.cmd_draw_indexed(self.buffer, index_count, 1, 0, 0, 0);
}
pub fn push_constants<U>(&self, stage_flags: impl Into<VkShaderStageFlagBits>, data: &U) {
self.calls.fetch_add(1, SeqCst);
pub fn push_constants<U>(
&'me mut self,
stage_flags: impl Into<VkShaderStageFlagBits>,
data: &U,
) {
*self.calls += 1;
let pipeline = match &self.pipeline {
Some(pipeline) => pipeline,
@ -571,16 +555,14 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn set_image_layout(
&mut self,
image: &Arc<Image>,
&'me mut self,
image: &'handle Image<'device>,
new_image_layout: VkImageLayout,
subresource_range: VkImageSubresourceRange,
) {
let src_access = Image::src_layout_to_access(image.image_layout());
let dst_access = Image::dst_layout_to_access(new_image_layout);
self.handles_lock.push(image.clone());
self.pipeline_barrier(
CommandBuffer::access_to_stage(src_access),
CommandBuffer::access_to_stage(dst_access),
@ -602,12 +584,14 @@ impl<'a> CommandBufferRecorder<'a> {
image.set_image_layout(new_image_layout);
}
pub fn set_full_image_layout(&mut self, image: &Arc<Image>, new_image_layout: VkImageLayout) {
pub fn set_full_image_layout(
&'me mut self,
image: &'handle Image<'device>,
new_image_layout: VkImageLayout,
) {
let src_access = Image::src_layout_to_access(image.image_layout());
let dst_access = Image::dst_layout_to_access(new_image_layout);
self.handles_lock.push(image.clone());
self.pipeline_barrier(
CommandBuffer::access_to_stage(src_access),
CommandBuffer::access_to_stage(dst_access),
@ -630,62 +614,59 @@ impl<'a> CommandBufferRecorder<'a> {
}
// TODO:
pub fn set_line_width(&self) {
pub fn set_line_width(&'me self) {
unimplemented!();
}
pub fn set_depth_bias(&self) {
pub fn set_depth_bias(&'me self) {
unimplemented!();
}
pub fn set_blend_constants(&self) {
pub fn set_blend_constants(&'me self) {
unimplemented!();
}
pub fn set_depth_bounds(&self) {
pub fn set_depth_bounds(&'me self) {
unimplemented!();
}
pub fn set_stencil_compare_mask(&self) {
pub fn set_stencil_compare_mask(&'me self) {
unimplemented!();
}
pub fn set_stencil_write_mask(&self) {
pub fn set_stencil_write_mask(&'me self) {
unimplemented!();
}
pub fn set_stencil_reference(&self) {
pub fn set_stencil_reference(&'me self) {
unimplemented!();
}
pub fn draw_indirect(&self) {
pub fn draw_indirect(&'me self) {
unimplemented!();
}
pub fn draw_indexed_indirect(&self) {
pub fn draw_indexed_indirect(&'me self) {
unimplemented!();
}
pub fn dispatch(&self, x: u32, y: u32, z: u32) {
self.calls.fetch_add(1, SeqCst);
pub fn dispatch(&'me mut self, x: u32, y: u32, z: u32) {
*self.calls += 1;
self.device.cmd_dispatch(self.buffer, x, y, z);
}
pub fn dispatch_indirect(&self) {
pub fn dispatch_indirect(&'me self) {
unimplemented!();
}
pub fn copy_buffer<T: ReprC + Send + Sync + 'static, U: ReprC + Send + Sync + 'static>(
&mut self,
src_buffer: &Arc<Buffer<T>>,
dst_buffer: &Arc<Buffer<U>>,
&'me mut self,
src_buffer: &'handle Buffer<'device, T>,
dst_buffer: &'handle Buffer<'device, U>,
regions: &[VkBufferCopy],
) {
self.calls.fetch_add(1, SeqCst);
self.handles_lock.push(src_buffer.clone());
self.handles_lock.push(dst_buffer.clone());
*self.calls += 1;
self.device.cmd_copy_buffer(
self.buffer,
@ -696,17 +677,14 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn copy_image(
&mut self,
src_image: &Arc<Image>,
dst_image: &Arc<Image>,
&'me mut self,
src_image: &'handle Image<'device>,
dst_image: &'handle Image<'device>,
src_layout: VkImageLayout,
dst_layout: VkImageLayout,
regions: &[VkImageCopy],
) {
self.calls.fetch_add(1, SeqCst);
self.handles_lock.push(src_image.clone());
self.handles_lock.push(dst_image.clone());
*self.calls += 1;
self.device.cmd_copy_image(
self.buffer,
@ -719,14 +697,11 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn blit_complete(
&mut self,
src_image: &Arc<Image>,
dst_image: &Arc<Image>,
&'me mut self,
src_image: &'handle Image<'device>,
dst_image: &'handle Image<'device>,
filter: VkFilter,
) {
self.handles_lock.push(src_image.clone());
self.handles_lock.push(dst_image.clone());
let image_blit = VkImageBlit {
srcSubresource: src_image.full_resource_layers(),
srcOffsets: [
@ -759,18 +734,15 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn blit_image(
&mut self,
src_image: &Arc<Image>,
dst_image: &Arc<Image>,
&'me mut self,
src_image: &'handle Image<'device>,
dst_image: &'handle Image<'device>,
src_layout: VkImageLayout,
dst_layout: VkImageLayout,
regions: &[VkImageBlit],
filter: VkFilter,
) {
self.calls.fetch_add(1, SeqCst);
self.handles_lock.push(src_image.clone());
self.handles_lock.push(dst_image.clone());
*self.calls += 1;
self.device.cmd_blit_image(
self.buffer,
@ -784,16 +756,13 @@ 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>,
&'me mut self,
src_buffer: &'handle Buffer<'device, T>,
dst_image: &'handle Image<'device>,
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.calls += 1;
self.device.cmd_copy_buffer_to_image(
self.buffer,
@ -805,16 +774,13 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn copy_image_to_buffer<T: ReprC + Send + Sync + 'static>(
&mut self,
src_image: &Arc<Image>,
&'me mut self,
src_image: &'handle Image<'device>,
image_layout: VkImageLayout,
dst_buffer: &Arc<Buffer<T>>,
dst_buffer: &'handle Buffer<'device, T>,
regions: &[VkBufferImageCopy],
) {
self.calls.fetch_add(1, SeqCst);
self.handles_lock.push(src_image.clone());
self.handles_lock.push(dst_buffer.clone());
*self.calls += 1;
self.device.cmd_copy_image_to_buffer(
self.buffer,
@ -825,18 +791,20 @@ impl<'a> CommandBufferRecorder<'a> {
)
}
pub fn update_buffer(&self) {
pub fn update_buffer(&'me self) {
unimplemented!();
}
pub fn fill_buffer(&self) {
pub fn fill_buffer(&'me self) {
unimplemented!();
}
pub fn clear_color_image(&mut self, image: &Arc<Image>, clear_color: VkClearColorValue) {
self.calls.fetch_add(1, SeqCst);
self.handles_lock.push(image.clone());
pub fn clear_color_image(
&'me mut self,
image: &Image<'device>,
clear_color: VkClearColorValue,
) {
*self.calls += 1;
self.device.cmd_clear_color_image(
self.buffer,
@ -847,24 +815,21 @@ impl<'a> CommandBufferRecorder<'a> {
);
}
pub fn clear_depth_stencil_image(&self) {
pub fn clear_depth_stencil_image(&'me self) {
unimplemented!();
}
pub fn clear_attachments(&self) {
pub fn clear_attachments(&'me self) {
unimplemented!();
}
pub fn resolve_image(
&mut self,
src_image: &Arc<Image>,
dst_image: &Arc<Image>,
&'me mut self,
src_image: &'handle Image<'device>,
dst_image: &'handle Image<'device>,
regions: &[VkImageResolve],
) {
self.calls.fetch_add(1, SeqCst);
self.handles_lock.push(src_image.clone());
self.handles_lock.push(dst_image.clone());
*self.calls += 1;
self.device.cmd_resolve_image(
self.buffer,
@ -876,61 +841,61 @@ impl<'a> CommandBufferRecorder<'a> {
);
}
pub fn set_event(&self) {
pub fn set_event(&'me self) {
unimplemented!();
}
pub fn reset_event(&self) {
pub fn reset_event(&'me self) {
unimplemented!();
}
pub fn wait_events(&self) {
pub fn wait_events(&'me self) {
unimplemented!();
}
pub fn begin_query(&self) {
pub fn begin_query(&'me self) {
unimplemented!();
}
pub fn end_query(&self) {
pub fn end_query(&'me self) {
unimplemented!();
}
pub fn reset_query_pool(&self) {
pub fn reset_query_pool(&'me self) {
unimplemented!();
}
pub fn write_timestamp(
&mut self,
query_pool: &Arc<QueryPool>,
&'me mut self,
query_pool: &'handle QueryPool,
query: u32,
pipeline_stage: impl Into<VkPipelineStageFlagBits>,
) {
self.calls.fetch_add(1, SeqCst);
self.handles_lock.push(query_pool.clone());
*self.calls += 1;
self.device
.cmd_write_timestamp(self.buffer, pipeline_stage, query_pool.vk_handle(), query);
}
pub fn copy_query_pool_results(&self) {
pub fn copy_query_pool_results(&'me self) {
unimplemented!();
}
}
impl<'a> CommandBufferRecorder<'a> {
impl<'me, 'handle, 'device, 'pipeline, 'cbuffer> CommandBufferRecorder<'device, 'pipeline, 'cbuffer>
where
'handle: 'me,
{
pub fn build_acceleration_structure_indirect(
&mut self,
&'me mut self,
infos: &[VkAccelerationStructureBuildGeometryInfoKHR],
indirect_buffers: &[Arc<Buffer<impl ReprC + Send + Sync + 'static>>],
indirect_buffers: &[Buffer<'device, impl ReprC + Send + Sync + 'static>],
indirect_strides: &[u32],
max_primitive_counts: &[&u32],
) {
let mut device_addresses: Vec<VkDeviceAddress> = Vec::with_capacity(indirect_buffers.len());
for indirect_buffer in indirect_buffers.iter() {
self.handles_lock.push(indirect_buffer.clone());
device_addresses.push(indirect_buffer.device_address().into());
}
@ -944,7 +909,7 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn build_acceleration_structures(
&self,
&'me self,
infos: &[VkAccelerationStructureBuildGeometryInfoKHR],
range_infos: &[&[VkAccelerationStructureBuildRangeInfoKHR]],
) {
@ -953,14 +918,11 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn copy_acceleration_structure(
&mut self,
src: &Arc<AccelerationStructure>,
dst: &Arc<AccelerationStructure>,
&'me mut self,
src: &'handle AccelerationStructure<'device>,
dst: &'handle AccelerationStructure<'device>,
mode: VkCopyAccelerationStructureModeKHR,
) {
self.handles_lock.push(src.clone());
self.handles_lock.push(dst.clone());
let info = VkCopyAccelerationStructureInfoKHR::new(src.vk_handle(), dst.vk_handle(), mode);
self.device
@ -968,13 +930,11 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn copy_acceleration_structure_to_memory(
&mut self,
src: &Arc<AccelerationStructure>,
&'me mut self,
src: &'handle AccelerationStructure<'device>,
dst: VkDeviceOrHostAddressKHR,
mode: VkCopyAccelerationStructureModeKHR,
) {
self.handles_lock.push(src.clone());
let info = VkCopyAccelerationStructureToMemoryInfoKHR::new(src.vk_handle(), dst, mode);
self.device
@ -982,13 +942,11 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn copy_memory_to_acceleration_structure(
&mut self,
&'me mut self,
src: VkDeviceOrHostAddressConstKHR,
dst: &Arc<AccelerationStructure>,
dst: &'handle AccelerationStructure<'device>,
mode: VkCopyAccelerationStructureModeKHR,
) {
self.handles_lock.push(dst.clone());
let info = VkCopyMemoryToAccelerationStructureInfoKHR::new(src, dst.vk_handle(), mode);
self.device
@ -996,12 +954,10 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn trace_rays_indirect(
&mut self,
sbt: ShaderBindingTable,
buffer: Arc<Buffer<impl ReprC + Send + Sync + 'static>>,
&'me mut self,
sbt: &'handle ShaderBindingTable<'device>,
buffer: &'handle Buffer<'device, impl ReprC + Send + Sync + 'static>,
) {
self.handles_lock.push(buffer.clone());
self.device.cmd_trace_rays_indirect(
self.buffer,
sbt.raygen_shader_binding_table(),
@ -1012,7 +968,13 @@ impl<'a> CommandBufferRecorder<'a> {
)
}
pub fn trace_rays(&self, sbt: &ShaderBindingTable, width: u32, height: u32, depth: u32) {
pub fn trace_rays(
&'me self,
sbt: &'handle ShaderBindingTable<'device>,
width: u32,
height: u32,
depth: u32,
) {
self.device.cmd_trace_rays(
self.buffer,
sbt.raygen_shader_binding_table(),
@ -1026,20 +988,15 @@ impl<'a> CommandBufferRecorder<'a> {
}
pub fn write_acceleration_structure_properties(
&mut self,
acceleration_structures: &[&Arc<AccelerationStructure>],
&'me mut self,
acceleration_structures: &[&'handle AccelerationStructure<'device>],
query_type: VkQueryType,
query_pool: &Arc<QueryPool>,
query_pool: &'handle QueryPool,
first_query: u32,
) {
self.handles_lock.push(query_pool.clone());
let as_handles: Vec<VkAccelerationStructureKHR> = acceleration_structures
.iter()
.map(|a| {
self.handles_lock.push((*a).clone());
a.vk_handle()
})
.map(|a| a.vk_handle())
.collect();
self.device.cmd_write_acceleration_structure_properties(
@ -1052,53 +1009,21 @@ impl<'a> CommandBufferRecorder<'a> {
}
}
impl VulkanDevice for CommandBuffer {
fn device(&self) -> &Arc<Device> {
impl<'device> VulkanDevice for CommandBuffer<'device> {
fn device(&self) -> &'device Device {
&self.device
}
}
impl Drop for CommandBuffer {
impl<'device> Drop for CommandBuffer<'device> {
fn drop(&mut self) {
self.device
.free_command_buffers(self.pool.vk_handle(), &[self.buffer]);
}
}
impl<'a> Drop for CommandBufferRecorder<'a> {
impl<'device, 'pipeline, 'cbuffer> Drop for CommandBufferRecorder<'device, 'pipeline, 'cbuffer> {
fn drop(&mut self) {
self.device.end_command_buffer(self.buffer).unwrap()
}
}
// ==========================================================================================
// ======================================== FFI =============================================
// ==========================================================================================
// use crate::{ffi::*, handle_ffi_result};
// #[no_mangle]
// pub extern "C" fn allocate_primary_buffer(
// flags: VkCommandPoolCreateFlagBits,
// device: *const Device,
// queue: *const Queue,
// ) -> *const CommandBuffer {
// handle_ffi_result!(CommandBuffer::new_primary()
// .set_flags(flags)
// .build(unsafe { Arc::from_raw(device) }, unsafe {
// Arc::from_raw(queue)
// }))
// }
// #[no_mangle]
// pub extern "C" fn allocate_secondary_buffer(
// flags: VkCommandPoolCreateFlagBits,
// device: *const Device,
// queue: *const Queue,
// ) -> *const CommandBuffer {
// handle_ffi_result!(CommandBuffer::new_secondary()
// .set_flags(flags)
// .build(unsafe { Arc::from_raw(device) }, unsafe {
// Arc::from_raw(queue)
// }))
// }

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

@ -2,8 +2,6 @@ use crate::prelude::*;
use anyhow::Result;
use std::sync::Arc;
pub(crate) struct CommandPoolBuilder {
flags: VkCommandPoolCreateFlagBits,
queue_family_index: u32,
@ -22,25 +20,25 @@ impl CommandPoolBuilder {
self
}
pub(crate) fn build(self, device: Arc<Device>) -> Result<Arc<CommandPool>> {
pub(crate) fn build<'a>(self, device: &'a Device) -> Result<CommandPool<'a>> {
let command_pool_ci = VkCommandPoolCreateInfo::new(self.flags, self.queue_family_index);
let command_pool = device.create_command_pool(&command_pool_ci)?;
Ok(Arc::new(CommandPool {
Ok(CommandPool {
device,
command_pool,
}))
})
}
}
#[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 +48,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_vk_handle!(CommandPool<'a>, 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) };
// }

92
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<'device> {
device: &'device Device,
descriptor_pool: VkDescriptorPool,
pub(crate) descriptor_set_layout: Arc<DescriptorSetLayout>,
pub(crate) descriptor_set_layout: &'device DescriptorSetLayout<'device>,
}
impl DescriptorPool {
pub fn builder() -> DescriptorPoolBuilder {
impl<'device> DescriptorPool<'device> {
pub fn builder() -> DescriptorPoolBuilder<'device> {
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(&'device self) -> DescriptorSetBuilder<'device> {
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_vk_handle!(DescriptorPool<'a>, 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) };
}

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

@ -2,17 +2,15 @@ use crate::prelude::*;
use anyhow::Result;
use std::any::Any;
use std::collections::HashMap;
use std::marker::PhantomData;
use std::slice;
use std::sync::{Arc, Mutex};
#[derive(Debug)]
pub struct DescriptorWrite {
pub struct DescriptorWrite<'handle> {
lifetime: &'handle PhantomData<()>,
binding: u32,
descriptor_type: VkDescriptorType,
inner: InnerWrite,
handles: Vec<Arc<dyn Any + Send + Sync>>,
}
#[derive(Debug)]
@ -27,10 +25,10 @@ enum InnerWrite {
),
}
impl DescriptorWrite {
impl<'device, 'handle> DescriptorWrite<'handle> {
pub fn uniform_buffers<T: ReprC + Send + Sync + 'static>(
binding: u32,
buffers: &[&Arc<Buffer<T>>],
buffers: &[&'handle Buffer<'device, T>],
) -> Self {
DescriptorWrite {
binding,
@ -45,16 +43,13 @@ impl DescriptorWrite {
})
.collect(),
),
handles: buffers
.iter()
.map(|b| (*b).clone() as Arc<dyn Any + Send + Sync>)
.collect(),
lifetime: &PhantomData,
}
}
pub fn storage_buffers<T: ReprC + Send + Sync + 'static>(
binding: u32,
buffers: &[&Arc<Buffer<T>>],
buffers: &[&'handle Buffer<'device, T>],
) -> Self {
DescriptorWrite {
binding,
@ -69,14 +64,11 @@ impl DescriptorWrite {
})
.collect(),
),
handles: buffers
.iter()
.map(|b| (*b).clone() as Arc<dyn Any + Send + Sync>)
.collect(),
lifetime: &PhantomData,
}
}
pub fn combined_samplers(binding: u32, images: &[&Arc<Image>]) -> Self {
pub fn combined_samplers(binding: u32, images: &[&'handle Image<'device>]) -> Self {
DescriptorWrite {
binding,
descriptor_type: VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
@ -94,14 +86,11 @@ impl DescriptorWrite {
})
.collect(),
),
handles: images
.iter()
.map(|i| (*i).clone() as Arc<dyn Any + Send + Sync>)
.collect(),
lifetime: &PhantomData,
}
}
pub fn storage_images(binding: u32, images: &[&Arc<Image>]) -> Self {
pub fn storage_images(binding: u32, images: &[&'handle Image<'device>]) -> Self {
DescriptorWrite {
binding,
descriptor_type: VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
@ -115,14 +104,11 @@ impl DescriptorWrite {
})
.collect(),
),
handles: images
.iter()
.map(|i| (*i).clone() as Arc<dyn Any + Send + Sync>)
.collect(),
lifetime: &PhantomData,
}
}
pub fn input_attachments(binding: u32, images: &[&Arc<Image>]) -> Self {
pub fn input_attachments(binding: u32, images: &[&'handle Image<'device>]) -> Self {
DescriptorWrite {
binding,
descriptor_type: VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
@ -136,16 +122,13 @@ impl DescriptorWrite {
})
.collect(),
),
handles: images
.iter()
.map(|i| (*i).clone() as Arc<dyn Any + Send + Sync>)
.collect(),
lifetime: &PhantomData,
}
}
pub fn acceleration_structures(
binding: u32,
acceleration_structures: &[&Arc<AccelerationStructure>],
acceleration_structures: &[&'handle AccelerationStructure<'device>],
) -> Self {
let vk_as: Vec<VkAccelerationStructureKHR> = acceleration_structures
.iter()
@ -159,10 +142,7 @@ impl DescriptorWrite {
VkWriteDescriptorSetAccelerationStructureKHR::default(),
vk_as,
)),
handles: acceleration_structures
.iter()
.map(|a| (*a).clone() as Arc<dyn Any + Send + Sync>)
.collect(),
lifetime: &PhantomData,
};
if let InnerWrite::AS((vk_write_as, vk_as)) = &mut write.inner {
@ -198,21 +178,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<'handle>(mut self) -> Result<DescriptorSet<'a, 'handle>> {
let layout = self.descriptor_pool.vk_handle();
let mut descriptor_set_ci = VkDescriptorSetAllocateInfo::new(
@ -228,30 +208,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()),
}))
lifetimes: &PhantomData,
})
}
}
#[derive(Debug)]
pub struct DescriptorSet {
device: Arc<Device>,
pool: Arc<DescriptorPool>,
pub struct DescriptorSet<'device, 'handle> {
device: &'device Device,
pool: &'device DescriptorPool<'device>,
descriptor_set: VkDescriptorSet,
handles: Mutex<HashMap<u32, Vec<Arc<dyn Any + Send + Sync>>>>,
lifetimes: &'handle PhantomData<()>,
}
impl DescriptorSet {
impl<'device, 'handle> DescriptorSet<'device, 'handle> {
pub(crate) fn builder(
device: Arc<Device>,
descriptor_pool: Arc<DescriptorPool>,
) -> DescriptorSetBuilder {
device: &'device Device,
descriptor_pool: &'device DescriptorPool<'device>,
) -> DescriptorSetBuilder<'device> {
DescriptorSetBuilder {
device,
descriptor_pool,
@ -263,7 +243,7 @@ impl DescriptorSet {
}
// TODO: add update function for VkCopyDescriptorSet
pub fn update(&self, writes: &[DescriptorWrite]) -> Result<()> {
pub fn update(&self, writes: &[DescriptorWrite<'handle>]) -> Result<()> {
debug_assert!(!writes.is_empty());
#[cfg(debug_assertions)]
@ -278,7 +258,6 @@ impl DescriptorSet {
}
let mut vk_writes = Vec::new();
let mut handles_lock = self.handles.lock().unwrap();
for write in writes {
let mut write_desc = VkWriteDescriptorSet::new(
@ -291,13 +270,6 @@ impl DescriptorSet {
write.vk_write(&mut write_desc);
vk_writes.push(write_desc);
match handles_lock.get_mut(&write.binding) {
Some(val) => *val = write.handles.clone(),
None => {
handles_lock.insert(write.binding, write.handles.clone());
}
}
}
self.device
@ -307,39 +279,31 @@ impl DescriptorSet {
}
}
impl VulkanDevice for DescriptorSet {
fn device(&self) -> &Arc<Device> {
impl<'device, 'handle> VulkanDevice for DescriptorSet<'device, 'handle> {
fn device(&self) -> &Device {
&self.device
}
}
impl_vk_handle!(DescriptorSet, VkDescriptorSet, descriptor_set);
impl_vk_handle!(
DescriptorSet<'device, 'handle>,
VkDescriptorSet,
descriptor_set
);
impl VkHandle<VkDescriptorSetLayout> for DescriptorSet {
impl<'device, 'handle> VkHandle<VkDescriptorSetLayout> for DescriptorSet<'device, 'handle> {
fn vk_handle(&self) -> VkDescriptorSetLayout {
self.pool.vk_handle()
}
}
impl<'a> VkHandle<VkDescriptorSetLayout> for &'a DescriptorSet {
impl<'a, 'device, 'handle> VkHandle<VkDescriptorSetLayout> for &'a DescriptorSet<'device, 'handle> {
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<'device, 'handle> Drop for DescriptorSet<'device, 'handle> {
fn drop(&mut self) {
if let Err(error) = self
.device
@ -355,8 +319,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 +332,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();

16
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,19 +124,19 @@ impl DescriptorSetLayout {
}
}
impl VulkanDevice for DescriptorSetLayout {
fn device(&self) -> &Arc<Device> {
impl<'a> VulkanDevice for DescriptorSetLayout<'a> {
fn device(&self) -> &Device {
&self.device
}
}
impl_vk_handle!(
DescriptorSetLayout,
DescriptorSetLayout<'a>,
VkDescriptorSetLayout,
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);

32
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<()> {

39
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_vk_handle!(Fence<'a>, 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
}

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

@ -2,24 +2,22 @@ use crate::prelude::*;
use anyhow::Result;
use std::sync::Arc;
pub struct FramebufferBuilder<'a> {
render_pass: Option<&'a Arc<RenderPass>>,
attachments: Vec<&'a Arc<Image>>,
pub struct FramebufferBuilder<'device, 'renderpass, 'image> {
render_pass: Option<&'renderpass RenderPass<'device>>,
attachments: Vec<&'image Image<'device>>,
width: u32,
height: u32,
layers: u32,
}
impl<'a> FramebufferBuilder<'a> {
pub fn set_render_pass(mut self, render_pass: &'a Arc<RenderPass>) -> Self {
impl<'device, 'renderpass, 'image> FramebufferBuilder<'device, 'renderpass, 'image> {
pub fn set_render_pass(mut self, render_pass: &'renderpass RenderPass<'device>) -> Self {
self.render_pass = Some(render_pass);
self
}
pub fn add_attachment(mut self, image: &'a Arc<Image>) -> Self {
pub fn add_attachment(mut self, image: &'image Image<'device>) -> Self {
self.attachments.push(image);
self
@ -43,7 +41,7 @@ impl<'a> FramebufferBuilder<'a> {
self
}
pub fn build(mut self, device: Arc<Device>) -> Result<Arc<Framebuffer>> {
pub fn build(mut self, device: &'device Device) -> Result<Framebuffer<'device, 'image>> {
if self.attachments.is_empty() {
panic!("no attachments added!");
}
@ -80,29 +78,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 {
device: Arc<Device>,
pub struct Framebuffer<'device, 'image> {
device: &'device Device,
framebuffer: VkFramebuffer,
images: Vec<Arc<Image>>,
images: Vec<&'image Image<'device>>,
width: u32,
height: u32,
}
impl Framebuffer {
pub fn builder<'a>() -> FramebufferBuilder<'a> {
impl<'device, 'image> Framebuffer<'device, 'image> {
pub fn builder<'renderpass>() -> FramebufferBuilder<'device, 'renderpass, 'image> {
FramebufferBuilder {
render_pass: None,
attachments: Vec::new(),
@ -120,11 +118,11 @@ impl Framebuffer {
self.height
}
pub fn attachments(&self) -> &[Arc<Image>] {
pub fn attachments(&self) -> &[&'image Image<'device>] {
&self.images
}
pub fn image(&self, index: usize) -> &Arc<Image> {
pub fn image(&self, index: usize) -> &Image<'device> {
&self.images[index]
}
@ -133,15 +131,15 @@ impl Framebuffer {
}
}
impl VulkanDevice for Framebuffer {
fn device(&self) -> &Arc<Device> {
impl<'device, 'image> VulkanDevice for Framebuffer<'device, 'image> {
fn device(&self) -> &Device {
&self.device
}
}
impl_vk_handle!(Framebuffer, VkFramebuffer, framebuffer);
impl_vk_handle!(Framebuffer<'device, 'image>, VkFramebuffer, framebuffer);
impl Drop for Framebuffer {
impl<'device, 'image> Drop for Framebuffer<'device, 'image> {
fn drop(&mut self) {
self.device.destroy_framebuffer(self.framebuffer);
}

163
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,15 +62,15 @@ 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,
@ -78,9 +78,9 @@ pub struct ImageBuilder {
sampler: Option<Arc<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 {
@ -384,13 +384,13 @@ impl ImageBuilder {
}
fn create_from_source(
device: &Arc<Device>,
queue: &Arc<Mutex<Queue>>,
info: &ImageCreateInfo,
device: &'a Device,
queue: &'a Mutex<Queue<'a>>,
info: &ImageCreateInfo<'a>,
sampler: Option<Arc<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,9 +399,9 @@ impl ImageBuilder {
let image_view = device.create_image_view(&view_ci)?;
Ok(Arc::new(Image {
device: device.clone(),
queue: queue.clone(),
Ok(Image {
device,
queue,
image,
image_view,
@ -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: &'a 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: &'a 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: &'a Device,
queue: &'a 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,7 +486,7 @@ pub struct Image {
image_view: VkImageView,
// optional handles
_memory: Option<Arc<Memory<RawBuffer>>>,
_memory: Option<Memory<'a, RawBuffer>>,
sampler: Option<Arc<Sampler>>,
// image information
@ -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: &'a 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)
}
@ -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(),
@ -829,10 +829,10 @@ impl Image {
.set_size((self.width * self.height * 4) as VkDeviceSize)
.build(self.device.clone())?;
let command_buffer =
let mut command_buffer =
CommandBuffer::new_primary().build(self.device.clone(), self.queue.clone())?;
SingleSubmit::builder(&command_buffer, &self.queue, |recorder| {
SingleSubmit::builder(&mut command_buffer, &self.queue, |recorder| {
// copy info for copying the content of the buffer into the image
let buffer_image_copy = VkBufferImageCopy {
bufferOffset: 0,
@ -885,21 +885,21 @@ 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
}
}
impl_vk_handle!(Image, VkImage, image);
impl_vk_handle!(Image, VkImageView, image_view);
impl_vk_handle!(Image<'a>, VkImage, image);
impl_vk_handle!(Image<'a>, 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 mut command_buffer = CommandBuffer::new_primary().build(image.device, image.queue)?;
{
// begin recording into this command buffer
@ -950,17 +949,17 @@ 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: &'a Device,
queue: &'a Mutex<Queue<'a>>,
buffer: &Buffer<'a, T>,
) -> Result<()>
where
T: Copy,
{
// create a new command buffer
let command_buffer = CommandBuffer::new_primary().build(device.clone(), queue.clone())?;
let mut command_buffer = CommandBuffer::new_primary().build(device, queue)?;
{
// begin recording into this command buffer
@ -1045,14 +1044,14 @@ 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: &'a Device,
queue: &'a 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())?;
let mut command_buffer = CommandBuffer::new_primary().build(device, queue)?;
{
// set command buffer buffer in recording state
@ -1119,10 +1118,10 @@ fn copy_images_to_imagearray(
Ok(())
}
fn copy_image_to_image(
buffer_recorder: &mut CommandBufferRecorder<'_>,
src_image: &Arc<Image>,
dst_image: &Arc<Image>,
fn copy_image_to_image<'device, 'pipeline, 'cbuffer>(
buffer_recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>,
src_image: &Image<'device>,
dst_image: &Image<'device>,
mip_level: u32,
dst_layer: u32,
) {
@ -1181,9 +1180,9 @@ fn copy_image_to_image(
);
}
fn blit_mip_maps(
buffer_recorder: &mut CommandBufferRecorder<'_>,
image: &Arc<Image>,
fn blit_mip_maps<'device, 'pipeline, 'cbuffer>(
buffer_recorder: &mut CommandBufferRecorder<'device, 'pipeline, 'cbuffer>,
image: &Image<'device>,
target_image_layout: VkImageLayout,
) {
let mut mip_width = image.width();

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(

54
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$(<$( $lt, )* $( $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 $($(, $lt )* $(, $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
}
@ -52,26 +28,14 @@ macro_rules! impl_vk_handle {
}
macro_rules! impl_vk_handle_t {
($struct_name:ident $([$($t:ident $(,)? )* ])?, $target_name:ident, $value:ident) => {
impl<T $(: $($t,)* )?> VkHandle<$target_name> for $struct_name<T> {
($struct_name:ident $([$($t:ident $(,)? )* ])? $(<$( $lt:lifetime $(,)? )* $( $const:ident $name:ident: $type:ident, )*>)?, $target_name:ident, $value:ident) => {
impl<$( $( $lt, )* $( $name: $type, )* )? T $(: $($t,)* )?> VkHandle<$target_name> for $struct_name<$( $($lt, )* $($name,)* )? T> {
fn vk_handle(&self) -> $target_name {
self.$value
}
}
impl<'a, T $(: $($t,)* )?> VkHandle<$target_name> for &'a $struct_name<T> {
fn vk_handle(&self) -> $target_name {
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>> {
impl<'a, $( $( $lt, )* $( $name: $type, )* )? T $(: $($t,)* )?> VkHandle<$target_name> for &'a $struct_name<$( $($lt, )* $($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: &'a 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: &'a 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: &'a 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: &'a 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: &'a 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)?;

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

@ -2,8 +2,6 @@ use crate::prelude::*;
use anyhow::Result;
use std::sync::Arc;
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum PipelineType {
Graphics,
@ -12,9 +10,9 @@ pub enum PipelineType {
}
#[derive(Debug)]
pub struct Pipeline {
device: Arc<Device>,
pipeline_layout: Arc<PipelineLayout>,
pub struct Pipeline<'a> {
device: &'a Device,
pipeline_layout: PipelineLayout,
pipeline_type: PipelineType,
@ -23,10 +21,10 @@ pub struct Pipeline {
sub_pass: u32,
}
impl Pipeline {
impl<'a> Pipeline<'a> {
pub(crate) fn new(
device: Arc<Device>,
pipeline_layout: Arc<PipelineLayout>,
device: &'a Device,
pipeline_layout: PipelineLayout,
pipeline_type: PipelineType,
pipeline: VkPipeline,
) -> Self {
@ -49,15 +47,15 @@ impl Pipeline {
self.sub_pass
}
pub fn new_graphics() -> GraphicsPipelineBuilder {
pub fn new_graphics() -> GraphicsPipelineBuilder<'a> {
GraphicsPipelineBuilder::default()
}
pub fn new_compute<'a>() -> ComputePipelineBuilder<'a> {
pub fn new_compute() -> ComputePipelineBuilder<'a> {
ComputePipelineBuilder::default()
}
pub fn new_ray_tracing<'a>() -> RayTracingPipelineBuilder<'a> {
pub fn new_ray_tracing() -> RayTracingPipelineBuilder<'a> {
RayTracingPipelineBuilder::default()
}
@ -74,7 +72,7 @@ impl Pipeline {
.get_ray_tracing_shader_group_handles(self.pipeline, 0, group_count, handle_size)
}
pub fn pipeline_layout(&self) -> &Arc<PipelineLayout> {
pub fn pipeline_layout(&self) -> &PipelineLayout {
&self.pipeline_layout
}
@ -83,15 +81,15 @@ impl Pipeline {
}
}
impl VulkanDevice for Pipeline {
fn device(&self) -> &Arc<Device> {
impl<'a> VulkanDevice for Pipeline<'a> {
fn device(&self) -> &Device {
&self.device
}
}
impl_vk_handle!(Pipeline, VkPipeline, pipeline);
impl_vk_handle!(Pipeline<'a>, VkPipeline, pipeline);
impl Drop for Pipeline {
impl<'a> Drop for Pipeline<'a> {
fn drop(&mut self) {
self.device.destroy_pipeline(self.pipeline);
}

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
}
}

24
vulkan-rs/src/pipelines/compute_pipeline.rs
View file

@ -3,11 +3,9 @@ use anyhow::Result;
use crate::pipeline::PipelineType;
use crate::prelude::*;
use std::sync::Arc;
pub struct ComputePipelineBuilder<'a> {
shader_module: Option<&'a Arc<ShaderModule<shader_type::Compute>>>,
pipeline_cache: Option<&'a Arc<PipelineCache>>,
shader_module: Option<&'a ShaderModule<'a, shader_type::Compute>>,
pipeline_cache: Option<PipelineCache>,
flags: VkPipelineCreateFlagBits,
}
@ -15,7 +13,7 @@ impl<'a> ComputePipelineBuilder<'a> {
// TODO: add support for specialization constants
pub fn set_shader_module(
mut self,
shader_module: &'a Arc<ShaderModule<shader_type::Compute>>,
shader_module: &'a ShaderModule<'a, shader_type::Compute>,
) -> Self {
if cfg!(debug_assertions) {
if self.shader_module.is_some() {
@ -28,7 +26,7 @@ impl<'a> ComputePipelineBuilder<'a> {
self
}
pub fn set_pipeline_cache(mut self, pipeline_cache: &'a Arc<PipelineCache>) -> Self {
pub fn set_pipeline_cache(mut self, pipeline_cache: PipelineCache) -> Self {
self.pipeline_cache = Some(pipeline_cache);
self
@ -42,9 +40,9 @@ impl<'a> ComputePipelineBuilder<'a> {
pub fn build(
self,
device: &Arc<Device>,
pipeline_layout: &Arc<PipelineLayout>,
) -> Result<Arc<Pipeline>> {
device: &'a Device,
pipeline_layout: PipelineLayout,
) -> Result<Pipeline<'a>> {
let pipeline_ci = match self.shader_module {
Some(module) => VkComputePipelineCreateInfo::new(
self.flags,
@ -63,12 +61,12 @@ impl<'a> ComputePipelineBuilder<'a> {
&[pipeline_ci],
)?[0];
Ok(Arc::new(Pipeline::new(
device.clone(),
pipeline_layout.clone(),
Ok(Pipeline::new(
device,
pipeline_layout,
PipelineType::Compute,
pipeline,
)))
))
}
}

51
vulkan-rs/src/pipelines/graphics_pipeline.rs
View file

@ -5,28 +5,28 @@ use anyhow::Result;
use std::sync::Arc;
pub struct GraphicsPipelineBuilder {
pub struct GraphicsPipelineBuilder<'a> {
flags: VkPipelineCreateFlagBits,
pipeline_cache: Option<Arc<PipelineCache>>,
amd_rasterization_order: Option<VkPipelineRasterizationStateRasterizationOrderAMD>,
vertex_shader: Option<Arc<ShaderModule<shader_type::Vertex>>>,
vertex_shader: Option<&'a ShaderModule<'a, shader_type::Vertex>>,
vertex_binding_description: Vec<VkVertexInputBindingDescription>,
vertex_attribute_description: Vec<VkVertexInputAttributeDescription>,
input_assembly: Option<VkPipelineInputAssemblyStateCreateInfo>,
tesselation_shader: Option<(
Arc<ShaderModule<shader_type::TesselationControl>>,
Arc<ShaderModule<shader_type::TesselationEvaluation>>,
&'a ShaderModule<'a, shader_type::TesselationControl>,
&'a ShaderModule<'a, shader_type::TesselationEvaluation>,
)>,
patch_control_points: u32,
geometry_shader: Option<Arc<ShaderModule<shader_type::Geometry>>>,
geometry_shader: Option<&'a ShaderModule<'a, shader_type::Geometry>>,
fragment_shader: Option<Arc<ShaderModule<shader_type::Fragment>>>,
fragment_shader: Option<&'a ShaderModule<'a, shader_type::Fragment>>,
viewports: Vec<VkViewport>,
scissors: Vec<VkRect2D>,
@ -41,11 +41,11 @@ pub struct GraphicsPipelineBuilder {
dynamic_states: Vec<VkDynamicState>,
}
impl GraphicsPipelineBuilder {
impl<'a> GraphicsPipelineBuilder<'a> {
// TODO: add support for specialization constants
pub fn set_vertex_shader<T: VertexInputDescription>(
mut self,
shader: Arc<ShaderModule<shader_type::Vertex>>,
shader: &'a ShaderModule<'a, shader_type::Vertex>,
) -> Self {
self.vertex_shader = Some(shader);
self.vertex_binding_description = T::bindings();
@ -57,8 +57,8 @@ impl GraphicsPipelineBuilder {
// TODO: add support for specialization constants
pub fn set_tesselation_shader(
mut self,
tesselation_control: Arc<ShaderModule<shader_type::TesselationControl>>,
tesselation_evaluation: Arc<ShaderModule<shader_type::TesselationEvaluation>>,
tesselation_control: &'a ShaderModule<'a, shader_type::TesselationControl>,
tesselation_evaluation: &'a ShaderModule<'a, shader_type::TesselationEvaluation>,
patch_control_points: u32,
) -> Self {
self.tesselation_shader = Some((tesselation_control, tesselation_evaluation));
@ -68,14 +68,20 @@ impl GraphicsPipelineBuilder {
}
// TODO: add support for specialization constants
pub fn set_geometry_shader(mut self, shader: Arc<ShaderModule<shader_type::Geometry>>) -> Self {
pub fn set_geometry_shader(
mut self,
shader: &'a ShaderModule<'a, shader_type::Geometry>,
) -> Self {
self.geometry_shader = Some(shader);
self
}
// TODO: add support for specialization constants
pub fn set_fragment_shader(mut self, shader: Arc<ShaderModule<shader_type::Fragment>>) -> Self {
pub fn set_fragment_shader(
mut self,
shader: &'a ShaderModule<'a, shader_type::Fragment>,
) -> Self {
self.fragment_shader = Some(shader);
self
@ -309,11 +315,11 @@ impl GraphicsPipelineBuilder {
pub fn build(
mut self,
device: Arc<Device>,
pipeline_layout: &Arc<PipelineLayout>,
render_pass: &Arc<RenderPass>,
device: &'a Device,
pipeline_layout: PipelineLayout,
render_pass: &RenderPass<'a>,
subpass: u32,
) -> Result<Arc<Pipeline>> {
) -> Result<Pipeline<'a>> {
let mut rasterization = self.rasterization.expect("rasterization state is required");
if let Some(amd_rasterization_order) = &self.amd_rasterization_order {
@ -393,19 +399,14 @@ impl GraphicsPipelineBuilder {
&[pipeline_ci],
)?[0];
Ok(Arc::new(
Pipeline::new(
device,
pipeline_layout.clone(),
PipelineType::Graphics,
pipeline,
)
Ok(
Pipeline::new(device, pipeline_layout, PipelineType::Graphics, pipeline)
.set_sub_pass(subpass),
))
)
}
}
impl Default for GraphicsPipelineBuilder {
impl<'a> Default for GraphicsPipelineBuilder<'a> {
fn default() -> Self {
GraphicsPipelineBuilder {
flags: 0.into(),

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

@ -8,18 +8,14 @@ use std::sync::Arc;
use super::shader_binding_table::ShaderBindingTableBuilder;
pub struct Library<'a> {
pipeline: &'a Arc<Pipeline>,
pipeline: &'a Pipeline<'a>,
max_payload_size: u32,
max_attribute_size: u32,
}
impl<'a> Library<'a> {
pub fn new(
pipeline: &'a Arc<Pipeline>,
max_payload_size: u32,
max_attribute_size: u32,
) -> Self {
pub fn new(pipeline: &'a Pipeline<'a>, max_payload_size: u32, max_attribute_size: u32) -> Self {
Library {
pipeline,
@ -31,8 +27,8 @@ impl<'a> Library<'a> {
macro_rules! impl_from_shader_type {
($struct: ident, $shader_type: ident) => {
impl From<Arc<ShaderModule<shader_type::$shader_type>>> for $struct {
fn from(value: Arc<ShaderModule<shader_type::$shader_type>>) -> Self {
impl<'a> From<&'a ShaderModule<'a, shader_type::$shader_type>> for $struct<'a> {
fn from(value: &'a ShaderModule<'a, shader_type::$shader_type>) -> Self {
Self::$shader_type(value)
}
}
@ -40,12 +36,12 @@ macro_rules! impl_from_shader_type {
}
#[derive(Clone)]
enum RaytracingShader {
RayGeneration(Arc<ShaderModule<shader_type::RayGeneration>>),
ClosestHit(Arc<ShaderModule<shader_type::ClosestHit>>),
Miss(Arc<ShaderModule<shader_type::Miss>>),
AnyHit(Arc<ShaderModule<shader_type::AnyHit>>),
Intersection(Arc<ShaderModule<shader_type::Intersection>>),
enum RaytracingShader<'a> {
RayGeneration(&'a ShaderModule<'a, shader_type::RayGeneration>),
ClosestHit(&'a ShaderModule<'a, shader_type::ClosestHit>),
Miss(&'a ShaderModule<'a, shader_type::Miss>),
AnyHit(&'a ShaderModule<'a, shader_type::AnyHit>),
Intersection(&'a ShaderModule<'a, shader_type::Intersection>),
}
impl_from_shader_type!(RaytracingShader, RayGeneration);
@ -54,8 +50,8 @@ impl_from_shader_type!(RaytracingShader, Miss);
impl_from_shader_type!(RaytracingShader, AnyHit);
impl_from_shader_type!(RaytracingShader, Intersection);
impl From<HitShader> for RaytracingShader {
fn from(value: HitShader) -> Self {
impl<'a> From<HitShader<'a>> for RaytracingShader<'a> {
fn from(value: HitShader<'a>) -> Self {
match value {
HitShader::ClosestHit(s) => Self::ClosestHit(s),
HitShader::AnyHit(s) => Self::AnyHit(s),
@ -64,8 +60,8 @@ impl From<HitShader> for RaytracingShader {
}
}
impl From<OtherShader> for RaytracingShader {
fn from(value: OtherShader) -> Self {
impl<'a> From<OtherShader<'a>> for RaytracingShader<'a> {
fn from(value: OtherShader<'a>) -> Self {
match value {
OtherShader::Miss(s) => Self::Miss(s),
OtherShader::RayGeneration(s) => Self::RayGeneration(s),
@ -74,10 +70,10 @@ impl From<OtherShader> for RaytracingShader {
}
#[derive(Clone)]
pub enum HitShader {
ClosestHit(Arc<ShaderModule<shader_type::ClosestHit>>),
AnyHit(Arc<ShaderModule<shader_type::AnyHit>>),
Intersection(Arc<ShaderModule<shader_type::Intersection>>),
pub enum HitShader<'a> {
ClosestHit(&'a ShaderModule<'a, shader_type::ClosestHit>),
AnyHit(&'a ShaderModule<'a, shader_type::AnyHit>),
Intersection(&'a ShaderModule<'a, shader_type::Intersection>),
}
impl_from_shader_type!(HitShader, ClosestHit);
@ -85,16 +81,16 @@ impl_from_shader_type!(HitShader, AnyHit);
impl_from_shader_type!(HitShader, Intersection);
#[derive(Clone)]
pub enum OtherShader {
RayGeneration(Arc<ShaderModule<shader_type::RayGeneration>>),
Miss(Arc<ShaderModule<shader_type::Miss>>),
pub enum OtherShader<'a> {
RayGeneration(&'a ShaderModule<'a, shader_type::RayGeneration>),
Miss(&'a ShaderModule<'a, shader_type::Miss>),
}
impl_from_shader_type!(OtherShader, RayGeneration);
impl_from_shader_type!(OtherShader, Miss);
pub struct RayTracingPipelineBuilder<'a> {
shader_modules: Vec<(RaytracingShader, Option<SpecializationConstants>)>,
shader_modules: Vec<(RaytracingShader<'a>, Option<SpecializationConstants>)>,
shader_groups: Vec<VkRayTracingShaderGroupCreateInfoKHR>,
@ -111,7 +107,7 @@ pub struct RayTracingPipelineBuilder<'a> {
}
impl<'a> RayTracingPipelineBuilder<'a> {
pub fn check_max_recursion(device: &Arc<Device>, max_recursion: u32) -> u32 {
pub fn check_max_recursion(device: &'a Device, max_recursion: u32) -> u32 {
max_recursion.min(
device
.physical_device()
@ -146,7 +142,7 @@ impl<'a> RayTracingPipelineBuilder<'a> {
pub fn add_shader(
mut self,
shader_module: impl Into<OtherShader>,
shader_module: impl Into<OtherShader<'a>>,
data: Option<Vec<u8>>,
specialization_constants: Option<SpecializationConstants>,
) -> Self {
@ -179,7 +175,7 @@ impl<'a> RayTracingPipelineBuilder<'a> {
pub fn add_hit_shaders(
mut self,
shader_modules: impl IntoIterator<Item = (HitShader, Option<SpecializationConstants>)>,
shader_modules: impl IntoIterator<Item = (HitShader<'a>, Option<SpecializationConstants>)>,
data: Option<Vec<u8>>,
) -> Self {
let mut group = VkRayTracingShaderGroupCreateInfoKHR::new(
@ -243,9 +239,9 @@ impl<'a> RayTracingPipelineBuilder<'a> {
pub fn build(
mut self,
device: Arc<Device>,
pipeline_layout: &Arc<PipelineLayout>,
) -> Result<(Arc<Pipeline>, ShaderBindingTable)> {
device: &'a Device,
pipeline_layout: PipelineLayout,
) -> Result<(Pipeline<'a>, ShaderBindingTable<'a>)> {
let shader_stages: Vec<VkPipelineShaderStageCreateInfo> = self
.shader_modules
.iter()
@ -267,7 +263,7 @@ impl<'a> RayTracingPipelineBuilder<'a> {
.collect();
// check that we dont exceed the gpu's capabilities
let max_recursion = Self::check_max_recursion(&device, self.max_recursion);
let max_recursion = Self::check_max_recursion(device, self.max_recursion);
let pipeline = {
let mut libraries = Vec::with_capacity(self.libraries.len());
@ -306,12 +302,7 @@ impl<'a> RayTracingPipelineBuilder<'a> {
)?[0]
};
let pipeline = Arc::new(Pipeline::new(
device.clone(),
pipeline_layout.clone(),
PipelineType::RayTracing,
pipeline,
));
let pipeline = Pipeline::new(device, pipeline_layout, PipelineType::RayTracing, pipeline);
let sbt = self
.shader_binding_table_builder

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

@ -2,8 +2,6 @@ use crate::prelude::*;
use anyhow::Result;
use std::sync::Arc;
struct ShaderBindingTableEntry {
group_index: u32,
inline_data: Vec<u8>,
@ -14,8 +12,8 @@ pub(crate) struct ShaderBindingTableBuilder {
hit_group_entries: Vec<ShaderBindingTableEntry>,
}
pub struct ShaderBindingTable {
_sbt_buffer: Arc<Buffer<RawBuffer>>,
pub struct ShaderBindingTable<'device> {
_sbt_buffer: Buffer<'device, RawBuffer>,
raygen_shader_binding_table: VkStridedDeviceAddressRegionKHR,
miss_shader_binding_table: VkStridedDeviceAddressRegionKHR,
@ -23,7 +21,7 @@ pub struct ShaderBindingTable {
callable_shader_binding_table: VkStridedDeviceAddressRegionKHR,
}
impl ShaderBindingTable {
impl<'device> ShaderBindingTable<'device> {
pub fn raygen_shader_binding_table(&self) -> &VkStridedDeviceAddressRegionKHR {
&self.raygen_shader_binding_table
}
@ -41,7 +39,7 @@ impl ShaderBindingTable {
}
fn create(
sbt_buffer: Arc<Buffer<RawBuffer>>,
sbt_buffer: Buffer<'device, RawBuffer>,
ray_gen_entry_size: VkDeviceSize,
ray_gen_entry_count: VkDeviceSize,
miss_offset: VkDeviceSize,
@ -128,11 +126,11 @@ impl ShaderBindingTableBuilder {
self
}
pub(crate) fn build(
pub(crate) fn build<'a>(
&mut self,
device: &Arc<Device>,
pipeline: &Arc<Pipeline>,
) -> Result<ShaderBindingTable> {
device: &'a Device,
pipeline: &Pipeline<'a>,
) -> Result<ShaderBindingTable<'a>> {
let ray_tracing_properties = device.physical_device().ray_tracing_properties();
let prog_id_size = ray_tracing_properties.shaderGroupHandleSize;
@ -194,6 +192,11 @@ impl ShaderBindingTableBuilder {
&shader_handle_storage,
);
let b = sbt_data
.into_iter()
.map(|u| RawBuffer { d: u })
.collect::<Vec<RawBuffer>>();
let sbt_buffer = Buffer::builder()
.set_usage(
VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR
@ -201,14 +204,8 @@ impl ShaderBindingTableBuilder {
| VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
)
.set_memory_usage(MemoryUsage::CpuToGpu)
.set_data(
sbt_data
.into_iter()
.map(|u| RawBuffer { d: u })
.collect::<Vec<RawBuffer>>()
.as_slice(),
)
.build(device.clone())?;
.set_data(b.as_slice())
.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
}
}

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

@ -2,11 +2,7 @@ use crate::prelude::*;
use anyhow::Result;
use std::{
slice,
sync::{Arc, Mutex},
time::Duration,
};
use std::{slice, sync::Mutex, time::Duration};
pub struct QueueRequestInfo {
pub queue_create_info: VkDeviceQueueCreateInfo,
@ -15,17 +11,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 {
impl<'a> Queue<'a> {
pub fn create_presentable_request_info(
physical_device: &Arc<PhysicalDevice>,
surface: &Arc<Surface>,
physical_device: &PhysicalDevice,
surface: &Surface<'a>,
queue_type: impl Into<VkQueueFlagBits>,
) -> Result<QueueRequestInfo> {
let index =
@ -41,7 +37,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 +52,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 +74,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,15 +89,15 @@ impl Queue {
pub fn minimal_submit(
&self,
time_out: Duration,
command_buffers: &[Arc<CommandBuffer>],
command_buffers: &[&CommandBuffer<'a>],
) -> Result<()> {
let mut submit = SubmitInfo::default();
for command_buffer in command_buffers.iter() {
for &command_buffer in command_buffers.iter() {
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 +109,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 +136,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_vk_handle!(Queue<'a>, 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 +175,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();

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

@ -1,32 +1,32 @@
use crate::prelude::*;
use anyhow::Result;
use std::sync::{
atomic::{AtomicU32, AtomicUsize, Ordering::SeqCst},
Arc,
};
use std::sync::atomic::{AtomicU32, AtomicUsize, Ordering::SeqCst};
pub mod sub_pass;
use sub_pass::{AttachmentInfo, AttachmentInfoUsage, SubPass};
pub struct RenderTargetBuilder<'a> {
old_render_target: Option<&'a RenderTarget>,
sub_passes: Vec<SubPass>,
pub struct RenderTargetBuilder<'device, 'image> {
old_render_target: Option<RenderTarget<'device, 'image>>,
sub_passes: Vec<SubPass<'device>>,
}
impl<'a> RenderTargetBuilder<'a> {
pub fn add_sub_pass(mut self, sub_pass: SubPass) -> Self {
impl<'device, 'image> RenderTargetBuilder<'device, 'image> {
pub fn add_sub_pass(mut self, sub_pass: SubPass<'device>) -> Self {
self.sub_passes.push(sub_pass);
self
}
pub fn preserve_old_render_pass(mut self, render_target: &'a RenderTarget) -> Self {
pub fn preserve_old_render_pass(
mut self,
render_target: RenderTarget<'device, 'image>,
) -> Self {
self.old_render_target = Some(render_target);
self
}
pub fn build(self, device: &Arc<Device>) -> Result<RenderTarget> {
pub fn build(self, device: &'device Device) -> Result<RenderTarget<'device, 'image>> {
#[cfg(debug_assertions)]
{
// sub passes must not be empty
@ -55,7 +55,7 @@ impl<'a> RenderTargetBuilder<'a> {
));
}
old_render_target.render_pass.clone()
old_render_target.render_pass
}
None => {
// gather attachment descriptions
@ -164,7 +164,7 @@ impl<'a> RenderTargetBuilder<'a> {
last_dependency.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT.into();
}
RenderPass::new(device.clone(), &descriptions, &attachments, &dependencies)?
RenderPass::new(device, &descriptions, &attachments, &dependencies)?
}
};
@ -185,10 +185,10 @@ impl<'a> RenderTargetBuilder<'a> {
})
}
fn create_framebuffers(
render_pass: &Arc<RenderPass>,
sub_passes: &[SubPass],
) -> Result<Vec<Arc<Framebuffer>>> {
fn create_framebuffers<'handle>(
render_pass: &'handle RenderPass<'device>,
sub_passes: &'handle [SubPass<'device>],
) -> Result<Vec<Framebuffer<'device, 'image>>> {
let extent = sub_passes[0].extent();
(0..Self::max_images(sub_passes))
@ -205,13 +205,13 @@ impl<'a> RenderTargetBuilder<'a> {
}
}
framebuffer_builder.build(render_pass.device().clone())
framebuffer_builder.build(render_pass.device())
})
.collect()
}
#[inline]
fn max_images(sub_passes: &[SubPass]) -> usize {
fn max_images(sub_passes: &[SubPass<'device>]) -> usize {
let mut max_images = 0;
for sub_pass in sub_passes.iter() {
@ -221,7 +221,10 @@ 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<'device>],
new_sub_passes: &[SubPass<'device>],
) -> bool {
if old_sub_passes.len() != new_sub_passes.len() {
return false;
}
@ -236,9 +239,9 @@ impl<'a> RenderTargetBuilder<'a> {
}
#[inline]
fn map_attachment<'b, F>(&'b self, mut f: F)
fn map_attachment<'handle, F>(&'handle self, mut f: F)
where
F: FnMut(&'b AttachmentInfo) -> (),
F: FnMut(&'handle AttachmentInfo<'device>) -> (),
{
for sub_pass in self.sub_passes.iter() {
for attachment in sub_pass.attachments().iter() {
@ -260,36 +263,36 @@ struct SubPassAttachmentReferences {
}
#[derive(Debug)]
pub struct RenderTarget {
render_pass: Arc<RenderPass>,
framebuffers: Vec<Arc<Framebuffer>>,
pub struct RenderTarget<'device, 'image> {
render_pass: RenderPass<'device>,
framebuffers: Vec<Framebuffer<'device, 'image>>,
clear_values: Vec<VkClearValue>,
extent: VkExtent2D,
sub_passes: Vec<SubPass>,
sub_passes: Vec<SubPass<'device>>,
current_subpass: AtomicU32,
framebuffer_index: AtomicUsize,
}
impl RenderTarget {
pub fn builder<'a>() -> RenderTargetBuilder<'a> {
impl<'device, 'image> RenderTarget<'device, 'image> {
pub fn builder() -> RenderTargetBuilder<'device, 'image> {
RenderTargetBuilder {
old_render_target: None,
sub_passes: Vec::new(),
}
}
pub fn render_pass(&self) -> &Arc<RenderPass> {
pub fn render_pass(&self) -> &RenderPass<'device> {
&self.render_pass
}
pub fn framebuffer(&self, index: usize) -> &Arc<Framebuffer> {
pub fn framebuffer(&self, index: usize) -> &Framebuffer<'device, 'image> {
&self.framebuffers[index]
}
pub fn sub_pass(&self, index: usize) -> &SubPass {
pub fn sub_pass(&self, index: usize) -> &SubPass<'device> {
&self.sub_passes[index]
}
@ -312,7 +315,7 @@ impl RenderTarget {
pub fn begin(
&self,
buffer_recorder: &mut CommandBufferRecorder<'_>,
buffer_recorder: &mut CommandBufferRecorder<'device, '_, '_>,
subpass_content: VkSubpassContents,
framebuffer_index: usize,
) {
@ -334,14 +337,14 @@ impl RenderTarget {
pub fn next_subpass(
&self,
buffer_recorder: &mut CommandBufferRecorder<'_>,
buffer_recorder: &mut CommandBufferRecorder<'device, '_, '_>,
subpass_content: VkSubpassContents,
) {
buffer_recorder.next_subpass(subpass_content);
self.current_subpass.fetch_add(1, SeqCst);
}
pub fn end(&self, buffer_recorder: &mut CommandBufferRecorder<'_>) {
pub fn end(&self, buffer_recorder: &mut CommandBufferRecorder<'device, '_, '_>) {
debug_assert_eq!(
self.current_subpass.load(SeqCst) as usize,
self.sub_passes.len() - 1
@ -353,48 +356,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,18 +378,26 @@ mod test {
Ok(image)
})
.collect::<Result<Vec<Arc<Image>>>>()
.collect::<Result<Vec<Image<'_>>>>()
.unwrap();
let width = target_images[0].width();
let height = target_images[0].height();
RenderTarget::builder()
.add_sub_pass(
SubPass::builder(target_images[0].width(), target_images[0].height())
.set_prepared_targets(&target_images, 0, [0.0, 0.0, 0.0, 0.0], false)
SubPass::builder(width, height)
.set_prepared_targets(
target_images.iter().collect(),
0,
[0.0, 0.0, 0.0, 0.0],
false,
)
.build(&device)
.unwrap(),
)
.add_sub_pass(
SubPass::builder(target_images[0].width(), target_images[0].height())
SubPass::builder(width, height)
.add_target_info(CustomTarget {
usage: VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT.into(),
format: VK_FORMAT_R8G8B8A8_UNORM,
@ -438,17 +415,22 @@ mod test {
false,
true,
))
.use_queue(queue.clone())
.use_queue(&queue)
.build(&device)
.unwrap(),
)
.add_sub_pass(
SubPass::builder(target_images[0].width(), target_images[0].height())
SubPass::builder(width, height)
.set_input_attachment_info(InputAttachmentInfo {
sub_pass_index: 1,
input_indices: vec![1],
})
.set_prepared_targets(&target_images, 0, [0.0, 0.0, 0.0, 0.0], false)
.set_prepared_targets(
target_images.iter().collect(),
0,
[0.0, 0.0, 0.0, 0.0],
false,
)
.build(&device)
.unwrap(),
)

119
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::{ops::Index, 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: &'a Device,
queue: &'a 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 {
@ -159,7 +159,7 @@ impl CustomTarget {
}
Ok(AttachmentInfo {
images: vec![image],
images: vec![image].into(),
clear_value,
layout,
description,
@ -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))
}
}
@ -197,25 +197,31 @@ pub struct InputAttachmentInfo {
pub input_indices: Vec<usize>,
}
pub struct SubPassBuilder<'a> {
pub struct SubPassBuilder<'a, 'b>
where
'b: 'a,
{
width: u32,
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<(Vec<&'b Image<'a>>, usize, [f32; 4], bool)>,
resolve_targets: Vec<ResolveTarget<'a>>,
output_usage: VkAccessFlagBits,
}
impl<'a> SubPassBuilder<'a> {
impl<'a, 'b> SubPassBuilder<'a, 'b>
where
'b: 'a,
{
pub fn set_sample_count(mut self, sample_count: VkSampleCountFlags) -> Self {
self.sample_count = sample_count;
@ -242,7 +248,7 @@ impl<'a> SubPassBuilder<'a> {
pub fn set_prepared_targets(
mut self,
prepared_targets: &'a [Arc<Image>],
prepared_targets: Vec<&'b Image<'a>>,
target_index: usize,
clear_color: impl Into<[f32; 4]>,
clear_on_load: bool,
@ -257,19 +263,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: &'a Device) -> Result<SubPass<'a>> {
Ok(SubPass {
extent: VkExtent2D {
width: self.width,
@ -284,7 +290,7 @@ impl<'a> SubPassBuilder<'a> {
}
#[inline]
fn create_images(self, device: &Arc<Device>) -> Result<Vec<AttachmentInfo>> {
fn create_images(self, device: &'a Device) -> Result<Vec<AttachmentInfo<'a>>> {
// check for correct sample count
let checked_sample_count = device.max_supported_sample_count(self.sample_count);
@ -314,7 +320,6 @@ impl<'a> SubPassBuilder<'a> {
attachment_infos.insert(
index,
AttachmentInfo {
images: prepared_images.iter().map(|image| image.clone()).collect(),
clear_value: VkClearValue::color(VkClearColorValue::float32(clear_color)),
layout: VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
description: VkAttachmentDescription::new(
@ -329,6 +334,7 @@ impl<'a> SubPassBuilder<'a> {
prepared_images[0].image_layout(),
),
usage: AttachmentInfoUsage::Output,
images: prepared_images.into(),
},
);
}
@ -353,7 +359,6 @@ impl<'a> SubPassBuilder<'a> {
}
ResolveTarget::PreparedTargets((prepared_targets, clear_on_load)) => {
attachment_infos.push(AttachmentInfo {
images: prepared_targets.iter().map(|image| image.clone()).collect(),
clear_value: VkClearValue::color(VkClearColorValue::float32([
0.0, 0.0, 0.0, 1.0,
])),
@ -370,6 +375,7 @@ impl<'a> SubPassBuilder<'a> {
prepared_targets[0].image_layout(),
),
usage: AttachmentInfoUsage::Resolve,
images: prepared_targets.into(),
});
}
}
@ -405,16 +411,61 @@ pub enum AttachmentInfoUsage {
}
#[derive(Debug)]
pub struct AttachmentInfo {
images: Vec<Arc<Image>>,
pub enum AttachmentInfoImages<'device> {
Owned(Vec<Image<'device>>),
Ref(Vec<&'device Image<'device>>),
}
impl<'device> AttachmentInfoImages<'device> {
fn len(&self) -> usize {
match self {
AttachmentInfoImages::Owned(v) => v.len(),
AttachmentInfoImages::Ref(v) => v.len(),
}
}
fn is_empty(&self) -> bool {
match self {
AttachmentInfoImages::Owned(v) => v.is_empty(),
AttachmentInfoImages::Ref(v) => v.is_empty(),
}
}
}
impl<'device> From<Vec<Image<'device>>> for AttachmentInfoImages<'device> {
fn from(value: Vec<Image<'device>>) -> Self {
Self::Owned(value)
}
}
impl<'device> From<Vec<&'device Image<'device>>> for AttachmentInfoImages<'device> {
fn from(value: Vec<&'device Image<'device>>) -> Self {
Self::Ref(value)
}
}
impl<'device> Index<usize> for AttachmentInfoImages<'device> {
type Output = Image<'device>;
fn index(&self, index: usize) -> &Self::Output {
match self {
AttachmentInfoImages::Owned(v) => &v[index],
AttachmentInfoImages::Ref(v) => &v[index],
}
}
}
#[derive(Debug)]
pub struct AttachmentInfo<'a> {
images: AttachmentInfoImages<'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 +484,17 @@ impl AttachmentInfo {
}
#[derive(Debug)]
pub struct SubPass {
pub struct SubPass<'device> {
extent: VkExtent2D,
input_info: Option<InputAttachmentInfo>,
attachments: Vec<AttachmentInfo>,
attachments: Vec<AttachmentInfo<'device>>,
output_usage: VkAccessFlagBits,
}
impl SubPass {
pub fn builder<'a>(width: u32, height: u32) -> SubPassBuilder<'a> {
impl<'device> SubPass<'device> {
pub fn builder<'b>(width: u32, height: u32) -> SubPassBuilder<'device, 'b> {
SubPassBuilder {
width,
height,
@ -475,7 +526,7 @@ impl SubPass {
self.extent
}
pub fn attachments(&self) -> &[AttachmentInfo] {
pub fn attachments(&self) -> &[AttachmentInfo<'device>] {
&self.attachments
}

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

@ -2,21 +2,19 @@ use crate::prelude::*;
use anyhow::Result;
use std::sync::Arc;
#[derive(Debug)]
pub struct RenderPass {
device: Arc<Device>,
pub struct RenderPass<'a> {
device: &'a Device,
render_pass: VkRenderPass,
}
impl RenderPass {
impl<'a> RenderPass<'a> {
pub fn new(
device: Arc<Device>,
device: &'a Device,
sub_passes: &[VkSubpassDescription],
attachments: &[VkAttachmentDescription],
dependencies: &[VkSubpassDependency],
) -> Result<Arc<RenderPass>> {
) -> Result<RenderPass<'a>> {
let render_pass_ci = VkRenderPassCreateInfo::new(
VK_RENDERPASS_CREATE_NULL_BIT,
attachments,
@ -26,22 +24,22 @@ impl RenderPass {
let render_pass = device.create_render_pass(&render_pass_ci)?;
Ok(Arc::new(RenderPass {
Ok(RenderPass {
device,
render_pass,
}))
})
}
}
impl VulkanDevice for RenderPass {
fn device(&self) -> &Arc<Device> {
impl<'a> VulkanDevice for RenderPass<'a> {
fn device(&self) -> &Device {
&self.device
}
}
impl_vk_handle!(RenderPass, VkRenderPass, render_pass);
impl_vk_handle!(RenderPass<'a>, VkRenderPass, render_pass);
impl Drop for RenderPass {
impl<'a> Drop for RenderPass<'a> {
fn drop(&mut self) {
self.device.destroy_render_pass(self.render_pass);
}

34
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_vk_handle!(Semaphore<'a>, 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) };
}

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

@ -5,7 +5,6 @@ use anyhow::{Context, Result};
use std::fs::File;
use std::io::Read;
use std::marker::PhantomData;
use std::sync::Arc;
pub mod shader_type {
mod sealed {
@ -77,7 +76,7 @@ pub trait PipelineStageInfo {
macro_rules! impl_pipeline_stage_info {
($func:ident, $type:ident) => {
impl PipelineStageInfo for ShaderModule<$type> {
impl<'a> PipelineStageInfo for ShaderModule<'a, $type> {
fn pipeline_stage_info(&self) -> VkPipelineShaderStageCreateInfo {
VkPipelineShaderStageCreateInfo::$func(self.shader_module)
}
@ -86,33 +85,30 @@ macro_rules! impl_pipeline_stage_info {
}
#[derive(Debug)]
pub struct ShaderModule<ShaderModuleType: ShaderType> {
pub struct ShaderModule<'a, ShaderModuleType: ShaderType> {
t: PhantomData<ShaderModuleType>,
device: Arc<Device>,
device: &'a Device,
shader_module: VkShaderModule,
}
impl<ShaderModuleType: ShaderType> ShaderModule<ShaderModuleType> {
pub fn new(device: Arc<Device>, path: &str) -> Result<Arc<ShaderModule<ShaderModuleType>>> {
impl<'a, ShaderModuleType: ShaderType> ShaderModule<'a, ShaderModuleType> {
pub fn new(device: &'a Device, path: &str) -> Result<Self> {
let code = Self::shader_code(path)?;
Self::from_slice(device, code.as_slice())
}
pub fn from_slice(
device: Arc<Device>,
code: &[u8],
) -> Result<Arc<ShaderModule<ShaderModuleType>>> {
pub fn from_slice(device: &'a Device, code: &[u8]) -> Result<Self> {
let shader_module_ci =
VkShaderModuleCreateInfo::new(VK_SHADER_MODULE_CREATE_NULL_BIT, code);
let shader_module = device.create_shader_module(&shader_module_ci)?;
Ok(Arc::new(ShaderModule {
Ok(ShaderModule {
t: PhantomData,
device,
shader_module,
}))
})
}
fn shader_code(path: &str) -> Result<Vec<u8>> {
@ -143,15 +139,29 @@ impl_pipeline_stage_info!(closest_hit, ClosestHit);
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> {
impl<'a, ShaderModuleType: ShaderType> VulkanDevice for ShaderModule<'a, ShaderModuleType> {
fn device(&self) -> &Device {
&self.device
}
}
impl_vk_handle!(ShaderModule<ShaderModuleType: ShaderType,>, VkShaderModule, shader_module);
impl<'a, ShaderModuleType: ShaderType> VkHandle<VkShaderModule>
for ShaderModule<'a, ShaderModuleType>
{
fn vk_handle(&self) -> VkShaderModule {
self.shader_module
}
}
impl<ShaderModuleType: ShaderType> Drop for ShaderModule<ShaderModuleType> {
impl<'a, ShaderModuleType: ShaderType> VkHandle<VkShaderModule>
for &'a ShaderModule<'a, ShaderModuleType>
{
fn vk_handle(&self) -> VkShaderModule {
self.shader_module
}
}
impl<'a, ShaderModuleType: ShaderType> Drop for ShaderModule<'a, ShaderModuleType> {
fn drop(&mut self) {
self.device.destroy_shader_module(self.shader_module);
}

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

@ -1,27 +1,27 @@
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>
pub struct SingleSubmit<'device, 'a, F, T>
where
F: FnOnce(&mut CommandBufferRecorder<'_>) -> Result<T>,
F: FnOnce(&mut CommandBufferRecorder<'device, '_, '_>) -> Result<T>,
{
command_buffer: &'a Arc<CommandBuffer>,
queue: &'a Arc<Mutex<Queue>>,
command_buffer: &'a mut CommandBuffer<'device>,
queue: &'a Mutex<Queue<'device>>,
f: F,
timeout: Option<Duration>,
}
impl<'a, F, T> SingleSubmit<'a, F, T>
impl<'device, 'a, F, T> SingleSubmit<'device, 'a, F, T>
where
F: FnOnce(&mut CommandBufferRecorder<'_>) -> Result<T>,
F: FnOnce(&mut CommandBufferRecorder<'device, '_, '_>) -> Result<T>,
{
pub fn builder(
command_buffer: &'a Arc<CommandBuffer>,
queue: &'a Arc<Mutex<Queue>>,
command_buffer: &'a mut CommandBuffer<'device>,
queue: &'a Mutex<Queue<'device>>,
f: F,
) -> Self {
SingleSubmit {
@ -48,12 +48,12 @@ where
(self.f)(&mut buffer_recorder)?
};
let submit = SubmitInfo::default().add_command_buffer(self.command_buffer);
let submit = SubmitInfo::default().add_command_buffer(&*self.command_buffer);
let queue_lock = self.queue.lock().unwrap();
match self.timeout {
Some(timeout) => {
let fence = Fence::builder().build(self.command_buffer.device().clone())?;
let fence = Fence::builder().build(self.command_buffer.device())?;
queue_lock.submit(Some(&fence), &[submit])?;

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

@ -2,25 +2,20 @@ use crate::prelude::*;
use anyhow::Result;
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> {
pub fn capabilities(&self, device: &'a Device) -> Result<VkSurfaceCapabilitiesKHR> {
self.instance.physical_device_surface_capabilities(
device.physical_device().vk_handle(),
self.surface,
@ -29,7 +24,7 @@ impl Surface {
pub fn format_colorspace(
&self,
device: &Arc<Device>,
device: &'a Device,
prefered_format: VkFormat,
) -> Result<(VkFormat, VkColorSpaceKHR)> {
let surface_formats = self
@ -61,15 +56,25 @@ impl Surface {
Ok((surface_formats[0].format, surface_formats[0].colorSpace))
}
pub fn present_modes(&self, device: &Arc<Device>) -> Result<Vec<VkPresentModeKHR>> {
pub fn present_modes(&self, device: &'a Device) -> Result<Vec<VkPresentModeKHR>> {
self.instance
.physical_device_present_modes(device.physical_device().vk_handle(), self.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)
}

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

@ -3,54 +3,51 @@ use crate::prelude::*;
use anyhow::Result;
use std::cmp;
use std::sync::{
atomic::{AtomicU32, Ordering::SeqCst},
Arc, Mutex,
};
use std::sync::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,77 +109,73 @@ impl Swapchain {
let swapchain = device.create_swapchain(&swapchain_ci)?;
Ok(Arc::new(Swapchain {
width: AtomicU32::new(extent.width),
height: AtomicU32::new(extent.height),
Ok(Swapchain {
width: extent.width,
height: extent.height,
usage: swapchain_ci.imageUsage,
index: AtomicU32::new(0),
index: 0,
device,
surface: surface.clone(),
surface,
create_info: Mutex::new(swapchain_ci),
create_info: swapchain_ci,
swapchain: Mutex::new(swapchain),
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),
usage: swapchain_ci.imageUsage,
index: AtomicU32::new(0),
surface: Surface::from_vk_surface(
swapchain_ci.surface,
device.physical_device().instance(),
),
create_info: Mutex::new(swapchain_ci.clone()),
swapchain: Mutex::new(device.create_swapchain(swapchain_ci)?),
device,
raw: false,
}))
}
pub fn from_raw(
device: Arc<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),
usage: swapchain_ci.imageUsage,
index: AtomicU32::new(0),
surface: Surface::from_vk_surface(
swapchain_ci.surface,
device.physical_device().instance(),
),
device,
create_info: Mutex::new(swapchain_ci.clone()),
swapchain: Mutex::new(swapchain),
raw: true,
})
}
pub fn recreate(&self) -> Result<()> {
pub fn from_ci(device: &'a Device, swapchain_ci: &VkSwapchainCreateInfoKHR) -> Result<Self> {
Ok(Swapchain {
width: swapchain_ci.imageExtent.width,
height: swapchain_ci.imageExtent.height,
usage: swapchain_ci.imageUsage,
index: 0,
surface: Surface::from_vk_surface(
swapchain_ci.surface,
device.physical_device().instance(),
),
create_info: swapchain_ci.clone(),
swapchain: device.create_swapchain(swapchain_ci)?,
device,
raw: false,
})
}
pub fn from_raw(
device: &'a Device,
swapchain_ci: &VkSwapchainCreateInfoKHR,
swapchain: VkSwapchainKHR,
) -> Self {
Swapchain {
width: swapchain_ci.imageExtent.width,
height: swapchain_ci.imageExtent.height,
usage: swapchain_ci.imageUsage,
index: 0,
surface: Surface::from_vk_surface(
swapchain_ci.surface,
device.physical_device().instance(),
),
device,
create_info: swapchain_ci.clone(),
swapchain,
raw: true,
}
}
pub fn recreate(&mut self) -> Result<()> {
// wait for the device to get idle
self.device.wait_idle()?;
let surface_caps = self.surface.capabilities(&self.device)?;
let surface_caps = self.surface.capabilities(self.device)?;
let extent = if surface_caps.currentExtent.width == u32::max_value()
|| surface_caps.currentExtent.height == u32::max_value()
@ -198,9 +191,9 @@ impl Swapchain {
}
};
let mut swapchain_ci = self.create_info.lock().unwrap();
let mut swapchain_ci = self.create_info.clone();
swapchain_ci.imageExtent = extent;
swapchain_ci.set_old_swapchain(*self.swapchain.lock().unwrap());
swapchain_ci.set_old_swapchain(self.swapchain);
let swapchain = self.device.create_swapchain(&swapchain_ci)?;
@ -208,24 +201,24 @@ impl Swapchain {
self.destroy();
// replace swapchain
*self.swapchain.lock().unwrap() = swapchain;
self.swapchain = swapchain;
// set new surface size
self.width.store(extent.width, SeqCst);
self.height.store(extent.height, SeqCst);
self.width = extent.width;
self.height = extent.height;
Ok(())
}
pub fn acquire_next_image<'a>(
&self,
pub fn acquire_next_image<'b>(
&mut self,
time_out: u64,
synchro: impl Into<NextImageSynchronization<'a>>,
synchro: impl Into<NextImageSynchronization<'b>>,
) -> Result<OutOfDate<u32>> {
let synchro = synchro.into();
let res = self.device.acquire_next_image(
*self.swapchain.lock().unwrap(),
self.swapchain,
time_out,
match synchro {
NextImageSynchronization::Semaphore(semaphore) => Some(semaphore.vk_handle()),
@ -239,7 +232,7 @@ impl Swapchain {
if let Ok(r) = &res {
if let OutOfDate::Ok(i) = r {
self.index.store(*i, SeqCst);
self.index = *i;
}
}
@ -248,25 +241,24 @@ impl Swapchain {
/// set current
/// only use when externally acquired next index !!!
pub unsafe fn set_image_index(&self, index: u32) {
self.index.store(index, SeqCst);
pub unsafe fn set_image_index(&mut self, index: u32) {
self.index = index;
}
pub fn current_index(&self) -> u32 {
self.index.load(SeqCst)
self.index
}
pub fn vk_images(&self) -> Result<Vec<VkImage>> {
self.device
.swapchain_images(*self.swapchain.lock().unwrap())
self.device.swapchain_images(self.swapchain)
}
pub fn wrap_images(
&self,
images: &[VkImage],
queue: &Arc<Mutex<Queue>>,
queue: &'a 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 +282,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 +291,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();