Use impl_reprc macro

vulkan-rs/Cargo.toml

@@ -10,5 +10,4 @@ vulkan-sys = { path = "../vulkan-sys" }
 vma-rs = { path = "../vma-rs" }
 anyhow = { version = "1.0.68", features = ["backtrace"] }
 assetpath = { path = "../assetpath" }
-safer-ffi = { version = "0.0.10", features = ["proc_macros"] }
 utilities = { git = "https://gavania.de/hodasemi/utilities.git" }

vulkan-rs/src/acceleration_structure.rs

@@ -3,6 +3,7 @@ use crate::prelude::*;
 use anyhow::Result;
 
 use cgmath::{Matrix, Matrix4, One};
+use utilities::impl_reprc;
 
 use core::slice;
 use std::{
@@ -10,6 +11,19 @@ use std::{
     sync::{Arc, Mutex},
 };
 
+impl_reprc!(
+    pub struct Transform {
+        #[assume_reprc]
+        m: Matrix4<f32>,
+    }
+);
+
+impl From<Matrix4<f32>> for Transform {
+    fn from(m: Matrix4<f32>) -> Self {
+        Self { m }
+    }
+}
+
 enum AccelerationStructureBuilderData {
     TopLevel(Vec<VkAccelerationStructureInstanceKHR>),
     BottomLevel(Vec<VkAccelerationStructureGeometryKHR>, Vec<u32>),
@@ -59,7 +73,7 @@ impl AccelerationStructureBuilder {
     pub fn add_vertices<T: ReprC + Send + Sync + 'static>(
         mut self,
         vertex_buffer: &Arc<Buffer<T>>,
-        transform: Option<Arc<Buffer<Matrix4<f32>>>>,
+        transform: Option<Arc<Buffer<Transform>>>,
         flags: impl Into<VkGeometryFlagBitsKHR>,
     ) -> Self {
         match &mut self.data {
@@ -261,8 +275,8 @@ pub struct AccelerationStructure {
 
     acceleration_structure: VkAccelerationStructureKHR,
 
-    result_buffer: Arc<Buffer<u8>>,
+    result_buffer: Arc<Buffer<RawBuffer>>,
-    scratch_buffer: Mutex<Arc<Buffer<u8>>>,
+    scratch_buffer: Mutex<Arc<Buffer<RawBuffer>>>,
 
     update_scratch_buffer_size: VkDeviceSize,
 
@@ -289,7 +303,7 @@ impl AccelerationStructure {
         }
     }
 
-    pub fn result_buffer(&self) -> &Arc<Buffer<u8>> {
+    pub fn result_buffer(&self) -> &Arc<Buffer<RawBuffer>> {
         &self.result_buffer
     }
 
@@ -379,7 +393,7 @@ impl AccelerationStructure {
         device: &Arc<Device>,
         size: VkDeviceSize,
         alignment: VkDeviceSize,
-    ) -> Result<Arc<Buffer<u8>>> {
+    ) -> Result<Arc<Buffer<RawBuffer>>> {
         Buffer::builder()
             .set_usage(
                 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,

vulkan-rs/src/image.rs

@@ -143,12 +143,12 @@ impl ImageBuilder {
 
                 Ok(image)
             }
-            ImageBuilderInternalType::NewImage(ref info) => match info.source_type {
+            ImageBuilderInternalType::NewImage(info) => match info.source_type {
                 ImageSourceType::Array(ref array) => {
                     let arc_image = Self::create_from_source(
                         device,
                         queue,
-                        info,
+                        &info,
                         self.sampler,
                         image_view_ci,
                         self.file_name,
@@ -162,13 +162,20 @@ impl ImageBuilder {
                     let arc_image = Self::create_from_source(
                         device,
                         queue,
-                        info,
+                        &info,
                         self.sampler,
                         image_view_ci,
                         self.file_name,
                     )?;
 
-                    Self::optimize_fill(device, queue, raw, &arc_image)?;
+                    Self::optimize_fill(
+                        device,
+                        queue,
+                        &raw.into_iter()
+                            .map(|&d| RawBuffer { d })
+                            .collect::<Vec<RawBuffer>>(),
+                        &arc_image,
+                    )?;
 
                     Ok(arc_image)
                 }
@@ -176,7 +183,7 @@ impl ImageBuilder {
                     let arc_image = Self::create_from_source(
                         device,
                         queue,
-                        info,
+                        &info,
                         self.sampler,
                         image_view_ci,
                         self.file_name,
@@ -421,7 +428,7 @@ impl ImageBuilder {
     fn create_texture(
         device: &Arc<Device>,
         image_ci: &VkImageCreateInfo,
-    ) -> Result<(VkImage, Arc<Memory<u8>>)> {
+    ) -> Result<(VkImage, Arc<Memory<RawBuffer>>)> {
         let image = Self::create_image(device, image_ci)?;
         let memory = Memory::image_memory(
             device,
@@ -439,7 +446,7 @@ impl ImageBuilder {
     fn optimize_fill(
         device: &Arc<Device>,
         queue: &Arc<Mutex<Queue>>,
-        data: &[u8],
+        data: &[RawBuffer],
         image: &Arc<Image>,
     ) -> Result<()> {
         let staging_buffer = Buffer::builder()
@@ -476,7 +483,7 @@ pub struct Image {
     image_view: VkImageView,
 
     // optional handles
-    _memory: Option<Arc<Memory<u8>>>,
+    _memory: Option<Arc<Memory<RawBuffer>>>,
     sampler: Option<Arc<Sampler>>,
 
     // image information
@@ -792,7 +799,7 @@ impl Image {
         let image = image::RgbaImage::from_raw(
             self.width,
             self.height,
-            memory.iter().map(|&v| v).collect(),
+            memory.iter().map(|&v| v.d).collect(),
         )
         .ok_or(anyhow::anyhow!(
             "failed to create image from raw while saving to file: {:?}",
@@ -804,7 +811,7 @@ impl Image {
         Ok(())
     }
 
-    fn copy_image_to_buffer(self: &Arc<Image>) -> Result<Arc<Buffer<u8>>> {
+    fn copy_image_to_buffer(self: &Arc<Image>) -> Result<Arc<Buffer<RawBuffer>>> {
         let buffer = Buffer::builder()
             .set_usage(VK_BUFFER_USAGE_TRANSFER_DST_BIT)
             .set_memory_usage(MemoryUsage::GpuToCpu)

vulkan-rs/src/memory.rs

@@ -2,11 +2,20 @@ use crate::prelude::*;
 
 use anyhow::Result;
 
+use utilities::impl_reprc;
 use vma_rs::prelude::*;
 
 use std::marker::PhantomData;
 use std::sync::Arc;
 
+impl_reprc!(
+    #[derive(Debug, Copy)]
+    pub struct RawBuffer {
+        #[assume_reprc]
+        d: u8,
+    }
+);
+
 #[derive(Debug, Clone, PartialEq, Hash, Eq)]
 pub enum MemoryUsage {
     GpuOnly,

vulkan-rs/src/pipelines/shader_binding_table.rs

@@ -15,7 +15,7 @@ pub(crate) struct ShaderBindingTableBuilder {
 }
 
 pub struct ShaderBindingTable {
-    _sbt_buffer: Arc<Buffer<u8>>,
+    _sbt_buffer: Arc<Buffer<RawBuffer>>,
 
     raygen_shader_binding_table: VkStridedDeviceAddressRegionKHR,
     miss_shader_binding_table: VkStridedDeviceAddressRegionKHR,
@@ -41,7 +41,7 @@ impl ShaderBindingTable {
     }
 
     fn create(
-        sbt_buffer: Arc<Buffer<u8>>,
+        sbt_buffer: Arc<Buffer<RawBuffer>>,
         ray_gen_entry_size: VkDeviceSize,
         ray_gen_entry_count: VkDeviceSize,
         miss_offset: VkDeviceSize,
@@ -201,7 +201,13 @@ impl ShaderBindingTableBuilder {
                     | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
             )
             .set_memory_usage(MemoryUsage::CpuToGpu)
-            .set_data(&sbt_data)
+            .set_data(
+                sbt_data
+                    .into_iter()
+                    .map(|u| RawBuffer { d: u })
+                    .collect::<Vec<RawBuffer>>()
+                    .as_slice(),
+            )
             .build(device.clone())?;
 
         Ok(ShaderBindingTable::create(

vulkan-rs/src/prelude.rs

@@ -13,7 +13,7 @@ pub use super::fence::Fence;
 pub use super::framebuffer::{Framebuffer, FramebufferBuilder};
 pub use super::image::*;
 pub use super::instance::*;
-pub use super::memory::{Memory, MemoryUsage};
+pub use super::memory::{Memory, MemoryUsage, RawBuffer};
 pub use super::physicaldevice::PhysicalDevice;
 pub use super::pipeline::Pipeline;
 pub use super::pipelinecache::PipelineCache;
@@ -46,10 +46,9 @@ pub use super::{OutOfDate, VkHandle, VulkanDevice};
 pub use image;
 pub use utilities::prelude::cgmath;
 pub use utilities::prelude::cgmath::prelude::*;
+pub use utilities::prelude::*;
 pub use vulkan_sys::prelude::*;
 
 pub use super::render_target::{sub_pass::*, *};
 
 pub use super::single_submit::SingleSubmit;
-
-pub use safer_ffi::prelude::*;

vulkan-rs/src/shadermodule.rs

@@ -51,7 +51,7 @@ impl Default for ShaderType {
     }
 }
 
-pub trait VertexInputDescription: ReprC {
+pub trait VertexInputDescription: ReprC + Sized {
     fn bindings() -> Vec<VkVertexInputBindingDescription> {
         vec![VkVertexInputBindingDescription {
             binding: 0,

vulkan-sys/Cargo.toml

@@ -9,4 +9,4 @@ library_loader = { path = "../library_loader" }
 paste = "1.0.11"
 shared_library = "0.1.9"
 anyhow = { version = "1.0.68", features = ["backtrace"] }
-safer-ffi = { version = "0.0.10", features = ["proc_macros"] }
+utilities = { git = "https://gavania.de/hodasemi/utilities.git" }

vulkan-sys/src/structs/khr/ray_tracing/acceleration_structure_instance.rs

@@ -1,16 +1,19 @@
 use crate::prelude::*;
-use safer_ffi::prelude::*;
 use std::fmt;
+use utilities::{impl_reprc, prelude::*};
 
-#[derive_ReprC]
+impl_reprc!(
-#[repr(C)]
+    #[derive(Copy, PartialEq)]
-#[derive(Copy, Clone, PartialEq)]
+    pub struct VkAccelerationStructureInstanceKHR {
-pub struct VkAccelerationStructureInstanceKHR {
+        transform: VkTransformMatrixKHR,
-    pub transform: VkTransformMatrixKHR,
+        #[assume_reprc]
-    instance_id_mask: u32,
+        instance_id_mask: u32,
-    instance_offset_flags: u32,
+        #[assume_reprc]
-    pub accelerationStructureReference: u64,
+        instance_offset_flags: u32,
-}
+        #[assume_reprc]
+        accelerationStructureReference: u64,
+    }
+);
 
 impl VkAccelerationStructureInstanceKHR {
     pub fn new(

vulkan-sys/src/structs/khr/ray_tracing/transform_matrix.rs

@@ -1,12 +1,12 @@
-use safer_ffi::prelude::*;
+use utilities::{impl_reprc, prelude::*};
 
-
+impl_reprc!(
-#[derive_ReprC]
+    #[derive(Debug, Copy, PartialEq)]
-#[repr(C)]
+    pub struct VkTransformMatrixKHR {
-#[derive(Debug, Copy, Clone, PartialEq)]
+        #[assume_reprc]
-pub struct VkTransformMatrixKHR {
+        matrix: [[f32; 4]; 3],
-    matrix: [[f32; 4]; 3],
+    }
-}
+);
 
 impl From<[[f32; 4]; 4]> for VkTransformMatrixKHR {
     fn from(matrix: [[f32; 4]; 4]) -> Self {