diff --git a/bindings_generator/src/main.rs b/bindings_generator/src/main.rs index 472778f5..be1e3835 100644 --- a/bindings_generator/src/main.rs +++ b/bindings_generator/src/main.rs @@ -21,6 +21,9 @@ fn main() { .rustified_enum("spv::BuiltIn") .rustified_enum("spv::Decoration") .rustified_enum("spv::ExecutionModel") + .rustified_enum("spv::ImageFormat") + .rustified_enum("spv::Dim") + .rustified_enum("spv::StorageClass") .rustified_enum("ScInternalResult") .rustified_enum("spirv_cross::SPIRType_BaseType") .rustified_enum("spirv_cross::MSLVertexFormat") diff --git a/spirv_cross/src/bindings_native.rs b/spirv_cross/src/bindings_native.rs index 778e118b..bfd77441 100644 --- a/spirv_cross/src/bindings_native.rs +++ b/spirv_cross/src/bindings_native.rs @@ -148,45 +148,72 @@ pub mod root { pub const ExecutionMode_ExecutionModeNumSIMDWorkitemsINTEL: root::spv::ExecutionMode = 5896; pub const ExecutionMode_ExecutionModeMax: root::spv::ExecutionMode = 2147483647; pub type ExecutionMode = u32; - pub const StorageClass_StorageClassUniformConstant: root::spv::StorageClass = 0; - pub const StorageClass_StorageClassInput: root::spv::StorageClass = 1; - pub const StorageClass_StorageClassUniform: root::spv::StorageClass = 2; - pub const StorageClass_StorageClassOutput: root::spv::StorageClass = 3; - pub const StorageClass_StorageClassWorkgroup: root::spv::StorageClass = 4; - pub const StorageClass_StorageClassCrossWorkgroup: root::spv::StorageClass = 5; - pub const StorageClass_StorageClassPrivate: root::spv::StorageClass = 6; - pub const StorageClass_StorageClassFunction: root::spv::StorageClass = 7; - pub const StorageClass_StorageClassGeneric: root::spv::StorageClass = 8; - pub const StorageClass_StorageClassPushConstant: root::spv::StorageClass = 9; - pub const StorageClass_StorageClassAtomicCounter: root::spv::StorageClass = 10; - pub const StorageClass_StorageClassImage: root::spv::StorageClass = 11; - pub const StorageClass_StorageClassStorageBuffer: root::spv::StorageClass = 12; - pub const StorageClass_StorageClassCallableDataKHR: root::spv::StorageClass = 5328; - pub const StorageClass_StorageClassCallableDataNV: root::spv::StorageClass = 5328; - pub const StorageClass_StorageClassIncomingCallableDataKHR: root::spv::StorageClass = 5329; - pub const StorageClass_StorageClassIncomingCallableDataNV: root::spv::StorageClass = 5329; - pub const StorageClass_StorageClassRayPayloadKHR: root::spv::StorageClass = 5338; - pub const StorageClass_StorageClassRayPayloadNV: root::spv::StorageClass = 5338; - pub const StorageClass_StorageClassHitAttributeKHR: root::spv::StorageClass = 5339; - pub const StorageClass_StorageClassHitAttributeNV: root::spv::StorageClass = 5339; - pub const StorageClass_StorageClassIncomingRayPayloadKHR: root::spv::StorageClass = 5342; - pub const StorageClass_StorageClassIncomingRayPayloadNV: root::spv::StorageClass = 5342; - pub const StorageClass_StorageClassShaderRecordBufferKHR: root::spv::StorageClass = 5343; - pub const StorageClass_StorageClassShaderRecordBufferNV: root::spv::StorageClass = 5343; - pub const StorageClass_StorageClassPhysicalStorageBuffer: root::spv::StorageClass = 5349; - pub const StorageClass_StorageClassPhysicalStorageBufferEXT: root::spv::StorageClass = 5349; - pub const StorageClass_StorageClassCodeSectionINTEL: root::spv::StorageClass = 5605; - pub const StorageClass_StorageClassMax: root::spv::StorageClass = 2147483647; - pub type StorageClass = u32; - pub const Dim_Dim1D: root::spv::Dim = 0; - pub const Dim_Dim2D: root::spv::Dim = 1; - pub const Dim_Dim3D: root::spv::Dim = 2; - pub const Dim_DimCube: root::spv::Dim = 3; - pub const Dim_DimRect: root::spv::Dim = 4; - pub const Dim_DimBuffer: root::spv::Dim = 5; - pub const Dim_DimSubpassData: root::spv::Dim = 6; - pub const Dim_DimMax: root::spv::Dim = 2147483647; - pub type Dim = u32; + impl root::spv::StorageClass { + pub const StorageClassCallableDataNV: root::spv::StorageClass = + StorageClass::StorageClassCallableDataKHR; + } + impl root::spv::StorageClass { + pub const StorageClassIncomingCallableDataNV: root::spv::StorageClass = + StorageClass::StorageClassIncomingCallableDataKHR; + } + impl root::spv::StorageClass { + pub const StorageClassRayPayloadNV: root::spv::StorageClass = + StorageClass::StorageClassRayPayloadKHR; + } + impl root::spv::StorageClass { + pub const StorageClassHitAttributeNV: root::spv::StorageClass = + StorageClass::StorageClassHitAttributeKHR; + } + impl root::spv::StorageClass { + pub const StorageClassIncomingRayPayloadNV: root::spv::StorageClass = + StorageClass::StorageClassIncomingRayPayloadKHR; + } + impl root::spv::StorageClass { + pub const StorageClassShaderRecordBufferNV: root::spv::StorageClass = + StorageClass::StorageClassShaderRecordBufferKHR; + } + impl root::spv::StorageClass { + pub const StorageClassPhysicalStorageBufferEXT: root::spv::StorageClass = + StorageClass::StorageClassPhysicalStorageBuffer; + } + #[repr(u32)] + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] + pub enum StorageClass { + StorageClassUniformConstant = 0, + StorageClassInput = 1, + StorageClassUniform = 2, + StorageClassOutput = 3, + StorageClassWorkgroup = 4, + StorageClassCrossWorkgroup = 5, + StorageClassPrivate = 6, + StorageClassFunction = 7, + StorageClassGeneric = 8, + StorageClassPushConstant = 9, + StorageClassAtomicCounter = 10, + StorageClassImage = 11, + StorageClassStorageBuffer = 12, + StorageClassCallableDataKHR = 5328, + StorageClassIncomingCallableDataKHR = 5329, + StorageClassRayPayloadKHR = 5338, + StorageClassHitAttributeKHR = 5339, + StorageClassIncomingRayPayloadKHR = 5342, + StorageClassShaderRecordBufferKHR = 5343, + StorageClassPhysicalStorageBuffer = 5349, + StorageClassCodeSectionINTEL = 5605, + StorageClassMax = 2147483647, + } + #[repr(u32)] + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] + pub enum Dim { + Dim1D = 0, + Dim2D = 1, + Dim3D = 2, + DimCube = 3, + DimRect = 4, + DimBuffer = 5, + DimSubpassData = 6, + DimMax = 2147483647, + } pub const SamplerAddressingMode_SamplerAddressingModeNone: root::spv::SamplerAddressingMode = 0; pub const SamplerAddressingMode_SamplerAddressingModeClampToEdge: @@ -204,50 +231,53 @@ pub mod root { pub const SamplerFilterMode_SamplerFilterModeLinear: root::spv::SamplerFilterMode = 1; pub const SamplerFilterMode_SamplerFilterModeMax: root::spv::SamplerFilterMode = 2147483647; pub type SamplerFilterMode = u32; - pub const ImageFormat_ImageFormatUnknown: root::spv::ImageFormat = 0; - pub const ImageFormat_ImageFormatRgba32f: root::spv::ImageFormat = 1; - pub const ImageFormat_ImageFormatRgba16f: root::spv::ImageFormat = 2; - pub const ImageFormat_ImageFormatR32f: root::spv::ImageFormat = 3; - pub const ImageFormat_ImageFormatRgba8: root::spv::ImageFormat = 4; - pub const ImageFormat_ImageFormatRgba8Snorm: root::spv::ImageFormat = 5; - pub const ImageFormat_ImageFormatRg32f: root::spv::ImageFormat = 6; - pub const ImageFormat_ImageFormatRg16f: root::spv::ImageFormat = 7; - pub const ImageFormat_ImageFormatR11fG11fB10f: root::spv::ImageFormat = 8; - pub const ImageFormat_ImageFormatR16f: root::spv::ImageFormat = 9; - pub const ImageFormat_ImageFormatRgba16: root::spv::ImageFormat = 10; - pub const ImageFormat_ImageFormatRgb10A2: root::spv::ImageFormat = 11; - pub const ImageFormat_ImageFormatRg16: root::spv::ImageFormat = 12; - pub const ImageFormat_ImageFormatRg8: root::spv::ImageFormat = 13; - pub const ImageFormat_ImageFormatR16: root::spv::ImageFormat = 14; - pub const ImageFormat_ImageFormatR8: root::spv::ImageFormat = 15; - pub const ImageFormat_ImageFormatRgba16Snorm: root::spv::ImageFormat = 16; - pub const ImageFormat_ImageFormatRg16Snorm: root::spv::ImageFormat = 17; - pub const ImageFormat_ImageFormatRg8Snorm: root::spv::ImageFormat = 18; - pub const ImageFormat_ImageFormatR16Snorm: root::spv::ImageFormat = 19; - pub const ImageFormat_ImageFormatR8Snorm: root::spv::ImageFormat = 20; - pub const ImageFormat_ImageFormatRgba32i: root::spv::ImageFormat = 21; - pub const ImageFormat_ImageFormatRgba16i: root::spv::ImageFormat = 22; - pub const ImageFormat_ImageFormatRgba8i: root::spv::ImageFormat = 23; - pub const ImageFormat_ImageFormatR32i: root::spv::ImageFormat = 24; - pub const ImageFormat_ImageFormatRg32i: root::spv::ImageFormat = 25; - pub const ImageFormat_ImageFormatRg16i: root::spv::ImageFormat = 26; - pub const ImageFormat_ImageFormatRg8i: root::spv::ImageFormat = 27; - pub const ImageFormat_ImageFormatR16i: root::spv::ImageFormat = 28; - pub const ImageFormat_ImageFormatR8i: root::spv::ImageFormat = 29; - pub const ImageFormat_ImageFormatRgba32ui: root::spv::ImageFormat = 30; - pub const ImageFormat_ImageFormatRgba16ui: root::spv::ImageFormat = 31; - pub const ImageFormat_ImageFormatRgba8ui: root::spv::ImageFormat = 32; - pub const ImageFormat_ImageFormatR32ui: root::spv::ImageFormat = 33; - pub const ImageFormat_ImageFormatRgb10a2ui: root::spv::ImageFormat = 34; - pub const ImageFormat_ImageFormatRg32ui: root::spv::ImageFormat = 35; - pub const ImageFormat_ImageFormatRg16ui: root::spv::ImageFormat = 36; - pub const ImageFormat_ImageFormatRg8ui: root::spv::ImageFormat = 37; - pub const ImageFormat_ImageFormatR16ui: root::spv::ImageFormat = 38; - pub const ImageFormat_ImageFormatR8ui: root::spv::ImageFormat = 39; - pub const ImageFormat_ImageFormatR64ui: root::spv::ImageFormat = 40; - pub const ImageFormat_ImageFormatR64i: root::spv::ImageFormat = 41; - pub const ImageFormat_ImageFormatMax: root::spv::ImageFormat = 2147483647; - pub type ImageFormat = u32; + #[repr(u32)] + #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] + pub enum ImageFormat { + ImageFormatUnknown = 0, + ImageFormatRgba32f = 1, + ImageFormatRgba16f = 2, + ImageFormatR32f = 3, + ImageFormatRgba8 = 4, + ImageFormatRgba8Snorm = 5, + ImageFormatRg32f = 6, + ImageFormatRg16f = 7, + ImageFormatR11fG11fB10f = 8, + ImageFormatR16f = 9, + ImageFormatRgba16 = 10, + ImageFormatRgb10A2 = 11, + ImageFormatRg16 = 12, + ImageFormatRg8 = 13, + ImageFormatR16 = 14, + ImageFormatR8 = 15, + ImageFormatRgba16Snorm = 16, + ImageFormatRg16Snorm = 17, + ImageFormatRg8Snorm = 18, + ImageFormatR16Snorm = 19, + ImageFormatR8Snorm = 20, + ImageFormatRgba32i = 21, + ImageFormatRgba16i = 22, + ImageFormatRgba8i = 23, + ImageFormatR32i = 24, + ImageFormatRg32i = 25, + ImageFormatRg16i = 26, + ImageFormatRg8i = 27, + ImageFormatR16i = 28, + ImageFormatR8i = 29, + ImageFormatRgba32ui = 30, + ImageFormatRgba16ui = 31, + ImageFormatRgba8ui = 32, + ImageFormatR32ui = 33, + ImageFormatRgb10a2ui = 34, + ImageFormatRg32ui = 35, + ImageFormatRg16ui = 36, + ImageFormatRg8ui = 37, + ImageFormatR16ui = 38, + ImageFormatR8ui = 39, + ImageFormatR64ui = 40, + ImageFormatR64i = 41, + ImageFormatMax = 2147483647, + } pub const ImageChannelOrder_ImageChannelOrderR: root::spv::ImageChannelOrder = 0; pub const ImageChannelOrder_ImageChannelOrderA: root::spv::ImageChannelOrder = 1; pub const ImageChannelOrder_ImageChannelOrderRG: root::spv::ImageChannelOrder = 2; @@ -2340,18 +2370,21 @@ pub mod root { pub const Op_OpMax: root::spv::Op = 2147483647; pub type Op = u32; } + pub type __uint8_t = ::std::os::raw::c_uchar; + pub type __int32_t = ::std::os::raw::c_int; + pub type __uint32_t = ::std::os::raw::c_uint; pub mod std { #[allow(unused_imports)] use self::super::super::root; - pub mod __fs { - #[allow(unused_imports)] - use self::super::super::super::root; - } } - pub type __darwin_size_t = ::std::os::raw::c_ulong; + pub mod __gnu_cxx { + #[allow(unused_imports)] + use self::super::super::root; + } pub mod spirv_cross { #[allow(unused_imports)] use self::super::super::root; + pub type TypeID = u32; #[repr(u32)] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SPIRType_BaseType { @@ -2380,6 +2413,18 @@ pub mod root { Interpolant = 22, Char = 23, } + #[repr(C)] + #[derive(Debug, Copy, Clone)] + pub struct SPIRType_ImageType { + pub type_: root::spirv_cross::TypeID, + pub dim: root::spv::Dim, + pub depth: bool, + pub arrayed: bool, + pub ms: bool, + pub sampled: u32, + pub format: root::spv::ImageFormat, + pub access: root::spv::AccessQualifier, + } pub const MSLShaderInputFormat_MSL_SHADER_INPUT_FORMAT_OTHER: root::spirv_cross::MSLShaderInputFormat = 0; pub const MSLShaderInputFormat_MSL_SHADER_INPUT_FORMAT_UINT8: @@ -2700,12 +2745,16 @@ pub mod root { #[derive(Debug, Copy, Clone)] pub struct ScType { pub type_: root::spirv_cross::SPIRType_BaseType, + pub width: u32, pub vecsize: u32, pub columns: u32, pub member_types: *mut u32, pub member_types_size: usize, pub array: *mut u32, + pub array_size_literal: *mut bool, pub array_size: usize, + pub storage: root::spv::StorageClass, + pub image: root::spirv_cross::SPIRType_ImageType, } extern "C" { pub fn sc_internal_get_latest_exception_message( diff --git a/spirv_cross/src/bindings_wasm.rs b/spirv_cross/src/bindings_wasm.rs index 7faa5180..77f937cc 100644 --- a/spirv_cross/src/bindings_wasm.rs +++ b/spirv_cross/src/bindings_wasm.rs @@ -2340,18 +2340,21 @@ pub mod root { pub const Op_OpMax: root::spv::Op = 2147483647; pub type Op = u32; } + pub type __uint8_t = ::std::os::raw::c_uchar; + pub type __int32_t = ::std::os::raw::c_int; + pub type __uint32_t = ::std::os::raw::c_uint; pub mod std { #[allow(unused_imports)] use self::super::super::root; - pub mod __fs { - #[allow(unused_imports)] - use self::super::super::super::root; - } } - pub type __darwin_size_t = ::std::os::raw::c_ulong; + pub mod __gnu_cxx { + #[allow(unused_imports)] + use self::super::super::root; + } pub mod spirv_cross { #[allow(unused_imports)] use self::super::super::root; + pub type TypeID = u32; #[repr(u32)] #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] pub enum SPIRType_BaseType { @@ -2380,6 +2383,18 @@ pub mod root { Interpolant = 22, Char = 23, } + #[repr(C)] + #[derive(Debug, Copy, Clone)] + pub struct SPIRType_ImageType { + pub type_: root::spirv_cross::TypeID, + pub dim: root::spv::Dim, + pub depth: bool, + pub arrayed: bool, + pub ms: bool, + pub sampled: u32, + pub format: root::spv::ImageFormat, + pub access: root::spv::AccessQualifier, + } pub const MSLSamplerCoord_MSL_SAMPLER_COORD_NORMALIZED: root::spirv_cross::MSLSamplerCoord = 0; pub const MSLSamplerCoord_MSL_SAMPLER_COORD_PIXEL: root::spirv_cross::MSLSamplerCoord = 1; @@ -2662,12 +2677,16 @@ pub mod root { #[derive(Debug, Copy, Clone)] pub struct ScType { pub type_: root::spirv_cross::SPIRType_BaseType, + pub width: u32, pub vecsize: u32, pub columns: u32, pub member_types: *mut u32, pub member_types_size: usize, pub array: *mut u32, + pub array_size_literal: *mut bool, pub array_size: usize, + pub storage: root::spv::StorageClass, + pub image: root::spirv_cross::SPIRType_ImageType, } #[repr(C)] #[derive(Debug, Copy, Clone)] diff --git a/spirv_cross/src/compiler.rs b/spirv_cross/src/compiler.rs index a5b95b3e..d2e6420d 100644 --- a/spirv_cross/src/compiler.rs +++ b/spirv_cross/src/compiler.rs @@ -1,5 +1,5 @@ //! Raw compiler bindings for SPIRV-Cross. -use crate::bindings as br; +use crate::{bindings as br, spirv::ImageType}; use crate::ptr_util::{read_from_ptr, read_into_vec_from_ptr, read_string_from_ptr}; use crate::spirv::{self, Decoration, Type}; use crate::ErrorCode; @@ -93,6 +93,89 @@ impl spirv::Decoration { } } +impl spirv::Dim { + fn from_raw(raw: br::spv::Dim) -> Result { + use crate::bindings::root::spv::Dim as D; + use crate::spirv::Dim::*; + match raw { + D::Dim1D => Ok(Dim1D), + D::Dim2D => Ok(Dim2D), + D::Dim3D => Ok(Dim3D), + D::DimCube => Ok(DimCube), + D::DimRect => Ok(DimRect), + D::DimBuffer => Ok(DimBuffer), + D::DimSubpassData => Ok(DimSubpassData), + _ => Err(ErrorCode::Unhandled), + } + } +} + +impl spirv::ImageFormat { + fn from_raw(raw: br::spv::ImageFormat) -> Result { + use crate::bindings::root::spv::ImageFormat as IF; + use crate::spirv::ImageFormat::*; + match raw { + IF::ImageFormatUnknown => Ok(Unknown), + IF::ImageFormatRgba32f => Ok(Rgba32f), + IF::ImageFormatRgba16f => Ok(Rgba16f), + IF::ImageFormatR32f => Ok(R32f), + IF::ImageFormatRgba8 => Ok(Rgba8), + IF::ImageFormatRgba8Snorm => Ok(Rgba8Snorm), + IF::ImageFormatRg32f => Ok(Rg32f), + IF::ImageFormatRg16f => Ok(Rg16f), + IF::ImageFormatR11fG11fB10f => Ok(R11fG11fB10f), + IF::ImageFormatR16f => Ok(R16f), + IF::ImageFormatRgba16 => Ok(Rgba16), + IF::ImageFormatRgb10A2 => Ok(Rgb10A2), + IF::ImageFormatRg16 => Ok(Rg16), + IF::ImageFormatRg8 => Ok(Rg8), + IF::ImageFormatR16 => Ok(R16), + IF::ImageFormatR8 => Ok(R8), + IF::ImageFormatRgba16Snorm => Ok(Rgba16Snorm), + IF::ImageFormatRg16Snorm => Ok(Rg16Snorm), + IF::ImageFormatRg8Snorm => Ok(Rg8Snorm), + IF::ImageFormatR16Snorm => Ok(R16Snorm), + IF::ImageFormatR8Snorm => Ok(R8Snorm), + IF::ImageFormatRgba32i => Ok(Rgba32i), + IF::ImageFormatRgba16i => Ok(Rgba16i), + IF::ImageFormatRgba8i => Ok(Rgba8i), + IF::ImageFormatR32i => Ok(R32i), + IF::ImageFormatRg32i => Ok(Rg32i), + IF::ImageFormatRg16i => Ok(Rg16i), + IF::ImageFormatRg8i => Ok(Rg8i), + IF::ImageFormatR16i => Ok(R16i), + IF::ImageFormatR8i => Ok(R8i), + IF::ImageFormatRgba32ui => Ok(Rgba32ui), + IF::ImageFormatRgba16ui => Ok(Rgba16ui), + IF::ImageFormatRgba8ui => Ok(Rgba8ui), + IF::ImageFormatR32ui => Ok(R32ui), + IF::ImageFormatRgb10a2ui => Ok(Rgb10a2ui), + IF::ImageFormatRg32ui => Ok(Rg32ui), + IF::ImageFormatRg16ui => Ok(Rg16ui), + IF::ImageFormatRg8ui => Ok(Rg8ui), + IF::ImageFormatR16ui => Ok(R16ui), + IF::ImageFormatR8ui => Ok(R8ui), + IF::ImageFormatR64ui => Ok(R64ui), + IF::ImageFormatR64i => Ok(R64i), + _ => Err(ErrorCode::Unhandled), + } + } +} + +impl spirv::ImageType { + pub(crate) fn from_raw(ty: br::spirv_cross::SPIRType_ImageType) -> Result { + Ok(ImageType { + type_id: ty.type_, + dim: spirv::Dim::from_raw(ty.dim)?, + depth: ty.depth, + arrayed: ty.arrayed, + ms: ty.ms, + sampled: ty.sampled, + format: spirv::ImageFormat::from_raw(ty.format)?, + }) + } +} + impl spirv::Type { pub(crate) fn from_raw( ty: br::spirv_cross::SPIRType_BaseType, @@ -100,62 +183,71 @@ impl spirv::Type { columns: u32, member_types: Vec, array: Vec, - ) -> Type { + array_size_literal: Vec, + image: br::spirv_cross::SPIRType_ImageType, + ) -> Result { use crate::bindings::root::spirv_cross::SPIRType_BaseType as B; use crate::spirv::Type::*; - match ty { + Ok(match ty { B::Unknown => Unknown, B::Void => Void, B::Boolean => Boolean { vecsize, columns, array, + array_size_literal, }, - B::Char => Char { array }, + B::Char => Char { array, array_size_literal, }, B::Int => Int { vecsize, columns, array, + array_size_literal, }, B::UInt => UInt { vecsize, columns, array, + array_size_literal, }, - B::Int64 => Int64 { vecsize, array }, - B::UInt64 => UInt64 { vecsize, array }, - B::AtomicCounter => AtomicCounter { array }, + B::Int64 => Int64 { vecsize, array, array_size_literal, }, + B::UInt64 => UInt64 { vecsize, array, array_size_literal, }, + B::AtomicCounter => AtomicCounter { array, array_size_literal, }, B::Half => Half { vecsize, columns, array, + array_size_literal, }, B::Float => Float { vecsize, columns, array, + array_size_literal, }, B::Double => Double { vecsize, columns, array, + array_size_literal, }, B::Struct => Struct { member_types, array, + array_size_literal, }, - B::Image => Image { array }, - B::SampledImage => SampledImage { array }, - B::Sampler => Sampler { array }, - B::SByte => SByte { vecsize, array }, - B::UByte => UByte { vecsize, array }, - B::Short => Short { vecsize, array }, - B::UShort => UShort { vecsize, array }, + B::Image => Image { array, array_size_literal, image: ImageType::from_raw(image)? }, + B::SampledImage => SampledImage { array, array_size_literal, image: ImageType::from_raw(image)? }, + B::Sampler => Sampler { array, array_size_literal }, + B::SByte => SByte { vecsize, array, array_size_literal }, + B::UByte => UByte { vecsize, array, array_size_literal }, + B::Short => Short { vecsize, array, array_size_literal }, + B::UShort => UShort { vecsize, array, array_size_literal }, B::ControlPointArray => ControlPointArray, B::AccelerationStructure => AccelerationStructure, B::RayQuery => RayQuery, B::Interpolant => Interpolant, - } + }) } } @@ -421,7 +513,9 @@ impl Compiler { let raw = read_from_ptr::(type_ptr); let member_types = read_into_vec_from_ptr(raw.member_types, raw.member_types_size); let array = read_into_vec_from_ptr(raw.array, raw.array_size); - let result = Type::from_raw(raw.type_, raw.vecsize, raw.columns, member_types, array); + let array_size_literal = read_into_vec_from_ptr(raw.array_size_literal, raw.array_size); + let image = raw.image; + let result = Type::from_raw(raw.type_, raw.vecsize, raw.columns, member_types, array, array_size_literal, image)?; if raw.member_types_size > 0 { check!(br::sc_internal_free_pointer( diff --git a/spirv_cross/src/spirv.rs b/spirv_cross/src/spirv.rs index 2a13d911..a84189c4 100644 --- a/spirv_cross/src/spirv.rs +++ b/spirv_cross/src/spirv.rs @@ -341,6 +341,74 @@ pub struct ShaderResources { pub separate_samplers: Vec, } +#[derive(Debug, Clone)] +pub enum Dim { + Dim1D = 0, + Dim2D = 1, + Dim3D = 2, + DimCube = 3, + DimRect = 4, + DimBuffer = 5, + DimSubpassData = 6, +} + +#[derive(Debug, Clone)] +pub enum ImageFormat { + Unknown = 0, + Rgba32f = 1, + Rgba16f = 2, + R32f = 3, + Rgba8 = 4, + Rgba8Snorm = 5, + Rg32f = 6, + Rg16f = 7, + R11fG11fB10f = 8, + R16f = 9, + Rgba16 = 10, + Rgb10A2 = 11, + Rg16 = 12, + Rg8 = 13, + R16 = 14, + R8 = 15, + Rgba16Snorm = 16, + Rg16Snorm = 17, + Rg8Snorm = 18, + R16Snorm = 19, + R8Snorm = 20, + Rgba32i = 21, + Rgba16i = 22, + Rgba8i = 23, + R32i = 24, + Rg32i = 25, + Rg16i = 26, + Rg8i = 27, + R16i = 28, + R8i = 29, + Rgba32ui = 30, + Rgba16ui = 31, + Rgba8ui = 32, + R32ui = 33, + Rgb10a2ui = 34, + Rg32ui = 35, + Rg16ui = 36, + Rg8ui = 37, + R16ui = 38, + R8ui = 39, + R64ui = 40, + R64i = 41, +} + +#[derive(Debug, Clone)] +pub struct ImageType { + pub type_id: u32, + pub dim: Dim, + pub depth: bool, + pub arrayed: bool, + pub ms: bool, + pub sampled: u32, + pub format: ImageFormat, +} + #[derive(Debug, Clone)] #[non_exhaustive] pub enum Type { @@ -351,74 +419,94 @@ pub enum Type { vecsize: u32, columns: u32, array: Vec, + array_size_literal: Vec, }, Char { array: Vec, + array_size_literal: Vec, }, Int { vecsize: u32, columns: u32, array: Vec, + array_size_literal: Vec, }, UInt { vecsize: u32, columns: u32, array: Vec, + array_size_literal: Vec, }, Int64 { vecsize: u32, array: Vec, + array_size_literal: Vec, }, UInt64 { vecsize: u32, array: Vec, + array_size_literal: Vec, }, AtomicCounter { array: Vec, + array_size_literal: Vec, }, Half { vecsize: u32, columns: u32, array: Vec, + array_size_literal: Vec, }, Float { vecsize: u32, columns: u32, array: Vec, + array_size_literal: Vec, }, Double { vecsize: u32, columns: u32, array: Vec, + array_size_literal: Vec, }, Struct { member_types: Vec, array: Vec, + array_size_literal: Vec, }, Image { array: Vec, + array_size_literal: Vec, + image: ImageType, }, SampledImage { array: Vec, + array_size_literal: Vec, + image: ImageType, }, Sampler { array: Vec, + array_size_literal: Vec, }, SByte { vecsize: u32, array: Vec, + array_size_literal: Vec, }, UByte { vecsize: u32, array: Vec, + array_size_literal: Vec, }, Short { vecsize: u32, array: Vec, + array_size_literal: Vec, }, UShort { vecsize: u32, array: Vec, + array_size_literal: Vec, }, ControlPointArray, AccelerationStructure, diff --git a/spirv_cross/src/wrapper.cpp b/spirv_cross/src/wrapper.cpp index 8dfa6287..80075d7e 100644 --- a/spirv_cross/src/wrapper.cpp +++ b/spirv_cross/src/wrapper.cpp @@ -412,10 +412,12 @@ extern "C" auto ty = (ScType *)malloc(sizeof(ScType)); ty->type = type.basetype; + ty->width = type.width; ty->vecsize = type.vecsize; ty->columns = type.columns; ty->member_types_size = member_types_size; ty->array_size = array_size; + ty->storage = type.storage; if (member_types_size > 0) { @@ -432,13 +434,21 @@ extern "C" if (array_size > 0) { auto const &array = (uint32_t *)malloc(array_size * sizeof(uint32_t)); + auto const &array_size_literal = (bool *)malloc(array_size * sizeof(bool)); for (size_t i = 0; i < array_size; i++) { array[i] = type.array[i]; + array_size_literal[i] = type.array_size_literal[i]; } ty->array = array; + ty->array_size_literal = array_size_literal; + } + + if (type.basetype == spirv_cross::SPIRType::Image || type.basetype == spirv_cross::SPIRType::SampledImage) + { + ty->image = type.image; } *spirv_type = ty; diff --git a/spirv_cross/src/wrapper.hpp b/spirv_cross/src/wrapper.hpp index fb870e90..c6393f82 100644 --- a/spirv_cross/src/wrapper.hpp +++ b/spirv_cross/src/wrapper.hpp @@ -144,12 +144,16 @@ extern "C" typedef struct ScType { spirv_cross::SPIRType::BaseType type; + uint32_t width; uint32_t vecsize; uint32_t columns; uint32_t *member_types; size_t member_types_size; uint32_t *array; + bool *array_size_literal; size_t array_size; + spv::StorageClass storage; + spirv_cross::SPIRType::ImageType image; } ScType; ScInternalResult sc_internal_get_latest_exception_message(const char **message); diff --git a/spirv_cross/tests/spirv_tests.rs b/spirv_cross/tests/spirv_tests.rs index 5cc151bb..7a0df59c 100644 --- a/spirv_cross/tests/spirv_tests.rs +++ b/spirv_cross/tests/spirv_tests.rs @@ -103,9 +103,11 @@ fn ast_gets_type_member_types_and_array() { spirv::Type::Struct { member_types, array, + array_size_literal } => { assert_eq!(member_types.len(), 2); assert_eq!(array.len(), 0); + assert_eq!(array_size_literal.len(), 0); true } _ => false, @@ -130,11 +132,14 @@ fn ast_gets_array_dimensions() { vecsize, columns, array, + array_size_literal } => { assert_eq!(vecsize, 3); assert_eq!(columns, 1); assert_eq!(array.len(), 1); + assert_eq!(array_size_literal.len(), 1); assert_eq!(array[0], 3); + assert_eq!(array_size_literal[0], true); true } _ => false,