4081 lines
179 KiB
Rust
4081 lines
179 KiB
Rust
// AUTOMATICALLY GENERATED from the SPIR-V JSON grammar:
|
|
// external/spirv.core.grammar.json.
|
|
// DO NOT MODIFY!
|
|
|
|
pub type Word = u32;
|
|
pub const MAGIC_NUMBER: u32 = 0x07230203;
|
|
pub const MAJOR_VERSION: u8 = 1u8;
|
|
pub const MINOR_VERSION: u8 = 6u8;
|
|
pub const REVISION: u8 = 1u8;
|
|
bitflags! { # [doc = "SPIR-V operand kind: [ImageOperands](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_image_operands_a_image_operands)"] # [derive (Clone , Copy , Debug , PartialEq , Eq , Hash)] # [cfg_attr (feature = "serialize" , derive (serde :: Serialize))] # [cfg_attr (feature = "deserialize" , derive (serde :: Deserialize))] pub struct ImageOperands : u32 { const NONE = 0u32 ; const BIAS = 1u32 ; const LOD = 2u32 ; const GRAD = 4u32 ; const CONST_OFFSET = 8u32 ; const OFFSET = 16u32 ; const CONST_OFFSETS = 32u32 ; const SAMPLE = 64u32 ; const MIN_LOD = 128u32 ; const MAKE_TEXEL_AVAILABLE = 256u32 ; const MAKE_TEXEL_AVAILABLE_KHR = 256u32 ; const MAKE_TEXEL_VISIBLE = 512u32 ; const MAKE_TEXEL_VISIBLE_KHR = 512u32 ; const NON_PRIVATE_TEXEL = 1024u32 ; const NON_PRIVATE_TEXEL_KHR = 1024u32 ; const VOLATILE_TEXEL = 2048u32 ; const VOLATILE_TEXEL_KHR = 2048u32 ; const SIGN_EXTEND = 4096u32 ; const ZERO_EXTEND = 8192u32 ; const NONTEMPORAL = 16384u32 ; const OFFSETS = 65536u32 ; } }
|
|
bitflags! { # [doc = "SPIR-V operand kind: [FPFastMathMode](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_fp_fast_math_mode_a_fp_fast_math_mode)"] # [derive (Clone , Copy , Debug , PartialEq , Eq , Hash)] # [cfg_attr (feature = "serialize" , derive (serde :: Serialize))] # [cfg_attr (feature = "deserialize" , derive (serde :: Deserialize))] pub struct FPFastMathMode : u32 { const NONE = 0u32 ; const NOT_NAN = 1u32 ; const NOT_INF = 2u32 ; const NSZ = 4u32 ; const ALLOW_RECIP = 8u32 ; const FAST = 16u32 ; const ALLOW_CONTRACT_FAST_INTEL = 65536u32 ; const ALLOW_REASSOC_INTEL = 131072u32 ; } }
|
|
bitflags! { # [doc = "SPIR-V operand kind: [SelectionControl](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_selection_control_a_selection_control)"] # [derive (Clone , Copy , Debug , PartialEq , Eq , Hash)] # [cfg_attr (feature = "serialize" , derive (serde :: Serialize))] # [cfg_attr (feature = "deserialize" , derive (serde :: Deserialize))] pub struct SelectionControl : u32 { const NONE = 0u32 ; const FLATTEN = 1u32 ; const DONT_FLATTEN = 2u32 ; } }
|
|
bitflags! { # [doc = "SPIR-V operand kind: [LoopControl](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_loop_control_a_loop_control)"] # [derive (Clone , Copy , Debug , PartialEq , Eq , Hash)] # [cfg_attr (feature = "serialize" , derive (serde :: Serialize))] # [cfg_attr (feature = "deserialize" , derive (serde :: Deserialize))] pub struct LoopControl : u32 { const NONE = 0u32 ; const UNROLL = 1u32 ; const DONT_UNROLL = 2u32 ; const DEPENDENCY_INFINITE = 4u32 ; const DEPENDENCY_LENGTH = 8u32 ; const MIN_ITERATIONS = 16u32 ; const MAX_ITERATIONS = 32u32 ; const ITERATION_MULTIPLE = 64u32 ; const PEEL_COUNT = 128u32 ; const PARTIAL_COUNT = 256u32 ; const INITIATION_INTERVAL_INTEL = 65536u32 ; const MAX_CONCURRENCY_INTEL = 131072u32 ; const DEPENDENCY_ARRAY_INTEL = 262144u32 ; const PIPELINE_ENABLE_INTEL = 524288u32 ; const LOOP_COALESCE_INTEL = 1048576u32 ; const MAX_INTERLEAVING_INTEL = 2097152u32 ; const SPECULATED_ITERATIONS_INTEL = 4194304u32 ; const NO_FUSION_INTEL = 8388608u32 ; const LOOP_COUNT_INTEL = 16777216u32 ; const MAX_REINVOCATION_DELAY_INTEL = 33554432u32 ; } }
|
|
bitflags! { # [doc = "SPIR-V operand kind: [FunctionControl](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_function_control_a_function_control)"] # [derive (Clone , Copy , Debug , PartialEq , Eq , Hash)] # [cfg_attr (feature = "serialize" , derive (serde :: Serialize))] # [cfg_attr (feature = "deserialize" , derive (serde :: Deserialize))] pub struct FunctionControl : u32 { const NONE = 0u32 ; const INLINE = 1u32 ; const DONT_INLINE = 2u32 ; const PURE = 4u32 ; const CONST = 8u32 ; const OPT_NONE_INTEL = 65536u32 ; } }
|
|
bitflags! { # [doc = "SPIR-V operand kind: [MemorySemantics](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_memory_semantics_a_memory_semantics)"] # [derive (Clone , Copy , Debug , PartialEq , Eq , Hash)] # [cfg_attr (feature = "serialize" , derive (serde :: Serialize))] # [cfg_attr (feature = "deserialize" , derive (serde :: Deserialize))] pub struct MemorySemantics : u32 { const RELAXED = 0u32 ; const NONE = 0u32 ; const ACQUIRE = 2u32 ; const RELEASE = 4u32 ; const ACQUIRE_RELEASE = 8u32 ; const SEQUENTIALLY_CONSISTENT = 16u32 ; const UNIFORM_MEMORY = 64u32 ; const SUBGROUP_MEMORY = 128u32 ; const WORKGROUP_MEMORY = 256u32 ; const CROSS_WORKGROUP_MEMORY = 512u32 ; const ATOMIC_COUNTER_MEMORY = 1024u32 ; const IMAGE_MEMORY = 2048u32 ; const OUTPUT_MEMORY = 4096u32 ; const OUTPUT_MEMORY_KHR = 4096u32 ; const MAKE_AVAILABLE = 8192u32 ; const MAKE_AVAILABLE_KHR = 8192u32 ; const MAKE_VISIBLE = 16384u32 ; const MAKE_VISIBLE_KHR = 16384u32 ; const VOLATILE = 32768u32 ; } }
|
|
bitflags! { # [doc = "SPIR-V operand kind: [MemoryAccess](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_memory_access_a_memory_access)"] # [derive (Clone , Copy , Debug , PartialEq , Eq , Hash)] # [cfg_attr (feature = "serialize" , derive (serde :: Serialize))] # [cfg_attr (feature = "deserialize" , derive (serde :: Deserialize))] pub struct MemoryAccess : u32 { const NONE = 0u32 ; const VOLATILE = 1u32 ; const ALIGNED = 2u32 ; const NONTEMPORAL = 4u32 ; const MAKE_POINTER_AVAILABLE = 8u32 ; const MAKE_POINTER_AVAILABLE_KHR = 8u32 ; const MAKE_POINTER_VISIBLE = 16u32 ; const MAKE_POINTER_VISIBLE_KHR = 16u32 ; const NON_PRIVATE_POINTER = 32u32 ; const NON_PRIVATE_POINTER_KHR = 32u32 ; const ALIAS_SCOPE_INTEL_MASK = 65536u32 ; const NO_ALIAS_INTEL_MASK = 131072u32 ; } }
|
|
bitflags! { # [doc = "SPIR-V operand kind: [KernelProfilingInfo](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_kernel_profiling_info_a_kernel_profiling_info)"] # [derive (Clone , Copy , Debug , PartialEq , Eq , Hash)] # [cfg_attr (feature = "serialize" , derive (serde :: Serialize))] # [cfg_attr (feature = "deserialize" , derive (serde :: Deserialize))] pub struct KernelProfilingInfo : u32 { const NONE = 0u32 ; const CMD_EXEC_TIME = 1u32 ; } }
|
|
bitflags! { # [doc = "SPIR-V operand kind: [RayFlags](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_ray_flags_a_ray_flags)"] # [derive (Clone , Copy , Debug , PartialEq , Eq , Hash)] # [cfg_attr (feature = "serialize" , derive (serde :: Serialize))] # [cfg_attr (feature = "deserialize" , derive (serde :: Deserialize))] pub struct RayFlags : u32 { const NONE_KHR = 0u32 ; const OPAQUE_KHR = 1u32 ; const NO_OPAQUE_KHR = 2u32 ; const TERMINATE_ON_FIRST_HIT_KHR = 4u32 ; const SKIP_CLOSEST_HIT_SHADER_KHR = 8u32 ; const CULL_BACK_FACING_TRIANGLES_KHR = 16u32 ; const CULL_FRONT_FACING_TRIANGLES_KHR = 32u32 ; const CULL_OPAQUE_KHR = 64u32 ; const CULL_NO_OPAQUE_KHR = 128u32 ; const SKIP_TRIANGLES_KHR = 256u32 ; const SKIP_AAB_BS_KHR = 512u32 ; const FORCE_OPACITY_MICROMAP2_STATE_EXT = 1024u32 ; } }
|
|
bitflags! { # [doc = "SPIR-V operand kind: [FragmentShadingRate](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_fragment_shading_rate_a_fragment_shading_rate)"] # [derive (Clone , Copy , Debug , PartialEq , Eq , Hash)] # [cfg_attr (feature = "serialize" , derive (serde :: Serialize))] # [cfg_attr (feature = "deserialize" , derive (serde :: Deserialize))] pub struct FragmentShadingRate : u32 { const VERTICAL2_PIXELS = 1u32 ; const VERTICAL4_PIXELS = 2u32 ; const HORIZONTAL2_PIXELS = 4u32 ; const HORIZONTAL4_PIXELS = 8u32 ; } }
|
|
#[doc = "SPIR-V operand kind: [SourceLanguage](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_source_language_a_source_language)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum SourceLanguage {
|
|
Unknown = 0u32,
|
|
ESSL = 1u32,
|
|
GLSL = 2u32,
|
|
OpenCL_C = 3u32,
|
|
OpenCL_CPP = 4u32,
|
|
HLSL = 5u32,
|
|
CPP_for_OpenCL = 6u32,
|
|
SYCL = 7u32,
|
|
HERO_C = 8u32,
|
|
NZSL = 9u32,
|
|
WGSL = 10u32,
|
|
Slang = 11u32,
|
|
}
|
|
impl SourceLanguage {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=11u32 => unsafe { core::mem::transmute::<u32, SourceLanguage>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl SourceLanguage {}
|
|
impl core::str::FromStr for SourceLanguage {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Unknown" => Ok(Self::Unknown),
|
|
"ESSL" => Ok(Self::ESSL),
|
|
"GLSL" => Ok(Self::GLSL),
|
|
"OpenCL_C" => Ok(Self::OpenCL_C),
|
|
"OpenCL_CPP" => Ok(Self::OpenCL_CPP),
|
|
"HLSL" => Ok(Self::HLSL),
|
|
"CPP_for_OpenCL" => Ok(Self::CPP_for_OpenCL),
|
|
"SYCL" => Ok(Self::SYCL),
|
|
"HERO_C" => Ok(Self::HERO_C),
|
|
"NZSL" => Ok(Self::NZSL),
|
|
"WGSL" => Ok(Self::WGSL),
|
|
"Slang" => Ok(Self::Slang),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [ExecutionModel](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_execution_model_a_execution_model)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum ExecutionModel {
|
|
Vertex = 0u32,
|
|
TessellationControl = 1u32,
|
|
TessellationEvaluation = 2u32,
|
|
Geometry = 3u32,
|
|
Fragment = 4u32,
|
|
GLCompute = 5u32,
|
|
Kernel = 6u32,
|
|
TaskNV = 5267u32,
|
|
MeshNV = 5268u32,
|
|
RayGenerationNV = 5313u32,
|
|
IntersectionNV = 5314u32,
|
|
AnyHitNV = 5315u32,
|
|
ClosestHitNV = 5316u32,
|
|
MissNV = 5317u32,
|
|
CallableNV = 5318u32,
|
|
TaskEXT = 5364u32,
|
|
MeshEXT = 5365u32,
|
|
}
|
|
impl ExecutionModel {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=6u32 => unsafe { core::mem::transmute::<u32, ExecutionModel>(n) },
|
|
5267u32..=5268u32 => unsafe { core::mem::transmute::<u32, ExecutionModel>(n) },
|
|
5313u32..=5318u32 => unsafe { core::mem::transmute::<u32, ExecutionModel>(n) },
|
|
5364u32..=5365u32 => unsafe { core::mem::transmute::<u32, ExecutionModel>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl ExecutionModel {
|
|
pub const RayGenerationKHR: Self = Self::RayGenerationNV;
|
|
pub const IntersectionKHR: Self = Self::IntersectionNV;
|
|
pub const AnyHitKHR: Self = Self::AnyHitNV;
|
|
pub const ClosestHitKHR: Self = Self::ClosestHitNV;
|
|
pub const MissKHR: Self = Self::MissNV;
|
|
pub const CallableKHR: Self = Self::CallableNV;
|
|
}
|
|
impl core::str::FromStr for ExecutionModel {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Vertex" => Ok(Self::Vertex),
|
|
"TessellationControl" => Ok(Self::TessellationControl),
|
|
"TessellationEvaluation" => Ok(Self::TessellationEvaluation),
|
|
"Geometry" => Ok(Self::Geometry),
|
|
"Fragment" => Ok(Self::Fragment),
|
|
"GLCompute" => Ok(Self::GLCompute),
|
|
"Kernel" => Ok(Self::Kernel),
|
|
"TaskNV" => Ok(Self::TaskNV),
|
|
"MeshNV" => Ok(Self::MeshNV),
|
|
"RayGenerationNV" => Ok(Self::RayGenerationNV),
|
|
"RayGenerationKHR" => Ok(Self::RayGenerationNV),
|
|
"IntersectionNV" => Ok(Self::IntersectionNV),
|
|
"IntersectionKHR" => Ok(Self::IntersectionNV),
|
|
"AnyHitNV" => Ok(Self::AnyHitNV),
|
|
"AnyHitKHR" => Ok(Self::AnyHitNV),
|
|
"ClosestHitNV" => Ok(Self::ClosestHitNV),
|
|
"ClosestHitKHR" => Ok(Self::ClosestHitNV),
|
|
"MissNV" => Ok(Self::MissNV),
|
|
"MissKHR" => Ok(Self::MissNV),
|
|
"CallableNV" => Ok(Self::CallableNV),
|
|
"CallableKHR" => Ok(Self::CallableNV),
|
|
"TaskEXT" => Ok(Self::TaskEXT),
|
|
"MeshEXT" => Ok(Self::MeshEXT),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [AddressingModel](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_addressing_model_a_addressing_model)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum AddressingModel {
|
|
Logical = 0u32,
|
|
Physical32 = 1u32,
|
|
Physical64 = 2u32,
|
|
PhysicalStorageBuffer64 = 5348u32,
|
|
}
|
|
impl AddressingModel {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=2u32 => unsafe { core::mem::transmute::<u32, AddressingModel>(n) },
|
|
5348u32 => unsafe { core::mem::transmute::<u32, AddressingModel>(5348u32) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl AddressingModel {
|
|
pub const PhysicalStorageBuffer64EXT: Self = Self::PhysicalStorageBuffer64;
|
|
}
|
|
impl core::str::FromStr for AddressingModel {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Logical" => Ok(Self::Logical),
|
|
"Physical32" => Ok(Self::Physical32),
|
|
"Physical64" => Ok(Self::Physical64),
|
|
"PhysicalStorageBuffer64" => Ok(Self::PhysicalStorageBuffer64),
|
|
"PhysicalStorageBuffer64EXT" => Ok(Self::PhysicalStorageBuffer64),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [MemoryModel](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_memory_model_a_memory_model)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum MemoryModel {
|
|
Simple = 0u32,
|
|
GLSL450 = 1u32,
|
|
OpenCL = 2u32,
|
|
Vulkan = 3u32,
|
|
}
|
|
impl MemoryModel {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=3u32 => unsafe { core::mem::transmute::<u32, MemoryModel>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl MemoryModel {
|
|
pub const VulkanKHR: Self = Self::Vulkan;
|
|
}
|
|
impl core::str::FromStr for MemoryModel {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Simple" => Ok(Self::Simple),
|
|
"GLSL450" => Ok(Self::GLSL450),
|
|
"OpenCL" => Ok(Self::OpenCL),
|
|
"Vulkan" => Ok(Self::Vulkan),
|
|
"VulkanKHR" => Ok(Self::Vulkan),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [ExecutionMode](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_execution_mode_a_execution_mode)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum ExecutionMode {
|
|
Invocations = 0u32,
|
|
SpacingEqual = 1u32,
|
|
SpacingFractionalEven = 2u32,
|
|
SpacingFractionalOdd = 3u32,
|
|
VertexOrderCw = 4u32,
|
|
VertexOrderCcw = 5u32,
|
|
PixelCenterInteger = 6u32,
|
|
OriginUpperLeft = 7u32,
|
|
OriginLowerLeft = 8u32,
|
|
EarlyFragmentTests = 9u32,
|
|
PointMode = 10u32,
|
|
Xfb = 11u32,
|
|
DepthReplacing = 12u32,
|
|
DepthGreater = 14u32,
|
|
DepthLess = 15u32,
|
|
DepthUnchanged = 16u32,
|
|
LocalSize = 17u32,
|
|
LocalSizeHint = 18u32,
|
|
InputPoints = 19u32,
|
|
InputLines = 20u32,
|
|
InputLinesAdjacency = 21u32,
|
|
Triangles = 22u32,
|
|
InputTrianglesAdjacency = 23u32,
|
|
Quads = 24u32,
|
|
Isolines = 25u32,
|
|
OutputVertices = 26u32,
|
|
OutputPoints = 27u32,
|
|
OutputLineStrip = 28u32,
|
|
OutputTriangleStrip = 29u32,
|
|
VecTypeHint = 30u32,
|
|
ContractionOff = 31u32,
|
|
Initializer = 33u32,
|
|
Finalizer = 34u32,
|
|
SubgroupSize = 35u32,
|
|
SubgroupsPerWorkgroup = 36u32,
|
|
SubgroupsPerWorkgroupId = 37u32,
|
|
LocalSizeId = 38u32,
|
|
LocalSizeHintId = 39u32,
|
|
NonCoherentColorAttachmentReadEXT = 4169u32,
|
|
NonCoherentDepthAttachmentReadEXT = 4170u32,
|
|
NonCoherentStencilAttachmentReadEXT = 4171u32,
|
|
SubgroupUniformControlFlowKHR = 4421u32,
|
|
PostDepthCoverage = 4446u32,
|
|
DenormPreserve = 4459u32,
|
|
DenormFlushToZero = 4460u32,
|
|
SignedZeroInfNanPreserve = 4461u32,
|
|
RoundingModeRTE = 4462u32,
|
|
RoundingModeRTZ = 4463u32,
|
|
EarlyAndLateFragmentTestsAMD = 5017u32,
|
|
StencilRefReplacingEXT = 5027u32,
|
|
CoalescingAMDX = 5069u32,
|
|
MaxNodeRecursionAMDX = 5071u32,
|
|
StaticNumWorkgroupsAMDX = 5072u32,
|
|
ShaderIndexAMDX = 5073u32,
|
|
MaxNumWorkgroupsAMDX = 5077u32,
|
|
StencilRefUnchangedFrontAMD = 5079u32,
|
|
StencilRefGreaterFrontAMD = 5080u32,
|
|
StencilRefLessFrontAMD = 5081u32,
|
|
StencilRefUnchangedBackAMD = 5082u32,
|
|
StencilRefGreaterBackAMD = 5083u32,
|
|
StencilRefLessBackAMD = 5084u32,
|
|
OutputLinesNV = 5269u32,
|
|
OutputPrimitivesNV = 5270u32,
|
|
DerivativeGroupQuadsNV = 5289u32,
|
|
DerivativeGroupLinearNV = 5290u32,
|
|
OutputTrianglesNV = 5298u32,
|
|
PixelInterlockOrderedEXT = 5366u32,
|
|
PixelInterlockUnorderedEXT = 5367u32,
|
|
SampleInterlockOrderedEXT = 5368u32,
|
|
SampleInterlockUnorderedEXT = 5369u32,
|
|
ShadingRateInterlockOrderedEXT = 5370u32,
|
|
ShadingRateInterlockUnorderedEXT = 5371u32,
|
|
SharedLocalMemorySizeINTEL = 5618u32,
|
|
RoundingModeRTPINTEL = 5620u32,
|
|
RoundingModeRTNINTEL = 5621u32,
|
|
FloatingPointModeALTINTEL = 5622u32,
|
|
FloatingPointModeIEEEINTEL = 5623u32,
|
|
MaxWorkgroupSizeINTEL = 5893u32,
|
|
MaxWorkDimINTEL = 5894u32,
|
|
NoGlobalOffsetINTEL = 5895u32,
|
|
NumSIMDWorkitemsINTEL = 5896u32,
|
|
SchedulerTargetFmaxMhzINTEL = 5903u32,
|
|
StreamingInterfaceINTEL = 6154u32,
|
|
RegisterMapInterfaceINTEL = 6160u32,
|
|
NamedBarrierCountINTEL = 6417u32,
|
|
}
|
|
impl ExecutionMode {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=12u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
14u32..=31u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
33u32..=39u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
4169u32..=4171u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
4421u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(4421u32) },
|
|
4446u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(4446u32) },
|
|
4459u32..=4463u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
5017u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5017u32) },
|
|
5027u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5027u32) },
|
|
5069u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5069u32) },
|
|
5071u32..=5073u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
5077u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5077u32) },
|
|
5079u32..=5084u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
5269u32..=5270u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
5289u32..=5290u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
5298u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5298u32) },
|
|
5366u32..=5371u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
5618u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5618u32) },
|
|
5620u32..=5623u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
5893u32..=5896u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
|
|
5903u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5903u32) },
|
|
6154u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(6154u32) },
|
|
6160u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(6160u32) },
|
|
6417u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(6417u32) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl ExecutionMode {
|
|
pub const OutputLinesEXT: Self = Self::OutputLinesNV;
|
|
pub const OutputPrimitivesEXT: Self = Self::OutputPrimitivesNV;
|
|
pub const OutputTrianglesEXT: Self = Self::OutputTrianglesNV;
|
|
}
|
|
impl core::str::FromStr for ExecutionMode {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Invocations" => Ok(Self::Invocations),
|
|
"SpacingEqual" => Ok(Self::SpacingEqual),
|
|
"SpacingFractionalEven" => Ok(Self::SpacingFractionalEven),
|
|
"SpacingFractionalOdd" => Ok(Self::SpacingFractionalOdd),
|
|
"VertexOrderCw" => Ok(Self::VertexOrderCw),
|
|
"VertexOrderCcw" => Ok(Self::VertexOrderCcw),
|
|
"PixelCenterInteger" => Ok(Self::PixelCenterInteger),
|
|
"OriginUpperLeft" => Ok(Self::OriginUpperLeft),
|
|
"OriginLowerLeft" => Ok(Self::OriginLowerLeft),
|
|
"EarlyFragmentTests" => Ok(Self::EarlyFragmentTests),
|
|
"PointMode" => Ok(Self::PointMode),
|
|
"Xfb" => Ok(Self::Xfb),
|
|
"DepthReplacing" => Ok(Self::DepthReplacing),
|
|
"DepthGreater" => Ok(Self::DepthGreater),
|
|
"DepthLess" => Ok(Self::DepthLess),
|
|
"DepthUnchanged" => Ok(Self::DepthUnchanged),
|
|
"LocalSize" => Ok(Self::LocalSize),
|
|
"LocalSizeHint" => Ok(Self::LocalSizeHint),
|
|
"InputPoints" => Ok(Self::InputPoints),
|
|
"InputLines" => Ok(Self::InputLines),
|
|
"InputLinesAdjacency" => Ok(Self::InputLinesAdjacency),
|
|
"Triangles" => Ok(Self::Triangles),
|
|
"InputTrianglesAdjacency" => Ok(Self::InputTrianglesAdjacency),
|
|
"Quads" => Ok(Self::Quads),
|
|
"Isolines" => Ok(Self::Isolines),
|
|
"OutputVertices" => Ok(Self::OutputVertices),
|
|
"OutputPoints" => Ok(Self::OutputPoints),
|
|
"OutputLineStrip" => Ok(Self::OutputLineStrip),
|
|
"OutputTriangleStrip" => Ok(Self::OutputTriangleStrip),
|
|
"VecTypeHint" => Ok(Self::VecTypeHint),
|
|
"ContractionOff" => Ok(Self::ContractionOff),
|
|
"Initializer" => Ok(Self::Initializer),
|
|
"Finalizer" => Ok(Self::Finalizer),
|
|
"SubgroupSize" => Ok(Self::SubgroupSize),
|
|
"SubgroupsPerWorkgroup" => Ok(Self::SubgroupsPerWorkgroup),
|
|
"SubgroupsPerWorkgroupId" => Ok(Self::SubgroupsPerWorkgroupId),
|
|
"LocalSizeId" => Ok(Self::LocalSizeId),
|
|
"LocalSizeHintId" => Ok(Self::LocalSizeHintId),
|
|
"NonCoherentColorAttachmentReadEXT" => Ok(Self::NonCoherentColorAttachmentReadEXT),
|
|
"NonCoherentDepthAttachmentReadEXT" => Ok(Self::NonCoherentDepthAttachmentReadEXT),
|
|
"NonCoherentStencilAttachmentReadEXT" => Ok(Self::NonCoherentStencilAttachmentReadEXT),
|
|
"SubgroupUniformControlFlowKHR" => Ok(Self::SubgroupUniformControlFlowKHR),
|
|
"PostDepthCoverage" => Ok(Self::PostDepthCoverage),
|
|
"DenormPreserve" => Ok(Self::DenormPreserve),
|
|
"DenormFlushToZero" => Ok(Self::DenormFlushToZero),
|
|
"SignedZeroInfNanPreserve" => Ok(Self::SignedZeroInfNanPreserve),
|
|
"RoundingModeRTE" => Ok(Self::RoundingModeRTE),
|
|
"RoundingModeRTZ" => Ok(Self::RoundingModeRTZ),
|
|
"EarlyAndLateFragmentTestsAMD" => Ok(Self::EarlyAndLateFragmentTestsAMD),
|
|
"StencilRefReplacingEXT" => Ok(Self::StencilRefReplacingEXT),
|
|
"CoalescingAMDX" => Ok(Self::CoalescingAMDX),
|
|
"MaxNodeRecursionAMDX" => Ok(Self::MaxNodeRecursionAMDX),
|
|
"StaticNumWorkgroupsAMDX" => Ok(Self::StaticNumWorkgroupsAMDX),
|
|
"ShaderIndexAMDX" => Ok(Self::ShaderIndexAMDX),
|
|
"MaxNumWorkgroupsAMDX" => Ok(Self::MaxNumWorkgroupsAMDX),
|
|
"StencilRefUnchangedFrontAMD" => Ok(Self::StencilRefUnchangedFrontAMD),
|
|
"StencilRefGreaterFrontAMD" => Ok(Self::StencilRefGreaterFrontAMD),
|
|
"StencilRefLessFrontAMD" => Ok(Self::StencilRefLessFrontAMD),
|
|
"StencilRefUnchangedBackAMD" => Ok(Self::StencilRefUnchangedBackAMD),
|
|
"StencilRefGreaterBackAMD" => Ok(Self::StencilRefGreaterBackAMD),
|
|
"StencilRefLessBackAMD" => Ok(Self::StencilRefLessBackAMD),
|
|
"OutputLinesNV" => Ok(Self::OutputLinesNV),
|
|
"OutputLinesEXT" => Ok(Self::OutputLinesNV),
|
|
"OutputPrimitivesNV" => Ok(Self::OutputPrimitivesNV),
|
|
"OutputPrimitivesEXT" => Ok(Self::OutputPrimitivesNV),
|
|
"DerivativeGroupQuadsNV" => Ok(Self::DerivativeGroupQuadsNV),
|
|
"DerivativeGroupLinearNV" => Ok(Self::DerivativeGroupLinearNV),
|
|
"OutputTrianglesNV" => Ok(Self::OutputTrianglesNV),
|
|
"OutputTrianglesEXT" => Ok(Self::OutputTrianglesNV),
|
|
"PixelInterlockOrderedEXT" => Ok(Self::PixelInterlockOrderedEXT),
|
|
"PixelInterlockUnorderedEXT" => Ok(Self::PixelInterlockUnorderedEXT),
|
|
"SampleInterlockOrderedEXT" => Ok(Self::SampleInterlockOrderedEXT),
|
|
"SampleInterlockUnorderedEXT" => Ok(Self::SampleInterlockUnorderedEXT),
|
|
"ShadingRateInterlockOrderedEXT" => Ok(Self::ShadingRateInterlockOrderedEXT),
|
|
"ShadingRateInterlockUnorderedEXT" => Ok(Self::ShadingRateInterlockUnorderedEXT),
|
|
"SharedLocalMemorySizeINTEL" => Ok(Self::SharedLocalMemorySizeINTEL),
|
|
"RoundingModeRTPINTEL" => Ok(Self::RoundingModeRTPINTEL),
|
|
"RoundingModeRTNINTEL" => Ok(Self::RoundingModeRTNINTEL),
|
|
"FloatingPointModeALTINTEL" => Ok(Self::FloatingPointModeALTINTEL),
|
|
"FloatingPointModeIEEEINTEL" => Ok(Self::FloatingPointModeIEEEINTEL),
|
|
"MaxWorkgroupSizeINTEL" => Ok(Self::MaxWorkgroupSizeINTEL),
|
|
"MaxWorkDimINTEL" => Ok(Self::MaxWorkDimINTEL),
|
|
"NoGlobalOffsetINTEL" => Ok(Self::NoGlobalOffsetINTEL),
|
|
"NumSIMDWorkitemsINTEL" => Ok(Self::NumSIMDWorkitemsINTEL),
|
|
"SchedulerTargetFmaxMhzINTEL" => Ok(Self::SchedulerTargetFmaxMhzINTEL),
|
|
"StreamingInterfaceINTEL" => Ok(Self::StreamingInterfaceINTEL),
|
|
"RegisterMapInterfaceINTEL" => Ok(Self::RegisterMapInterfaceINTEL),
|
|
"NamedBarrierCountINTEL" => Ok(Self::NamedBarrierCountINTEL),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [StorageClass](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_storage_class_a_storage_class)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum StorageClass {
|
|
UniformConstant = 0u32,
|
|
Input = 1u32,
|
|
Uniform = 2u32,
|
|
Output = 3u32,
|
|
Workgroup = 4u32,
|
|
CrossWorkgroup = 5u32,
|
|
Private = 6u32,
|
|
Function = 7u32,
|
|
Generic = 8u32,
|
|
PushConstant = 9u32,
|
|
AtomicCounter = 10u32,
|
|
Image = 11u32,
|
|
StorageBuffer = 12u32,
|
|
TileImageEXT = 4172u32,
|
|
NodePayloadAMDX = 5068u32,
|
|
NodeOutputPayloadAMDX = 5076u32,
|
|
CallableDataNV = 5328u32,
|
|
IncomingCallableDataNV = 5329u32,
|
|
RayPayloadNV = 5338u32,
|
|
HitAttributeNV = 5339u32,
|
|
IncomingRayPayloadNV = 5342u32,
|
|
ShaderRecordBufferNV = 5343u32,
|
|
PhysicalStorageBuffer = 5349u32,
|
|
HitObjectAttributeNV = 5385u32,
|
|
TaskPayloadWorkgroupEXT = 5402u32,
|
|
CodeSectionINTEL = 5605u32,
|
|
DeviceOnlyINTEL = 5936u32,
|
|
HostOnlyINTEL = 5937u32,
|
|
}
|
|
impl StorageClass {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=12u32 => unsafe { core::mem::transmute::<u32, StorageClass>(n) },
|
|
4172u32 => unsafe { core::mem::transmute::<u32, StorageClass>(4172u32) },
|
|
5068u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5068u32) },
|
|
5076u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5076u32) },
|
|
5328u32..=5329u32 => unsafe { core::mem::transmute::<u32, StorageClass>(n) },
|
|
5338u32..=5339u32 => unsafe { core::mem::transmute::<u32, StorageClass>(n) },
|
|
5342u32..=5343u32 => unsafe { core::mem::transmute::<u32, StorageClass>(n) },
|
|
5349u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5349u32) },
|
|
5385u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5385u32) },
|
|
5402u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5402u32) },
|
|
5605u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5605u32) },
|
|
5936u32..=5937u32 => unsafe { core::mem::transmute::<u32, StorageClass>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl StorageClass {
|
|
pub const CallableDataKHR: Self = Self::CallableDataNV;
|
|
pub const IncomingCallableDataKHR: Self = Self::IncomingCallableDataNV;
|
|
pub const RayPayloadKHR: Self = Self::RayPayloadNV;
|
|
pub const HitAttributeKHR: Self = Self::HitAttributeNV;
|
|
pub const IncomingRayPayloadKHR: Self = Self::IncomingRayPayloadNV;
|
|
pub const ShaderRecordBufferKHR: Self = Self::ShaderRecordBufferNV;
|
|
pub const PhysicalStorageBufferEXT: Self = Self::PhysicalStorageBuffer;
|
|
}
|
|
impl core::str::FromStr for StorageClass {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"UniformConstant" => Ok(Self::UniformConstant),
|
|
"Input" => Ok(Self::Input),
|
|
"Uniform" => Ok(Self::Uniform),
|
|
"Output" => Ok(Self::Output),
|
|
"Workgroup" => Ok(Self::Workgroup),
|
|
"CrossWorkgroup" => Ok(Self::CrossWorkgroup),
|
|
"Private" => Ok(Self::Private),
|
|
"Function" => Ok(Self::Function),
|
|
"Generic" => Ok(Self::Generic),
|
|
"PushConstant" => Ok(Self::PushConstant),
|
|
"AtomicCounter" => Ok(Self::AtomicCounter),
|
|
"Image" => Ok(Self::Image),
|
|
"StorageBuffer" => Ok(Self::StorageBuffer),
|
|
"TileImageEXT" => Ok(Self::TileImageEXT),
|
|
"NodePayloadAMDX" => Ok(Self::NodePayloadAMDX),
|
|
"NodeOutputPayloadAMDX" => Ok(Self::NodeOutputPayloadAMDX),
|
|
"CallableDataNV" => Ok(Self::CallableDataNV),
|
|
"CallableDataKHR" => Ok(Self::CallableDataNV),
|
|
"IncomingCallableDataNV" => Ok(Self::IncomingCallableDataNV),
|
|
"IncomingCallableDataKHR" => Ok(Self::IncomingCallableDataNV),
|
|
"RayPayloadNV" => Ok(Self::RayPayloadNV),
|
|
"RayPayloadKHR" => Ok(Self::RayPayloadNV),
|
|
"HitAttributeNV" => Ok(Self::HitAttributeNV),
|
|
"HitAttributeKHR" => Ok(Self::HitAttributeNV),
|
|
"IncomingRayPayloadNV" => Ok(Self::IncomingRayPayloadNV),
|
|
"IncomingRayPayloadKHR" => Ok(Self::IncomingRayPayloadNV),
|
|
"ShaderRecordBufferNV" => Ok(Self::ShaderRecordBufferNV),
|
|
"ShaderRecordBufferKHR" => Ok(Self::ShaderRecordBufferNV),
|
|
"PhysicalStorageBuffer" => Ok(Self::PhysicalStorageBuffer),
|
|
"PhysicalStorageBufferEXT" => Ok(Self::PhysicalStorageBuffer),
|
|
"HitObjectAttributeNV" => Ok(Self::HitObjectAttributeNV),
|
|
"TaskPayloadWorkgroupEXT" => Ok(Self::TaskPayloadWorkgroupEXT),
|
|
"CodeSectionINTEL" => Ok(Self::CodeSectionINTEL),
|
|
"DeviceOnlyINTEL" => Ok(Self::DeviceOnlyINTEL),
|
|
"HostOnlyINTEL" => Ok(Self::HostOnlyINTEL),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [Dim](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_dim_a_dim)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum Dim {
|
|
Dim1D = 0u32,
|
|
Dim2D = 1u32,
|
|
Dim3D = 2u32,
|
|
DimCube = 3u32,
|
|
DimRect = 4u32,
|
|
DimBuffer = 5u32,
|
|
DimSubpassData = 6u32,
|
|
DimTileImageDataEXT = 4173u32,
|
|
}
|
|
impl Dim {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=6u32 => unsafe { core::mem::transmute::<u32, Dim>(n) },
|
|
4173u32 => unsafe { core::mem::transmute::<u32, Dim>(4173u32) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl Dim {}
|
|
impl core::str::FromStr for Dim {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Dim1D" => Ok(Self::Dim1D),
|
|
"Dim2D" => Ok(Self::Dim2D),
|
|
"Dim3D" => Ok(Self::Dim3D),
|
|
"DimCube" => Ok(Self::DimCube),
|
|
"DimRect" => Ok(Self::DimRect),
|
|
"DimBuffer" => Ok(Self::DimBuffer),
|
|
"DimSubpassData" => Ok(Self::DimSubpassData),
|
|
"DimTileImageDataEXT" => Ok(Self::DimTileImageDataEXT),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [SamplerAddressingMode](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_sampler_addressing_mode_a_sampler_addressing_mode)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum SamplerAddressingMode {
|
|
None = 0u32,
|
|
ClampToEdge = 1u32,
|
|
Clamp = 2u32,
|
|
Repeat = 3u32,
|
|
RepeatMirrored = 4u32,
|
|
}
|
|
impl SamplerAddressingMode {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=4u32 => unsafe { core::mem::transmute::<u32, SamplerAddressingMode>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl SamplerAddressingMode {}
|
|
impl core::str::FromStr for SamplerAddressingMode {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"None" => Ok(Self::None),
|
|
"ClampToEdge" => Ok(Self::ClampToEdge),
|
|
"Clamp" => Ok(Self::Clamp),
|
|
"Repeat" => Ok(Self::Repeat),
|
|
"RepeatMirrored" => Ok(Self::RepeatMirrored),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [SamplerFilterMode](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_sampler_filter_mode_a_sampler_filter_mode)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum SamplerFilterMode {
|
|
Nearest = 0u32,
|
|
Linear = 1u32,
|
|
}
|
|
impl SamplerFilterMode {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=1u32 => unsafe { core::mem::transmute::<u32, SamplerFilterMode>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl SamplerFilterMode {}
|
|
impl core::str::FromStr for SamplerFilterMode {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Nearest" => Ok(Self::Nearest),
|
|
"Linear" => Ok(Self::Linear),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [ImageFormat](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_image_format_a_image_format)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum ImageFormat {
|
|
Unknown = 0u32,
|
|
Rgba32f = 1u32,
|
|
Rgba16f = 2u32,
|
|
R32f = 3u32,
|
|
Rgba8 = 4u32,
|
|
Rgba8Snorm = 5u32,
|
|
Rg32f = 6u32,
|
|
Rg16f = 7u32,
|
|
R11fG11fB10f = 8u32,
|
|
R16f = 9u32,
|
|
Rgba16 = 10u32,
|
|
Rgb10A2 = 11u32,
|
|
Rg16 = 12u32,
|
|
Rg8 = 13u32,
|
|
R16 = 14u32,
|
|
R8 = 15u32,
|
|
Rgba16Snorm = 16u32,
|
|
Rg16Snorm = 17u32,
|
|
Rg8Snorm = 18u32,
|
|
R16Snorm = 19u32,
|
|
R8Snorm = 20u32,
|
|
Rgba32i = 21u32,
|
|
Rgba16i = 22u32,
|
|
Rgba8i = 23u32,
|
|
R32i = 24u32,
|
|
Rg32i = 25u32,
|
|
Rg16i = 26u32,
|
|
Rg8i = 27u32,
|
|
R16i = 28u32,
|
|
R8i = 29u32,
|
|
Rgba32ui = 30u32,
|
|
Rgba16ui = 31u32,
|
|
Rgba8ui = 32u32,
|
|
R32ui = 33u32,
|
|
Rgb10a2ui = 34u32,
|
|
Rg32ui = 35u32,
|
|
Rg16ui = 36u32,
|
|
Rg8ui = 37u32,
|
|
R16ui = 38u32,
|
|
R8ui = 39u32,
|
|
R64ui = 40u32,
|
|
R64i = 41u32,
|
|
}
|
|
impl ImageFormat {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=41u32 => unsafe { core::mem::transmute::<u32, ImageFormat>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl ImageFormat {}
|
|
impl core::str::FromStr for ImageFormat {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Unknown" => Ok(Self::Unknown),
|
|
"Rgba32f" => Ok(Self::Rgba32f),
|
|
"Rgba16f" => Ok(Self::Rgba16f),
|
|
"R32f" => Ok(Self::R32f),
|
|
"Rgba8" => Ok(Self::Rgba8),
|
|
"Rgba8Snorm" => Ok(Self::Rgba8Snorm),
|
|
"Rg32f" => Ok(Self::Rg32f),
|
|
"Rg16f" => Ok(Self::Rg16f),
|
|
"R11fG11fB10f" => Ok(Self::R11fG11fB10f),
|
|
"R16f" => Ok(Self::R16f),
|
|
"Rgba16" => Ok(Self::Rgba16),
|
|
"Rgb10A2" => Ok(Self::Rgb10A2),
|
|
"Rg16" => Ok(Self::Rg16),
|
|
"Rg8" => Ok(Self::Rg8),
|
|
"R16" => Ok(Self::R16),
|
|
"R8" => Ok(Self::R8),
|
|
"Rgba16Snorm" => Ok(Self::Rgba16Snorm),
|
|
"Rg16Snorm" => Ok(Self::Rg16Snorm),
|
|
"Rg8Snorm" => Ok(Self::Rg8Snorm),
|
|
"R16Snorm" => Ok(Self::R16Snorm),
|
|
"R8Snorm" => Ok(Self::R8Snorm),
|
|
"Rgba32i" => Ok(Self::Rgba32i),
|
|
"Rgba16i" => Ok(Self::Rgba16i),
|
|
"Rgba8i" => Ok(Self::Rgba8i),
|
|
"R32i" => Ok(Self::R32i),
|
|
"Rg32i" => Ok(Self::Rg32i),
|
|
"Rg16i" => Ok(Self::Rg16i),
|
|
"Rg8i" => Ok(Self::Rg8i),
|
|
"R16i" => Ok(Self::R16i),
|
|
"R8i" => Ok(Self::R8i),
|
|
"Rgba32ui" => Ok(Self::Rgba32ui),
|
|
"Rgba16ui" => Ok(Self::Rgba16ui),
|
|
"Rgba8ui" => Ok(Self::Rgba8ui),
|
|
"R32ui" => Ok(Self::R32ui),
|
|
"Rgb10a2ui" => Ok(Self::Rgb10a2ui),
|
|
"Rg32ui" => Ok(Self::Rg32ui),
|
|
"Rg16ui" => Ok(Self::Rg16ui),
|
|
"Rg8ui" => Ok(Self::Rg8ui),
|
|
"R16ui" => Ok(Self::R16ui),
|
|
"R8ui" => Ok(Self::R8ui),
|
|
"R64ui" => Ok(Self::R64ui),
|
|
"R64i" => Ok(Self::R64i),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [ImageChannelOrder](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_image_channel_order_a_image_channel_order)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum ImageChannelOrder {
|
|
R = 0u32,
|
|
A = 1u32,
|
|
RG = 2u32,
|
|
RA = 3u32,
|
|
RGB = 4u32,
|
|
RGBA = 5u32,
|
|
BGRA = 6u32,
|
|
ARGB = 7u32,
|
|
Intensity = 8u32,
|
|
Luminance = 9u32,
|
|
Rx = 10u32,
|
|
RGx = 11u32,
|
|
RGBx = 12u32,
|
|
Depth = 13u32,
|
|
DepthStencil = 14u32,
|
|
sRGB = 15u32,
|
|
sRGBx = 16u32,
|
|
sRGBA = 17u32,
|
|
sBGRA = 18u32,
|
|
ABGR = 19u32,
|
|
}
|
|
impl ImageChannelOrder {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=19u32 => unsafe { core::mem::transmute::<u32, ImageChannelOrder>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl ImageChannelOrder {}
|
|
impl core::str::FromStr for ImageChannelOrder {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"R" => Ok(Self::R),
|
|
"A" => Ok(Self::A),
|
|
"RG" => Ok(Self::RG),
|
|
"RA" => Ok(Self::RA),
|
|
"RGB" => Ok(Self::RGB),
|
|
"RGBA" => Ok(Self::RGBA),
|
|
"BGRA" => Ok(Self::BGRA),
|
|
"ARGB" => Ok(Self::ARGB),
|
|
"Intensity" => Ok(Self::Intensity),
|
|
"Luminance" => Ok(Self::Luminance),
|
|
"Rx" => Ok(Self::Rx),
|
|
"RGx" => Ok(Self::RGx),
|
|
"RGBx" => Ok(Self::RGBx),
|
|
"Depth" => Ok(Self::Depth),
|
|
"DepthStencil" => Ok(Self::DepthStencil),
|
|
"sRGB" => Ok(Self::sRGB),
|
|
"sRGBx" => Ok(Self::sRGBx),
|
|
"sRGBA" => Ok(Self::sRGBA),
|
|
"sBGRA" => Ok(Self::sBGRA),
|
|
"ABGR" => Ok(Self::ABGR),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [ImageChannelDataType](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_image_channel_data_type_a_image_channel_data_type)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum ImageChannelDataType {
|
|
SnormInt8 = 0u32,
|
|
SnormInt16 = 1u32,
|
|
UnormInt8 = 2u32,
|
|
UnormInt16 = 3u32,
|
|
UnormShort565 = 4u32,
|
|
UnormShort555 = 5u32,
|
|
UnormInt101010 = 6u32,
|
|
SignedInt8 = 7u32,
|
|
SignedInt16 = 8u32,
|
|
SignedInt32 = 9u32,
|
|
UnsignedInt8 = 10u32,
|
|
UnsignedInt16 = 11u32,
|
|
UnsignedInt32 = 12u32,
|
|
HalfFloat = 13u32,
|
|
Float = 14u32,
|
|
UnormInt24 = 15u32,
|
|
UnormInt101010_2 = 16u32,
|
|
UnsignedIntRaw10EXT = 19u32,
|
|
UnsignedIntRaw12EXT = 20u32,
|
|
}
|
|
impl ImageChannelDataType {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=16u32 => unsafe { core::mem::transmute::<u32, ImageChannelDataType>(n) },
|
|
19u32..=20u32 => unsafe { core::mem::transmute::<u32, ImageChannelDataType>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl ImageChannelDataType {}
|
|
impl core::str::FromStr for ImageChannelDataType {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"SnormInt8" => Ok(Self::SnormInt8),
|
|
"SnormInt16" => Ok(Self::SnormInt16),
|
|
"UnormInt8" => Ok(Self::UnormInt8),
|
|
"UnormInt16" => Ok(Self::UnormInt16),
|
|
"UnormShort565" => Ok(Self::UnormShort565),
|
|
"UnormShort555" => Ok(Self::UnormShort555),
|
|
"UnormInt101010" => Ok(Self::UnormInt101010),
|
|
"SignedInt8" => Ok(Self::SignedInt8),
|
|
"SignedInt16" => Ok(Self::SignedInt16),
|
|
"SignedInt32" => Ok(Self::SignedInt32),
|
|
"UnsignedInt8" => Ok(Self::UnsignedInt8),
|
|
"UnsignedInt16" => Ok(Self::UnsignedInt16),
|
|
"UnsignedInt32" => Ok(Self::UnsignedInt32),
|
|
"HalfFloat" => Ok(Self::HalfFloat),
|
|
"Float" => Ok(Self::Float),
|
|
"UnormInt24" => Ok(Self::UnormInt24),
|
|
"UnormInt101010_2" => Ok(Self::UnormInt101010_2),
|
|
"UnsignedIntRaw10EXT" => Ok(Self::UnsignedIntRaw10EXT),
|
|
"UnsignedIntRaw12EXT" => Ok(Self::UnsignedIntRaw12EXT),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [FPRoundingMode](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_fp_rounding_mode_a_fp_rounding_mode)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum FPRoundingMode {
|
|
RTE = 0u32,
|
|
RTZ = 1u32,
|
|
RTP = 2u32,
|
|
RTN = 3u32,
|
|
}
|
|
impl FPRoundingMode {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=3u32 => unsafe { core::mem::transmute::<u32, FPRoundingMode>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl FPRoundingMode {}
|
|
impl core::str::FromStr for FPRoundingMode {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"RTE" => Ok(Self::RTE),
|
|
"RTZ" => Ok(Self::RTZ),
|
|
"RTP" => Ok(Self::RTP),
|
|
"RTN" => Ok(Self::RTN),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [FPDenormMode](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_fp_denorm_mode_a_fp_denorm_mode)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum FPDenormMode {
|
|
Preserve = 0u32,
|
|
FlushToZero = 1u32,
|
|
}
|
|
impl FPDenormMode {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=1u32 => unsafe { core::mem::transmute::<u32, FPDenormMode>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl FPDenormMode {}
|
|
impl core::str::FromStr for FPDenormMode {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Preserve" => Ok(Self::Preserve),
|
|
"FlushToZero" => Ok(Self::FlushToZero),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [QuantizationModes](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_quantization_modes_a_quantization_modes)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum QuantizationModes {
|
|
TRN = 0u32,
|
|
TRN_ZERO = 1u32,
|
|
RND = 2u32,
|
|
RND_ZERO = 3u32,
|
|
RND_INF = 4u32,
|
|
RND_MIN_INF = 5u32,
|
|
RND_CONV = 6u32,
|
|
RND_CONV_ODD = 7u32,
|
|
}
|
|
impl QuantizationModes {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=7u32 => unsafe { core::mem::transmute::<u32, QuantizationModes>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl QuantizationModes {}
|
|
impl core::str::FromStr for QuantizationModes {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"TRN" => Ok(Self::TRN),
|
|
"TRN_ZERO" => Ok(Self::TRN_ZERO),
|
|
"RND" => Ok(Self::RND),
|
|
"RND_ZERO" => Ok(Self::RND_ZERO),
|
|
"RND_INF" => Ok(Self::RND_INF),
|
|
"RND_MIN_INF" => Ok(Self::RND_MIN_INF),
|
|
"RND_CONV" => Ok(Self::RND_CONV),
|
|
"RND_CONV_ODD" => Ok(Self::RND_CONV_ODD),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [FPOperationMode](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_fp_operation_mode_a_fp_operation_mode)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum FPOperationMode {
|
|
IEEE = 0u32,
|
|
ALT = 1u32,
|
|
}
|
|
impl FPOperationMode {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=1u32 => unsafe { core::mem::transmute::<u32, FPOperationMode>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl FPOperationMode {}
|
|
impl core::str::FromStr for FPOperationMode {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"IEEE" => Ok(Self::IEEE),
|
|
"ALT" => Ok(Self::ALT),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [OverflowModes](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_overflow_modes_a_overflow_modes)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum OverflowModes {
|
|
WRAP = 0u32,
|
|
SAT = 1u32,
|
|
SAT_ZERO = 2u32,
|
|
SAT_SYM = 3u32,
|
|
}
|
|
impl OverflowModes {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=3u32 => unsafe { core::mem::transmute::<u32, OverflowModes>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl OverflowModes {}
|
|
impl core::str::FromStr for OverflowModes {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"WRAP" => Ok(Self::WRAP),
|
|
"SAT" => Ok(Self::SAT),
|
|
"SAT_ZERO" => Ok(Self::SAT_ZERO),
|
|
"SAT_SYM" => Ok(Self::SAT_SYM),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [LinkageType](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_linkage_type_a_linkage_type)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum LinkageType {
|
|
Export = 0u32,
|
|
Import = 1u32,
|
|
LinkOnceODR = 2u32,
|
|
}
|
|
impl LinkageType {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=2u32 => unsafe { core::mem::transmute::<u32, LinkageType>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl LinkageType {}
|
|
impl core::str::FromStr for LinkageType {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Export" => Ok(Self::Export),
|
|
"Import" => Ok(Self::Import),
|
|
"LinkOnceODR" => Ok(Self::LinkOnceODR),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [AccessQualifier](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_access_qualifier_a_access_qualifier)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum AccessQualifier {
|
|
ReadOnly = 0u32,
|
|
WriteOnly = 1u32,
|
|
ReadWrite = 2u32,
|
|
}
|
|
impl AccessQualifier {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=2u32 => unsafe { core::mem::transmute::<u32, AccessQualifier>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl AccessQualifier {}
|
|
impl core::str::FromStr for AccessQualifier {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"ReadOnly" => Ok(Self::ReadOnly),
|
|
"WriteOnly" => Ok(Self::WriteOnly),
|
|
"ReadWrite" => Ok(Self::ReadWrite),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [HostAccessQualifier](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_host_access_qualifier_a_host_access_qualifier)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum HostAccessQualifier {
|
|
NoneINTEL = 0u32,
|
|
ReadINTEL = 1u32,
|
|
WriteINTEL = 2u32,
|
|
ReadWriteINTEL = 3u32,
|
|
}
|
|
impl HostAccessQualifier {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=3u32 => unsafe { core::mem::transmute::<u32, HostAccessQualifier>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl HostAccessQualifier {}
|
|
impl core::str::FromStr for HostAccessQualifier {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"NoneINTEL" => Ok(Self::NoneINTEL),
|
|
"ReadINTEL" => Ok(Self::ReadINTEL),
|
|
"WriteINTEL" => Ok(Self::WriteINTEL),
|
|
"ReadWriteINTEL" => Ok(Self::ReadWriteINTEL),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [FunctionParameterAttribute](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_function_parameter_attribute_a_function_parameter_attribute)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum FunctionParameterAttribute {
|
|
Zext = 0u32,
|
|
Sext = 1u32,
|
|
ByVal = 2u32,
|
|
Sret = 3u32,
|
|
NoAlias = 4u32,
|
|
NoCapture = 5u32,
|
|
NoWrite = 6u32,
|
|
NoReadWrite = 7u32,
|
|
RuntimeAlignedINTEL = 5940u32,
|
|
}
|
|
impl FunctionParameterAttribute {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=7u32 => unsafe { core::mem::transmute::<u32, FunctionParameterAttribute>(n) },
|
|
5940u32 => unsafe { core::mem::transmute::<u32, FunctionParameterAttribute>(5940u32) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl FunctionParameterAttribute {}
|
|
impl core::str::FromStr for FunctionParameterAttribute {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Zext" => Ok(Self::Zext),
|
|
"Sext" => Ok(Self::Sext),
|
|
"ByVal" => Ok(Self::ByVal),
|
|
"Sret" => Ok(Self::Sret),
|
|
"NoAlias" => Ok(Self::NoAlias),
|
|
"NoCapture" => Ok(Self::NoCapture),
|
|
"NoWrite" => Ok(Self::NoWrite),
|
|
"NoReadWrite" => Ok(Self::NoReadWrite),
|
|
"RuntimeAlignedINTEL" => Ok(Self::RuntimeAlignedINTEL),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [Decoration](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_decoration_a_decoration)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum Decoration {
|
|
RelaxedPrecision = 0u32,
|
|
SpecId = 1u32,
|
|
Block = 2u32,
|
|
BufferBlock = 3u32,
|
|
RowMajor = 4u32,
|
|
ColMajor = 5u32,
|
|
ArrayStride = 6u32,
|
|
MatrixStride = 7u32,
|
|
GLSLShared = 8u32,
|
|
GLSLPacked = 9u32,
|
|
CPacked = 10u32,
|
|
BuiltIn = 11u32,
|
|
NoPerspective = 13u32,
|
|
Flat = 14u32,
|
|
Patch = 15u32,
|
|
Centroid = 16u32,
|
|
Sample = 17u32,
|
|
Invariant = 18u32,
|
|
Restrict = 19u32,
|
|
Aliased = 20u32,
|
|
Volatile = 21u32,
|
|
Constant = 22u32,
|
|
Coherent = 23u32,
|
|
NonWritable = 24u32,
|
|
NonReadable = 25u32,
|
|
Uniform = 26u32,
|
|
UniformId = 27u32,
|
|
SaturatedConversion = 28u32,
|
|
Stream = 29u32,
|
|
Location = 30u32,
|
|
Component = 31u32,
|
|
Index = 32u32,
|
|
Binding = 33u32,
|
|
DescriptorSet = 34u32,
|
|
Offset = 35u32,
|
|
XfbBuffer = 36u32,
|
|
XfbStride = 37u32,
|
|
FuncParamAttr = 38u32,
|
|
FPRoundingMode = 39u32,
|
|
FPFastMathMode = 40u32,
|
|
LinkageAttributes = 41u32,
|
|
NoContraction = 42u32,
|
|
InputAttachmentIndex = 43u32,
|
|
Alignment = 44u32,
|
|
MaxByteOffset = 45u32,
|
|
AlignmentId = 46u32,
|
|
MaxByteOffsetId = 47u32,
|
|
NoSignedWrap = 4469u32,
|
|
NoUnsignedWrap = 4470u32,
|
|
WeightTextureQCOM = 4487u32,
|
|
BlockMatchTextureQCOM = 4488u32,
|
|
ExplicitInterpAMD = 4999u32,
|
|
NodeSharesPayloadLimitsWithAMDX = 5019u32,
|
|
NodeMaxPayloadsAMDX = 5020u32,
|
|
TrackFinishWritingAMDX = 5078u32,
|
|
PayloadNodeNameAMDX = 5091u32,
|
|
OverrideCoverageNV = 5248u32,
|
|
PassthroughNV = 5250u32,
|
|
ViewportRelativeNV = 5252u32,
|
|
SecondaryViewportRelativeNV = 5256u32,
|
|
PerPrimitiveNV = 5271u32,
|
|
PerViewNV = 5272u32,
|
|
PerTaskNV = 5273u32,
|
|
PerVertexKHR = 5285u32,
|
|
NonUniform = 5300u32,
|
|
RestrictPointer = 5355u32,
|
|
AliasedPointer = 5356u32,
|
|
HitObjectShaderRecordBufferNV = 5386u32,
|
|
BindlessSamplerNV = 5398u32,
|
|
BindlessImageNV = 5399u32,
|
|
BoundSamplerNV = 5400u32,
|
|
BoundImageNV = 5401u32,
|
|
SIMTCallINTEL = 5599u32,
|
|
ReferencedIndirectlyINTEL = 5602u32,
|
|
ClobberINTEL = 5607u32,
|
|
SideEffectsINTEL = 5608u32,
|
|
VectorComputeVariableINTEL = 5624u32,
|
|
FuncParamIOKindINTEL = 5625u32,
|
|
VectorComputeFunctionINTEL = 5626u32,
|
|
StackCallINTEL = 5627u32,
|
|
GlobalVariableOffsetINTEL = 5628u32,
|
|
CounterBuffer = 5634u32,
|
|
UserSemantic = 5635u32,
|
|
UserTypeGOOGLE = 5636u32,
|
|
FunctionRoundingModeINTEL = 5822u32,
|
|
FunctionDenormModeINTEL = 5823u32,
|
|
RegisterINTEL = 5825u32,
|
|
MemoryINTEL = 5826u32,
|
|
NumbanksINTEL = 5827u32,
|
|
BankwidthINTEL = 5828u32,
|
|
MaxPrivateCopiesINTEL = 5829u32,
|
|
SinglepumpINTEL = 5830u32,
|
|
DoublepumpINTEL = 5831u32,
|
|
MaxReplicatesINTEL = 5832u32,
|
|
SimpleDualPortINTEL = 5833u32,
|
|
MergeINTEL = 5834u32,
|
|
BankBitsINTEL = 5835u32,
|
|
ForcePow2DepthINTEL = 5836u32,
|
|
BurstCoalesceINTEL = 5899u32,
|
|
CacheSizeINTEL = 5900u32,
|
|
DontStaticallyCoalesceINTEL = 5901u32,
|
|
PrefetchINTEL = 5902u32,
|
|
StallEnableINTEL = 5905u32,
|
|
FuseLoopsInFunctionINTEL = 5907u32,
|
|
MathOpDSPModeINTEL = 5909u32,
|
|
AliasScopeINTEL = 5914u32,
|
|
NoAliasINTEL = 5915u32,
|
|
InitiationIntervalINTEL = 5917u32,
|
|
MaxConcurrencyINTEL = 5918u32,
|
|
PipelineEnableINTEL = 5919u32,
|
|
BufferLocationINTEL = 5921u32,
|
|
IOPipeStorageINTEL = 5944u32,
|
|
FunctionFloatingPointModeINTEL = 6080u32,
|
|
SingleElementVectorINTEL = 6085u32,
|
|
VectorComputeCallableFunctionINTEL = 6087u32,
|
|
MediaBlockIOINTEL = 6140u32,
|
|
InitModeINTEL = 6147u32,
|
|
ImplementInRegisterMapINTEL = 6148u32,
|
|
HostAccessINTEL = 6168u32,
|
|
FPMaxErrorDecorationINTEL = 6170u32,
|
|
LatencyControlLabelINTEL = 6172u32,
|
|
LatencyControlConstraintINTEL = 6173u32,
|
|
ConduitKernelArgumentINTEL = 6175u32,
|
|
RegisterMapKernelArgumentINTEL = 6176u32,
|
|
MMHostInterfaceAddressWidthINTEL = 6177u32,
|
|
MMHostInterfaceDataWidthINTEL = 6178u32,
|
|
MMHostInterfaceLatencyINTEL = 6179u32,
|
|
MMHostInterfaceReadWriteModeINTEL = 6180u32,
|
|
MMHostInterfaceMaxBurstINTEL = 6181u32,
|
|
MMHostInterfaceWaitRequestINTEL = 6182u32,
|
|
StableKernelArgumentINTEL = 6183u32,
|
|
CacheControlLoadINTEL = 6442u32,
|
|
CacheControlStoreINTEL = 6443u32,
|
|
}
|
|
impl Decoration {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=11u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
13u32..=47u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
4469u32..=4470u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
4487u32..=4488u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
4999u32 => unsafe { core::mem::transmute::<u32, Decoration>(4999u32) },
|
|
5019u32..=5020u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5078u32 => unsafe { core::mem::transmute::<u32, Decoration>(5078u32) },
|
|
5091u32 => unsafe { core::mem::transmute::<u32, Decoration>(5091u32) },
|
|
5248u32 => unsafe { core::mem::transmute::<u32, Decoration>(5248u32) },
|
|
5250u32 => unsafe { core::mem::transmute::<u32, Decoration>(5250u32) },
|
|
5252u32 => unsafe { core::mem::transmute::<u32, Decoration>(5252u32) },
|
|
5256u32 => unsafe { core::mem::transmute::<u32, Decoration>(5256u32) },
|
|
5271u32..=5273u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5285u32 => unsafe { core::mem::transmute::<u32, Decoration>(5285u32) },
|
|
5300u32 => unsafe { core::mem::transmute::<u32, Decoration>(5300u32) },
|
|
5355u32..=5356u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5386u32 => unsafe { core::mem::transmute::<u32, Decoration>(5386u32) },
|
|
5398u32..=5401u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5599u32 => unsafe { core::mem::transmute::<u32, Decoration>(5599u32) },
|
|
5602u32 => unsafe { core::mem::transmute::<u32, Decoration>(5602u32) },
|
|
5607u32..=5608u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5624u32..=5628u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5634u32..=5636u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5822u32..=5823u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5825u32..=5836u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5899u32..=5902u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5905u32 => unsafe { core::mem::transmute::<u32, Decoration>(5905u32) },
|
|
5907u32 => unsafe { core::mem::transmute::<u32, Decoration>(5907u32) },
|
|
5909u32 => unsafe { core::mem::transmute::<u32, Decoration>(5909u32) },
|
|
5914u32..=5915u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5917u32..=5919u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
5921u32 => unsafe { core::mem::transmute::<u32, Decoration>(5921u32) },
|
|
5944u32 => unsafe { core::mem::transmute::<u32, Decoration>(5944u32) },
|
|
6080u32 => unsafe { core::mem::transmute::<u32, Decoration>(6080u32) },
|
|
6085u32 => unsafe { core::mem::transmute::<u32, Decoration>(6085u32) },
|
|
6087u32 => unsafe { core::mem::transmute::<u32, Decoration>(6087u32) },
|
|
6140u32 => unsafe { core::mem::transmute::<u32, Decoration>(6140u32) },
|
|
6147u32..=6148u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
6168u32 => unsafe { core::mem::transmute::<u32, Decoration>(6168u32) },
|
|
6170u32 => unsafe { core::mem::transmute::<u32, Decoration>(6170u32) },
|
|
6172u32..=6173u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
6175u32..=6183u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
6442u32..=6443u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl Decoration {
|
|
pub const PerPrimitiveEXT: Self = Self::PerPrimitiveNV;
|
|
pub const PerVertexNV: Self = Self::PerVertexKHR;
|
|
pub const NonUniformEXT: Self = Self::NonUniform;
|
|
pub const RestrictPointerEXT: Self = Self::RestrictPointer;
|
|
pub const AliasedPointerEXT: Self = Self::AliasedPointer;
|
|
pub const HlslCounterBufferGOOGLE: Self = Self::CounterBuffer;
|
|
pub const HlslSemanticGOOGLE: Self = Self::UserSemantic;
|
|
}
|
|
impl core::str::FromStr for Decoration {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"RelaxedPrecision" => Ok(Self::RelaxedPrecision),
|
|
"SpecId" => Ok(Self::SpecId),
|
|
"Block" => Ok(Self::Block),
|
|
"BufferBlock" => Ok(Self::BufferBlock),
|
|
"RowMajor" => Ok(Self::RowMajor),
|
|
"ColMajor" => Ok(Self::ColMajor),
|
|
"ArrayStride" => Ok(Self::ArrayStride),
|
|
"MatrixStride" => Ok(Self::MatrixStride),
|
|
"GLSLShared" => Ok(Self::GLSLShared),
|
|
"GLSLPacked" => Ok(Self::GLSLPacked),
|
|
"CPacked" => Ok(Self::CPacked),
|
|
"BuiltIn" => Ok(Self::BuiltIn),
|
|
"NoPerspective" => Ok(Self::NoPerspective),
|
|
"Flat" => Ok(Self::Flat),
|
|
"Patch" => Ok(Self::Patch),
|
|
"Centroid" => Ok(Self::Centroid),
|
|
"Sample" => Ok(Self::Sample),
|
|
"Invariant" => Ok(Self::Invariant),
|
|
"Restrict" => Ok(Self::Restrict),
|
|
"Aliased" => Ok(Self::Aliased),
|
|
"Volatile" => Ok(Self::Volatile),
|
|
"Constant" => Ok(Self::Constant),
|
|
"Coherent" => Ok(Self::Coherent),
|
|
"NonWritable" => Ok(Self::NonWritable),
|
|
"NonReadable" => Ok(Self::NonReadable),
|
|
"Uniform" => Ok(Self::Uniform),
|
|
"UniformId" => Ok(Self::UniformId),
|
|
"SaturatedConversion" => Ok(Self::SaturatedConversion),
|
|
"Stream" => Ok(Self::Stream),
|
|
"Location" => Ok(Self::Location),
|
|
"Component" => Ok(Self::Component),
|
|
"Index" => Ok(Self::Index),
|
|
"Binding" => Ok(Self::Binding),
|
|
"DescriptorSet" => Ok(Self::DescriptorSet),
|
|
"Offset" => Ok(Self::Offset),
|
|
"XfbBuffer" => Ok(Self::XfbBuffer),
|
|
"XfbStride" => Ok(Self::XfbStride),
|
|
"FuncParamAttr" => Ok(Self::FuncParamAttr),
|
|
"FPRoundingMode" => Ok(Self::FPRoundingMode),
|
|
"FPFastMathMode" => Ok(Self::FPFastMathMode),
|
|
"LinkageAttributes" => Ok(Self::LinkageAttributes),
|
|
"NoContraction" => Ok(Self::NoContraction),
|
|
"InputAttachmentIndex" => Ok(Self::InputAttachmentIndex),
|
|
"Alignment" => Ok(Self::Alignment),
|
|
"MaxByteOffset" => Ok(Self::MaxByteOffset),
|
|
"AlignmentId" => Ok(Self::AlignmentId),
|
|
"MaxByteOffsetId" => Ok(Self::MaxByteOffsetId),
|
|
"NoSignedWrap" => Ok(Self::NoSignedWrap),
|
|
"NoUnsignedWrap" => Ok(Self::NoUnsignedWrap),
|
|
"WeightTextureQCOM" => Ok(Self::WeightTextureQCOM),
|
|
"BlockMatchTextureQCOM" => Ok(Self::BlockMatchTextureQCOM),
|
|
"ExplicitInterpAMD" => Ok(Self::ExplicitInterpAMD),
|
|
"NodeSharesPayloadLimitsWithAMDX" => Ok(Self::NodeSharesPayloadLimitsWithAMDX),
|
|
"NodeMaxPayloadsAMDX" => Ok(Self::NodeMaxPayloadsAMDX),
|
|
"TrackFinishWritingAMDX" => Ok(Self::TrackFinishWritingAMDX),
|
|
"PayloadNodeNameAMDX" => Ok(Self::PayloadNodeNameAMDX),
|
|
"OverrideCoverageNV" => Ok(Self::OverrideCoverageNV),
|
|
"PassthroughNV" => Ok(Self::PassthroughNV),
|
|
"ViewportRelativeNV" => Ok(Self::ViewportRelativeNV),
|
|
"SecondaryViewportRelativeNV" => Ok(Self::SecondaryViewportRelativeNV),
|
|
"PerPrimitiveNV" => Ok(Self::PerPrimitiveNV),
|
|
"PerPrimitiveEXT" => Ok(Self::PerPrimitiveNV),
|
|
"PerViewNV" => Ok(Self::PerViewNV),
|
|
"PerTaskNV" => Ok(Self::PerTaskNV),
|
|
"PerVertexKHR" => Ok(Self::PerVertexKHR),
|
|
"PerVertexNV" => Ok(Self::PerVertexKHR),
|
|
"NonUniform" => Ok(Self::NonUniform),
|
|
"NonUniformEXT" => Ok(Self::NonUniform),
|
|
"RestrictPointer" => Ok(Self::RestrictPointer),
|
|
"RestrictPointerEXT" => Ok(Self::RestrictPointer),
|
|
"AliasedPointer" => Ok(Self::AliasedPointer),
|
|
"AliasedPointerEXT" => Ok(Self::AliasedPointer),
|
|
"HitObjectShaderRecordBufferNV" => Ok(Self::HitObjectShaderRecordBufferNV),
|
|
"BindlessSamplerNV" => Ok(Self::BindlessSamplerNV),
|
|
"BindlessImageNV" => Ok(Self::BindlessImageNV),
|
|
"BoundSamplerNV" => Ok(Self::BoundSamplerNV),
|
|
"BoundImageNV" => Ok(Self::BoundImageNV),
|
|
"SIMTCallINTEL" => Ok(Self::SIMTCallINTEL),
|
|
"ReferencedIndirectlyINTEL" => Ok(Self::ReferencedIndirectlyINTEL),
|
|
"ClobberINTEL" => Ok(Self::ClobberINTEL),
|
|
"SideEffectsINTEL" => Ok(Self::SideEffectsINTEL),
|
|
"VectorComputeVariableINTEL" => Ok(Self::VectorComputeVariableINTEL),
|
|
"FuncParamIOKindINTEL" => Ok(Self::FuncParamIOKindINTEL),
|
|
"VectorComputeFunctionINTEL" => Ok(Self::VectorComputeFunctionINTEL),
|
|
"StackCallINTEL" => Ok(Self::StackCallINTEL),
|
|
"GlobalVariableOffsetINTEL" => Ok(Self::GlobalVariableOffsetINTEL),
|
|
"CounterBuffer" => Ok(Self::CounterBuffer),
|
|
"HlslCounterBufferGOOGLE" => Ok(Self::CounterBuffer),
|
|
"UserSemantic" => Ok(Self::UserSemantic),
|
|
"HlslSemanticGOOGLE" => Ok(Self::UserSemantic),
|
|
"UserTypeGOOGLE" => Ok(Self::UserTypeGOOGLE),
|
|
"FunctionRoundingModeINTEL" => Ok(Self::FunctionRoundingModeINTEL),
|
|
"FunctionDenormModeINTEL" => Ok(Self::FunctionDenormModeINTEL),
|
|
"RegisterINTEL" => Ok(Self::RegisterINTEL),
|
|
"MemoryINTEL" => Ok(Self::MemoryINTEL),
|
|
"NumbanksINTEL" => Ok(Self::NumbanksINTEL),
|
|
"BankwidthINTEL" => Ok(Self::BankwidthINTEL),
|
|
"MaxPrivateCopiesINTEL" => Ok(Self::MaxPrivateCopiesINTEL),
|
|
"SinglepumpINTEL" => Ok(Self::SinglepumpINTEL),
|
|
"DoublepumpINTEL" => Ok(Self::DoublepumpINTEL),
|
|
"MaxReplicatesINTEL" => Ok(Self::MaxReplicatesINTEL),
|
|
"SimpleDualPortINTEL" => Ok(Self::SimpleDualPortINTEL),
|
|
"MergeINTEL" => Ok(Self::MergeINTEL),
|
|
"BankBitsINTEL" => Ok(Self::BankBitsINTEL),
|
|
"ForcePow2DepthINTEL" => Ok(Self::ForcePow2DepthINTEL),
|
|
"BurstCoalesceINTEL" => Ok(Self::BurstCoalesceINTEL),
|
|
"CacheSizeINTEL" => Ok(Self::CacheSizeINTEL),
|
|
"DontStaticallyCoalesceINTEL" => Ok(Self::DontStaticallyCoalesceINTEL),
|
|
"PrefetchINTEL" => Ok(Self::PrefetchINTEL),
|
|
"StallEnableINTEL" => Ok(Self::StallEnableINTEL),
|
|
"FuseLoopsInFunctionINTEL" => Ok(Self::FuseLoopsInFunctionINTEL),
|
|
"MathOpDSPModeINTEL" => Ok(Self::MathOpDSPModeINTEL),
|
|
"AliasScopeINTEL" => Ok(Self::AliasScopeINTEL),
|
|
"NoAliasINTEL" => Ok(Self::NoAliasINTEL),
|
|
"InitiationIntervalINTEL" => Ok(Self::InitiationIntervalINTEL),
|
|
"MaxConcurrencyINTEL" => Ok(Self::MaxConcurrencyINTEL),
|
|
"PipelineEnableINTEL" => Ok(Self::PipelineEnableINTEL),
|
|
"BufferLocationINTEL" => Ok(Self::BufferLocationINTEL),
|
|
"IOPipeStorageINTEL" => Ok(Self::IOPipeStorageINTEL),
|
|
"FunctionFloatingPointModeINTEL" => Ok(Self::FunctionFloatingPointModeINTEL),
|
|
"SingleElementVectorINTEL" => Ok(Self::SingleElementVectorINTEL),
|
|
"VectorComputeCallableFunctionINTEL" => Ok(Self::VectorComputeCallableFunctionINTEL),
|
|
"MediaBlockIOINTEL" => Ok(Self::MediaBlockIOINTEL),
|
|
"InitModeINTEL" => Ok(Self::InitModeINTEL),
|
|
"ImplementInRegisterMapINTEL" => Ok(Self::ImplementInRegisterMapINTEL),
|
|
"HostAccessINTEL" => Ok(Self::HostAccessINTEL),
|
|
"FPMaxErrorDecorationINTEL" => Ok(Self::FPMaxErrorDecorationINTEL),
|
|
"LatencyControlLabelINTEL" => Ok(Self::LatencyControlLabelINTEL),
|
|
"LatencyControlConstraintINTEL" => Ok(Self::LatencyControlConstraintINTEL),
|
|
"ConduitKernelArgumentINTEL" => Ok(Self::ConduitKernelArgumentINTEL),
|
|
"RegisterMapKernelArgumentINTEL" => Ok(Self::RegisterMapKernelArgumentINTEL),
|
|
"MMHostInterfaceAddressWidthINTEL" => Ok(Self::MMHostInterfaceAddressWidthINTEL),
|
|
"MMHostInterfaceDataWidthINTEL" => Ok(Self::MMHostInterfaceDataWidthINTEL),
|
|
"MMHostInterfaceLatencyINTEL" => Ok(Self::MMHostInterfaceLatencyINTEL),
|
|
"MMHostInterfaceReadWriteModeINTEL" => Ok(Self::MMHostInterfaceReadWriteModeINTEL),
|
|
"MMHostInterfaceMaxBurstINTEL" => Ok(Self::MMHostInterfaceMaxBurstINTEL),
|
|
"MMHostInterfaceWaitRequestINTEL" => Ok(Self::MMHostInterfaceWaitRequestINTEL),
|
|
"StableKernelArgumentINTEL" => Ok(Self::StableKernelArgumentINTEL),
|
|
"CacheControlLoadINTEL" => Ok(Self::CacheControlLoadINTEL),
|
|
"CacheControlStoreINTEL" => Ok(Self::CacheControlStoreINTEL),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [BuiltIn](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_built_in_a_built_in)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum BuiltIn {
|
|
Position = 0u32,
|
|
PointSize = 1u32,
|
|
ClipDistance = 3u32,
|
|
CullDistance = 4u32,
|
|
VertexId = 5u32,
|
|
InstanceId = 6u32,
|
|
PrimitiveId = 7u32,
|
|
InvocationId = 8u32,
|
|
Layer = 9u32,
|
|
ViewportIndex = 10u32,
|
|
TessLevelOuter = 11u32,
|
|
TessLevelInner = 12u32,
|
|
TessCoord = 13u32,
|
|
PatchVertices = 14u32,
|
|
FragCoord = 15u32,
|
|
PointCoord = 16u32,
|
|
FrontFacing = 17u32,
|
|
SampleId = 18u32,
|
|
SamplePosition = 19u32,
|
|
SampleMask = 20u32,
|
|
FragDepth = 22u32,
|
|
HelperInvocation = 23u32,
|
|
NumWorkgroups = 24u32,
|
|
WorkgroupSize = 25u32,
|
|
WorkgroupId = 26u32,
|
|
LocalInvocationId = 27u32,
|
|
GlobalInvocationId = 28u32,
|
|
LocalInvocationIndex = 29u32,
|
|
WorkDim = 30u32,
|
|
GlobalSize = 31u32,
|
|
EnqueuedWorkgroupSize = 32u32,
|
|
GlobalOffset = 33u32,
|
|
GlobalLinearId = 34u32,
|
|
SubgroupSize = 36u32,
|
|
SubgroupMaxSize = 37u32,
|
|
NumSubgroups = 38u32,
|
|
NumEnqueuedSubgroups = 39u32,
|
|
SubgroupId = 40u32,
|
|
SubgroupLocalInvocationId = 41u32,
|
|
VertexIndex = 42u32,
|
|
InstanceIndex = 43u32,
|
|
CoreIDARM = 4160u32,
|
|
CoreCountARM = 4161u32,
|
|
CoreMaxIDARM = 4162u32,
|
|
WarpIDARM = 4163u32,
|
|
WarpMaxIDARM = 4164u32,
|
|
SubgroupEqMask = 4416u32,
|
|
SubgroupGeMask = 4417u32,
|
|
SubgroupGtMask = 4418u32,
|
|
SubgroupLeMask = 4419u32,
|
|
SubgroupLtMask = 4420u32,
|
|
BaseVertex = 4424u32,
|
|
BaseInstance = 4425u32,
|
|
DrawIndex = 4426u32,
|
|
PrimitiveShadingRateKHR = 4432u32,
|
|
DeviceIndex = 4438u32,
|
|
ViewIndex = 4440u32,
|
|
ShadingRateKHR = 4444u32,
|
|
BaryCoordNoPerspAMD = 4992u32,
|
|
BaryCoordNoPerspCentroidAMD = 4993u32,
|
|
BaryCoordNoPerspSampleAMD = 4994u32,
|
|
BaryCoordSmoothAMD = 4995u32,
|
|
BaryCoordSmoothCentroidAMD = 4996u32,
|
|
BaryCoordSmoothSampleAMD = 4997u32,
|
|
BaryCoordPullModelAMD = 4998u32,
|
|
FragStencilRefEXT = 5014u32,
|
|
CoalescedInputCountAMDX = 5021u32,
|
|
ShaderIndexAMDX = 5073u32,
|
|
ViewportMaskNV = 5253u32,
|
|
SecondaryPositionNV = 5257u32,
|
|
SecondaryViewportMaskNV = 5258u32,
|
|
PositionPerViewNV = 5261u32,
|
|
ViewportMaskPerViewNV = 5262u32,
|
|
FullyCoveredEXT = 5264u32,
|
|
TaskCountNV = 5274u32,
|
|
PrimitiveCountNV = 5275u32,
|
|
PrimitiveIndicesNV = 5276u32,
|
|
ClipDistancePerViewNV = 5277u32,
|
|
CullDistancePerViewNV = 5278u32,
|
|
LayerPerViewNV = 5279u32,
|
|
MeshViewCountNV = 5280u32,
|
|
MeshViewIndicesNV = 5281u32,
|
|
BaryCoordKHR = 5286u32,
|
|
BaryCoordNoPerspKHR = 5287u32,
|
|
FragSizeEXT = 5292u32,
|
|
FragInvocationCountEXT = 5293u32,
|
|
PrimitivePointIndicesEXT = 5294u32,
|
|
PrimitiveLineIndicesEXT = 5295u32,
|
|
PrimitiveTriangleIndicesEXT = 5296u32,
|
|
CullPrimitiveEXT = 5299u32,
|
|
LaunchIdNV = 5319u32,
|
|
LaunchSizeNV = 5320u32,
|
|
WorldRayOriginNV = 5321u32,
|
|
WorldRayDirectionNV = 5322u32,
|
|
ObjectRayOriginNV = 5323u32,
|
|
ObjectRayDirectionNV = 5324u32,
|
|
RayTminNV = 5325u32,
|
|
RayTmaxNV = 5326u32,
|
|
InstanceCustomIndexNV = 5327u32,
|
|
ObjectToWorldNV = 5330u32,
|
|
WorldToObjectNV = 5331u32,
|
|
HitTNV = 5332u32,
|
|
HitKindNV = 5333u32,
|
|
CurrentRayTimeNV = 5334u32,
|
|
HitTriangleVertexPositionsKHR = 5335u32,
|
|
HitMicroTriangleVertexPositionsNV = 5337u32,
|
|
HitMicroTriangleVertexBarycentricsNV = 5344u32,
|
|
IncomingRayFlagsNV = 5351u32,
|
|
RayGeometryIndexKHR = 5352u32,
|
|
WarpsPerSMNV = 5374u32,
|
|
SMCountNV = 5375u32,
|
|
WarpIDNV = 5376u32,
|
|
SMIDNV = 5377u32,
|
|
HitKindFrontFacingMicroTriangleNV = 5405u32,
|
|
HitKindBackFacingMicroTriangleNV = 5406u32,
|
|
CullMaskKHR = 6021u32,
|
|
}
|
|
impl BuiltIn {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=1u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
3u32..=20u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
22u32..=34u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
36u32..=43u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
4160u32..=4164u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
4416u32..=4420u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
4424u32..=4426u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
4432u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(4432u32) },
|
|
4438u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(4438u32) },
|
|
4440u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(4440u32) },
|
|
4444u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(4444u32) },
|
|
4992u32..=4998u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
5014u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5014u32) },
|
|
5021u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5021u32) },
|
|
5073u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5073u32) },
|
|
5253u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5253u32) },
|
|
5257u32..=5258u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
5261u32..=5262u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
5264u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5264u32) },
|
|
5274u32..=5281u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
5286u32..=5287u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
5292u32..=5296u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
5299u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5299u32) },
|
|
5319u32..=5327u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
5330u32..=5335u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
5337u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5337u32) },
|
|
5344u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5344u32) },
|
|
5351u32..=5352u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
5374u32..=5377u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
5405u32..=5406u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
|
|
6021u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(6021u32) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl BuiltIn {
|
|
pub const SubgroupEqMaskKHR: Self = Self::SubgroupEqMask;
|
|
pub const SubgroupGeMaskKHR: Self = Self::SubgroupGeMask;
|
|
pub const SubgroupGtMaskKHR: Self = Self::SubgroupGtMask;
|
|
pub const SubgroupLeMaskKHR: Self = Self::SubgroupLeMask;
|
|
pub const SubgroupLtMaskKHR: Self = Self::SubgroupLtMask;
|
|
pub const BaryCoordNV: Self = Self::BaryCoordKHR;
|
|
pub const BaryCoordNoPerspNV: Self = Self::BaryCoordNoPerspKHR;
|
|
pub const FragmentSizeNV: Self = Self::FragSizeEXT;
|
|
pub const InvocationsPerPixelNV: Self = Self::FragInvocationCountEXT;
|
|
pub const LaunchIdKHR: Self = Self::LaunchIdNV;
|
|
pub const LaunchSizeKHR: Self = Self::LaunchSizeNV;
|
|
pub const WorldRayOriginKHR: Self = Self::WorldRayOriginNV;
|
|
pub const WorldRayDirectionKHR: Self = Self::WorldRayDirectionNV;
|
|
pub const ObjectRayOriginKHR: Self = Self::ObjectRayOriginNV;
|
|
pub const ObjectRayDirectionKHR: Self = Self::ObjectRayDirectionNV;
|
|
pub const RayTminKHR: Self = Self::RayTminNV;
|
|
pub const RayTmaxKHR: Self = Self::RayTmaxNV;
|
|
pub const InstanceCustomIndexKHR: Self = Self::InstanceCustomIndexNV;
|
|
pub const ObjectToWorldKHR: Self = Self::ObjectToWorldNV;
|
|
pub const WorldToObjectKHR: Self = Self::WorldToObjectNV;
|
|
pub const HitKindKHR: Self = Self::HitKindNV;
|
|
pub const IncomingRayFlagsKHR: Self = Self::IncomingRayFlagsNV;
|
|
}
|
|
impl core::str::FromStr for BuiltIn {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Position" => Ok(Self::Position),
|
|
"PointSize" => Ok(Self::PointSize),
|
|
"ClipDistance" => Ok(Self::ClipDistance),
|
|
"CullDistance" => Ok(Self::CullDistance),
|
|
"VertexId" => Ok(Self::VertexId),
|
|
"InstanceId" => Ok(Self::InstanceId),
|
|
"PrimitiveId" => Ok(Self::PrimitiveId),
|
|
"InvocationId" => Ok(Self::InvocationId),
|
|
"Layer" => Ok(Self::Layer),
|
|
"ViewportIndex" => Ok(Self::ViewportIndex),
|
|
"TessLevelOuter" => Ok(Self::TessLevelOuter),
|
|
"TessLevelInner" => Ok(Self::TessLevelInner),
|
|
"TessCoord" => Ok(Self::TessCoord),
|
|
"PatchVertices" => Ok(Self::PatchVertices),
|
|
"FragCoord" => Ok(Self::FragCoord),
|
|
"PointCoord" => Ok(Self::PointCoord),
|
|
"FrontFacing" => Ok(Self::FrontFacing),
|
|
"SampleId" => Ok(Self::SampleId),
|
|
"SamplePosition" => Ok(Self::SamplePosition),
|
|
"SampleMask" => Ok(Self::SampleMask),
|
|
"FragDepth" => Ok(Self::FragDepth),
|
|
"HelperInvocation" => Ok(Self::HelperInvocation),
|
|
"NumWorkgroups" => Ok(Self::NumWorkgroups),
|
|
"WorkgroupSize" => Ok(Self::WorkgroupSize),
|
|
"WorkgroupId" => Ok(Self::WorkgroupId),
|
|
"LocalInvocationId" => Ok(Self::LocalInvocationId),
|
|
"GlobalInvocationId" => Ok(Self::GlobalInvocationId),
|
|
"LocalInvocationIndex" => Ok(Self::LocalInvocationIndex),
|
|
"WorkDim" => Ok(Self::WorkDim),
|
|
"GlobalSize" => Ok(Self::GlobalSize),
|
|
"EnqueuedWorkgroupSize" => Ok(Self::EnqueuedWorkgroupSize),
|
|
"GlobalOffset" => Ok(Self::GlobalOffset),
|
|
"GlobalLinearId" => Ok(Self::GlobalLinearId),
|
|
"SubgroupSize" => Ok(Self::SubgroupSize),
|
|
"SubgroupMaxSize" => Ok(Self::SubgroupMaxSize),
|
|
"NumSubgroups" => Ok(Self::NumSubgroups),
|
|
"NumEnqueuedSubgroups" => Ok(Self::NumEnqueuedSubgroups),
|
|
"SubgroupId" => Ok(Self::SubgroupId),
|
|
"SubgroupLocalInvocationId" => Ok(Self::SubgroupLocalInvocationId),
|
|
"VertexIndex" => Ok(Self::VertexIndex),
|
|
"InstanceIndex" => Ok(Self::InstanceIndex),
|
|
"CoreIDARM" => Ok(Self::CoreIDARM),
|
|
"CoreCountARM" => Ok(Self::CoreCountARM),
|
|
"CoreMaxIDARM" => Ok(Self::CoreMaxIDARM),
|
|
"WarpIDARM" => Ok(Self::WarpIDARM),
|
|
"WarpMaxIDARM" => Ok(Self::WarpMaxIDARM),
|
|
"SubgroupEqMask" => Ok(Self::SubgroupEqMask),
|
|
"SubgroupEqMaskKHR" => Ok(Self::SubgroupEqMask),
|
|
"SubgroupGeMask" => Ok(Self::SubgroupGeMask),
|
|
"SubgroupGeMaskKHR" => Ok(Self::SubgroupGeMask),
|
|
"SubgroupGtMask" => Ok(Self::SubgroupGtMask),
|
|
"SubgroupGtMaskKHR" => Ok(Self::SubgroupGtMask),
|
|
"SubgroupLeMask" => Ok(Self::SubgroupLeMask),
|
|
"SubgroupLeMaskKHR" => Ok(Self::SubgroupLeMask),
|
|
"SubgroupLtMask" => Ok(Self::SubgroupLtMask),
|
|
"SubgroupLtMaskKHR" => Ok(Self::SubgroupLtMask),
|
|
"BaseVertex" => Ok(Self::BaseVertex),
|
|
"BaseInstance" => Ok(Self::BaseInstance),
|
|
"DrawIndex" => Ok(Self::DrawIndex),
|
|
"PrimitiveShadingRateKHR" => Ok(Self::PrimitiveShadingRateKHR),
|
|
"DeviceIndex" => Ok(Self::DeviceIndex),
|
|
"ViewIndex" => Ok(Self::ViewIndex),
|
|
"ShadingRateKHR" => Ok(Self::ShadingRateKHR),
|
|
"BaryCoordNoPerspAMD" => Ok(Self::BaryCoordNoPerspAMD),
|
|
"BaryCoordNoPerspCentroidAMD" => Ok(Self::BaryCoordNoPerspCentroidAMD),
|
|
"BaryCoordNoPerspSampleAMD" => Ok(Self::BaryCoordNoPerspSampleAMD),
|
|
"BaryCoordSmoothAMD" => Ok(Self::BaryCoordSmoothAMD),
|
|
"BaryCoordSmoothCentroidAMD" => Ok(Self::BaryCoordSmoothCentroidAMD),
|
|
"BaryCoordSmoothSampleAMD" => Ok(Self::BaryCoordSmoothSampleAMD),
|
|
"BaryCoordPullModelAMD" => Ok(Self::BaryCoordPullModelAMD),
|
|
"FragStencilRefEXT" => Ok(Self::FragStencilRefEXT),
|
|
"CoalescedInputCountAMDX" => Ok(Self::CoalescedInputCountAMDX),
|
|
"ShaderIndexAMDX" => Ok(Self::ShaderIndexAMDX),
|
|
"ViewportMaskNV" => Ok(Self::ViewportMaskNV),
|
|
"SecondaryPositionNV" => Ok(Self::SecondaryPositionNV),
|
|
"SecondaryViewportMaskNV" => Ok(Self::SecondaryViewportMaskNV),
|
|
"PositionPerViewNV" => Ok(Self::PositionPerViewNV),
|
|
"ViewportMaskPerViewNV" => Ok(Self::ViewportMaskPerViewNV),
|
|
"FullyCoveredEXT" => Ok(Self::FullyCoveredEXT),
|
|
"TaskCountNV" => Ok(Self::TaskCountNV),
|
|
"PrimitiveCountNV" => Ok(Self::PrimitiveCountNV),
|
|
"PrimitiveIndicesNV" => Ok(Self::PrimitiveIndicesNV),
|
|
"ClipDistancePerViewNV" => Ok(Self::ClipDistancePerViewNV),
|
|
"CullDistancePerViewNV" => Ok(Self::CullDistancePerViewNV),
|
|
"LayerPerViewNV" => Ok(Self::LayerPerViewNV),
|
|
"MeshViewCountNV" => Ok(Self::MeshViewCountNV),
|
|
"MeshViewIndicesNV" => Ok(Self::MeshViewIndicesNV),
|
|
"BaryCoordKHR" => Ok(Self::BaryCoordKHR),
|
|
"BaryCoordNV" => Ok(Self::BaryCoordKHR),
|
|
"BaryCoordNoPerspKHR" => Ok(Self::BaryCoordNoPerspKHR),
|
|
"BaryCoordNoPerspNV" => Ok(Self::BaryCoordNoPerspKHR),
|
|
"FragSizeEXT" => Ok(Self::FragSizeEXT),
|
|
"FragmentSizeNV" => Ok(Self::FragSizeEXT),
|
|
"FragInvocationCountEXT" => Ok(Self::FragInvocationCountEXT),
|
|
"InvocationsPerPixelNV" => Ok(Self::FragInvocationCountEXT),
|
|
"PrimitivePointIndicesEXT" => Ok(Self::PrimitivePointIndicesEXT),
|
|
"PrimitiveLineIndicesEXT" => Ok(Self::PrimitiveLineIndicesEXT),
|
|
"PrimitiveTriangleIndicesEXT" => Ok(Self::PrimitiveTriangleIndicesEXT),
|
|
"CullPrimitiveEXT" => Ok(Self::CullPrimitiveEXT),
|
|
"LaunchIdNV" => Ok(Self::LaunchIdNV),
|
|
"LaunchIdKHR" => Ok(Self::LaunchIdNV),
|
|
"LaunchSizeNV" => Ok(Self::LaunchSizeNV),
|
|
"LaunchSizeKHR" => Ok(Self::LaunchSizeNV),
|
|
"WorldRayOriginNV" => Ok(Self::WorldRayOriginNV),
|
|
"WorldRayOriginKHR" => Ok(Self::WorldRayOriginNV),
|
|
"WorldRayDirectionNV" => Ok(Self::WorldRayDirectionNV),
|
|
"WorldRayDirectionKHR" => Ok(Self::WorldRayDirectionNV),
|
|
"ObjectRayOriginNV" => Ok(Self::ObjectRayOriginNV),
|
|
"ObjectRayOriginKHR" => Ok(Self::ObjectRayOriginNV),
|
|
"ObjectRayDirectionNV" => Ok(Self::ObjectRayDirectionNV),
|
|
"ObjectRayDirectionKHR" => Ok(Self::ObjectRayDirectionNV),
|
|
"RayTminNV" => Ok(Self::RayTminNV),
|
|
"RayTminKHR" => Ok(Self::RayTminNV),
|
|
"RayTmaxNV" => Ok(Self::RayTmaxNV),
|
|
"RayTmaxKHR" => Ok(Self::RayTmaxNV),
|
|
"InstanceCustomIndexNV" => Ok(Self::InstanceCustomIndexNV),
|
|
"InstanceCustomIndexKHR" => Ok(Self::InstanceCustomIndexNV),
|
|
"ObjectToWorldNV" => Ok(Self::ObjectToWorldNV),
|
|
"ObjectToWorldKHR" => Ok(Self::ObjectToWorldNV),
|
|
"WorldToObjectNV" => Ok(Self::WorldToObjectNV),
|
|
"WorldToObjectKHR" => Ok(Self::WorldToObjectNV),
|
|
"HitTNV" => Ok(Self::HitTNV),
|
|
"HitKindNV" => Ok(Self::HitKindNV),
|
|
"HitKindKHR" => Ok(Self::HitKindNV),
|
|
"CurrentRayTimeNV" => Ok(Self::CurrentRayTimeNV),
|
|
"HitTriangleVertexPositionsKHR" => Ok(Self::HitTriangleVertexPositionsKHR),
|
|
"HitMicroTriangleVertexPositionsNV" => Ok(Self::HitMicroTriangleVertexPositionsNV),
|
|
"HitMicroTriangleVertexBarycentricsNV" => {
|
|
Ok(Self::HitMicroTriangleVertexBarycentricsNV)
|
|
}
|
|
"IncomingRayFlagsNV" => Ok(Self::IncomingRayFlagsNV),
|
|
"IncomingRayFlagsKHR" => Ok(Self::IncomingRayFlagsNV),
|
|
"RayGeometryIndexKHR" => Ok(Self::RayGeometryIndexKHR),
|
|
"WarpsPerSMNV" => Ok(Self::WarpsPerSMNV),
|
|
"SMCountNV" => Ok(Self::SMCountNV),
|
|
"WarpIDNV" => Ok(Self::WarpIDNV),
|
|
"SMIDNV" => Ok(Self::SMIDNV),
|
|
"HitKindFrontFacingMicroTriangleNV" => Ok(Self::HitKindFrontFacingMicroTriangleNV),
|
|
"HitKindBackFacingMicroTriangleNV" => Ok(Self::HitKindBackFacingMicroTriangleNV),
|
|
"CullMaskKHR" => Ok(Self::CullMaskKHR),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [Scope](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_scope_a_scope)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum Scope {
|
|
CrossDevice = 0u32,
|
|
Device = 1u32,
|
|
Workgroup = 2u32,
|
|
Subgroup = 3u32,
|
|
Invocation = 4u32,
|
|
QueueFamily = 5u32,
|
|
ShaderCallKHR = 6u32,
|
|
}
|
|
impl Scope {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=6u32 => unsafe { core::mem::transmute::<u32, Scope>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl Scope {
|
|
pub const QueueFamilyKHR: Self = Self::QueueFamily;
|
|
}
|
|
impl core::str::FromStr for Scope {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"CrossDevice" => Ok(Self::CrossDevice),
|
|
"Device" => Ok(Self::Device),
|
|
"Workgroup" => Ok(Self::Workgroup),
|
|
"Subgroup" => Ok(Self::Subgroup),
|
|
"Invocation" => Ok(Self::Invocation),
|
|
"QueueFamily" => Ok(Self::QueueFamily),
|
|
"QueueFamilyKHR" => Ok(Self::QueueFamily),
|
|
"ShaderCallKHR" => Ok(Self::ShaderCallKHR),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [GroupOperation](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_group_operation_a_group_operation)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum GroupOperation {
|
|
Reduce = 0u32,
|
|
InclusiveScan = 1u32,
|
|
ExclusiveScan = 2u32,
|
|
ClusteredReduce = 3u32,
|
|
PartitionedReduceNV = 6u32,
|
|
PartitionedInclusiveScanNV = 7u32,
|
|
PartitionedExclusiveScanNV = 8u32,
|
|
}
|
|
impl GroupOperation {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=3u32 => unsafe { core::mem::transmute::<u32, GroupOperation>(n) },
|
|
6u32..=8u32 => unsafe { core::mem::transmute::<u32, GroupOperation>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl GroupOperation {}
|
|
impl core::str::FromStr for GroupOperation {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Reduce" => Ok(Self::Reduce),
|
|
"InclusiveScan" => Ok(Self::InclusiveScan),
|
|
"ExclusiveScan" => Ok(Self::ExclusiveScan),
|
|
"ClusteredReduce" => Ok(Self::ClusteredReduce),
|
|
"PartitionedReduceNV" => Ok(Self::PartitionedReduceNV),
|
|
"PartitionedInclusiveScanNV" => Ok(Self::PartitionedInclusiveScanNV),
|
|
"PartitionedExclusiveScanNV" => Ok(Self::PartitionedExclusiveScanNV),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [KernelEnqueueFlags](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_kernel_enqueue_flags_a_kernel_enqueue_flags)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum KernelEnqueueFlags {
|
|
NoWait = 0u32,
|
|
WaitKernel = 1u32,
|
|
WaitWorkGroup = 2u32,
|
|
}
|
|
impl KernelEnqueueFlags {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=2u32 => unsafe { core::mem::transmute::<u32, KernelEnqueueFlags>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl KernelEnqueueFlags {}
|
|
impl core::str::FromStr for KernelEnqueueFlags {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"NoWait" => Ok(Self::NoWait),
|
|
"WaitKernel" => Ok(Self::WaitKernel),
|
|
"WaitWorkGroup" => Ok(Self::WaitWorkGroup),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [Capability](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_capability_a_capability)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum Capability {
|
|
Matrix = 0u32,
|
|
Shader = 1u32,
|
|
Geometry = 2u32,
|
|
Tessellation = 3u32,
|
|
Addresses = 4u32,
|
|
Linkage = 5u32,
|
|
Kernel = 6u32,
|
|
Vector16 = 7u32,
|
|
Float16Buffer = 8u32,
|
|
Float16 = 9u32,
|
|
Float64 = 10u32,
|
|
Int64 = 11u32,
|
|
Int64Atomics = 12u32,
|
|
ImageBasic = 13u32,
|
|
ImageReadWrite = 14u32,
|
|
ImageMipmap = 15u32,
|
|
Pipes = 17u32,
|
|
Groups = 18u32,
|
|
DeviceEnqueue = 19u32,
|
|
LiteralSampler = 20u32,
|
|
AtomicStorage = 21u32,
|
|
Int16 = 22u32,
|
|
TessellationPointSize = 23u32,
|
|
GeometryPointSize = 24u32,
|
|
ImageGatherExtended = 25u32,
|
|
StorageImageMultisample = 27u32,
|
|
UniformBufferArrayDynamicIndexing = 28u32,
|
|
SampledImageArrayDynamicIndexing = 29u32,
|
|
StorageBufferArrayDynamicIndexing = 30u32,
|
|
StorageImageArrayDynamicIndexing = 31u32,
|
|
ClipDistance = 32u32,
|
|
CullDistance = 33u32,
|
|
ImageCubeArray = 34u32,
|
|
SampleRateShading = 35u32,
|
|
ImageRect = 36u32,
|
|
SampledRect = 37u32,
|
|
GenericPointer = 38u32,
|
|
Int8 = 39u32,
|
|
InputAttachment = 40u32,
|
|
SparseResidency = 41u32,
|
|
MinLod = 42u32,
|
|
Sampled1D = 43u32,
|
|
Image1D = 44u32,
|
|
SampledCubeArray = 45u32,
|
|
SampledBuffer = 46u32,
|
|
ImageBuffer = 47u32,
|
|
ImageMSArray = 48u32,
|
|
StorageImageExtendedFormats = 49u32,
|
|
ImageQuery = 50u32,
|
|
DerivativeControl = 51u32,
|
|
InterpolationFunction = 52u32,
|
|
TransformFeedback = 53u32,
|
|
GeometryStreams = 54u32,
|
|
StorageImageReadWithoutFormat = 55u32,
|
|
StorageImageWriteWithoutFormat = 56u32,
|
|
MultiViewport = 57u32,
|
|
SubgroupDispatch = 58u32,
|
|
NamedBarrier = 59u32,
|
|
PipeStorage = 60u32,
|
|
GroupNonUniform = 61u32,
|
|
GroupNonUniformVote = 62u32,
|
|
GroupNonUniformArithmetic = 63u32,
|
|
GroupNonUniformBallot = 64u32,
|
|
GroupNonUniformShuffle = 65u32,
|
|
GroupNonUniformShuffleRelative = 66u32,
|
|
GroupNonUniformClustered = 67u32,
|
|
GroupNonUniformQuad = 68u32,
|
|
ShaderLayer = 69u32,
|
|
ShaderViewportIndex = 70u32,
|
|
UniformDecoration = 71u32,
|
|
CoreBuiltinsARM = 4165u32,
|
|
TileImageColorReadAccessEXT = 4166u32,
|
|
TileImageDepthReadAccessEXT = 4167u32,
|
|
TileImageStencilReadAccessEXT = 4168u32,
|
|
FragmentShadingRateKHR = 4422u32,
|
|
SubgroupBallotKHR = 4423u32,
|
|
DrawParameters = 4427u32,
|
|
WorkgroupMemoryExplicitLayoutKHR = 4428u32,
|
|
WorkgroupMemoryExplicitLayout8BitAccessKHR = 4429u32,
|
|
WorkgroupMemoryExplicitLayout16BitAccessKHR = 4430u32,
|
|
SubgroupVoteKHR = 4431u32,
|
|
StorageBuffer16BitAccess = 4433u32,
|
|
UniformAndStorageBuffer16BitAccess = 4434u32,
|
|
StoragePushConstant16 = 4435u32,
|
|
StorageInputOutput16 = 4436u32,
|
|
DeviceGroup = 4437u32,
|
|
MultiView = 4439u32,
|
|
VariablePointersStorageBuffer = 4441u32,
|
|
VariablePointers = 4442u32,
|
|
AtomicStorageOps = 4445u32,
|
|
SampleMaskPostDepthCoverage = 4447u32,
|
|
StorageBuffer8BitAccess = 4448u32,
|
|
UniformAndStorageBuffer8BitAccess = 4449u32,
|
|
StoragePushConstant8 = 4450u32,
|
|
DenormPreserve = 4464u32,
|
|
DenormFlushToZero = 4465u32,
|
|
SignedZeroInfNanPreserve = 4466u32,
|
|
RoundingModeRTE = 4467u32,
|
|
RoundingModeRTZ = 4468u32,
|
|
RayQueryProvisionalKHR = 4471u32,
|
|
RayQueryKHR = 4472u32,
|
|
RayTraversalPrimitiveCullingKHR = 4478u32,
|
|
RayTracingKHR = 4479u32,
|
|
TextureSampleWeightedQCOM = 4484u32,
|
|
TextureBoxFilterQCOM = 4485u32,
|
|
TextureBlockMatchQCOM = 4486u32,
|
|
Float16ImageAMD = 5008u32,
|
|
ImageGatherBiasLodAMD = 5009u32,
|
|
FragmentMaskAMD = 5010u32,
|
|
StencilExportEXT = 5013u32,
|
|
ImageReadWriteLodAMD = 5015u32,
|
|
Int64ImageEXT = 5016u32,
|
|
ShaderClockKHR = 5055u32,
|
|
ShaderEnqueueAMDX = 5067u32,
|
|
SampleMaskOverrideCoverageNV = 5249u32,
|
|
GeometryShaderPassthroughNV = 5251u32,
|
|
ShaderViewportIndexLayerEXT = 5254u32,
|
|
ShaderViewportMaskNV = 5255u32,
|
|
ShaderStereoViewNV = 5259u32,
|
|
PerViewAttributesNV = 5260u32,
|
|
FragmentFullyCoveredEXT = 5265u32,
|
|
MeshShadingNV = 5266u32,
|
|
ImageFootprintNV = 5282u32,
|
|
MeshShadingEXT = 5283u32,
|
|
FragmentBarycentricKHR = 5284u32,
|
|
ComputeDerivativeGroupQuadsNV = 5288u32,
|
|
FragmentDensityEXT = 5291u32,
|
|
GroupNonUniformPartitionedNV = 5297u32,
|
|
ShaderNonUniform = 5301u32,
|
|
RuntimeDescriptorArray = 5302u32,
|
|
InputAttachmentArrayDynamicIndexing = 5303u32,
|
|
UniformTexelBufferArrayDynamicIndexing = 5304u32,
|
|
StorageTexelBufferArrayDynamicIndexing = 5305u32,
|
|
UniformBufferArrayNonUniformIndexing = 5306u32,
|
|
SampledImageArrayNonUniformIndexing = 5307u32,
|
|
StorageBufferArrayNonUniformIndexing = 5308u32,
|
|
StorageImageArrayNonUniformIndexing = 5309u32,
|
|
InputAttachmentArrayNonUniformIndexing = 5310u32,
|
|
UniformTexelBufferArrayNonUniformIndexing = 5311u32,
|
|
StorageTexelBufferArrayNonUniformIndexing = 5312u32,
|
|
RayTracingPositionFetchKHR = 5336u32,
|
|
RayTracingNV = 5340u32,
|
|
RayTracingMotionBlurNV = 5341u32,
|
|
VulkanMemoryModel = 5345u32,
|
|
VulkanMemoryModelDeviceScope = 5346u32,
|
|
PhysicalStorageBufferAddresses = 5347u32,
|
|
ComputeDerivativeGroupLinearNV = 5350u32,
|
|
RayTracingProvisionalKHR = 5353u32,
|
|
CooperativeMatrixNV = 5357u32,
|
|
FragmentShaderSampleInterlockEXT = 5363u32,
|
|
FragmentShaderShadingRateInterlockEXT = 5372u32,
|
|
ShaderSMBuiltinsNV = 5373u32,
|
|
FragmentShaderPixelInterlockEXT = 5378u32,
|
|
DemoteToHelperInvocation = 5379u32,
|
|
DisplacementMicromapNV = 5380u32,
|
|
RayTracingOpacityMicromapEXT = 5381u32,
|
|
ShaderInvocationReorderNV = 5383u32,
|
|
BindlessTextureNV = 5390u32,
|
|
RayQueryPositionFetchKHR = 5391u32,
|
|
RayTracingDisplacementMicromapNV = 5409u32,
|
|
SubgroupShuffleINTEL = 5568u32,
|
|
SubgroupBufferBlockIOINTEL = 5569u32,
|
|
SubgroupImageBlockIOINTEL = 5570u32,
|
|
SubgroupImageMediaBlockIOINTEL = 5579u32,
|
|
RoundToInfinityINTEL = 5582u32,
|
|
FloatingPointModeINTEL = 5583u32,
|
|
IntegerFunctions2INTEL = 5584u32,
|
|
FunctionPointersINTEL = 5603u32,
|
|
IndirectReferencesINTEL = 5604u32,
|
|
AsmINTEL = 5606u32,
|
|
AtomicFloat32MinMaxEXT = 5612u32,
|
|
AtomicFloat64MinMaxEXT = 5613u32,
|
|
AtomicFloat16MinMaxEXT = 5616u32,
|
|
VectorComputeINTEL = 5617u32,
|
|
VectorAnyINTEL = 5619u32,
|
|
ExpectAssumeKHR = 5629u32,
|
|
SubgroupAvcMotionEstimationINTEL = 5696u32,
|
|
SubgroupAvcMotionEstimationIntraINTEL = 5697u32,
|
|
SubgroupAvcMotionEstimationChromaINTEL = 5698u32,
|
|
VariableLengthArrayINTEL = 5817u32,
|
|
FunctionFloatControlINTEL = 5821u32,
|
|
FPGAMemoryAttributesINTEL = 5824u32,
|
|
FPFastMathModeINTEL = 5837u32,
|
|
ArbitraryPrecisionIntegersINTEL = 5844u32,
|
|
ArbitraryPrecisionFloatingPointINTEL = 5845u32,
|
|
UnstructuredLoopControlsINTEL = 5886u32,
|
|
FPGALoopControlsINTEL = 5888u32,
|
|
KernelAttributesINTEL = 5892u32,
|
|
FPGAKernelAttributesINTEL = 5897u32,
|
|
FPGAMemoryAccessesINTEL = 5898u32,
|
|
FPGAClusterAttributesINTEL = 5904u32,
|
|
LoopFuseINTEL = 5906u32,
|
|
FPGADSPControlINTEL = 5908u32,
|
|
MemoryAccessAliasingINTEL = 5910u32,
|
|
FPGAInvocationPipeliningAttributesINTEL = 5916u32,
|
|
FPGABufferLocationINTEL = 5920u32,
|
|
ArbitraryPrecisionFixedPointINTEL = 5922u32,
|
|
USMStorageClassesINTEL = 5935u32,
|
|
RuntimeAlignedAttributeINTEL = 5939u32,
|
|
IOPipesINTEL = 5943u32,
|
|
BlockingPipesINTEL = 5945u32,
|
|
FPGARegINTEL = 5948u32,
|
|
DotProductInputAll = 6016u32,
|
|
DotProductInput4x8Bit = 6017u32,
|
|
DotProductInput4x8BitPacked = 6018u32,
|
|
DotProduct = 6019u32,
|
|
RayCullMaskKHR = 6020u32,
|
|
CooperativeMatrixKHR = 6022u32,
|
|
BitInstructions = 6025u32,
|
|
GroupNonUniformRotateKHR = 6026u32,
|
|
AtomicFloat32AddEXT = 6033u32,
|
|
AtomicFloat64AddEXT = 6034u32,
|
|
LongConstantCompositeINTEL = 6089u32,
|
|
OptNoneINTEL = 6094u32,
|
|
AtomicFloat16AddEXT = 6095u32,
|
|
DebugInfoModuleINTEL = 6114u32,
|
|
BFloat16ConversionINTEL = 6115u32,
|
|
SplitBarrierINTEL = 6141u32,
|
|
GlobalVariableFPGADecorationsINTEL = 6146u32,
|
|
FPGAKernelAttributesv2INTEL = 6161u32,
|
|
GlobalVariableHostAccessINTEL = 6167u32,
|
|
FPMaxErrorINTEL = 6169u32,
|
|
FPGALatencyControlINTEL = 6171u32,
|
|
FPGAArgumentInterfacesINTEL = 6174u32,
|
|
GroupUniformArithmeticKHR = 6400u32,
|
|
CacheControlsINTEL = 6441u32,
|
|
}
|
|
impl Capability {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=15u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
17u32..=25u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
27u32..=71u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
4165u32..=4168u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
4422u32..=4423u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
4427u32..=4431u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
4433u32..=4437u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
4439u32 => unsafe { core::mem::transmute::<u32, Capability>(4439u32) },
|
|
4441u32..=4442u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
4445u32 => unsafe { core::mem::transmute::<u32, Capability>(4445u32) },
|
|
4447u32..=4450u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
4464u32..=4468u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
4471u32..=4472u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
4478u32..=4479u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
4484u32..=4486u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5008u32..=5010u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5013u32 => unsafe { core::mem::transmute::<u32, Capability>(5013u32) },
|
|
5015u32..=5016u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5055u32 => unsafe { core::mem::transmute::<u32, Capability>(5055u32) },
|
|
5067u32 => unsafe { core::mem::transmute::<u32, Capability>(5067u32) },
|
|
5249u32 => unsafe { core::mem::transmute::<u32, Capability>(5249u32) },
|
|
5251u32 => unsafe { core::mem::transmute::<u32, Capability>(5251u32) },
|
|
5254u32..=5255u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5259u32..=5260u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5265u32..=5266u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5282u32..=5284u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5288u32 => unsafe { core::mem::transmute::<u32, Capability>(5288u32) },
|
|
5291u32 => unsafe { core::mem::transmute::<u32, Capability>(5291u32) },
|
|
5297u32 => unsafe { core::mem::transmute::<u32, Capability>(5297u32) },
|
|
5301u32..=5312u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5336u32 => unsafe { core::mem::transmute::<u32, Capability>(5336u32) },
|
|
5340u32..=5341u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5345u32..=5347u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5350u32 => unsafe { core::mem::transmute::<u32, Capability>(5350u32) },
|
|
5353u32 => unsafe { core::mem::transmute::<u32, Capability>(5353u32) },
|
|
5357u32 => unsafe { core::mem::transmute::<u32, Capability>(5357u32) },
|
|
5363u32 => unsafe { core::mem::transmute::<u32, Capability>(5363u32) },
|
|
5372u32..=5373u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5378u32..=5381u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5383u32 => unsafe { core::mem::transmute::<u32, Capability>(5383u32) },
|
|
5390u32..=5391u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5409u32 => unsafe { core::mem::transmute::<u32, Capability>(5409u32) },
|
|
5568u32..=5570u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5579u32 => unsafe { core::mem::transmute::<u32, Capability>(5579u32) },
|
|
5582u32..=5584u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5603u32..=5604u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5606u32 => unsafe { core::mem::transmute::<u32, Capability>(5606u32) },
|
|
5612u32..=5613u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5616u32..=5617u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5619u32 => unsafe { core::mem::transmute::<u32, Capability>(5619u32) },
|
|
5629u32 => unsafe { core::mem::transmute::<u32, Capability>(5629u32) },
|
|
5696u32..=5698u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5817u32 => unsafe { core::mem::transmute::<u32, Capability>(5817u32) },
|
|
5821u32 => unsafe { core::mem::transmute::<u32, Capability>(5821u32) },
|
|
5824u32 => unsafe { core::mem::transmute::<u32, Capability>(5824u32) },
|
|
5837u32 => unsafe { core::mem::transmute::<u32, Capability>(5837u32) },
|
|
5844u32..=5845u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5886u32 => unsafe { core::mem::transmute::<u32, Capability>(5886u32) },
|
|
5888u32 => unsafe { core::mem::transmute::<u32, Capability>(5888u32) },
|
|
5892u32 => unsafe { core::mem::transmute::<u32, Capability>(5892u32) },
|
|
5897u32..=5898u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
5904u32 => unsafe { core::mem::transmute::<u32, Capability>(5904u32) },
|
|
5906u32 => unsafe { core::mem::transmute::<u32, Capability>(5906u32) },
|
|
5908u32 => unsafe { core::mem::transmute::<u32, Capability>(5908u32) },
|
|
5910u32 => unsafe { core::mem::transmute::<u32, Capability>(5910u32) },
|
|
5916u32 => unsafe { core::mem::transmute::<u32, Capability>(5916u32) },
|
|
5920u32 => unsafe { core::mem::transmute::<u32, Capability>(5920u32) },
|
|
5922u32 => unsafe { core::mem::transmute::<u32, Capability>(5922u32) },
|
|
5935u32 => unsafe { core::mem::transmute::<u32, Capability>(5935u32) },
|
|
5939u32 => unsafe { core::mem::transmute::<u32, Capability>(5939u32) },
|
|
5943u32 => unsafe { core::mem::transmute::<u32, Capability>(5943u32) },
|
|
5945u32 => unsafe { core::mem::transmute::<u32, Capability>(5945u32) },
|
|
5948u32 => unsafe { core::mem::transmute::<u32, Capability>(5948u32) },
|
|
6016u32..=6020u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
6022u32 => unsafe { core::mem::transmute::<u32, Capability>(6022u32) },
|
|
6025u32..=6026u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
6033u32..=6034u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
6089u32 => unsafe { core::mem::transmute::<u32, Capability>(6089u32) },
|
|
6094u32..=6095u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
6114u32..=6115u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
|
|
6141u32 => unsafe { core::mem::transmute::<u32, Capability>(6141u32) },
|
|
6146u32 => unsafe { core::mem::transmute::<u32, Capability>(6146u32) },
|
|
6161u32 => unsafe { core::mem::transmute::<u32, Capability>(6161u32) },
|
|
6167u32 => unsafe { core::mem::transmute::<u32, Capability>(6167u32) },
|
|
6169u32 => unsafe { core::mem::transmute::<u32, Capability>(6169u32) },
|
|
6171u32 => unsafe { core::mem::transmute::<u32, Capability>(6171u32) },
|
|
6174u32 => unsafe { core::mem::transmute::<u32, Capability>(6174u32) },
|
|
6400u32 => unsafe { core::mem::transmute::<u32, Capability>(6400u32) },
|
|
6441u32 => unsafe { core::mem::transmute::<u32, Capability>(6441u32) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl Capability {
|
|
pub const StorageUniformBufferBlock16: Self = Self::StorageBuffer16BitAccess;
|
|
pub const StorageUniform16: Self = Self::UniformAndStorageBuffer16BitAccess;
|
|
pub const ShaderViewportIndexLayerNV: Self = Self::ShaderViewportIndexLayerEXT;
|
|
pub const FragmentBarycentricNV: Self = Self::FragmentBarycentricKHR;
|
|
pub const ShadingRateNV: Self = Self::FragmentDensityEXT;
|
|
pub const ShaderNonUniformEXT: Self = Self::ShaderNonUniform;
|
|
pub const RuntimeDescriptorArrayEXT: Self = Self::RuntimeDescriptorArray;
|
|
pub const InputAttachmentArrayDynamicIndexingEXT: Self =
|
|
Self::InputAttachmentArrayDynamicIndexing;
|
|
pub const UniformTexelBufferArrayDynamicIndexingEXT: Self =
|
|
Self::UniformTexelBufferArrayDynamicIndexing;
|
|
pub const StorageTexelBufferArrayDynamicIndexingEXT: Self =
|
|
Self::StorageTexelBufferArrayDynamicIndexing;
|
|
pub const UniformBufferArrayNonUniformIndexingEXT: Self =
|
|
Self::UniformBufferArrayNonUniformIndexing;
|
|
pub const SampledImageArrayNonUniformIndexingEXT: Self =
|
|
Self::SampledImageArrayNonUniformIndexing;
|
|
pub const StorageBufferArrayNonUniformIndexingEXT: Self =
|
|
Self::StorageBufferArrayNonUniformIndexing;
|
|
pub const StorageImageArrayNonUniformIndexingEXT: Self =
|
|
Self::StorageImageArrayNonUniformIndexing;
|
|
pub const InputAttachmentArrayNonUniformIndexingEXT: Self =
|
|
Self::InputAttachmentArrayNonUniformIndexing;
|
|
pub const UniformTexelBufferArrayNonUniformIndexingEXT: Self =
|
|
Self::UniformTexelBufferArrayNonUniformIndexing;
|
|
pub const StorageTexelBufferArrayNonUniformIndexingEXT: Self =
|
|
Self::StorageTexelBufferArrayNonUniformIndexing;
|
|
pub const VulkanMemoryModelKHR: Self = Self::VulkanMemoryModel;
|
|
pub const VulkanMemoryModelDeviceScopeKHR: Self = Self::VulkanMemoryModelDeviceScope;
|
|
pub const PhysicalStorageBufferAddressesEXT: Self = Self::PhysicalStorageBufferAddresses;
|
|
pub const DemoteToHelperInvocationEXT: Self = Self::DemoteToHelperInvocation;
|
|
pub const DotProductInputAllKHR: Self = Self::DotProductInputAll;
|
|
pub const DotProductInput4x8BitKHR: Self = Self::DotProductInput4x8Bit;
|
|
pub const DotProductInput4x8BitPackedKHR: Self = Self::DotProductInput4x8BitPacked;
|
|
pub const DotProductKHR: Self = Self::DotProduct;
|
|
}
|
|
impl core::str::FromStr for Capability {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Matrix" => Ok(Self::Matrix),
|
|
"Shader" => Ok(Self::Shader),
|
|
"Geometry" => Ok(Self::Geometry),
|
|
"Tessellation" => Ok(Self::Tessellation),
|
|
"Addresses" => Ok(Self::Addresses),
|
|
"Linkage" => Ok(Self::Linkage),
|
|
"Kernel" => Ok(Self::Kernel),
|
|
"Vector16" => Ok(Self::Vector16),
|
|
"Float16Buffer" => Ok(Self::Float16Buffer),
|
|
"Float16" => Ok(Self::Float16),
|
|
"Float64" => Ok(Self::Float64),
|
|
"Int64" => Ok(Self::Int64),
|
|
"Int64Atomics" => Ok(Self::Int64Atomics),
|
|
"ImageBasic" => Ok(Self::ImageBasic),
|
|
"ImageReadWrite" => Ok(Self::ImageReadWrite),
|
|
"ImageMipmap" => Ok(Self::ImageMipmap),
|
|
"Pipes" => Ok(Self::Pipes),
|
|
"Groups" => Ok(Self::Groups),
|
|
"DeviceEnqueue" => Ok(Self::DeviceEnqueue),
|
|
"LiteralSampler" => Ok(Self::LiteralSampler),
|
|
"AtomicStorage" => Ok(Self::AtomicStorage),
|
|
"Int16" => Ok(Self::Int16),
|
|
"TessellationPointSize" => Ok(Self::TessellationPointSize),
|
|
"GeometryPointSize" => Ok(Self::GeometryPointSize),
|
|
"ImageGatherExtended" => Ok(Self::ImageGatherExtended),
|
|
"StorageImageMultisample" => Ok(Self::StorageImageMultisample),
|
|
"UniformBufferArrayDynamicIndexing" => Ok(Self::UniformBufferArrayDynamicIndexing),
|
|
"SampledImageArrayDynamicIndexing" => Ok(Self::SampledImageArrayDynamicIndexing),
|
|
"StorageBufferArrayDynamicIndexing" => Ok(Self::StorageBufferArrayDynamicIndexing),
|
|
"StorageImageArrayDynamicIndexing" => Ok(Self::StorageImageArrayDynamicIndexing),
|
|
"ClipDistance" => Ok(Self::ClipDistance),
|
|
"CullDistance" => Ok(Self::CullDistance),
|
|
"ImageCubeArray" => Ok(Self::ImageCubeArray),
|
|
"SampleRateShading" => Ok(Self::SampleRateShading),
|
|
"ImageRect" => Ok(Self::ImageRect),
|
|
"SampledRect" => Ok(Self::SampledRect),
|
|
"GenericPointer" => Ok(Self::GenericPointer),
|
|
"Int8" => Ok(Self::Int8),
|
|
"InputAttachment" => Ok(Self::InputAttachment),
|
|
"SparseResidency" => Ok(Self::SparseResidency),
|
|
"MinLod" => Ok(Self::MinLod),
|
|
"Sampled1D" => Ok(Self::Sampled1D),
|
|
"Image1D" => Ok(Self::Image1D),
|
|
"SampledCubeArray" => Ok(Self::SampledCubeArray),
|
|
"SampledBuffer" => Ok(Self::SampledBuffer),
|
|
"ImageBuffer" => Ok(Self::ImageBuffer),
|
|
"ImageMSArray" => Ok(Self::ImageMSArray),
|
|
"StorageImageExtendedFormats" => Ok(Self::StorageImageExtendedFormats),
|
|
"ImageQuery" => Ok(Self::ImageQuery),
|
|
"DerivativeControl" => Ok(Self::DerivativeControl),
|
|
"InterpolationFunction" => Ok(Self::InterpolationFunction),
|
|
"TransformFeedback" => Ok(Self::TransformFeedback),
|
|
"GeometryStreams" => Ok(Self::GeometryStreams),
|
|
"StorageImageReadWithoutFormat" => Ok(Self::StorageImageReadWithoutFormat),
|
|
"StorageImageWriteWithoutFormat" => Ok(Self::StorageImageWriteWithoutFormat),
|
|
"MultiViewport" => Ok(Self::MultiViewport),
|
|
"SubgroupDispatch" => Ok(Self::SubgroupDispatch),
|
|
"NamedBarrier" => Ok(Self::NamedBarrier),
|
|
"PipeStorage" => Ok(Self::PipeStorage),
|
|
"GroupNonUniform" => Ok(Self::GroupNonUniform),
|
|
"GroupNonUniformVote" => Ok(Self::GroupNonUniformVote),
|
|
"GroupNonUniformArithmetic" => Ok(Self::GroupNonUniformArithmetic),
|
|
"GroupNonUniformBallot" => Ok(Self::GroupNonUniformBallot),
|
|
"GroupNonUniformShuffle" => Ok(Self::GroupNonUniformShuffle),
|
|
"GroupNonUniformShuffleRelative" => Ok(Self::GroupNonUniformShuffleRelative),
|
|
"GroupNonUniformClustered" => Ok(Self::GroupNonUniformClustered),
|
|
"GroupNonUniformQuad" => Ok(Self::GroupNonUniformQuad),
|
|
"ShaderLayer" => Ok(Self::ShaderLayer),
|
|
"ShaderViewportIndex" => Ok(Self::ShaderViewportIndex),
|
|
"UniformDecoration" => Ok(Self::UniformDecoration),
|
|
"CoreBuiltinsARM" => Ok(Self::CoreBuiltinsARM),
|
|
"TileImageColorReadAccessEXT" => Ok(Self::TileImageColorReadAccessEXT),
|
|
"TileImageDepthReadAccessEXT" => Ok(Self::TileImageDepthReadAccessEXT),
|
|
"TileImageStencilReadAccessEXT" => Ok(Self::TileImageStencilReadAccessEXT),
|
|
"FragmentShadingRateKHR" => Ok(Self::FragmentShadingRateKHR),
|
|
"SubgroupBallotKHR" => Ok(Self::SubgroupBallotKHR),
|
|
"DrawParameters" => Ok(Self::DrawParameters),
|
|
"WorkgroupMemoryExplicitLayoutKHR" => Ok(Self::WorkgroupMemoryExplicitLayoutKHR),
|
|
"WorkgroupMemoryExplicitLayout8BitAccessKHR" => {
|
|
Ok(Self::WorkgroupMemoryExplicitLayout8BitAccessKHR)
|
|
}
|
|
"WorkgroupMemoryExplicitLayout16BitAccessKHR" => {
|
|
Ok(Self::WorkgroupMemoryExplicitLayout16BitAccessKHR)
|
|
}
|
|
"SubgroupVoteKHR" => Ok(Self::SubgroupVoteKHR),
|
|
"StorageBuffer16BitAccess" => Ok(Self::StorageBuffer16BitAccess),
|
|
"StorageUniformBufferBlock16" => Ok(Self::StorageBuffer16BitAccess),
|
|
"UniformAndStorageBuffer16BitAccess" => Ok(Self::UniformAndStorageBuffer16BitAccess),
|
|
"StorageUniform16" => Ok(Self::UniformAndStorageBuffer16BitAccess),
|
|
"StoragePushConstant16" => Ok(Self::StoragePushConstant16),
|
|
"StorageInputOutput16" => Ok(Self::StorageInputOutput16),
|
|
"DeviceGroup" => Ok(Self::DeviceGroup),
|
|
"MultiView" => Ok(Self::MultiView),
|
|
"VariablePointersStorageBuffer" => Ok(Self::VariablePointersStorageBuffer),
|
|
"VariablePointers" => Ok(Self::VariablePointers),
|
|
"AtomicStorageOps" => Ok(Self::AtomicStorageOps),
|
|
"SampleMaskPostDepthCoverage" => Ok(Self::SampleMaskPostDepthCoverage),
|
|
"StorageBuffer8BitAccess" => Ok(Self::StorageBuffer8BitAccess),
|
|
"UniformAndStorageBuffer8BitAccess" => Ok(Self::UniformAndStorageBuffer8BitAccess),
|
|
"StoragePushConstant8" => Ok(Self::StoragePushConstant8),
|
|
"DenormPreserve" => Ok(Self::DenormPreserve),
|
|
"DenormFlushToZero" => Ok(Self::DenormFlushToZero),
|
|
"SignedZeroInfNanPreserve" => Ok(Self::SignedZeroInfNanPreserve),
|
|
"RoundingModeRTE" => Ok(Self::RoundingModeRTE),
|
|
"RoundingModeRTZ" => Ok(Self::RoundingModeRTZ),
|
|
"RayQueryProvisionalKHR" => Ok(Self::RayQueryProvisionalKHR),
|
|
"RayQueryKHR" => Ok(Self::RayQueryKHR),
|
|
"RayTraversalPrimitiveCullingKHR" => Ok(Self::RayTraversalPrimitiveCullingKHR),
|
|
"RayTracingKHR" => Ok(Self::RayTracingKHR),
|
|
"TextureSampleWeightedQCOM" => Ok(Self::TextureSampleWeightedQCOM),
|
|
"TextureBoxFilterQCOM" => Ok(Self::TextureBoxFilterQCOM),
|
|
"TextureBlockMatchQCOM" => Ok(Self::TextureBlockMatchQCOM),
|
|
"Float16ImageAMD" => Ok(Self::Float16ImageAMD),
|
|
"ImageGatherBiasLodAMD" => Ok(Self::ImageGatherBiasLodAMD),
|
|
"FragmentMaskAMD" => Ok(Self::FragmentMaskAMD),
|
|
"StencilExportEXT" => Ok(Self::StencilExportEXT),
|
|
"ImageReadWriteLodAMD" => Ok(Self::ImageReadWriteLodAMD),
|
|
"Int64ImageEXT" => Ok(Self::Int64ImageEXT),
|
|
"ShaderClockKHR" => Ok(Self::ShaderClockKHR),
|
|
"ShaderEnqueueAMDX" => Ok(Self::ShaderEnqueueAMDX),
|
|
"SampleMaskOverrideCoverageNV" => Ok(Self::SampleMaskOverrideCoverageNV),
|
|
"GeometryShaderPassthroughNV" => Ok(Self::GeometryShaderPassthroughNV),
|
|
"ShaderViewportIndexLayerEXT" => Ok(Self::ShaderViewportIndexLayerEXT),
|
|
"ShaderViewportIndexLayerNV" => Ok(Self::ShaderViewportIndexLayerEXT),
|
|
"ShaderViewportMaskNV" => Ok(Self::ShaderViewportMaskNV),
|
|
"ShaderStereoViewNV" => Ok(Self::ShaderStereoViewNV),
|
|
"PerViewAttributesNV" => Ok(Self::PerViewAttributesNV),
|
|
"FragmentFullyCoveredEXT" => Ok(Self::FragmentFullyCoveredEXT),
|
|
"MeshShadingNV" => Ok(Self::MeshShadingNV),
|
|
"ImageFootprintNV" => Ok(Self::ImageFootprintNV),
|
|
"MeshShadingEXT" => Ok(Self::MeshShadingEXT),
|
|
"FragmentBarycentricKHR" => Ok(Self::FragmentBarycentricKHR),
|
|
"FragmentBarycentricNV" => Ok(Self::FragmentBarycentricKHR),
|
|
"ComputeDerivativeGroupQuadsNV" => Ok(Self::ComputeDerivativeGroupQuadsNV),
|
|
"FragmentDensityEXT" => Ok(Self::FragmentDensityEXT),
|
|
"ShadingRateNV" => Ok(Self::FragmentDensityEXT),
|
|
"GroupNonUniformPartitionedNV" => Ok(Self::GroupNonUniformPartitionedNV),
|
|
"ShaderNonUniform" => Ok(Self::ShaderNonUniform),
|
|
"ShaderNonUniformEXT" => Ok(Self::ShaderNonUniform),
|
|
"RuntimeDescriptorArray" => Ok(Self::RuntimeDescriptorArray),
|
|
"RuntimeDescriptorArrayEXT" => Ok(Self::RuntimeDescriptorArray),
|
|
"InputAttachmentArrayDynamicIndexing" => Ok(Self::InputAttachmentArrayDynamicIndexing),
|
|
"InputAttachmentArrayDynamicIndexingEXT" => {
|
|
Ok(Self::InputAttachmentArrayDynamicIndexing)
|
|
}
|
|
"UniformTexelBufferArrayDynamicIndexing" => {
|
|
Ok(Self::UniformTexelBufferArrayDynamicIndexing)
|
|
}
|
|
"UniformTexelBufferArrayDynamicIndexingEXT" => {
|
|
Ok(Self::UniformTexelBufferArrayDynamicIndexing)
|
|
}
|
|
"StorageTexelBufferArrayDynamicIndexing" => {
|
|
Ok(Self::StorageTexelBufferArrayDynamicIndexing)
|
|
}
|
|
"StorageTexelBufferArrayDynamicIndexingEXT" => {
|
|
Ok(Self::StorageTexelBufferArrayDynamicIndexing)
|
|
}
|
|
"UniformBufferArrayNonUniformIndexing" => {
|
|
Ok(Self::UniformBufferArrayNonUniformIndexing)
|
|
}
|
|
"UniformBufferArrayNonUniformIndexingEXT" => {
|
|
Ok(Self::UniformBufferArrayNonUniformIndexing)
|
|
}
|
|
"SampledImageArrayNonUniformIndexing" => Ok(Self::SampledImageArrayNonUniformIndexing),
|
|
"SampledImageArrayNonUniformIndexingEXT" => {
|
|
Ok(Self::SampledImageArrayNonUniformIndexing)
|
|
}
|
|
"StorageBufferArrayNonUniformIndexing" => {
|
|
Ok(Self::StorageBufferArrayNonUniformIndexing)
|
|
}
|
|
"StorageBufferArrayNonUniformIndexingEXT" => {
|
|
Ok(Self::StorageBufferArrayNonUniformIndexing)
|
|
}
|
|
"StorageImageArrayNonUniformIndexing" => Ok(Self::StorageImageArrayNonUniformIndexing),
|
|
"StorageImageArrayNonUniformIndexingEXT" => {
|
|
Ok(Self::StorageImageArrayNonUniformIndexing)
|
|
}
|
|
"InputAttachmentArrayNonUniformIndexing" => {
|
|
Ok(Self::InputAttachmentArrayNonUniformIndexing)
|
|
}
|
|
"InputAttachmentArrayNonUniformIndexingEXT" => {
|
|
Ok(Self::InputAttachmentArrayNonUniformIndexing)
|
|
}
|
|
"UniformTexelBufferArrayNonUniformIndexing" => {
|
|
Ok(Self::UniformTexelBufferArrayNonUniformIndexing)
|
|
}
|
|
"UniformTexelBufferArrayNonUniformIndexingEXT" => {
|
|
Ok(Self::UniformTexelBufferArrayNonUniformIndexing)
|
|
}
|
|
"StorageTexelBufferArrayNonUniformIndexing" => {
|
|
Ok(Self::StorageTexelBufferArrayNonUniformIndexing)
|
|
}
|
|
"StorageTexelBufferArrayNonUniformIndexingEXT" => {
|
|
Ok(Self::StorageTexelBufferArrayNonUniformIndexing)
|
|
}
|
|
"RayTracingPositionFetchKHR" => Ok(Self::RayTracingPositionFetchKHR),
|
|
"RayTracingNV" => Ok(Self::RayTracingNV),
|
|
"RayTracingMotionBlurNV" => Ok(Self::RayTracingMotionBlurNV),
|
|
"VulkanMemoryModel" => Ok(Self::VulkanMemoryModel),
|
|
"VulkanMemoryModelKHR" => Ok(Self::VulkanMemoryModel),
|
|
"VulkanMemoryModelDeviceScope" => Ok(Self::VulkanMemoryModelDeviceScope),
|
|
"VulkanMemoryModelDeviceScopeKHR" => Ok(Self::VulkanMemoryModelDeviceScope),
|
|
"PhysicalStorageBufferAddresses" => Ok(Self::PhysicalStorageBufferAddresses),
|
|
"PhysicalStorageBufferAddressesEXT" => Ok(Self::PhysicalStorageBufferAddresses),
|
|
"ComputeDerivativeGroupLinearNV" => Ok(Self::ComputeDerivativeGroupLinearNV),
|
|
"RayTracingProvisionalKHR" => Ok(Self::RayTracingProvisionalKHR),
|
|
"CooperativeMatrixNV" => Ok(Self::CooperativeMatrixNV),
|
|
"FragmentShaderSampleInterlockEXT" => Ok(Self::FragmentShaderSampleInterlockEXT),
|
|
"FragmentShaderShadingRateInterlockEXT" => {
|
|
Ok(Self::FragmentShaderShadingRateInterlockEXT)
|
|
}
|
|
"ShaderSMBuiltinsNV" => Ok(Self::ShaderSMBuiltinsNV),
|
|
"FragmentShaderPixelInterlockEXT" => Ok(Self::FragmentShaderPixelInterlockEXT),
|
|
"DemoteToHelperInvocation" => Ok(Self::DemoteToHelperInvocation),
|
|
"DemoteToHelperInvocationEXT" => Ok(Self::DemoteToHelperInvocation),
|
|
"DisplacementMicromapNV" => Ok(Self::DisplacementMicromapNV),
|
|
"RayTracingOpacityMicromapEXT" => Ok(Self::RayTracingOpacityMicromapEXT),
|
|
"ShaderInvocationReorderNV" => Ok(Self::ShaderInvocationReorderNV),
|
|
"BindlessTextureNV" => Ok(Self::BindlessTextureNV),
|
|
"RayQueryPositionFetchKHR" => Ok(Self::RayQueryPositionFetchKHR),
|
|
"RayTracingDisplacementMicromapNV" => Ok(Self::RayTracingDisplacementMicromapNV),
|
|
"SubgroupShuffleINTEL" => Ok(Self::SubgroupShuffleINTEL),
|
|
"SubgroupBufferBlockIOINTEL" => Ok(Self::SubgroupBufferBlockIOINTEL),
|
|
"SubgroupImageBlockIOINTEL" => Ok(Self::SubgroupImageBlockIOINTEL),
|
|
"SubgroupImageMediaBlockIOINTEL" => Ok(Self::SubgroupImageMediaBlockIOINTEL),
|
|
"RoundToInfinityINTEL" => Ok(Self::RoundToInfinityINTEL),
|
|
"FloatingPointModeINTEL" => Ok(Self::FloatingPointModeINTEL),
|
|
"IntegerFunctions2INTEL" => Ok(Self::IntegerFunctions2INTEL),
|
|
"FunctionPointersINTEL" => Ok(Self::FunctionPointersINTEL),
|
|
"IndirectReferencesINTEL" => Ok(Self::IndirectReferencesINTEL),
|
|
"AsmINTEL" => Ok(Self::AsmINTEL),
|
|
"AtomicFloat32MinMaxEXT" => Ok(Self::AtomicFloat32MinMaxEXT),
|
|
"AtomicFloat64MinMaxEXT" => Ok(Self::AtomicFloat64MinMaxEXT),
|
|
"AtomicFloat16MinMaxEXT" => Ok(Self::AtomicFloat16MinMaxEXT),
|
|
"VectorComputeINTEL" => Ok(Self::VectorComputeINTEL),
|
|
"VectorAnyINTEL" => Ok(Self::VectorAnyINTEL),
|
|
"ExpectAssumeKHR" => Ok(Self::ExpectAssumeKHR),
|
|
"SubgroupAvcMotionEstimationINTEL" => Ok(Self::SubgroupAvcMotionEstimationINTEL),
|
|
"SubgroupAvcMotionEstimationIntraINTEL" => {
|
|
Ok(Self::SubgroupAvcMotionEstimationIntraINTEL)
|
|
}
|
|
"SubgroupAvcMotionEstimationChromaINTEL" => {
|
|
Ok(Self::SubgroupAvcMotionEstimationChromaINTEL)
|
|
}
|
|
"VariableLengthArrayINTEL" => Ok(Self::VariableLengthArrayINTEL),
|
|
"FunctionFloatControlINTEL" => Ok(Self::FunctionFloatControlINTEL),
|
|
"FPGAMemoryAttributesINTEL" => Ok(Self::FPGAMemoryAttributesINTEL),
|
|
"FPFastMathModeINTEL" => Ok(Self::FPFastMathModeINTEL),
|
|
"ArbitraryPrecisionIntegersINTEL" => Ok(Self::ArbitraryPrecisionIntegersINTEL),
|
|
"ArbitraryPrecisionFloatingPointINTEL" => {
|
|
Ok(Self::ArbitraryPrecisionFloatingPointINTEL)
|
|
}
|
|
"UnstructuredLoopControlsINTEL" => Ok(Self::UnstructuredLoopControlsINTEL),
|
|
"FPGALoopControlsINTEL" => Ok(Self::FPGALoopControlsINTEL),
|
|
"KernelAttributesINTEL" => Ok(Self::KernelAttributesINTEL),
|
|
"FPGAKernelAttributesINTEL" => Ok(Self::FPGAKernelAttributesINTEL),
|
|
"FPGAMemoryAccessesINTEL" => Ok(Self::FPGAMemoryAccessesINTEL),
|
|
"FPGAClusterAttributesINTEL" => Ok(Self::FPGAClusterAttributesINTEL),
|
|
"LoopFuseINTEL" => Ok(Self::LoopFuseINTEL),
|
|
"FPGADSPControlINTEL" => Ok(Self::FPGADSPControlINTEL),
|
|
"MemoryAccessAliasingINTEL" => Ok(Self::MemoryAccessAliasingINTEL),
|
|
"FPGAInvocationPipeliningAttributesINTEL" => {
|
|
Ok(Self::FPGAInvocationPipeliningAttributesINTEL)
|
|
}
|
|
"FPGABufferLocationINTEL" => Ok(Self::FPGABufferLocationINTEL),
|
|
"ArbitraryPrecisionFixedPointINTEL" => Ok(Self::ArbitraryPrecisionFixedPointINTEL),
|
|
"USMStorageClassesINTEL" => Ok(Self::USMStorageClassesINTEL),
|
|
"RuntimeAlignedAttributeINTEL" => Ok(Self::RuntimeAlignedAttributeINTEL),
|
|
"IOPipesINTEL" => Ok(Self::IOPipesINTEL),
|
|
"BlockingPipesINTEL" => Ok(Self::BlockingPipesINTEL),
|
|
"FPGARegINTEL" => Ok(Self::FPGARegINTEL),
|
|
"DotProductInputAll" => Ok(Self::DotProductInputAll),
|
|
"DotProductInputAllKHR" => Ok(Self::DotProductInputAll),
|
|
"DotProductInput4x8Bit" => Ok(Self::DotProductInput4x8Bit),
|
|
"DotProductInput4x8BitKHR" => Ok(Self::DotProductInput4x8Bit),
|
|
"DotProductInput4x8BitPacked" => Ok(Self::DotProductInput4x8BitPacked),
|
|
"DotProductInput4x8BitPackedKHR" => Ok(Self::DotProductInput4x8BitPacked),
|
|
"DotProduct" => Ok(Self::DotProduct),
|
|
"DotProductKHR" => Ok(Self::DotProduct),
|
|
"RayCullMaskKHR" => Ok(Self::RayCullMaskKHR),
|
|
"CooperativeMatrixKHR" => Ok(Self::CooperativeMatrixKHR),
|
|
"BitInstructions" => Ok(Self::BitInstructions),
|
|
"GroupNonUniformRotateKHR" => Ok(Self::GroupNonUniformRotateKHR),
|
|
"AtomicFloat32AddEXT" => Ok(Self::AtomicFloat32AddEXT),
|
|
"AtomicFloat64AddEXT" => Ok(Self::AtomicFloat64AddEXT),
|
|
"LongConstantCompositeINTEL" => Ok(Self::LongConstantCompositeINTEL),
|
|
"OptNoneINTEL" => Ok(Self::OptNoneINTEL),
|
|
"AtomicFloat16AddEXT" => Ok(Self::AtomicFloat16AddEXT),
|
|
"DebugInfoModuleINTEL" => Ok(Self::DebugInfoModuleINTEL),
|
|
"BFloat16ConversionINTEL" => Ok(Self::BFloat16ConversionINTEL),
|
|
"SplitBarrierINTEL" => Ok(Self::SplitBarrierINTEL),
|
|
"GlobalVariableFPGADecorationsINTEL" => Ok(Self::GlobalVariableFPGADecorationsINTEL),
|
|
"FPGAKernelAttributesv2INTEL" => Ok(Self::FPGAKernelAttributesv2INTEL),
|
|
"GlobalVariableHostAccessINTEL" => Ok(Self::GlobalVariableHostAccessINTEL),
|
|
"FPMaxErrorINTEL" => Ok(Self::FPMaxErrorINTEL),
|
|
"FPGALatencyControlINTEL" => Ok(Self::FPGALatencyControlINTEL),
|
|
"FPGAArgumentInterfacesINTEL" => Ok(Self::FPGAArgumentInterfacesINTEL),
|
|
"GroupUniformArithmeticKHR" => Ok(Self::GroupUniformArithmeticKHR),
|
|
"CacheControlsINTEL" => Ok(Self::CacheControlsINTEL),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [RayQueryIntersection](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_ray_query_intersection_a_ray_query_intersection)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum RayQueryIntersection {
|
|
RayQueryCandidateIntersectionKHR = 0u32,
|
|
RayQueryCommittedIntersectionKHR = 1u32,
|
|
}
|
|
impl RayQueryIntersection {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=1u32 => unsafe { core::mem::transmute::<u32, RayQueryIntersection>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl RayQueryIntersection {}
|
|
impl core::str::FromStr for RayQueryIntersection {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"RayQueryCandidateIntersectionKHR" => Ok(Self::RayQueryCandidateIntersectionKHR),
|
|
"RayQueryCommittedIntersectionKHR" => Ok(Self::RayQueryCommittedIntersectionKHR),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [RayQueryCommittedIntersectionType](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_ray_query_committed_intersection_type_a_ray_query_committed_intersection_type)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum RayQueryCommittedIntersectionType {
|
|
RayQueryCommittedIntersectionNoneKHR = 0u32,
|
|
RayQueryCommittedIntersectionTriangleKHR = 1u32,
|
|
RayQueryCommittedIntersectionGeneratedKHR = 2u32,
|
|
}
|
|
impl RayQueryCommittedIntersectionType {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=2u32 => unsafe {
|
|
core::mem::transmute::<u32, RayQueryCommittedIntersectionType>(n)
|
|
},
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl RayQueryCommittedIntersectionType {}
|
|
impl core::str::FromStr for RayQueryCommittedIntersectionType {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"RayQueryCommittedIntersectionNoneKHR" => {
|
|
Ok(Self::RayQueryCommittedIntersectionNoneKHR)
|
|
}
|
|
"RayQueryCommittedIntersectionTriangleKHR" => {
|
|
Ok(Self::RayQueryCommittedIntersectionTriangleKHR)
|
|
}
|
|
"RayQueryCommittedIntersectionGeneratedKHR" => {
|
|
Ok(Self::RayQueryCommittedIntersectionGeneratedKHR)
|
|
}
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [RayQueryCandidateIntersectionType](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_ray_query_candidate_intersection_type_a_ray_query_candidate_intersection_type)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum RayQueryCandidateIntersectionType {
|
|
RayQueryCandidateIntersectionTriangleKHR = 0u32,
|
|
RayQueryCandidateIntersectionAABBKHR = 1u32,
|
|
}
|
|
impl RayQueryCandidateIntersectionType {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=1u32 => unsafe {
|
|
core::mem::transmute::<u32, RayQueryCandidateIntersectionType>(n)
|
|
},
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl RayQueryCandidateIntersectionType {}
|
|
impl core::str::FromStr for RayQueryCandidateIntersectionType {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"RayQueryCandidateIntersectionTriangleKHR" => {
|
|
Ok(Self::RayQueryCandidateIntersectionTriangleKHR)
|
|
}
|
|
"RayQueryCandidateIntersectionAABBKHR" => {
|
|
Ok(Self::RayQueryCandidateIntersectionAABBKHR)
|
|
}
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [PackedVectorFormat](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_packed_vector_format_a_packed_vector_format)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum PackedVectorFormat {
|
|
PackedVectorFormat4x8Bit = 0u32,
|
|
}
|
|
impl PackedVectorFormat {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32 => unsafe { core::mem::transmute::<u32, PackedVectorFormat>(0u32) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl PackedVectorFormat {
|
|
pub const PackedVectorFormat4x8BitKHR: Self = Self::PackedVectorFormat4x8Bit;
|
|
}
|
|
impl core::str::FromStr for PackedVectorFormat {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"PackedVectorFormat4x8Bit" => Ok(Self::PackedVectorFormat4x8Bit),
|
|
"PackedVectorFormat4x8BitKHR" => Ok(Self::PackedVectorFormat4x8Bit),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
bitflags! { # [doc = "SPIR-V operand kind: [CooperativeMatrixOperands](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_cooperative_matrix_operands_a_cooperative_matrix_operands)"] # [derive (Clone , Copy , Debug , PartialEq , Eq , Hash)] # [cfg_attr (feature = "serialize" , derive (serde :: Serialize))] # [cfg_attr (feature = "deserialize" , derive (serde :: Deserialize))] pub struct CooperativeMatrixOperands : u32 { const NONE_KHR = 0u32 ; const MATRIX_A_SIGNED_COMPONENTS_KHR = 1u32 ; const MATRIX_B_SIGNED_COMPONENTS_KHR = 2u32 ; const MATRIX_C_SIGNED_COMPONENTS_KHR = 4u32 ; const MATRIX_RESULT_SIGNED_COMPONENTS_KHR = 8u32 ; const SATURATING_ACCUMULATION_KHR = 16u32 ; } }
|
|
#[doc = "SPIR-V operand kind: [CooperativeMatrixLayout](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_cooperative_matrix_layout_a_cooperative_matrix_layout)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum CooperativeMatrixLayout {
|
|
RowMajorKHR = 0u32,
|
|
ColumnMajorKHR = 1u32,
|
|
}
|
|
impl CooperativeMatrixLayout {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=1u32 => unsafe { core::mem::transmute::<u32, CooperativeMatrixLayout>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl CooperativeMatrixLayout {}
|
|
impl core::str::FromStr for CooperativeMatrixLayout {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"RowMajorKHR" => Ok(Self::RowMajorKHR),
|
|
"ColumnMajorKHR" => Ok(Self::ColumnMajorKHR),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [CooperativeMatrixUse](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_cooperative_matrix_use_a_cooperative_matrix_use)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum CooperativeMatrixUse {
|
|
MatrixAKHR = 0u32,
|
|
MatrixBKHR = 1u32,
|
|
MatrixAccumulatorKHR = 2u32,
|
|
}
|
|
impl CooperativeMatrixUse {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=2u32 => unsafe { core::mem::transmute::<u32, CooperativeMatrixUse>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl CooperativeMatrixUse {}
|
|
impl core::str::FromStr for CooperativeMatrixUse {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"MatrixAKHR" => Ok(Self::MatrixAKHR),
|
|
"MatrixBKHR" => Ok(Self::MatrixBKHR),
|
|
"MatrixAccumulatorKHR" => Ok(Self::MatrixAccumulatorKHR),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [InitializationModeQualifier](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_initialization_mode_qualifier_a_initialization_mode_qualifier)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum InitializationModeQualifier {
|
|
InitOnDeviceReprogramINTEL = 0u32,
|
|
InitOnDeviceResetINTEL = 1u32,
|
|
}
|
|
impl InitializationModeQualifier {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=1u32 => unsafe { core::mem::transmute::<u32, InitializationModeQualifier>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl InitializationModeQualifier {}
|
|
impl core::str::FromStr for InitializationModeQualifier {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"InitOnDeviceReprogramINTEL" => Ok(Self::InitOnDeviceReprogramINTEL),
|
|
"InitOnDeviceResetINTEL" => Ok(Self::InitOnDeviceResetINTEL),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [LoadCacheControl](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_load_cache_control_a_load_cache_control)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum LoadCacheControl {
|
|
UncachedINTEL = 0u32,
|
|
CachedINTEL = 1u32,
|
|
StreamingINTEL = 2u32,
|
|
InvalidateAfterReadINTEL = 3u32,
|
|
ConstCachedINTEL = 4u32,
|
|
}
|
|
impl LoadCacheControl {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=4u32 => unsafe { core::mem::transmute::<u32, LoadCacheControl>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl LoadCacheControl {}
|
|
impl core::str::FromStr for LoadCacheControl {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"UncachedINTEL" => Ok(Self::UncachedINTEL),
|
|
"CachedINTEL" => Ok(Self::CachedINTEL),
|
|
"StreamingINTEL" => Ok(Self::StreamingINTEL),
|
|
"InvalidateAfterReadINTEL" => Ok(Self::InvalidateAfterReadINTEL),
|
|
"ConstCachedINTEL" => Ok(Self::ConstCachedINTEL),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V operand kind: [StoreCacheControl](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_store_cache_control_a_store_cache_control)"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum StoreCacheControl {
|
|
UncachedINTEL = 0u32,
|
|
WriteThroughINTEL = 1u32,
|
|
WriteBackINTEL = 2u32,
|
|
StreamingINTEL = 3u32,
|
|
}
|
|
impl StoreCacheControl {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=3u32 => unsafe { core::mem::transmute::<u32, StoreCacheControl>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(non_upper_case_globals)]
|
|
impl StoreCacheControl {}
|
|
impl core::str::FromStr for StoreCacheControl {
|
|
type Err = ();
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"UncachedINTEL" => Ok(Self::UncachedINTEL),
|
|
"WriteThroughINTEL" => Ok(Self::WriteThroughINTEL),
|
|
"WriteBackINTEL" => Ok(Self::WriteBackINTEL),
|
|
"StreamingINTEL" => Ok(Self::StreamingINTEL),
|
|
_ => Err(()),
|
|
}
|
|
}
|
|
}
|
|
#[doc = "SPIR-V [instructions](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_instructions_a_instructions) opcodes"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum Op {
|
|
Nop = 0u32,
|
|
Undef = 1u32,
|
|
SourceContinued = 2u32,
|
|
Source = 3u32,
|
|
SourceExtension = 4u32,
|
|
Name = 5u32,
|
|
MemberName = 6u32,
|
|
String = 7u32,
|
|
Line = 8u32,
|
|
Extension = 10u32,
|
|
ExtInstImport = 11u32,
|
|
ExtInst = 12u32,
|
|
MemoryModel = 14u32,
|
|
EntryPoint = 15u32,
|
|
ExecutionMode = 16u32,
|
|
Capability = 17u32,
|
|
TypeVoid = 19u32,
|
|
TypeBool = 20u32,
|
|
TypeInt = 21u32,
|
|
TypeFloat = 22u32,
|
|
TypeVector = 23u32,
|
|
TypeMatrix = 24u32,
|
|
TypeImage = 25u32,
|
|
TypeSampler = 26u32,
|
|
TypeSampledImage = 27u32,
|
|
TypeArray = 28u32,
|
|
TypeRuntimeArray = 29u32,
|
|
TypeStruct = 30u32,
|
|
TypeOpaque = 31u32,
|
|
TypePointer = 32u32,
|
|
TypeFunction = 33u32,
|
|
TypeEvent = 34u32,
|
|
TypeDeviceEvent = 35u32,
|
|
TypeReserveId = 36u32,
|
|
TypeQueue = 37u32,
|
|
TypePipe = 38u32,
|
|
TypeForwardPointer = 39u32,
|
|
ConstantTrue = 41u32,
|
|
ConstantFalse = 42u32,
|
|
Constant = 43u32,
|
|
ConstantComposite = 44u32,
|
|
ConstantSampler = 45u32,
|
|
ConstantNull = 46u32,
|
|
SpecConstantTrue = 48u32,
|
|
SpecConstantFalse = 49u32,
|
|
SpecConstant = 50u32,
|
|
SpecConstantComposite = 51u32,
|
|
SpecConstantOp = 52u32,
|
|
Function = 54u32,
|
|
FunctionParameter = 55u32,
|
|
FunctionEnd = 56u32,
|
|
FunctionCall = 57u32,
|
|
Variable = 59u32,
|
|
ImageTexelPointer = 60u32,
|
|
Load = 61u32,
|
|
Store = 62u32,
|
|
CopyMemory = 63u32,
|
|
CopyMemorySized = 64u32,
|
|
AccessChain = 65u32,
|
|
InBoundsAccessChain = 66u32,
|
|
PtrAccessChain = 67u32,
|
|
ArrayLength = 68u32,
|
|
GenericPtrMemSemantics = 69u32,
|
|
InBoundsPtrAccessChain = 70u32,
|
|
Decorate = 71u32,
|
|
MemberDecorate = 72u32,
|
|
DecorationGroup = 73u32,
|
|
GroupDecorate = 74u32,
|
|
GroupMemberDecorate = 75u32,
|
|
VectorExtractDynamic = 77u32,
|
|
VectorInsertDynamic = 78u32,
|
|
VectorShuffle = 79u32,
|
|
CompositeConstruct = 80u32,
|
|
CompositeExtract = 81u32,
|
|
CompositeInsert = 82u32,
|
|
CopyObject = 83u32,
|
|
Transpose = 84u32,
|
|
SampledImage = 86u32,
|
|
ImageSampleImplicitLod = 87u32,
|
|
ImageSampleExplicitLod = 88u32,
|
|
ImageSampleDrefImplicitLod = 89u32,
|
|
ImageSampleDrefExplicitLod = 90u32,
|
|
ImageSampleProjImplicitLod = 91u32,
|
|
ImageSampleProjExplicitLod = 92u32,
|
|
ImageSampleProjDrefImplicitLod = 93u32,
|
|
ImageSampleProjDrefExplicitLod = 94u32,
|
|
ImageFetch = 95u32,
|
|
ImageGather = 96u32,
|
|
ImageDrefGather = 97u32,
|
|
ImageRead = 98u32,
|
|
ImageWrite = 99u32,
|
|
Image = 100u32,
|
|
ImageQueryFormat = 101u32,
|
|
ImageQueryOrder = 102u32,
|
|
ImageQuerySizeLod = 103u32,
|
|
ImageQuerySize = 104u32,
|
|
ImageQueryLod = 105u32,
|
|
ImageQueryLevels = 106u32,
|
|
ImageQuerySamples = 107u32,
|
|
ConvertFToU = 109u32,
|
|
ConvertFToS = 110u32,
|
|
ConvertSToF = 111u32,
|
|
ConvertUToF = 112u32,
|
|
UConvert = 113u32,
|
|
SConvert = 114u32,
|
|
FConvert = 115u32,
|
|
QuantizeToF16 = 116u32,
|
|
ConvertPtrToU = 117u32,
|
|
SatConvertSToU = 118u32,
|
|
SatConvertUToS = 119u32,
|
|
ConvertUToPtr = 120u32,
|
|
PtrCastToGeneric = 121u32,
|
|
GenericCastToPtr = 122u32,
|
|
GenericCastToPtrExplicit = 123u32,
|
|
Bitcast = 124u32,
|
|
SNegate = 126u32,
|
|
FNegate = 127u32,
|
|
IAdd = 128u32,
|
|
FAdd = 129u32,
|
|
ISub = 130u32,
|
|
FSub = 131u32,
|
|
IMul = 132u32,
|
|
FMul = 133u32,
|
|
UDiv = 134u32,
|
|
SDiv = 135u32,
|
|
FDiv = 136u32,
|
|
UMod = 137u32,
|
|
SRem = 138u32,
|
|
SMod = 139u32,
|
|
FRem = 140u32,
|
|
FMod = 141u32,
|
|
VectorTimesScalar = 142u32,
|
|
MatrixTimesScalar = 143u32,
|
|
VectorTimesMatrix = 144u32,
|
|
MatrixTimesVector = 145u32,
|
|
MatrixTimesMatrix = 146u32,
|
|
OuterProduct = 147u32,
|
|
Dot = 148u32,
|
|
IAddCarry = 149u32,
|
|
ISubBorrow = 150u32,
|
|
UMulExtended = 151u32,
|
|
SMulExtended = 152u32,
|
|
Any = 154u32,
|
|
All = 155u32,
|
|
IsNan = 156u32,
|
|
IsInf = 157u32,
|
|
IsFinite = 158u32,
|
|
IsNormal = 159u32,
|
|
SignBitSet = 160u32,
|
|
LessOrGreater = 161u32,
|
|
Ordered = 162u32,
|
|
Unordered = 163u32,
|
|
LogicalEqual = 164u32,
|
|
LogicalNotEqual = 165u32,
|
|
LogicalOr = 166u32,
|
|
LogicalAnd = 167u32,
|
|
LogicalNot = 168u32,
|
|
Select = 169u32,
|
|
IEqual = 170u32,
|
|
INotEqual = 171u32,
|
|
UGreaterThan = 172u32,
|
|
SGreaterThan = 173u32,
|
|
UGreaterThanEqual = 174u32,
|
|
SGreaterThanEqual = 175u32,
|
|
ULessThan = 176u32,
|
|
SLessThan = 177u32,
|
|
ULessThanEqual = 178u32,
|
|
SLessThanEqual = 179u32,
|
|
FOrdEqual = 180u32,
|
|
FUnordEqual = 181u32,
|
|
FOrdNotEqual = 182u32,
|
|
FUnordNotEqual = 183u32,
|
|
FOrdLessThan = 184u32,
|
|
FUnordLessThan = 185u32,
|
|
FOrdGreaterThan = 186u32,
|
|
FUnordGreaterThan = 187u32,
|
|
FOrdLessThanEqual = 188u32,
|
|
FUnordLessThanEqual = 189u32,
|
|
FOrdGreaterThanEqual = 190u32,
|
|
FUnordGreaterThanEqual = 191u32,
|
|
ShiftRightLogical = 194u32,
|
|
ShiftRightArithmetic = 195u32,
|
|
ShiftLeftLogical = 196u32,
|
|
BitwiseOr = 197u32,
|
|
BitwiseXor = 198u32,
|
|
BitwiseAnd = 199u32,
|
|
Not = 200u32,
|
|
BitFieldInsert = 201u32,
|
|
BitFieldSExtract = 202u32,
|
|
BitFieldUExtract = 203u32,
|
|
BitReverse = 204u32,
|
|
BitCount = 205u32,
|
|
DPdx = 207u32,
|
|
DPdy = 208u32,
|
|
Fwidth = 209u32,
|
|
DPdxFine = 210u32,
|
|
DPdyFine = 211u32,
|
|
FwidthFine = 212u32,
|
|
DPdxCoarse = 213u32,
|
|
DPdyCoarse = 214u32,
|
|
FwidthCoarse = 215u32,
|
|
EmitVertex = 218u32,
|
|
EndPrimitive = 219u32,
|
|
EmitStreamVertex = 220u32,
|
|
EndStreamPrimitive = 221u32,
|
|
ControlBarrier = 224u32,
|
|
MemoryBarrier = 225u32,
|
|
AtomicLoad = 227u32,
|
|
AtomicStore = 228u32,
|
|
AtomicExchange = 229u32,
|
|
AtomicCompareExchange = 230u32,
|
|
AtomicCompareExchangeWeak = 231u32,
|
|
AtomicIIncrement = 232u32,
|
|
AtomicIDecrement = 233u32,
|
|
AtomicIAdd = 234u32,
|
|
AtomicISub = 235u32,
|
|
AtomicSMin = 236u32,
|
|
AtomicUMin = 237u32,
|
|
AtomicSMax = 238u32,
|
|
AtomicUMax = 239u32,
|
|
AtomicAnd = 240u32,
|
|
AtomicOr = 241u32,
|
|
AtomicXor = 242u32,
|
|
Phi = 245u32,
|
|
LoopMerge = 246u32,
|
|
SelectionMerge = 247u32,
|
|
Label = 248u32,
|
|
Branch = 249u32,
|
|
BranchConditional = 250u32,
|
|
Switch = 251u32,
|
|
Kill = 252u32,
|
|
Return = 253u32,
|
|
ReturnValue = 254u32,
|
|
Unreachable = 255u32,
|
|
LifetimeStart = 256u32,
|
|
LifetimeStop = 257u32,
|
|
GroupAsyncCopy = 259u32,
|
|
GroupWaitEvents = 260u32,
|
|
GroupAll = 261u32,
|
|
GroupAny = 262u32,
|
|
GroupBroadcast = 263u32,
|
|
GroupIAdd = 264u32,
|
|
GroupFAdd = 265u32,
|
|
GroupFMin = 266u32,
|
|
GroupUMin = 267u32,
|
|
GroupSMin = 268u32,
|
|
GroupFMax = 269u32,
|
|
GroupUMax = 270u32,
|
|
GroupSMax = 271u32,
|
|
ReadPipe = 274u32,
|
|
WritePipe = 275u32,
|
|
ReservedReadPipe = 276u32,
|
|
ReservedWritePipe = 277u32,
|
|
ReserveReadPipePackets = 278u32,
|
|
ReserveWritePipePackets = 279u32,
|
|
CommitReadPipe = 280u32,
|
|
CommitWritePipe = 281u32,
|
|
IsValidReserveId = 282u32,
|
|
GetNumPipePackets = 283u32,
|
|
GetMaxPipePackets = 284u32,
|
|
GroupReserveReadPipePackets = 285u32,
|
|
GroupReserveWritePipePackets = 286u32,
|
|
GroupCommitReadPipe = 287u32,
|
|
GroupCommitWritePipe = 288u32,
|
|
EnqueueMarker = 291u32,
|
|
EnqueueKernel = 292u32,
|
|
GetKernelNDrangeSubGroupCount = 293u32,
|
|
GetKernelNDrangeMaxSubGroupSize = 294u32,
|
|
GetKernelWorkGroupSize = 295u32,
|
|
GetKernelPreferredWorkGroupSizeMultiple = 296u32,
|
|
RetainEvent = 297u32,
|
|
ReleaseEvent = 298u32,
|
|
CreateUserEvent = 299u32,
|
|
IsValidEvent = 300u32,
|
|
SetUserEventStatus = 301u32,
|
|
CaptureEventProfilingInfo = 302u32,
|
|
GetDefaultQueue = 303u32,
|
|
BuildNDRange = 304u32,
|
|
ImageSparseSampleImplicitLod = 305u32,
|
|
ImageSparseSampleExplicitLod = 306u32,
|
|
ImageSparseSampleDrefImplicitLod = 307u32,
|
|
ImageSparseSampleDrefExplicitLod = 308u32,
|
|
ImageSparseSampleProjImplicitLod = 309u32,
|
|
ImageSparseSampleProjExplicitLod = 310u32,
|
|
ImageSparseSampleProjDrefImplicitLod = 311u32,
|
|
ImageSparseSampleProjDrefExplicitLod = 312u32,
|
|
ImageSparseFetch = 313u32,
|
|
ImageSparseGather = 314u32,
|
|
ImageSparseDrefGather = 315u32,
|
|
ImageSparseTexelsResident = 316u32,
|
|
NoLine = 317u32,
|
|
AtomicFlagTestAndSet = 318u32,
|
|
AtomicFlagClear = 319u32,
|
|
ImageSparseRead = 320u32,
|
|
SizeOf = 321u32,
|
|
TypePipeStorage = 322u32,
|
|
ConstantPipeStorage = 323u32,
|
|
CreatePipeFromPipeStorage = 324u32,
|
|
GetKernelLocalSizeForSubgroupCount = 325u32,
|
|
GetKernelMaxNumSubgroups = 326u32,
|
|
TypeNamedBarrier = 327u32,
|
|
NamedBarrierInitialize = 328u32,
|
|
MemoryNamedBarrier = 329u32,
|
|
ModuleProcessed = 330u32,
|
|
ExecutionModeId = 331u32,
|
|
DecorateId = 332u32,
|
|
GroupNonUniformElect = 333u32,
|
|
GroupNonUniformAll = 334u32,
|
|
GroupNonUniformAny = 335u32,
|
|
GroupNonUniformAllEqual = 336u32,
|
|
GroupNonUniformBroadcast = 337u32,
|
|
GroupNonUniformBroadcastFirst = 338u32,
|
|
GroupNonUniformBallot = 339u32,
|
|
GroupNonUniformInverseBallot = 340u32,
|
|
GroupNonUniformBallotBitExtract = 341u32,
|
|
GroupNonUniformBallotBitCount = 342u32,
|
|
GroupNonUniformBallotFindLSB = 343u32,
|
|
GroupNonUniformBallotFindMSB = 344u32,
|
|
GroupNonUniformShuffle = 345u32,
|
|
GroupNonUniformShuffleXor = 346u32,
|
|
GroupNonUniformShuffleUp = 347u32,
|
|
GroupNonUniformShuffleDown = 348u32,
|
|
GroupNonUniformIAdd = 349u32,
|
|
GroupNonUniformFAdd = 350u32,
|
|
GroupNonUniformIMul = 351u32,
|
|
GroupNonUniformFMul = 352u32,
|
|
GroupNonUniformSMin = 353u32,
|
|
GroupNonUniformUMin = 354u32,
|
|
GroupNonUniformFMin = 355u32,
|
|
GroupNonUniformSMax = 356u32,
|
|
GroupNonUniformUMax = 357u32,
|
|
GroupNonUniformFMax = 358u32,
|
|
GroupNonUniformBitwiseAnd = 359u32,
|
|
GroupNonUniformBitwiseOr = 360u32,
|
|
GroupNonUniformBitwiseXor = 361u32,
|
|
GroupNonUniformLogicalAnd = 362u32,
|
|
GroupNonUniformLogicalOr = 363u32,
|
|
GroupNonUniformLogicalXor = 364u32,
|
|
GroupNonUniformQuadBroadcast = 365u32,
|
|
GroupNonUniformQuadSwap = 366u32,
|
|
CopyLogical = 400u32,
|
|
PtrEqual = 401u32,
|
|
PtrNotEqual = 402u32,
|
|
PtrDiff = 403u32,
|
|
ColorAttachmentReadEXT = 4160u32,
|
|
DepthAttachmentReadEXT = 4161u32,
|
|
StencilAttachmentReadEXT = 4162u32,
|
|
TerminateInvocation = 4416u32,
|
|
SubgroupBallotKHR = 4421u32,
|
|
SubgroupFirstInvocationKHR = 4422u32,
|
|
SubgroupAllKHR = 4428u32,
|
|
SubgroupAnyKHR = 4429u32,
|
|
SubgroupAllEqualKHR = 4430u32,
|
|
GroupNonUniformRotateKHR = 4431u32,
|
|
SubgroupReadInvocationKHR = 4432u32,
|
|
TraceRayKHR = 4445u32,
|
|
ExecuteCallableKHR = 4446u32,
|
|
ConvertUToAccelerationStructureKHR = 4447u32,
|
|
IgnoreIntersectionKHR = 4448u32,
|
|
TerminateRayKHR = 4449u32,
|
|
SDot = 4450u32,
|
|
UDot = 4451u32,
|
|
SUDot = 4452u32,
|
|
SDotAccSat = 4453u32,
|
|
UDotAccSat = 4454u32,
|
|
SUDotAccSat = 4455u32,
|
|
TypeCooperativeMatrixKHR = 4456u32,
|
|
CooperativeMatrixLoadKHR = 4457u32,
|
|
CooperativeMatrixStoreKHR = 4458u32,
|
|
CooperativeMatrixMulAddKHR = 4459u32,
|
|
CooperativeMatrixLengthKHR = 4460u32,
|
|
TypeRayQueryKHR = 4472u32,
|
|
RayQueryInitializeKHR = 4473u32,
|
|
RayQueryTerminateKHR = 4474u32,
|
|
RayQueryGenerateIntersectionKHR = 4475u32,
|
|
RayQueryConfirmIntersectionKHR = 4476u32,
|
|
RayQueryProceedKHR = 4477u32,
|
|
RayQueryGetIntersectionTypeKHR = 4479u32,
|
|
ImageSampleWeightedQCOM = 4480u32,
|
|
ImageBoxFilterQCOM = 4481u32,
|
|
ImageBlockMatchSSDQCOM = 4482u32,
|
|
ImageBlockMatchSADQCOM = 4483u32,
|
|
GroupIAddNonUniformAMD = 5000u32,
|
|
GroupFAddNonUniformAMD = 5001u32,
|
|
GroupFMinNonUniformAMD = 5002u32,
|
|
GroupUMinNonUniformAMD = 5003u32,
|
|
GroupSMinNonUniformAMD = 5004u32,
|
|
GroupFMaxNonUniformAMD = 5005u32,
|
|
GroupUMaxNonUniformAMD = 5006u32,
|
|
GroupSMaxNonUniformAMD = 5007u32,
|
|
FragmentMaskFetchAMD = 5011u32,
|
|
FragmentFetchAMD = 5012u32,
|
|
ReadClockKHR = 5056u32,
|
|
FinalizeNodePayloadsAMDX = 5075u32,
|
|
FinishWritingNodePayloadAMDX = 5078u32,
|
|
InitializeNodePayloadsAMDX = 5090u32,
|
|
HitObjectRecordHitMotionNV = 5249u32,
|
|
HitObjectRecordHitWithIndexMotionNV = 5250u32,
|
|
HitObjectRecordMissMotionNV = 5251u32,
|
|
HitObjectGetWorldToObjectNV = 5252u32,
|
|
HitObjectGetObjectToWorldNV = 5253u32,
|
|
HitObjectGetObjectRayDirectionNV = 5254u32,
|
|
HitObjectGetObjectRayOriginNV = 5255u32,
|
|
HitObjectTraceRayMotionNV = 5256u32,
|
|
HitObjectGetShaderRecordBufferHandleNV = 5257u32,
|
|
HitObjectGetShaderBindingTableRecordIndexNV = 5258u32,
|
|
HitObjectRecordEmptyNV = 5259u32,
|
|
HitObjectTraceRayNV = 5260u32,
|
|
HitObjectRecordHitNV = 5261u32,
|
|
HitObjectRecordHitWithIndexNV = 5262u32,
|
|
HitObjectRecordMissNV = 5263u32,
|
|
HitObjectExecuteShaderNV = 5264u32,
|
|
HitObjectGetCurrentTimeNV = 5265u32,
|
|
HitObjectGetAttributesNV = 5266u32,
|
|
HitObjectGetHitKindNV = 5267u32,
|
|
HitObjectGetPrimitiveIndexNV = 5268u32,
|
|
HitObjectGetGeometryIndexNV = 5269u32,
|
|
HitObjectGetInstanceIdNV = 5270u32,
|
|
HitObjectGetInstanceCustomIndexNV = 5271u32,
|
|
HitObjectGetWorldRayDirectionNV = 5272u32,
|
|
HitObjectGetWorldRayOriginNV = 5273u32,
|
|
HitObjectGetRayTMaxNV = 5274u32,
|
|
HitObjectGetRayTMinNV = 5275u32,
|
|
HitObjectIsEmptyNV = 5276u32,
|
|
HitObjectIsHitNV = 5277u32,
|
|
HitObjectIsMissNV = 5278u32,
|
|
ReorderThreadWithHitObjectNV = 5279u32,
|
|
ReorderThreadWithHintNV = 5280u32,
|
|
TypeHitObjectNV = 5281u32,
|
|
ImageSampleFootprintNV = 5283u32,
|
|
EmitMeshTasksEXT = 5294u32,
|
|
SetMeshOutputsEXT = 5295u32,
|
|
GroupNonUniformPartitionNV = 5296u32,
|
|
WritePackedPrimitiveIndices4x8NV = 5299u32,
|
|
FetchMicroTriangleVertexPositionNV = 5300u32,
|
|
FetchMicroTriangleVertexBarycentricNV = 5301u32,
|
|
ReportIntersectionKHR = 5334u32,
|
|
IgnoreIntersectionNV = 5335u32,
|
|
TerminateRayNV = 5336u32,
|
|
TraceNV = 5337u32,
|
|
TraceMotionNV = 5338u32,
|
|
TraceRayMotionNV = 5339u32,
|
|
RayQueryGetIntersectionTriangleVertexPositionsKHR = 5340u32,
|
|
TypeAccelerationStructureKHR = 5341u32,
|
|
ExecuteCallableNV = 5344u32,
|
|
TypeCooperativeMatrixNV = 5358u32,
|
|
CooperativeMatrixLoadNV = 5359u32,
|
|
CooperativeMatrixStoreNV = 5360u32,
|
|
CooperativeMatrixMulAddNV = 5361u32,
|
|
CooperativeMatrixLengthNV = 5362u32,
|
|
BeginInvocationInterlockEXT = 5364u32,
|
|
EndInvocationInterlockEXT = 5365u32,
|
|
DemoteToHelperInvocation = 5380u32,
|
|
IsHelperInvocationEXT = 5381u32,
|
|
ConvertUToImageNV = 5391u32,
|
|
ConvertUToSamplerNV = 5392u32,
|
|
ConvertImageToUNV = 5393u32,
|
|
ConvertSamplerToUNV = 5394u32,
|
|
ConvertUToSampledImageNV = 5395u32,
|
|
ConvertSampledImageToUNV = 5396u32,
|
|
SamplerImageAddressingModeNV = 5397u32,
|
|
SubgroupShuffleINTEL = 5571u32,
|
|
SubgroupShuffleDownINTEL = 5572u32,
|
|
SubgroupShuffleUpINTEL = 5573u32,
|
|
SubgroupShuffleXorINTEL = 5574u32,
|
|
SubgroupBlockReadINTEL = 5575u32,
|
|
SubgroupBlockWriteINTEL = 5576u32,
|
|
SubgroupImageBlockReadINTEL = 5577u32,
|
|
SubgroupImageBlockWriteINTEL = 5578u32,
|
|
SubgroupImageMediaBlockReadINTEL = 5580u32,
|
|
SubgroupImageMediaBlockWriteINTEL = 5581u32,
|
|
UCountLeadingZerosINTEL = 5585u32,
|
|
UCountTrailingZerosINTEL = 5586u32,
|
|
AbsISubINTEL = 5587u32,
|
|
AbsUSubINTEL = 5588u32,
|
|
IAddSatINTEL = 5589u32,
|
|
UAddSatINTEL = 5590u32,
|
|
IAverageINTEL = 5591u32,
|
|
UAverageINTEL = 5592u32,
|
|
IAverageRoundedINTEL = 5593u32,
|
|
UAverageRoundedINTEL = 5594u32,
|
|
ISubSatINTEL = 5595u32,
|
|
USubSatINTEL = 5596u32,
|
|
IMul32x16INTEL = 5597u32,
|
|
UMul32x16INTEL = 5598u32,
|
|
ConstantFunctionPointerINTEL = 5600u32,
|
|
FunctionPointerCallINTEL = 5601u32,
|
|
AsmTargetINTEL = 5609u32,
|
|
AsmINTEL = 5610u32,
|
|
AsmCallINTEL = 5611u32,
|
|
AtomicFMinEXT = 5614u32,
|
|
AtomicFMaxEXT = 5615u32,
|
|
AssumeTrueKHR = 5630u32,
|
|
ExpectKHR = 5631u32,
|
|
DecorateString = 5632u32,
|
|
MemberDecorateString = 5633u32,
|
|
VmeImageINTEL = 5699u32,
|
|
TypeVmeImageINTEL = 5700u32,
|
|
TypeAvcImePayloadINTEL = 5701u32,
|
|
TypeAvcRefPayloadINTEL = 5702u32,
|
|
TypeAvcSicPayloadINTEL = 5703u32,
|
|
TypeAvcMcePayloadINTEL = 5704u32,
|
|
TypeAvcMceResultINTEL = 5705u32,
|
|
TypeAvcImeResultINTEL = 5706u32,
|
|
TypeAvcImeResultSingleReferenceStreamoutINTEL = 5707u32,
|
|
TypeAvcImeResultDualReferenceStreamoutINTEL = 5708u32,
|
|
TypeAvcImeSingleReferenceStreaminINTEL = 5709u32,
|
|
TypeAvcImeDualReferenceStreaminINTEL = 5710u32,
|
|
TypeAvcRefResultINTEL = 5711u32,
|
|
TypeAvcSicResultINTEL = 5712u32,
|
|
SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713u32,
|
|
SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714u32,
|
|
SubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715u32,
|
|
SubgroupAvcMceSetInterShapePenaltyINTEL = 5716u32,
|
|
SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717u32,
|
|
SubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718u32,
|
|
SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719u32,
|
|
SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720u32,
|
|
SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721u32,
|
|
SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722u32,
|
|
SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723u32,
|
|
SubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724u32,
|
|
SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725u32,
|
|
SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726u32,
|
|
SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727u32,
|
|
SubgroupAvcMceSetAcOnlyHaarINTEL = 5728u32,
|
|
SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729u32,
|
|
SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730u32,
|
|
SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731u32,
|
|
SubgroupAvcMceConvertToImePayloadINTEL = 5732u32,
|
|
SubgroupAvcMceConvertToImeResultINTEL = 5733u32,
|
|
SubgroupAvcMceConvertToRefPayloadINTEL = 5734u32,
|
|
SubgroupAvcMceConvertToRefResultINTEL = 5735u32,
|
|
SubgroupAvcMceConvertToSicPayloadINTEL = 5736u32,
|
|
SubgroupAvcMceConvertToSicResultINTEL = 5737u32,
|
|
SubgroupAvcMceGetMotionVectorsINTEL = 5738u32,
|
|
SubgroupAvcMceGetInterDistortionsINTEL = 5739u32,
|
|
SubgroupAvcMceGetBestInterDistortionsINTEL = 5740u32,
|
|
SubgroupAvcMceGetInterMajorShapeINTEL = 5741u32,
|
|
SubgroupAvcMceGetInterMinorShapeINTEL = 5742u32,
|
|
SubgroupAvcMceGetInterDirectionsINTEL = 5743u32,
|
|
SubgroupAvcMceGetInterMotionVectorCountINTEL = 5744u32,
|
|
SubgroupAvcMceGetInterReferenceIdsINTEL = 5745u32,
|
|
SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746u32,
|
|
SubgroupAvcImeInitializeINTEL = 5747u32,
|
|
SubgroupAvcImeSetSingleReferenceINTEL = 5748u32,
|
|
SubgroupAvcImeSetDualReferenceINTEL = 5749u32,
|
|
SubgroupAvcImeRefWindowSizeINTEL = 5750u32,
|
|
SubgroupAvcImeAdjustRefOffsetINTEL = 5751u32,
|
|
SubgroupAvcImeConvertToMcePayloadINTEL = 5752u32,
|
|
SubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753u32,
|
|
SubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754u32,
|
|
SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755u32,
|
|
SubgroupAvcImeSetWeightedSadINTEL = 5756u32,
|
|
SubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757u32,
|
|
SubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758u32,
|
|
SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759u32,
|
|
SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760u32,
|
|
SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761u32,
|
|
SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762u32,
|
|
SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763u32,
|
|
SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764u32,
|
|
SubgroupAvcImeConvertToMceResultINTEL = 5765u32,
|
|
SubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766u32,
|
|
SubgroupAvcImeGetDualReferenceStreaminINTEL = 5767u32,
|
|
SubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768u32,
|
|
SubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769u32,
|
|
SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770u32,
|
|
SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771u32,
|
|
SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772u32,
|
|
SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773u32,
|
|
SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774u32,
|
|
SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775u32,
|
|
SubgroupAvcImeGetBorderReachedINTEL = 5776u32,
|
|
SubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777u32,
|
|
SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778u32,
|
|
SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779u32,
|
|
SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780u32,
|
|
SubgroupAvcFmeInitializeINTEL = 5781u32,
|
|
SubgroupAvcBmeInitializeINTEL = 5782u32,
|
|
SubgroupAvcRefConvertToMcePayloadINTEL = 5783u32,
|
|
SubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784u32,
|
|
SubgroupAvcRefSetBilinearFilterEnableINTEL = 5785u32,
|
|
SubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786u32,
|
|
SubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787u32,
|
|
SubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788u32,
|
|
SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789u32,
|
|
SubgroupAvcRefConvertToMceResultINTEL = 5790u32,
|
|
SubgroupAvcSicInitializeINTEL = 5791u32,
|
|
SubgroupAvcSicConfigureSkcINTEL = 5792u32,
|
|
SubgroupAvcSicConfigureIpeLumaINTEL = 5793u32,
|
|
SubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794u32,
|
|
SubgroupAvcSicGetMotionVectorMaskINTEL = 5795u32,
|
|
SubgroupAvcSicConvertToMcePayloadINTEL = 5796u32,
|
|
SubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797u32,
|
|
SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798u32,
|
|
SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799u32,
|
|
SubgroupAvcSicSetBilinearFilterEnableINTEL = 5800u32,
|
|
SubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801u32,
|
|
SubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802u32,
|
|
SubgroupAvcSicEvaluateIpeINTEL = 5803u32,
|
|
SubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804u32,
|
|
SubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805u32,
|
|
SubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806u32,
|
|
SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807u32,
|
|
SubgroupAvcSicConvertToMceResultINTEL = 5808u32,
|
|
SubgroupAvcSicGetIpeLumaShapeINTEL = 5809u32,
|
|
SubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810u32,
|
|
SubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811u32,
|
|
SubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812u32,
|
|
SubgroupAvcSicGetIpeChromaModeINTEL = 5813u32,
|
|
SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814u32,
|
|
SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815u32,
|
|
SubgroupAvcSicGetInterRawSadsINTEL = 5816u32,
|
|
VariableLengthArrayINTEL = 5818u32,
|
|
SaveMemoryINTEL = 5819u32,
|
|
RestoreMemoryINTEL = 5820u32,
|
|
ArbitraryFloatSinCosPiINTEL = 5840u32,
|
|
ArbitraryFloatCastINTEL = 5841u32,
|
|
ArbitraryFloatCastFromIntINTEL = 5842u32,
|
|
ArbitraryFloatCastToIntINTEL = 5843u32,
|
|
ArbitraryFloatAddINTEL = 5846u32,
|
|
ArbitraryFloatSubINTEL = 5847u32,
|
|
ArbitraryFloatMulINTEL = 5848u32,
|
|
ArbitraryFloatDivINTEL = 5849u32,
|
|
ArbitraryFloatGTINTEL = 5850u32,
|
|
ArbitraryFloatGEINTEL = 5851u32,
|
|
ArbitraryFloatLTINTEL = 5852u32,
|
|
ArbitraryFloatLEINTEL = 5853u32,
|
|
ArbitraryFloatEQINTEL = 5854u32,
|
|
ArbitraryFloatRecipINTEL = 5855u32,
|
|
ArbitraryFloatRSqrtINTEL = 5856u32,
|
|
ArbitraryFloatCbrtINTEL = 5857u32,
|
|
ArbitraryFloatHypotINTEL = 5858u32,
|
|
ArbitraryFloatSqrtINTEL = 5859u32,
|
|
ArbitraryFloatLogINTEL = 5860u32,
|
|
ArbitraryFloatLog2INTEL = 5861u32,
|
|
ArbitraryFloatLog10INTEL = 5862u32,
|
|
ArbitraryFloatLog1pINTEL = 5863u32,
|
|
ArbitraryFloatExpINTEL = 5864u32,
|
|
ArbitraryFloatExp2INTEL = 5865u32,
|
|
ArbitraryFloatExp10INTEL = 5866u32,
|
|
ArbitraryFloatExpm1INTEL = 5867u32,
|
|
ArbitraryFloatSinINTEL = 5868u32,
|
|
ArbitraryFloatCosINTEL = 5869u32,
|
|
ArbitraryFloatSinCosINTEL = 5870u32,
|
|
ArbitraryFloatSinPiINTEL = 5871u32,
|
|
ArbitraryFloatCosPiINTEL = 5872u32,
|
|
ArbitraryFloatASinINTEL = 5873u32,
|
|
ArbitraryFloatASinPiINTEL = 5874u32,
|
|
ArbitraryFloatACosINTEL = 5875u32,
|
|
ArbitraryFloatACosPiINTEL = 5876u32,
|
|
ArbitraryFloatATanINTEL = 5877u32,
|
|
ArbitraryFloatATanPiINTEL = 5878u32,
|
|
ArbitraryFloatATan2INTEL = 5879u32,
|
|
ArbitraryFloatPowINTEL = 5880u32,
|
|
ArbitraryFloatPowRINTEL = 5881u32,
|
|
ArbitraryFloatPowNINTEL = 5882u32,
|
|
LoopControlINTEL = 5887u32,
|
|
AliasDomainDeclINTEL = 5911u32,
|
|
AliasScopeDeclINTEL = 5912u32,
|
|
AliasScopeListDeclINTEL = 5913u32,
|
|
FixedSqrtINTEL = 5923u32,
|
|
FixedRecipINTEL = 5924u32,
|
|
FixedRsqrtINTEL = 5925u32,
|
|
FixedSinINTEL = 5926u32,
|
|
FixedCosINTEL = 5927u32,
|
|
FixedSinCosINTEL = 5928u32,
|
|
FixedSinPiINTEL = 5929u32,
|
|
FixedCosPiINTEL = 5930u32,
|
|
FixedSinCosPiINTEL = 5931u32,
|
|
FixedLogINTEL = 5932u32,
|
|
FixedExpINTEL = 5933u32,
|
|
PtrCastToCrossWorkgroupINTEL = 5934u32,
|
|
CrossWorkgroupCastToPtrINTEL = 5938u32,
|
|
ReadPipeBlockingINTEL = 5946u32,
|
|
WritePipeBlockingINTEL = 5947u32,
|
|
FPGARegINTEL = 5949u32,
|
|
RayQueryGetRayTMinKHR = 6016u32,
|
|
RayQueryGetRayFlagsKHR = 6017u32,
|
|
RayQueryGetIntersectionTKHR = 6018u32,
|
|
RayQueryGetIntersectionInstanceCustomIndexKHR = 6019u32,
|
|
RayQueryGetIntersectionInstanceIdKHR = 6020u32,
|
|
RayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021u32,
|
|
RayQueryGetIntersectionGeometryIndexKHR = 6022u32,
|
|
RayQueryGetIntersectionPrimitiveIndexKHR = 6023u32,
|
|
RayQueryGetIntersectionBarycentricsKHR = 6024u32,
|
|
RayQueryGetIntersectionFrontFaceKHR = 6025u32,
|
|
RayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026u32,
|
|
RayQueryGetIntersectionObjectRayDirectionKHR = 6027u32,
|
|
RayQueryGetIntersectionObjectRayOriginKHR = 6028u32,
|
|
RayQueryGetWorldRayDirectionKHR = 6029u32,
|
|
RayQueryGetWorldRayOriginKHR = 6030u32,
|
|
RayQueryGetIntersectionObjectToWorldKHR = 6031u32,
|
|
RayQueryGetIntersectionWorldToObjectKHR = 6032u32,
|
|
AtomicFAddEXT = 6035u32,
|
|
TypeBufferSurfaceINTEL = 6086u32,
|
|
TypeStructContinuedINTEL = 6090u32,
|
|
ConstantCompositeContinuedINTEL = 6091u32,
|
|
SpecConstantCompositeContinuedINTEL = 6092u32,
|
|
ConvertFToBF16INTEL = 6116u32,
|
|
ConvertBF16ToFINTEL = 6117u32,
|
|
ControlBarrierArriveINTEL = 6142u32,
|
|
ControlBarrierWaitINTEL = 6143u32,
|
|
GroupIMulKHR = 6401u32,
|
|
GroupFMulKHR = 6402u32,
|
|
GroupBitwiseAndKHR = 6403u32,
|
|
GroupBitwiseOrKHR = 6404u32,
|
|
GroupBitwiseXorKHR = 6405u32,
|
|
GroupLogicalAndKHR = 6406u32,
|
|
GroupLogicalOrKHR = 6407u32,
|
|
GroupLogicalXorKHR = 6408u32,
|
|
}
|
|
impl Op {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=8u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
10u32..=12u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
14u32..=17u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
19u32..=39u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
41u32..=46u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
48u32..=52u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
54u32..=57u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
59u32..=75u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
77u32..=84u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
86u32..=107u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
109u32..=124u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
126u32..=152u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
154u32..=191u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
194u32..=205u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
207u32..=215u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
218u32..=221u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
224u32..=225u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
227u32..=242u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
245u32..=257u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
259u32..=271u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
274u32..=288u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
291u32..=366u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
400u32..=403u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
4160u32..=4162u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
4416u32 => unsafe { core::mem::transmute::<u32, Op>(4416u32) },
|
|
4421u32..=4422u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
4428u32..=4432u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
4445u32..=4460u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
4472u32..=4477u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
4479u32..=4483u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5000u32..=5007u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5011u32..=5012u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5056u32 => unsafe { core::mem::transmute::<u32, Op>(5056u32) },
|
|
5075u32 => unsafe { core::mem::transmute::<u32, Op>(5075u32) },
|
|
5078u32 => unsafe { core::mem::transmute::<u32, Op>(5078u32) },
|
|
5090u32 => unsafe { core::mem::transmute::<u32, Op>(5090u32) },
|
|
5249u32..=5281u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5283u32 => unsafe { core::mem::transmute::<u32, Op>(5283u32) },
|
|
5294u32..=5296u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5299u32..=5301u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5334u32..=5341u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5344u32 => unsafe { core::mem::transmute::<u32, Op>(5344u32) },
|
|
5358u32..=5362u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5364u32..=5365u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5380u32..=5381u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5391u32..=5397u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5571u32..=5578u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5580u32..=5581u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5585u32..=5598u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5600u32..=5601u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5609u32..=5611u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5614u32..=5615u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5630u32..=5633u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5699u32..=5816u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5818u32..=5820u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5840u32..=5843u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5846u32..=5882u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5887u32 => unsafe { core::mem::transmute::<u32, Op>(5887u32) },
|
|
5911u32..=5913u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5923u32..=5934u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5938u32 => unsafe { core::mem::transmute::<u32, Op>(5938u32) },
|
|
5946u32..=5947u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
5949u32 => unsafe { core::mem::transmute::<u32, Op>(5949u32) },
|
|
6016u32..=6032u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
6035u32 => unsafe { core::mem::transmute::<u32, Op>(6035u32) },
|
|
6086u32 => unsafe { core::mem::transmute::<u32, Op>(6086u32) },
|
|
6090u32..=6092u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
6116u32..=6117u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
6142u32..=6143u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
6401u32..=6408u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
#[allow(non_upper_case_globals)]
|
|
impl Op {
|
|
pub const SDotKHR: Op = Op::SDot;
|
|
pub const UDotKHR: Op = Op::UDot;
|
|
pub const SUDotKHR: Op = Op::SUDot;
|
|
pub const SDotAccSatKHR: Op = Op::SDotAccSat;
|
|
pub const UDotAccSatKHR: Op = Op::UDotAccSat;
|
|
pub const SUDotAccSatKHR: Op = Op::SUDotAccSat;
|
|
pub const ReportIntersectionNV: Op = Op::ReportIntersectionKHR;
|
|
pub const TypeAccelerationStructureNV: Op = Op::TypeAccelerationStructureKHR;
|
|
pub const DemoteToHelperInvocationEXT: Op = Op::DemoteToHelperInvocation;
|
|
pub const DecorateStringGOOGLE: Op = Op::DecorateString;
|
|
pub const MemberDecorateStringGOOGLE: Op = Op::MemberDecorateString;
|
|
}
|
|
#[doc = "[GLSL.std.450](https://www.khronos.org/registry/spir-v/specs/unified1/GLSL.std.450.html) extended instruction opcode"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum GLOp {
|
|
Round = 1u32,
|
|
RoundEven = 2u32,
|
|
Trunc = 3u32,
|
|
FAbs = 4u32,
|
|
SAbs = 5u32,
|
|
FSign = 6u32,
|
|
SSign = 7u32,
|
|
Floor = 8u32,
|
|
Ceil = 9u32,
|
|
Fract = 10u32,
|
|
Radians = 11u32,
|
|
Degrees = 12u32,
|
|
Sin = 13u32,
|
|
Cos = 14u32,
|
|
Tan = 15u32,
|
|
Asin = 16u32,
|
|
Acos = 17u32,
|
|
Atan = 18u32,
|
|
Sinh = 19u32,
|
|
Cosh = 20u32,
|
|
Tanh = 21u32,
|
|
Asinh = 22u32,
|
|
Acosh = 23u32,
|
|
Atanh = 24u32,
|
|
Atan2 = 25u32,
|
|
Pow = 26u32,
|
|
Exp = 27u32,
|
|
Log = 28u32,
|
|
Exp2 = 29u32,
|
|
Log2 = 30u32,
|
|
Sqrt = 31u32,
|
|
InverseSqrt = 32u32,
|
|
Determinant = 33u32,
|
|
MatrixInverse = 34u32,
|
|
Modf = 35u32,
|
|
ModfStruct = 36u32,
|
|
FMin = 37u32,
|
|
UMin = 38u32,
|
|
SMin = 39u32,
|
|
FMax = 40u32,
|
|
UMax = 41u32,
|
|
SMax = 42u32,
|
|
FClamp = 43u32,
|
|
UClamp = 44u32,
|
|
SClamp = 45u32,
|
|
FMix = 46u32,
|
|
IMix = 47u32,
|
|
Step = 48u32,
|
|
SmoothStep = 49u32,
|
|
Fma = 50u32,
|
|
Frexp = 51u32,
|
|
FrexpStruct = 52u32,
|
|
Ldexp = 53u32,
|
|
PackSnorm4x8 = 54u32,
|
|
PackUnorm4x8 = 55u32,
|
|
PackSnorm2x16 = 56u32,
|
|
PackUnorm2x16 = 57u32,
|
|
PackHalf2x16 = 58u32,
|
|
PackDouble2x32 = 59u32,
|
|
UnpackSnorm2x16 = 60u32,
|
|
UnpackUnorm2x16 = 61u32,
|
|
UnpackHalf2x16 = 62u32,
|
|
UnpackSnorm4x8 = 63u32,
|
|
UnpackUnorm4x8 = 64u32,
|
|
UnpackDouble2x32 = 65u32,
|
|
Length = 66u32,
|
|
Distance = 67u32,
|
|
Cross = 68u32,
|
|
Normalize = 69u32,
|
|
FaceForward = 70u32,
|
|
Reflect = 71u32,
|
|
Refract = 72u32,
|
|
FindILsb = 73u32,
|
|
FindSMsb = 74u32,
|
|
FindUMsb = 75u32,
|
|
InterpolateAtCentroid = 76u32,
|
|
InterpolateAtSample = 77u32,
|
|
InterpolateAtOffset = 78u32,
|
|
NMin = 79u32,
|
|
NMax = 80u32,
|
|
NClamp = 81u32,
|
|
}
|
|
impl GLOp {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
1u32..=81u32 => unsafe { core::mem::transmute::<u32, GLOp>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|
|
#[doc = "[OpenCL.std](https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.ExtendedInstructionSet.100.html) extended instruction opcode"]
|
|
#[repr(u32)]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
|
|
#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum CLOp {
|
|
acos = 0u32,
|
|
acosh = 1u32,
|
|
acospi = 2u32,
|
|
asin = 3u32,
|
|
asinh = 4u32,
|
|
asinpi = 5u32,
|
|
atan = 6u32,
|
|
atan2 = 7u32,
|
|
atanh = 8u32,
|
|
atanpi = 9u32,
|
|
atan2pi = 10u32,
|
|
cbrt = 11u32,
|
|
ceil = 12u32,
|
|
copysign = 13u32,
|
|
cos = 14u32,
|
|
cosh = 15u32,
|
|
cospi = 16u32,
|
|
erfc = 17u32,
|
|
erf = 18u32,
|
|
exp = 19u32,
|
|
exp2 = 20u32,
|
|
exp10 = 21u32,
|
|
expm1 = 22u32,
|
|
fabs = 23u32,
|
|
fdim = 24u32,
|
|
floor = 25u32,
|
|
fma = 26u32,
|
|
fmax = 27u32,
|
|
fmin = 28u32,
|
|
fmod = 29u32,
|
|
fract = 30u32,
|
|
frexp = 31u32,
|
|
hypot = 32u32,
|
|
ilogb = 33u32,
|
|
ldexp = 34u32,
|
|
lgamma = 35u32,
|
|
lgamma_r = 36u32,
|
|
log = 37u32,
|
|
log2 = 38u32,
|
|
log10 = 39u32,
|
|
log1p = 40u32,
|
|
logb = 41u32,
|
|
mad = 42u32,
|
|
maxmag = 43u32,
|
|
minmag = 44u32,
|
|
modf = 45u32,
|
|
nan = 46u32,
|
|
nextafter = 47u32,
|
|
pow = 48u32,
|
|
pown = 49u32,
|
|
powr = 50u32,
|
|
remainder = 51u32,
|
|
remquo = 52u32,
|
|
rint = 53u32,
|
|
rootn = 54u32,
|
|
round = 55u32,
|
|
rsqrt = 56u32,
|
|
sin = 57u32,
|
|
sincos = 58u32,
|
|
sinh = 59u32,
|
|
sinpi = 60u32,
|
|
sqrt = 61u32,
|
|
tan = 62u32,
|
|
tanh = 63u32,
|
|
tanpi = 64u32,
|
|
tgamma = 65u32,
|
|
trunc = 66u32,
|
|
half_cos = 67u32,
|
|
half_divide = 68u32,
|
|
half_exp = 69u32,
|
|
half_exp2 = 70u32,
|
|
half_exp10 = 71u32,
|
|
half_log = 72u32,
|
|
half_log2 = 73u32,
|
|
half_log10 = 74u32,
|
|
half_powr = 75u32,
|
|
half_recip = 76u32,
|
|
half_rsqrt = 77u32,
|
|
half_sin = 78u32,
|
|
half_sqrt = 79u32,
|
|
half_tan = 80u32,
|
|
native_cos = 81u32,
|
|
native_divide = 82u32,
|
|
native_exp = 83u32,
|
|
native_exp2 = 84u32,
|
|
native_exp10 = 85u32,
|
|
native_log = 86u32,
|
|
native_log2 = 87u32,
|
|
native_log10 = 88u32,
|
|
native_powr = 89u32,
|
|
native_recip = 90u32,
|
|
native_rsqrt = 91u32,
|
|
native_sin = 92u32,
|
|
native_sqrt = 93u32,
|
|
native_tan = 94u32,
|
|
fclamp = 95u32,
|
|
degrees = 96u32,
|
|
fmax_common = 97u32,
|
|
fmin_common = 98u32,
|
|
mix = 99u32,
|
|
radians = 100u32,
|
|
step = 101u32,
|
|
smoothstep = 102u32,
|
|
sign = 103u32,
|
|
cross = 104u32,
|
|
distance = 105u32,
|
|
length = 106u32,
|
|
normalize = 107u32,
|
|
fast_distance = 108u32,
|
|
fast_length = 109u32,
|
|
fast_normalize = 110u32,
|
|
s_abs = 141u32,
|
|
s_abs_diff = 142u32,
|
|
s_add_sat = 143u32,
|
|
u_add_sat = 144u32,
|
|
s_hadd = 145u32,
|
|
u_hadd = 146u32,
|
|
s_rhadd = 147u32,
|
|
u_rhadd = 148u32,
|
|
s_clamp = 149u32,
|
|
u_clamp = 150u32,
|
|
clz = 151u32,
|
|
ctz = 152u32,
|
|
s_mad_hi = 153u32,
|
|
u_mad_sat = 154u32,
|
|
s_mad_sat = 155u32,
|
|
s_max = 156u32,
|
|
u_max = 157u32,
|
|
s_min = 158u32,
|
|
u_min = 159u32,
|
|
s_mul_hi = 160u32,
|
|
rotate = 161u32,
|
|
s_sub_sat = 162u32,
|
|
u_sub_sat = 163u32,
|
|
u_upsample = 164u32,
|
|
s_upsample = 165u32,
|
|
popcount = 166u32,
|
|
s_mad24 = 167u32,
|
|
u_mad24 = 168u32,
|
|
s_mul24 = 169u32,
|
|
u_mul24 = 170u32,
|
|
vloadn = 171u32,
|
|
vstoren = 172u32,
|
|
vload_half = 173u32,
|
|
vload_halfn = 174u32,
|
|
vstore_half = 175u32,
|
|
vstore_half_r = 176u32,
|
|
vstore_halfn = 177u32,
|
|
vstore_halfn_r = 178u32,
|
|
vloada_halfn = 179u32,
|
|
vstorea_halfn = 180u32,
|
|
vstorea_halfn_r = 181u32,
|
|
shuffle = 182u32,
|
|
shuffle2 = 183u32,
|
|
printf = 184u32,
|
|
prefetch = 185u32,
|
|
bitselect = 186u32,
|
|
select = 187u32,
|
|
u_abs = 201u32,
|
|
u_abs_diff = 202u32,
|
|
u_mul_hi = 203u32,
|
|
u_mad_hi = 204u32,
|
|
}
|
|
impl CLOp {
|
|
pub fn from_u32(n: u32) -> Option<Self> {
|
|
Some(match n {
|
|
0u32..=110u32 => unsafe { core::mem::transmute::<u32, CLOp>(n) },
|
|
141u32..=187u32 => unsafe { core::mem::transmute::<u32, CLOp>(n) },
|
|
201u32..=204u32 => unsafe { core::mem::transmute::<u32, CLOp>(n) },
|
|
_ => return None,
|
|
})
|
|
}
|
|
}
|