1pub type Word = u32;
6pub const MAGIC_NUMBER: u32 = 0x07230203;
7pub const MAJOR_VERSION: u8 = 1u8;
8pub const MINOR_VERSION: u8 = 6u8;
9pub const REVISION: u8 = 1u8;
10bitflags! { # [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 ; } }
11bitflags! { # [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 ; } }
12bitflags! { # [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 ; } }
13bitflags! { # [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 ; } }
14bitflags! { # [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 ; } }
15bitflags! { # [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 ; } }
16bitflags! { # [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 ; } }
17bitflags! { # [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 ; } }
18bitflags! { # [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 ; } }
19bitflags! { # [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 ; } }
20#[doc = "SPIR-V operand kind: [SourceLanguage](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_source_language_a_source_language)"]
21#[repr(u32)]
22#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
23#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
24#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
25#[allow(clippy::upper_case_acronyms)]
26pub enum SourceLanguage {
27 Unknown = 0u32,
28 ESSL = 1u32,
29 GLSL = 2u32,
30 OpenCL_C = 3u32,
31 OpenCL_CPP = 4u32,
32 HLSL = 5u32,
33 CPP_for_OpenCL = 6u32,
34 SYCL = 7u32,
35 HERO_C = 8u32,
36 NZSL = 9u32,
37 WGSL = 10u32,
38 Slang = 11u32,
39}
40impl SourceLanguage {
41 pub fn from_u32(n: u32) -> Option<Self> {
42 Some(match n {
43 0u32..=11u32 => unsafe { core::mem::transmute::<u32, SourceLanguage>(n) },
44 _ => return None,
45 })
46 }
47}
48#[allow(non_upper_case_globals)]
49impl SourceLanguage {}
50impl core::str::FromStr for SourceLanguage {
51 type Err = ();
52 fn from_str(s: &str) -> Result<Self, Self::Err> {
53 match s {
54 "Unknown" => Ok(Self::Unknown),
55 "ESSL" => Ok(Self::ESSL),
56 "GLSL" => Ok(Self::GLSL),
57 "OpenCL_C" => Ok(Self::OpenCL_C),
58 "OpenCL_CPP" => Ok(Self::OpenCL_CPP),
59 "HLSL" => Ok(Self::HLSL),
60 "CPP_for_OpenCL" => Ok(Self::CPP_for_OpenCL),
61 "SYCL" => Ok(Self::SYCL),
62 "HERO_C" => Ok(Self::HERO_C),
63 "NZSL" => Ok(Self::NZSL),
64 "WGSL" => Ok(Self::WGSL),
65 "Slang" => Ok(Self::Slang),
66 _ => Err(()),
67 }
68 }
69}
70#[doc = "SPIR-V operand kind: [ExecutionModel](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_execution_model_a_execution_model)"]
71#[repr(u32)]
72#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
73#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
74#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
75#[allow(clippy::upper_case_acronyms)]
76pub enum ExecutionModel {
77 Vertex = 0u32,
78 TessellationControl = 1u32,
79 TessellationEvaluation = 2u32,
80 Geometry = 3u32,
81 Fragment = 4u32,
82 GLCompute = 5u32,
83 Kernel = 6u32,
84 TaskNV = 5267u32,
85 MeshNV = 5268u32,
86 RayGenerationNV = 5313u32,
87 IntersectionNV = 5314u32,
88 AnyHitNV = 5315u32,
89 ClosestHitNV = 5316u32,
90 MissNV = 5317u32,
91 CallableNV = 5318u32,
92 TaskEXT = 5364u32,
93 MeshEXT = 5365u32,
94}
95impl ExecutionModel {
96 pub fn from_u32(n: u32) -> Option<Self> {
97 Some(match n {
98 0u32..=6u32 => unsafe { core::mem::transmute::<u32, ExecutionModel>(n) },
99 5267u32..=5268u32 => unsafe { core::mem::transmute::<u32, ExecutionModel>(n) },
100 5313u32..=5318u32 => unsafe { core::mem::transmute::<u32, ExecutionModel>(n) },
101 5364u32..=5365u32 => unsafe { core::mem::transmute::<u32, ExecutionModel>(n) },
102 _ => return None,
103 })
104 }
105}
106#[allow(non_upper_case_globals)]
107impl ExecutionModel {
108 pub const RayGenerationKHR: Self = Self::RayGenerationNV;
109 pub const IntersectionKHR: Self = Self::IntersectionNV;
110 pub const AnyHitKHR: Self = Self::AnyHitNV;
111 pub const ClosestHitKHR: Self = Self::ClosestHitNV;
112 pub const MissKHR: Self = Self::MissNV;
113 pub const CallableKHR: Self = Self::CallableNV;
114}
115impl core::str::FromStr for ExecutionModel {
116 type Err = ();
117 fn from_str(s: &str) -> Result<Self, Self::Err> {
118 match s {
119 "Vertex" => Ok(Self::Vertex),
120 "TessellationControl" => Ok(Self::TessellationControl),
121 "TessellationEvaluation" => Ok(Self::TessellationEvaluation),
122 "Geometry" => Ok(Self::Geometry),
123 "Fragment" => Ok(Self::Fragment),
124 "GLCompute" => Ok(Self::GLCompute),
125 "Kernel" => Ok(Self::Kernel),
126 "TaskNV" => Ok(Self::TaskNV),
127 "MeshNV" => Ok(Self::MeshNV),
128 "RayGenerationNV" => Ok(Self::RayGenerationNV),
129 "RayGenerationKHR" => Ok(Self::RayGenerationNV),
130 "IntersectionNV" => Ok(Self::IntersectionNV),
131 "IntersectionKHR" => Ok(Self::IntersectionNV),
132 "AnyHitNV" => Ok(Self::AnyHitNV),
133 "AnyHitKHR" => Ok(Self::AnyHitNV),
134 "ClosestHitNV" => Ok(Self::ClosestHitNV),
135 "ClosestHitKHR" => Ok(Self::ClosestHitNV),
136 "MissNV" => Ok(Self::MissNV),
137 "MissKHR" => Ok(Self::MissNV),
138 "CallableNV" => Ok(Self::CallableNV),
139 "CallableKHR" => Ok(Self::CallableNV),
140 "TaskEXT" => Ok(Self::TaskEXT),
141 "MeshEXT" => Ok(Self::MeshEXT),
142 _ => Err(()),
143 }
144 }
145}
146#[doc = "SPIR-V operand kind: [AddressingModel](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_addressing_model_a_addressing_model)"]
147#[repr(u32)]
148#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
149#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
150#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
151#[allow(clippy::upper_case_acronyms)]
152pub enum AddressingModel {
153 Logical = 0u32,
154 Physical32 = 1u32,
155 Physical64 = 2u32,
156 PhysicalStorageBuffer64 = 5348u32,
157}
158impl AddressingModel {
159 pub fn from_u32(n: u32) -> Option<Self> {
160 Some(match n {
161 0u32..=2u32 => unsafe { core::mem::transmute::<u32, AddressingModel>(n) },
162 5348u32 => unsafe { core::mem::transmute::<u32, AddressingModel>(5348u32) },
163 _ => return None,
164 })
165 }
166}
167#[allow(non_upper_case_globals)]
168impl AddressingModel {
169 pub const PhysicalStorageBuffer64EXT: Self = Self::PhysicalStorageBuffer64;
170}
171impl core::str::FromStr for AddressingModel {
172 type Err = ();
173 fn from_str(s: &str) -> Result<Self, Self::Err> {
174 match s {
175 "Logical" => Ok(Self::Logical),
176 "Physical32" => Ok(Self::Physical32),
177 "Physical64" => Ok(Self::Physical64),
178 "PhysicalStorageBuffer64" => Ok(Self::PhysicalStorageBuffer64),
179 "PhysicalStorageBuffer64EXT" => Ok(Self::PhysicalStorageBuffer64),
180 _ => Err(()),
181 }
182 }
183}
184#[doc = "SPIR-V operand kind: [MemoryModel](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_memory_model_a_memory_model)"]
185#[repr(u32)]
186#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
187#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
188#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
189#[allow(clippy::upper_case_acronyms)]
190pub enum MemoryModel {
191 Simple = 0u32,
192 GLSL450 = 1u32,
193 OpenCL = 2u32,
194 Vulkan = 3u32,
195}
196impl MemoryModel {
197 pub fn from_u32(n: u32) -> Option<Self> {
198 Some(match n {
199 0u32..=3u32 => unsafe { core::mem::transmute::<u32, MemoryModel>(n) },
200 _ => return None,
201 })
202 }
203}
204#[allow(non_upper_case_globals)]
205impl MemoryModel {
206 pub const VulkanKHR: Self = Self::Vulkan;
207}
208impl core::str::FromStr for MemoryModel {
209 type Err = ();
210 fn from_str(s: &str) -> Result<Self, Self::Err> {
211 match s {
212 "Simple" => Ok(Self::Simple),
213 "GLSL450" => Ok(Self::GLSL450),
214 "OpenCL" => Ok(Self::OpenCL),
215 "Vulkan" => Ok(Self::Vulkan),
216 "VulkanKHR" => Ok(Self::Vulkan),
217 _ => Err(()),
218 }
219 }
220}
221#[doc = "SPIR-V operand kind: [ExecutionMode](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_execution_mode_a_execution_mode)"]
222#[repr(u32)]
223#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
224#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
225#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
226#[allow(clippy::upper_case_acronyms)]
227pub enum ExecutionMode {
228 Invocations = 0u32,
229 SpacingEqual = 1u32,
230 SpacingFractionalEven = 2u32,
231 SpacingFractionalOdd = 3u32,
232 VertexOrderCw = 4u32,
233 VertexOrderCcw = 5u32,
234 PixelCenterInteger = 6u32,
235 OriginUpperLeft = 7u32,
236 OriginLowerLeft = 8u32,
237 EarlyFragmentTests = 9u32,
238 PointMode = 10u32,
239 Xfb = 11u32,
240 DepthReplacing = 12u32,
241 DepthGreater = 14u32,
242 DepthLess = 15u32,
243 DepthUnchanged = 16u32,
244 LocalSize = 17u32,
245 LocalSizeHint = 18u32,
246 InputPoints = 19u32,
247 InputLines = 20u32,
248 InputLinesAdjacency = 21u32,
249 Triangles = 22u32,
250 InputTrianglesAdjacency = 23u32,
251 Quads = 24u32,
252 Isolines = 25u32,
253 OutputVertices = 26u32,
254 OutputPoints = 27u32,
255 OutputLineStrip = 28u32,
256 OutputTriangleStrip = 29u32,
257 VecTypeHint = 30u32,
258 ContractionOff = 31u32,
259 Initializer = 33u32,
260 Finalizer = 34u32,
261 SubgroupSize = 35u32,
262 SubgroupsPerWorkgroup = 36u32,
263 SubgroupsPerWorkgroupId = 37u32,
264 LocalSizeId = 38u32,
265 LocalSizeHintId = 39u32,
266 NonCoherentColorAttachmentReadEXT = 4169u32,
267 NonCoherentDepthAttachmentReadEXT = 4170u32,
268 NonCoherentStencilAttachmentReadEXT = 4171u32,
269 SubgroupUniformControlFlowKHR = 4421u32,
270 PostDepthCoverage = 4446u32,
271 DenormPreserve = 4459u32,
272 DenormFlushToZero = 4460u32,
273 SignedZeroInfNanPreserve = 4461u32,
274 RoundingModeRTE = 4462u32,
275 RoundingModeRTZ = 4463u32,
276 EarlyAndLateFragmentTestsAMD = 5017u32,
277 StencilRefReplacingEXT = 5027u32,
278 CoalescingAMDX = 5069u32,
279 MaxNodeRecursionAMDX = 5071u32,
280 StaticNumWorkgroupsAMDX = 5072u32,
281 ShaderIndexAMDX = 5073u32,
282 MaxNumWorkgroupsAMDX = 5077u32,
283 StencilRefUnchangedFrontAMD = 5079u32,
284 StencilRefGreaterFrontAMD = 5080u32,
285 StencilRefLessFrontAMD = 5081u32,
286 StencilRefUnchangedBackAMD = 5082u32,
287 StencilRefGreaterBackAMD = 5083u32,
288 StencilRefLessBackAMD = 5084u32,
289 OutputLinesNV = 5269u32,
290 OutputPrimitivesNV = 5270u32,
291 DerivativeGroupQuadsNV = 5289u32,
292 DerivativeGroupLinearNV = 5290u32,
293 OutputTrianglesNV = 5298u32,
294 PixelInterlockOrderedEXT = 5366u32,
295 PixelInterlockUnorderedEXT = 5367u32,
296 SampleInterlockOrderedEXT = 5368u32,
297 SampleInterlockUnorderedEXT = 5369u32,
298 ShadingRateInterlockOrderedEXT = 5370u32,
299 ShadingRateInterlockUnorderedEXT = 5371u32,
300 SharedLocalMemorySizeINTEL = 5618u32,
301 RoundingModeRTPINTEL = 5620u32,
302 RoundingModeRTNINTEL = 5621u32,
303 FloatingPointModeALTINTEL = 5622u32,
304 FloatingPointModeIEEEINTEL = 5623u32,
305 MaxWorkgroupSizeINTEL = 5893u32,
306 MaxWorkDimINTEL = 5894u32,
307 NoGlobalOffsetINTEL = 5895u32,
308 NumSIMDWorkitemsINTEL = 5896u32,
309 SchedulerTargetFmaxMhzINTEL = 5903u32,
310 StreamingInterfaceINTEL = 6154u32,
311 RegisterMapInterfaceINTEL = 6160u32,
312 NamedBarrierCountINTEL = 6417u32,
313}
314impl ExecutionMode {
315 pub fn from_u32(n: u32) -> Option<Self> {
316 Some(match n {
317 0u32..=12u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
318 14u32..=31u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
319 33u32..=39u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
320 4169u32..=4171u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
321 4421u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(4421u32) },
322 4446u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(4446u32) },
323 4459u32..=4463u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
324 5017u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5017u32) },
325 5027u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5027u32) },
326 5069u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5069u32) },
327 5071u32..=5073u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
328 5077u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5077u32) },
329 5079u32..=5084u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
330 5269u32..=5270u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
331 5289u32..=5290u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
332 5298u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5298u32) },
333 5366u32..=5371u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
334 5618u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5618u32) },
335 5620u32..=5623u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
336 5893u32..=5896u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(n) },
337 5903u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(5903u32) },
338 6154u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(6154u32) },
339 6160u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(6160u32) },
340 6417u32 => unsafe { core::mem::transmute::<u32, ExecutionMode>(6417u32) },
341 _ => return None,
342 })
343 }
344}
345#[allow(non_upper_case_globals)]
346impl ExecutionMode {
347 pub const OutputLinesEXT: Self = Self::OutputLinesNV;
348 pub const OutputPrimitivesEXT: Self = Self::OutputPrimitivesNV;
349 pub const OutputTrianglesEXT: Self = Self::OutputTrianglesNV;
350}
351impl core::str::FromStr for ExecutionMode {
352 type Err = ();
353 fn from_str(s: &str) -> Result<Self, Self::Err> {
354 match s {
355 "Invocations" => Ok(Self::Invocations),
356 "SpacingEqual" => Ok(Self::SpacingEqual),
357 "SpacingFractionalEven" => Ok(Self::SpacingFractionalEven),
358 "SpacingFractionalOdd" => Ok(Self::SpacingFractionalOdd),
359 "VertexOrderCw" => Ok(Self::VertexOrderCw),
360 "VertexOrderCcw" => Ok(Self::VertexOrderCcw),
361 "PixelCenterInteger" => Ok(Self::PixelCenterInteger),
362 "OriginUpperLeft" => Ok(Self::OriginUpperLeft),
363 "OriginLowerLeft" => Ok(Self::OriginLowerLeft),
364 "EarlyFragmentTests" => Ok(Self::EarlyFragmentTests),
365 "PointMode" => Ok(Self::PointMode),
366 "Xfb" => Ok(Self::Xfb),
367 "DepthReplacing" => Ok(Self::DepthReplacing),
368 "DepthGreater" => Ok(Self::DepthGreater),
369 "DepthLess" => Ok(Self::DepthLess),
370 "DepthUnchanged" => Ok(Self::DepthUnchanged),
371 "LocalSize" => Ok(Self::LocalSize),
372 "LocalSizeHint" => Ok(Self::LocalSizeHint),
373 "InputPoints" => Ok(Self::InputPoints),
374 "InputLines" => Ok(Self::InputLines),
375 "InputLinesAdjacency" => Ok(Self::InputLinesAdjacency),
376 "Triangles" => Ok(Self::Triangles),
377 "InputTrianglesAdjacency" => Ok(Self::InputTrianglesAdjacency),
378 "Quads" => Ok(Self::Quads),
379 "Isolines" => Ok(Self::Isolines),
380 "OutputVertices" => Ok(Self::OutputVertices),
381 "OutputPoints" => Ok(Self::OutputPoints),
382 "OutputLineStrip" => Ok(Self::OutputLineStrip),
383 "OutputTriangleStrip" => Ok(Self::OutputTriangleStrip),
384 "VecTypeHint" => Ok(Self::VecTypeHint),
385 "ContractionOff" => Ok(Self::ContractionOff),
386 "Initializer" => Ok(Self::Initializer),
387 "Finalizer" => Ok(Self::Finalizer),
388 "SubgroupSize" => Ok(Self::SubgroupSize),
389 "SubgroupsPerWorkgroup" => Ok(Self::SubgroupsPerWorkgroup),
390 "SubgroupsPerWorkgroupId" => Ok(Self::SubgroupsPerWorkgroupId),
391 "LocalSizeId" => Ok(Self::LocalSizeId),
392 "LocalSizeHintId" => Ok(Self::LocalSizeHintId),
393 "NonCoherentColorAttachmentReadEXT" => Ok(Self::NonCoherentColorAttachmentReadEXT),
394 "NonCoherentDepthAttachmentReadEXT" => Ok(Self::NonCoherentDepthAttachmentReadEXT),
395 "NonCoherentStencilAttachmentReadEXT" => Ok(Self::NonCoherentStencilAttachmentReadEXT),
396 "SubgroupUniformControlFlowKHR" => Ok(Self::SubgroupUniformControlFlowKHR),
397 "PostDepthCoverage" => Ok(Self::PostDepthCoverage),
398 "DenormPreserve" => Ok(Self::DenormPreserve),
399 "DenormFlushToZero" => Ok(Self::DenormFlushToZero),
400 "SignedZeroInfNanPreserve" => Ok(Self::SignedZeroInfNanPreserve),
401 "RoundingModeRTE" => Ok(Self::RoundingModeRTE),
402 "RoundingModeRTZ" => Ok(Self::RoundingModeRTZ),
403 "EarlyAndLateFragmentTestsAMD" => Ok(Self::EarlyAndLateFragmentTestsAMD),
404 "StencilRefReplacingEXT" => Ok(Self::StencilRefReplacingEXT),
405 "CoalescingAMDX" => Ok(Self::CoalescingAMDX),
406 "MaxNodeRecursionAMDX" => Ok(Self::MaxNodeRecursionAMDX),
407 "StaticNumWorkgroupsAMDX" => Ok(Self::StaticNumWorkgroupsAMDX),
408 "ShaderIndexAMDX" => Ok(Self::ShaderIndexAMDX),
409 "MaxNumWorkgroupsAMDX" => Ok(Self::MaxNumWorkgroupsAMDX),
410 "StencilRefUnchangedFrontAMD" => Ok(Self::StencilRefUnchangedFrontAMD),
411 "StencilRefGreaterFrontAMD" => Ok(Self::StencilRefGreaterFrontAMD),
412 "StencilRefLessFrontAMD" => Ok(Self::StencilRefLessFrontAMD),
413 "StencilRefUnchangedBackAMD" => Ok(Self::StencilRefUnchangedBackAMD),
414 "StencilRefGreaterBackAMD" => Ok(Self::StencilRefGreaterBackAMD),
415 "StencilRefLessBackAMD" => Ok(Self::StencilRefLessBackAMD),
416 "OutputLinesNV" => Ok(Self::OutputLinesNV),
417 "OutputLinesEXT" => Ok(Self::OutputLinesNV),
418 "OutputPrimitivesNV" => Ok(Self::OutputPrimitivesNV),
419 "OutputPrimitivesEXT" => Ok(Self::OutputPrimitivesNV),
420 "DerivativeGroupQuadsNV" => Ok(Self::DerivativeGroupQuadsNV),
421 "DerivativeGroupLinearNV" => Ok(Self::DerivativeGroupLinearNV),
422 "OutputTrianglesNV" => Ok(Self::OutputTrianglesNV),
423 "OutputTrianglesEXT" => Ok(Self::OutputTrianglesNV),
424 "PixelInterlockOrderedEXT" => Ok(Self::PixelInterlockOrderedEXT),
425 "PixelInterlockUnorderedEXT" => Ok(Self::PixelInterlockUnorderedEXT),
426 "SampleInterlockOrderedEXT" => Ok(Self::SampleInterlockOrderedEXT),
427 "SampleInterlockUnorderedEXT" => Ok(Self::SampleInterlockUnorderedEXT),
428 "ShadingRateInterlockOrderedEXT" => Ok(Self::ShadingRateInterlockOrderedEXT),
429 "ShadingRateInterlockUnorderedEXT" => Ok(Self::ShadingRateInterlockUnorderedEXT),
430 "SharedLocalMemorySizeINTEL" => Ok(Self::SharedLocalMemorySizeINTEL),
431 "RoundingModeRTPINTEL" => Ok(Self::RoundingModeRTPINTEL),
432 "RoundingModeRTNINTEL" => Ok(Self::RoundingModeRTNINTEL),
433 "FloatingPointModeALTINTEL" => Ok(Self::FloatingPointModeALTINTEL),
434 "FloatingPointModeIEEEINTEL" => Ok(Self::FloatingPointModeIEEEINTEL),
435 "MaxWorkgroupSizeINTEL" => Ok(Self::MaxWorkgroupSizeINTEL),
436 "MaxWorkDimINTEL" => Ok(Self::MaxWorkDimINTEL),
437 "NoGlobalOffsetINTEL" => Ok(Self::NoGlobalOffsetINTEL),
438 "NumSIMDWorkitemsINTEL" => Ok(Self::NumSIMDWorkitemsINTEL),
439 "SchedulerTargetFmaxMhzINTEL" => Ok(Self::SchedulerTargetFmaxMhzINTEL),
440 "StreamingInterfaceINTEL" => Ok(Self::StreamingInterfaceINTEL),
441 "RegisterMapInterfaceINTEL" => Ok(Self::RegisterMapInterfaceINTEL),
442 "NamedBarrierCountINTEL" => Ok(Self::NamedBarrierCountINTEL),
443 _ => Err(()),
444 }
445 }
446}
447#[doc = "SPIR-V operand kind: [StorageClass](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_storage_class_a_storage_class)"]
448#[repr(u32)]
449#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
450#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
451#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
452#[allow(clippy::upper_case_acronyms)]
453pub enum StorageClass {
454 UniformConstant = 0u32,
455 Input = 1u32,
456 Uniform = 2u32,
457 Output = 3u32,
458 Workgroup = 4u32,
459 CrossWorkgroup = 5u32,
460 Private = 6u32,
461 Function = 7u32,
462 Generic = 8u32,
463 PushConstant = 9u32,
464 AtomicCounter = 10u32,
465 Image = 11u32,
466 StorageBuffer = 12u32,
467 TileImageEXT = 4172u32,
468 NodePayloadAMDX = 5068u32,
469 NodeOutputPayloadAMDX = 5076u32,
470 CallableDataNV = 5328u32,
471 IncomingCallableDataNV = 5329u32,
472 RayPayloadNV = 5338u32,
473 HitAttributeNV = 5339u32,
474 IncomingRayPayloadNV = 5342u32,
475 ShaderRecordBufferNV = 5343u32,
476 PhysicalStorageBuffer = 5349u32,
477 HitObjectAttributeNV = 5385u32,
478 TaskPayloadWorkgroupEXT = 5402u32,
479 CodeSectionINTEL = 5605u32,
480 DeviceOnlyINTEL = 5936u32,
481 HostOnlyINTEL = 5937u32,
482}
483impl StorageClass {
484 pub fn from_u32(n: u32) -> Option<Self> {
485 Some(match n {
486 0u32..=12u32 => unsafe { core::mem::transmute::<u32, StorageClass>(n) },
487 4172u32 => unsafe { core::mem::transmute::<u32, StorageClass>(4172u32) },
488 5068u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5068u32) },
489 5076u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5076u32) },
490 5328u32..=5329u32 => unsafe { core::mem::transmute::<u32, StorageClass>(n) },
491 5338u32..=5339u32 => unsafe { core::mem::transmute::<u32, StorageClass>(n) },
492 5342u32..=5343u32 => unsafe { core::mem::transmute::<u32, StorageClass>(n) },
493 5349u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5349u32) },
494 5385u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5385u32) },
495 5402u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5402u32) },
496 5605u32 => unsafe { core::mem::transmute::<u32, StorageClass>(5605u32) },
497 5936u32..=5937u32 => unsafe { core::mem::transmute::<u32, StorageClass>(n) },
498 _ => return None,
499 })
500 }
501}
502#[allow(non_upper_case_globals)]
503impl StorageClass {
504 pub const CallableDataKHR: Self = Self::CallableDataNV;
505 pub const IncomingCallableDataKHR: Self = Self::IncomingCallableDataNV;
506 pub const RayPayloadKHR: Self = Self::RayPayloadNV;
507 pub const HitAttributeKHR: Self = Self::HitAttributeNV;
508 pub const IncomingRayPayloadKHR: Self = Self::IncomingRayPayloadNV;
509 pub const ShaderRecordBufferKHR: Self = Self::ShaderRecordBufferNV;
510 pub const PhysicalStorageBufferEXT: Self = Self::PhysicalStorageBuffer;
511}
512impl core::str::FromStr for StorageClass {
513 type Err = ();
514 fn from_str(s: &str) -> Result<Self, Self::Err> {
515 match s {
516 "UniformConstant" => Ok(Self::UniformConstant),
517 "Input" => Ok(Self::Input),
518 "Uniform" => Ok(Self::Uniform),
519 "Output" => Ok(Self::Output),
520 "Workgroup" => Ok(Self::Workgroup),
521 "CrossWorkgroup" => Ok(Self::CrossWorkgroup),
522 "Private" => Ok(Self::Private),
523 "Function" => Ok(Self::Function),
524 "Generic" => Ok(Self::Generic),
525 "PushConstant" => Ok(Self::PushConstant),
526 "AtomicCounter" => Ok(Self::AtomicCounter),
527 "Image" => Ok(Self::Image),
528 "StorageBuffer" => Ok(Self::StorageBuffer),
529 "TileImageEXT" => Ok(Self::TileImageEXT),
530 "NodePayloadAMDX" => Ok(Self::NodePayloadAMDX),
531 "NodeOutputPayloadAMDX" => Ok(Self::NodeOutputPayloadAMDX),
532 "CallableDataNV" => Ok(Self::CallableDataNV),
533 "CallableDataKHR" => Ok(Self::CallableDataNV),
534 "IncomingCallableDataNV" => Ok(Self::IncomingCallableDataNV),
535 "IncomingCallableDataKHR" => Ok(Self::IncomingCallableDataNV),
536 "RayPayloadNV" => Ok(Self::RayPayloadNV),
537 "RayPayloadKHR" => Ok(Self::RayPayloadNV),
538 "HitAttributeNV" => Ok(Self::HitAttributeNV),
539 "HitAttributeKHR" => Ok(Self::HitAttributeNV),
540 "IncomingRayPayloadNV" => Ok(Self::IncomingRayPayloadNV),
541 "IncomingRayPayloadKHR" => Ok(Self::IncomingRayPayloadNV),
542 "ShaderRecordBufferNV" => Ok(Self::ShaderRecordBufferNV),
543 "ShaderRecordBufferKHR" => Ok(Self::ShaderRecordBufferNV),
544 "PhysicalStorageBuffer" => Ok(Self::PhysicalStorageBuffer),
545 "PhysicalStorageBufferEXT" => Ok(Self::PhysicalStorageBuffer),
546 "HitObjectAttributeNV" => Ok(Self::HitObjectAttributeNV),
547 "TaskPayloadWorkgroupEXT" => Ok(Self::TaskPayloadWorkgroupEXT),
548 "CodeSectionINTEL" => Ok(Self::CodeSectionINTEL),
549 "DeviceOnlyINTEL" => Ok(Self::DeviceOnlyINTEL),
550 "HostOnlyINTEL" => Ok(Self::HostOnlyINTEL),
551 _ => Err(()),
552 }
553 }
554}
555#[doc = "SPIR-V operand kind: [Dim](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_dim_a_dim)"]
556#[repr(u32)]
557#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
558#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
559#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
560#[allow(clippy::upper_case_acronyms)]
561pub enum Dim {
562 Dim1D = 0u32,
563 Dim2D = 1u32,
564 Dim3D = 2u32,
565 DimCube = 3u32,
566 DimRect = 4u32,
567 DimBuffer = 5u32,
568 DimSubpassData = 6u32,
569 DimTileImageDataEXT = 4173u32,
570}
571impl Dim {
572 pub fn from_u32(n: u32) -> Option<Self> {
573 Some(match n {
574 0u32..=6u32 => unsafe { core::mem::transmute::<u32, Dim>(n) },
575 4173u32 => unsafe { core::mem::transmute::<u32, Dim>(4173u32) },
576 _ => return None,
577 })
578 }
579}
580#[allow(non_upper_case_globals)]
581impl Dim {}
582impl core::str::FromStr for Dim {
583 type Err = ();
584 fn from_str(s: &str) -> Result<Self, Self::Err> {
585 match s {
586 "Dim1D" => Ok(Self::Dim1D),
587 "Dim2D" => Ok(Self::Dim2D),
588 "Dim3D" => Ok(Self::Dim3D),
589 "DimCube" => Ok(Self::DimCube),
590 "DimRect" => Ok(Self::DimRect),
591 "DimBuffer" => Ok(Self::DimBuffer),
592 "DimSubpassData" => Ok(Self::DimSubpassData),
593 "DimTileImageDataEXT" => Ok(Self::DimTileImageDataEXT),
594 _ => Err(()),
595 }
596 }
597}
598#[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)"]
599#[repr(u32)]
600#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
601#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
602#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
603#[allow(clippy::upper_case_acronyms)]
604pub enum SamplerAddressingMode {
605 None = 0u32,
606 ClampToEdge = 1u32,
607 Clamp = 2u32,
608 Repeat = 3u32,
609 RepeatMirrored = 4u32,
610}
611impl SamplerAddressingMode {
612 pub fn from_u32(n: u32) -> Option<Self> {
613 Some(match n {
614 0u32..=4u32 => unsafe { core::mem::transmute::<u32, SamplerAddressingMode>(n) },
615 _ => return None,
616 })
617 }
618}
619#[allow(non_upper_case_globals)]
620impl SamplerAddressingMode {}
621impl core::str::FromStr for SamplerAddressingMode {
622 type Err = ();
623 fn from_str(s: &str) -> Result<Self, Self::Err> {
624 match s {
625 "None" => Ok(Self::None),
626 "ClampToEdge" => Ok(Self::ClampToEdge),
627 "Clamp" => Ok(Self::Clamp),
628 "Repeat" => Ok(Self::Repeat),
629 "RepeatMirrored" => Ok(Self::RepeatMirrored),
630 _ => Err(()),
631 }
632 }
633}
634#[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)"]
635#[repr(u32)]
636#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
637#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
638#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
639#[allow(clippy::upper_case_acronyms)]
640pub enum SamplerFilterMode {
641 Nearest = 0u32,
642 Linear = 1u32,
643}
644impl SamplerFilterMode {
645 pub fn from_u32(n: u32) -> Option<Self> {
646 Some(match n {
647 0u32..=1u32 => unsafe { core::mem::transmute::<u32, SamplerFilterMode>(n) },
648 _ => return None,
649 })
650 }
651}
652#[allow(non_upper_case_globals)]
653impl SamplerFilterMode {}
654impl core::str::FromStr for SamplerFilterMode {
655 type Err = ();
656 fn from_str(s: &str) -> Result<Self, Self::Err> {
657 match s {
658 "Nearest" => Ok(Self::Nearest),
659 "Linear" => Ok(Self::Linear),
660 _ => Err(()),
661 }
662 }
663}
664#[doc = "SPIR-V operand kind: [ImageFormat](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_image_format_a_image_format)"]
665#[repr(u32)]
666#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
667#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
668#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
669#[allow(clippy::upper_case_acronyms)]
670pub enum ImageFormat {
671 Unknown = 0u32,
672 Rgba32f = 1u32,
673 Rgba16f = 2u32,
674 R32f = 3u32,
675 Rgba8 = 4u32,
676 Rgba8Snorm = 5u32,
677 Rg32f = 6u32,
678 Rg16f = 7u32,
679 R11fG11fB10f = 8u32,
680 R16f = 9u32,
681 Rgba16 = 10u32,
682 Rgb10A2 = 11u32,
683 Rg16 = 12u32,
684 Rg8 = 13u32,
685 R16 = 14u32,
686 R8 = 15u32,
687 Rgba16Snorm = 16u32,
688 Rg16Snorm = 17u32,
689 Rg8Snorm = 18u32,
690 R16Snorm = 19u32,
691 R8Snorm = 20u32,
692 Rgba32i = 21u32,
693 Rgba16i = 22u32,
694 Rgba8i = 23u32,
695 R32i = 24u32,
696 Rg32i = 25u32,
697 Rg16i = 26u32,
698 Rg8i = 27u32,
699 R16i = 28u32,
700 R8i = 29u32,
701 Rgba32ui = 30u32,
702 Rgba16ui = 31u32,
703 Rgba8ui = 32u32,
704 R32ui = 33u32,
705 Rgb10a2ui = 34u32,
706 Rg32ui = 35u32,
707 Rg16ui = 36u32,
708 Rg8ui = 37u32,
709 R16ui = 38u32,
710 R8ui = 39u32,
711 R64ui = 40u32,
712 R64i = 41u32,
713}
714impl ImageFormat {
715 pub fn from_u32(n: u32) -> Option<Self> {
716 Some(match n {
717 0u32..=41u32 => unsafe { core::mem::transmute::<u32, ImageFormat>(n) },
718 _ => return None,
719 })
720 }
721}
722#[allow(non_upper_case_globals)]
723impl ImageFormat {}
724impl core::str::FromStr for ImageFormat {
725 type Err = ();
726 fn from_str(s: &str) -> Result<Self, Self::Err> {
727 match s {
728 "Unknown" => Ok(Self::Unknown),
729 "Rgba32f" => Ok(Self::Rgba32f),
730 "Rgba16f" => Ok(Self::Rgba16f),
731 "R32f" => Ok(Self::R32f),
732 "Rgba8" => Ok(Self::Rgba8),
733 "Rgba8Snorm" => Ok(Self::Rgba8Snorm),
734 "Rg32f" => Ok(Self::Rg32f),
735 "Rg16f" => Ok(Self::Rg16f),
736 "R11fG11fB10f" => Ok(Self::R11fG11fB10f),
737 "R16f" => Ok(Self::R16f),
738 "Rgba16" => Ok(Self::Rgba16),
739 "Rgb10A2" => Ok(Self::Rgb10A2),
740 "Rg16" => Ok(Self::Rg16),
741 "Rg8" => Ok(Self::Rg8),
742 "R16" => Ok(Self::R16),
743 "R8" => Ok(Self::R8),
744 "Rgba16Snorm" => Ok(Self::Rgba16Snorm),
745 "Rg16Snorm" => Ok(Self::Rg16Snorm),
746 "Rg8Snorm" => Ok(Self::Rg8Snorm),
747 "R16Snorm" => Ok(Self::R16Snorm),
748 "R8Snorm" => Ok(Self::R8Snorm),
749 "Rgba32i" => Ok(Self::Rgba32i),
750 "Rgba16i" => Ok(Self::Rgba16i),
751 "Rgba8i" => Ok(Self::Rgba8i),
752 "R32i" => Ok(Self::R32i),
753 "Rg32i" => Ok(Self::Rg32i),
754 "Rg16i" => Ok(Self::Rg16i),
755 "Rg8i" => Ok(Self::Rg8i),
756 "R16i" => Ok(Self::R16i),
757 "R8i" => Ok(Self::R8i),
758 "Rgba32ui" => Ok(Self::Rgba32ui),
759 "Rgba16ui" => Ok(Self::Rgba16ui),
760 "Rgba8ui" => Ok(Self::Rgba8ui),
761 "R32ui" => Ok(Self::R32ui),
762 "Rgb10a2ui" => Ok(Self::Rgb10a2ui),
763 "Rg32ui" => Ok(Self::Rg32ui),
764 "Rg16ui" => Ok(Self::Rg16ui),
765 "Rg8ui" => Ok(Self::Rg8ui),
766 "R16ui" => Ok(Self::R16ui),
767 "R8ui" => Ok(Self::R8ui),
768 "R64ui" => Ok(Self::R64ui),
769 "R64i" => Ok(Self::R64i),
770 _ => Err(()),
771 }
772 }
773}
774#[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)"]
775#[repr(u32)]
776#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
777#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
778#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
779#[allow(clippy::upper_case_acronyms)]
780pub enum ImageChannelOrder {
781 R = 0u32,
782 A = 1u32,
783 RG = 2u32,
784 RA = 3u32,
785 RGB = 4u32,
786 RGBA = 5u32,
787 BGRA = 6u32,
788 ARGB = 7u32,
789 Intensity = 8u32,
790 Luminance = 9u32,
791 Rx = 10u32,
792 RGx = 11u32,
793 RGBx = 12u32,
794 Depth = 13u32,
795 DepthStencil = 14u32,
796 sRGB = 15u32,
797 sRGBx = 16u32,
798 sRGBA = 17u32,
799 sBGRA = 18u32,
800 ABGR = 19u32,
801}
802impl ImageChannelOrder {
803 pub fn from_u32(n: u32) -> Option<Self> {
804 Some(match n {
805 0u32..=19u32 => unsafe { core::mem::transmute::<u32, ImageChannelOrder>(n) },
806 _ => return None,
807 })
808 }
809}
810#[allow(non_upper_case_globals)]
811impl ImageChannelOrder {}
812impl core::str::FromStr for ImageChannelOrder {
813 type Err = ();
814 fn from_str(s: &str) -> Result<Self, Self::Err> {
815 match s {
816 "R" => Ok(Self::R),
817 "A" => Ok(Self::A),
818 "RG" => Ok(Self::RG),
819 "RA" => Ok(Self::RA),
820 "RGB" => Ok(Self::RGB),
821 "RGBA" => Ok(Self::RGBA),
822 "BGRA" => Ok(Self::BGRA),
823 "ARGB" => Ok(Self::ARGB),
824 "Intensity" => Ok(Self::Intensity),
825 "Luminance" => Ok(Self::Luminance),
826 "Rx" => Ok(Self::Rx),
827 "RGx" => Ok(Self::RGx),
828 "RGBx" => Ok(Self::RGBx),
829 "Depth" => Ok(Self::Depth),
830 "DepthStencil" => Ok(Self::DepthStencil),
831 "sRGB" => Ok(Self::sRGB),
832 "sRGBx" => Ok(Self::sRGBx),
833 "sRGBA" => Ok(Self::sRGBA),
834 "sBGRA" => Ok(Self::sBGRA),
835 "ABGR" => Ok(Self::ABGR),
836 _ => Err(()),
837 }
838 }
839}
840#[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)"]
841#[repr(u32)]
842#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
843#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
844#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
845#[allow(clippy::upper_case_acronyms)]
846pub enum ImageChannelDataType {
847 SnormInt8 = 0u32,
848 SnormInt16 = 1u32,
849 UnormInt8 = 2u32,
850 UnormInt16 = 3u32,
851 UnormShort565 = 4u32,
852 UnormShort555 = 5u32,
853 UnormInt101010 = 6u32,
854 SignedInt8 = 7u32,
855 SignedInt16 = 8u32,
856 SignedInt32 = 9u32,
857 UnsignedInt8 = 10u32,
858 UnsignedInt16 = 11u32,
859 UnsignedInt32 = 12u32,
860 HalfFloat = 13u32,
861 Float = 14u32,
862 UnormInt24 = 15u32,
863 UnormInt101010_2 = 16u32,
864 UnsignedIntRaw10EXT = 19u32,
865 UnsignedIntRaw12EXT = 20u32,
866}
867impl ImageChannelDataType {
868 pub fn from_u32(n: u32) -> Option<Self> {
869 Some(match n {
870 0u32..=16u32 => unsafe { core::mem::transmute::<u32, ImageChannelDataType>(n) },
871 19u32..=20u32 => unsafe { core::mem::transmute::<u32, ImageChannelDataType>(n) },
872 _ => return None,
873 })
874 }
875}
876#[allow(non_upper_case_globals)]
877impl ImageChannelDataType {}
878impl core::str::FromStr for ImageChannelDataType {
879 type Err = ();
880 fn from_str(s: &str) -> Result<Self, Self::Err> {
881 match s {
882 "SnormInt8" => Ok(Self::SnormInt8),
883 "SnormInt16" => Ok(Self::SnormInt16),
884 "UnormInt8" => Ok(Self::UnormInt8),
885 "UnormInt16" => Ok(Self::UnormInt16),
886 "UnormShort565" => Ok(Self::UnormShort565),
887 "UnormShort555" => Ok(Self::UnormShort555),
888 "UnormInt101010" => Ok(Self::UnormInt101010),
889 "SignedInt8" => Ok(Self::SignedInt8),
890 "SignedInt16" => Ok(Self::SignedInt16),
891 "SignedInt32" => Ok(Self::SignedInt32),
892 "UnsignedInt8" => Ok(Self::UnsignedInt8),
893 "UnsignedInt16" => Ok(Self::UnsignedInt16),
894 "UnsignedInt32" => Ok(Self::UnsignedInt32),
895 "HalfFloat" => Ok(Self::HalfFloat),
896 "Float" => Ok(Self::Float),
897 "UnormInt24" => Ok(Self::UnormInt24),
898 "UnormInt101010_2" => Ok(Self::UnormInt101010_2),
899 "UnsignedIntRaw10EXT" => Ok(Self::UnsignedIntRaw10EXT),
900 "UnsignedIntRaw12EXT" => Ok(Self::UnsignedIntRaw12EXT),
901 _ => Err(()),
902 }
903 }
904}
905#[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)"]
906#[repr(u32)]
907#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
908#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
909#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
910#[allow(clippy::upper_case_acronyms)]
911pub enum FPRoundingMode {
912 RTE = 0u32,
913 RTZ = 1u32,
914 RTP = 2u32,
915 RTN = 3u32,
916}
917impl FPRoundingMode {
918 pub fn from_u32(n: u32) -> Option<Self> {
919 Some(match n {
920 0u32..=3u32 => unsafe { core::mem::transmute::<u32, FPRoundingMode>(n) },
921 _ => return None,
922 })
923 }
924}
925#[allow(non_upper_case_globals)]
926impl FPRoundingMode {}
927impl core::str::FromStr for FPRoundingMode {
928 type Err = ();
929 fn from_str(s: &str) -> Result<Self, Self::Err> {
930 match s {
931 "RTE" => Ok(Self::RTE),
932 "RTZ" => Ok(Self::RTZ),
933 "RTP" => Ok(Self::RTP),
934 "RTN" => Ok(Self::RTN),
935 _ => Err(()),
936 }
937 }
938}
939#[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)"]
940#[repr(u32)]
941#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
942#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
943#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
944#[allow(clippy::upper_case_acronyms)]
945pub enum FPDenormMode {
946 Preserve = 0u32,
947 FlushToZero = 1u32,
948}
949impl FPDenormMode {
950 pub fn from_u32(n: u32) -> Option<Self> {
951 Some(match n {
952 0u32..=1u32 => unsafe { core::mem::transmute::<u32, FPDenormMode>(n) },
953 _ => return None,
954 })
955 }
956}
957#[allow(non_upper_case_globals)]
958impl FPDenormMode {}
959impl core::str::FromStr for FPDenormMode {
960 type Err = ();
961 fn from_str(s: &str) -> Result<Self, Self::Err> {
962 match s {
963 "Preserve" => Ok(Self::Preserve),
964 "FlushToZero" => Ok(Self::FlushToZero),
965 _ => Err(()),
966 }
967 }
968}
969#[doc = "SPIR-V operand kind: [QuantizationModes](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_quantization_modes_a_quantization_modes)"]
970#[repr(u32)]
971#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
972#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
973#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
974#[allow(clippy::upper_case_acronyms)]
975pub enum QuantizationModes {
976 TRN = 0u32,
977 TRN_ZERO = 1u32,
978 RND = 2u32,
979 RND_ZERO = 3u32,
980 RND_INF = 4u32,
981 RND_MIN_INF = 5u32,
982 RND_CONV = 6u32,
983 RND_CONV_ODD = 7u32,
984}
985impl QuantizationModes {
986 pub fn from_u32(n: u32) -> Option<Self> {
987 Some(match n {
988 0u32..=7u32 => unsafe { core::mem::transmute::<u32, QuantizationModes>(n) },
989 _ => return None,
990 })
991 }
992}
993#[allow(non_upper_case_globals)]
994impl QuantizationModes {}
995impl core::str::FromStr for QuantizationModes {
996 type Err = ();
997 fn from_str(s: &str) -> Result<Self, Self::Err> {
998 match s {
999 "TRN" => Ok(Self::TRN),
1000 "TRN_ZERO" => Ok(Self::TRN_ZERO),
1001 "RND" => Ok(Self::RND),
1002 "RND_ZERO" => Ok(Self::RND_ZERO),
1003 "RND_INF" => Ok(Self::RND_INF),
1004 "RND_MIN_INF" => Ok(Self::RND_MIN_INF),
1005 "RND_CONV" => Ok(Self::RND_CONV),
1006 "RND_CONV_ODD" => Ok(Self::RND_CONV_ODD),
1007 _ => Err(()),
1008 }
1009 }
1010}
1011#[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)"]
1012#[repr(u32)]
1013#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1014#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
1015#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
1016#[allow(clippy::upper_case_acronyms)]
1017pub enum FPOperationMode {
1018 IEEE = 0u32,
1019 ALT = 1u32,
1020}
1021impl FPOperationMode {
1022 pub fn from_u32(n: u32) -> Option<Self> {
1023 Some(match n {
1024 0u32..=1u32 => unsafe { core::mem::transmute::<u32, FPOperationMode>(n) },
1025 _ => return None,
1026 })
1027 }
1028}
1029#[allow(non_upper_case_globals)]
1030impl FPOperationMode {}
1031impl core::str::FromStr for FPOperationMode {
1032 type Err = ();
1033 fn from_str(s: &str) -> Result<Self, Self::Err> {
1034 match s {
1035 "IEEE" => Ok(Self::IEEE),
1036 "ALT" => Ok(Self::ALT),
1037 _ => Err(()),
1038 }
1039 }
1040}
1041#[doc = "SPIR-V operand kind: [OverflowModes](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_overflow_modes_a_overflow_modes)"]
1042#[repr(u32)]
1043#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1044#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
1045#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
1046#[allow(clippy::upper_case_acronyms)]
1047pub enum OverflowModes {
1048 WRAP = 0u32,
1049 SAT = 1u32,
1050 SAT_ZERO = 2u32,
1051 SAT_SYM = 3u32,
1052}
1053impl OverflowModes {
1054 pub fn from_u32(n: u32) -> Option<Self> {
1055 Some(match n {
1056 0u32..=3u32 => unsafe { core::mem::transmute::<u32, OverflowModes>(n) },
1057 _ => return None,
1058 })
1059 }
1060}
1061#[allow(non_upper_case_globals)]
1062impl OverflowModes {}
1063impl core::str::FromStr for OverflowModes {
1064 type Err = ();
1065 fn from_str(s: &str) -> Result<Self, Self::Err> {
1066 match s {
1067 "WRAP" => Ok(Self::WRAP),
1068 "SAT" => Ok(Self::SAT),
1069 "SAT_ZERO" => Ok(Self::SAT_ZERO),
1070 "SAT_SYM" => Ok(Self::SAT_SYM),
1071 _ => Err(()),
1072 }
1073 }
1074}
1075#[doc = "SPIR-V operand kind: [LinkageType](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_linkage_type_a_linkage_type)"]
1076#[repr(u32)]
1077#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1078#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
1079#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
1080#[allow(clippy::upper_case_acronyms)]
1081pub enum LinkageType {
1082 Export = 0u32,
1083 Import = 1u32,
1084 LinkOnceODR = 2u32,
1085}
1086impl LinkageType {
1087 pub fn from_u32(n: u32) -> Option<Self> {
1088 Some(match n {
1089 0u32..=2u32 => unsafe { core::mem::transmute::<u32, LinkageType>(n) },
1090 _ => return None,
1091 })
1092 }
1093}
1094#[allow(non_upper_case_globals)]
1095impl LinkageType {}
1096impl core::str::FromStr for LinkageType {
1097 type Err = ();
1098 fn from_str(s: &str) -> Result<Self, Self::Err> {
1099 match s {
1100 "Export" => Ok(Self::Export),
1101 "Import" => Ok(Self::Import),
1102 "LinkOnceODR" => Ok(Self::LinkOnceODR),
1103 _ => Err(()),
1104 }
1105 }
1106}
1107#[doc = "SPIR-V operand kind: [AccessQualifier](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_access_qualifier_a_access_qualifier)"]
1108#[repr(u32)]
1109#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1110#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
1111#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
1112#[allow(clippy::upper_case_acronyms)]
1113pub enum AccessQualifier {
1114 ReadOnly = 0u32,
1115 WriteOnly = 1u32,
1116 ReadWrite = 2u32,
1117}
1118impl AccessQualifier {
1119 pub fn from_u32(n: u32) -> Option<Self> {
1120 Some(match n {
1121 0u32..=2u32 => unsafe { core::mem::transmute::<u32, AccessQualifier>(n) },
1122 _ => return None,
1123 })
1124 }
1125}
1126#[allow(non_upper_case_globals)]
1127impl AccessQualifier {}
1128impl core::str::FromStr for AccessQualifier {
1129 type Err = ();
1130 fn from_str(s: &str) -> Result<Self, Self::Err> {
1131 match s {
1132 "ReadOnly" => Ok(Self::ReadOnly),
1133 "WriteOnly" => Ok(Self::WriteOnly),
1134 "ReadWrite" => Ok(Self::ReadWrite),
1135 _ => Err(()),
1136 }
1137 }
1138}
1139#[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)"]
1140#[repr(u32)]
1141#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1142#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
1143#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
1144#[allow(clippy::upper_case_acronyms)]
1145pub enum HostAccessQualifier {
1146 NoneINTEL = 0u32,
1147 ReadINTEL = 1u32,
1148 WriteINTEL = 2u32,
1149 ReadWriteINTEL = 3u32,
1150}
1151impl HostAccessQualifier {
1152 pub fn from_u32(n: u32) -> Option<Self> {
1153 Some(match n {
1154 0u32..=3u32 => unsafe { core::mem::transmute::<u32, HostAccessQualifier>(n) },
1155 _ => return None,
1156 })
1157 }
1158}
1159#[allow(non_upper_case_globals)]
1160impl HostAccessQualifier {}
1161impl core::str::FromStr for HostAccessQualifier {
1162 type Err = ();
1163 fn from_str(s: &str) -> Result<Self, Self::Err> {
1164 match s {
1165 "NoneINTEL" => Ok(Self::NoneINTEL),
1166 "ReadINTEL" => Ok(Self::ReadINTEL),
1167 "WriteINTEL" => Ok(Self::WriteINTEL),
1168 "ReadWriteINTEL" => Ok(Self::ReadWriteINTEL),
1169 _ => Err(()),
1170 }
1171 }
1172}
1173#[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)"]
1174#[repr(u32)]
1175#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1176#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
1177#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
1178#[allow(clippy::upper_case_acronyms)]
1179pub enum FunctionParameterAttribute {
1180 Zext = 0u32,
1181 Sext = 1u32,
1182 ByVal = 2u32,
1183 Sret = 3u32,
1184 NoAlias = 4u32,
1185 NoCapture = 5u32,
1186 NoWrite = 6u32,
1187 NoReadWrite = 7u32,
1188 RuntimeAlignedINTEL = 5940u32,
1189}
1190impl FunctionParameterAttribute {
1191 pub fn from_u32(n: u32) -> Option<Self> {
1192 Some(match n {
1193 0u32..=7u32 => unsafe { core::mem::transmute::<u32, FunctionParameterAttribute>(n) },
1194 5940u32 => unsafe { core::mem::transmute::<u32, FunctionParameterAttribute>(5940u32) },
1195 _ => return None,
1196 })
1197 }
1198}
1199#[allow(non_upper_case_globals)]
1200impl FunctionParameterAttribute {}
1201impl core::str::FromStr for FunctionParameterAttribute {
1202 type Err = ();
1203 fn from_str(s: &str) -> Result<Self, Self::Err> {
1204 match s {
1205 "Zext" => Ok(Self::Zext),
1206 "Sext" => Ok(Self::Sext),
1207 "ByVal" => Ok(Self::ByVal),
1208 "Sret" => Ok(Self::Sret),
1209 "NoAlias" => Ok(Self::NoAlias),
1210 "NoCapture" => Ok(Self::NoCapture),
1211 "NoWrite" => Ok(Self::NoWrite),
1212 "NoReadWrite" => Ok(Self::NoReadWrite),
1213 "RuntimeAlignedINTEL" => Ok(Self::RuntimeAlignedINTEL),
1214 _ => Err(()),
1215 }
1216 }
1217}
1218#[doc = "SPIR-V operand kind: [Decoration](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_decoration_a_decoration)"]
1219#[repr(u32)]
1220#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1221#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
1222#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
1223#[allow(clippy::upper_case_acronyms)]
1224pub enum Decoration {
1225 RelaxedPrecision = 0u32,
1226 SpecId = 1u32,
1227 Block = 2u32,
1228 BufferBlock = 3u32,
1229 RowMajor = 4u32,
1230 ColMajor = 5u32,
1231 ArrayStride = 6u32,
1232 MatrixStride = 7u32,
1233 GLSLShared = 8u32,
1234 GLSLPacked = 9u32,
1235 CPacked = 10u32,
1236 BuiltIn = 11u32,
1237 NoPerspective = 13u32,
1238 Flat = 14u32,
1239 Patch = 15u32,
1240 Centroid = 16u32,
1241 Sample = 17u32,
1242 Invariant = 18u32,
1243 Restrict = 19u32,
1244 Aliased = 20u32,
1245 Volatile = 21u32,
1246 Constant = 22u32,
1247 Coherent = 23u32,
1248 NonWritable = 24u32,
1249 NonReadable = 25u32,
1250 Uniform = 26u32,
1251 UniformId = 27u32,
1252 SaturatedConversion = 28u32,
1253 Stream = 29u32,
1254 Location = 30u32,
1255 Component = 31u32,
1256 Index = 32u32,
1257 Binding = 33u32,
1258 DescriptorSet = 34u32,
1259 Offset = 35u32,
1260 XfbBuffer = 36u32,
1261 XfbStride = 37u32,
1262 FuncParamAttr = 38u32,
1263 FPRoundingMode = 39u32,
1264 FPFastMathMode = 40u32,
1265 LinkageAttributes = 41u32,
1266 NoContraction = 42u32,
1267 InputAttachmentIndex = 43u32,
1268 Alignment = 44u32,
1269 MaxByteOffset = 45u32,
1270 AlignmentId = 46u32,
1271 MaxByteOffsetId = 47u32,
1272 NoSignedWrap = 4469u32,
1273 NoUnsignedWrap = 4470u32,
1274 WeightTextureQCOM = 4487u32,
1275 BlockMatchTextureQCOM = 4488u32,
1276 ExplicitInterpAMD = 4999u32,
1277 NodeSharesPayloadLimitsWithAMDX = 5019u32,
1278 NodeMaxPayloadsAMDX = 5020u32,
1279 TrackFinishWritingAMDX = 5078u32,
1280 PayloadNodeNameAMDX = 5091u32,
1281 OverrideCoverageNV = 5248u32,
1282 PassthroughNV = 5250u32,
1283 ViewportRelativeNV = 5252u32,
1284 SecondaryViewportRelativeNV = 5256u32,
1285 PerPrimitiveNV = 5271u32,
1286 PerViewNV = 5272u32,
1287 PerTaskNV = 5273u32,
1288 PerVertexKHR = 5285u32,
1289 NonUniform = 5300u32,
1290 RestrictPointer = 5355u32,
1291 AliasedPointer = 5356u32,
1292 HitObjectShaderRecordBufferNV = 5386u32,
1293 BindlessSamplerNV = 5398u32,
1294 BindlessImageNV = 5399u32,
1295 BoundSamplerNV = 5400u32,
1296 BoundImageNV = 5401u32,
1297 SIMTCallINTEL = 5599u32,
1298 ReferencedIndirectlyINTEL = 5602u32,
1299 ClobberINTEL = 5607u32,
1300 SideEffectsINTEL = 5608u32,
1301 VectorComputeVariableINTEL = 5624u32,
1302 FuncParamIOKindINTEL = 5625u32,
1303 VectorComputeFunctionINTEL = 5626u32,
1304 StackCallINTEL = 5627u32,
1305 GlobalVariableOffsetINTEL = 5628u32,
1306 CounterBuffer = 5634u32,
1307 UserSemantic = 5635u32,
1308 UserTypeGOOGLE = 5636u32,
1309 FunctionRoundingModeINTEL = 5822u32,
1310 FunctionDenormModeINTEL = 5823u32,
1311 RegisterINTEL = 5825u32,
1312 MemoryINTEL = 5826u32,
1313 NumbanksINTEL = 5827u32,
1314 BankwidthINTEL = 5828u32,
1315 MaxPrivateCopiesINTEL = 5829u32,
1316 SinglepumpINTEL = 5830u32,
1317 DoublepumpINTEL = 5831u32,
1318 MaxReplicatesINTEL = 5832u32,
1319 SimpleDualPortINTEL = 5833u32,
1320 MergeINTEL = 5834u32,
1321 BankBitsINTEL = 5835u32,
1322 ForcePow2DepthINTEL = 5836u32,
1323 BurstCoalesceINTEL = 5899u32,
1324 CacheSizeINTEL = 5900u32,
1325 DontStaticallyCoalesceINTEL = 5901u32,
1326 PrefetchINTEL = 5902u32,
1327 StallEnableINTEL = 5905u32,
1328 FuseLoopsInFunctionINTEL = 5907u32,
1329 MathOpDSPModeINTEL = 5909u32,
1330 AliasScopeINTEL = 5914u32,
1331 NoAliasINTEL = 5915u32,
1332 InitiationIntervalINTEL = 5917u32,
1333 MaxConcurrencyINTEL = 5918u32,
1334 PipelineEnableINTEL = 5919u32,
1335 BufferLocationINTEL = 5921u32,
1336 IOPipeStorageINTEL = 5944u32,
1337 FunctionFloatingPointModeINTEL = 6080u32,
1338 SingleElementVectorINTEL = 6085u32,
1339 VectorComputeCallableFunctionINTEL = 6087u32,
1340 MediaBlockIOINTEL = 6140u32,
1341 InitModeINTEL = 6147u32,
1342 ImplementInRegisterMapINTEL = 6148u32,
1343 HostAccessINTEL = 6168u32,
1344 FPMaxErrorDecorationINTEL = 6170u32,
1345 LatencyControlLabelINTEL = 6172u32,
1346 LatencyControlConstraintINTEL = 6173u32,
1347 ConduitKernelArgumentINTEL = 6175u32,
1348 RegisterMapKernelArgumentINTEL = 6176u32,
1349 MMHostInterfaceAddressWidthINTEL = 6177u32,
1350 MMHostInterfaceDataWidthINTEL = 6178u32,
1351 MMHostInterfaceLatencyINTEL = 6179u32,
1352 MMHostInterfaceReadWriteModeINTEL = 6180u32,
1353 MMHostInterfaceMaxBurstINTEL = 6181u32,
1354 MMHostInterfaceWaitRequestINTEL = 6182u32,
1355 StableKernelArgumentINTEL = 6183u32,
1356 CacheControlLoadINTEL = 6442u32,
1357 CacheControlStoreINTEL = 6443u32,
1358}
1359impl Decoration {
1360 pub fn from_u32(n: u32) -> Option<Self> {
1361 Some(match n {
1362 0u32..=11u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1363 13u32..=47u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1364 4469u32..=4470u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1365 4487u32..=4488u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1366 4999u32 => unsafe { core::mem::transmute::<u32, Decoration>(4999u32) },
1367 5019u32..=5020u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1368 5078u32 => unsafe { core::mem::transmute::<u32, Decoration>(5078u32) },
1369 5091u32 => unsafe { core::mem::transmute::<u32, Decoration>(5091u32) },
1370 5248u32 => unsafe { core::mem::transmute::<u32, Decoration>(5248u32) },
1371 5250u32 => unsafe { core::mem::transmute::<u32, Decoration>(5250u32) },
1372 5252u32 => unsafe { core::mem::transmute::<u32, Decoration>(5252u32) },
1373 5256u32 => unsafe { core::mem::transmute::<u32, Decoration>(5256u32) },
1374 5271u32..=5273u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1375 5285u32 => unsafe { core::mem::transmute::<u32, Decoration>(5285u32) },
1376 5300u32 => unsafe { core::mem::transmute::<u32, Decoration>(5300u32) },
1377 5355u32..=5356u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1378 5386u32 => unsafe { core::mem::transmute::<u32, Decoration>(5386u32) },
1379 5398u32..=5401u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1380 5599u32 => unsafe { core::mem::transmute::<u32, Decoration>(5599u32) },
1381 5602u32 => unsafe { core::mem::transmute::<u32, Decoration>(5602u32) },
1382 5607u32..=5608u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1383 5624u32..=5628u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1384 5634u32..=5636u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1385 5822u32..=5823u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1386 5825u32..=5836u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1387 5899u32..=5902u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1388 5905u32 => unsafe { core::mem::transmute::<u32, Decoration>(5905u32) },
1389 5907u32 => unsafe { core::mem::transmute::<u32, Decoration>(5907u32) },
1390 5909u32 => unsafe { core::mem::transmute::<u32, Decoration>(5909u32) },
1391 5914u32..=5915u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1392 5917u32..=5919u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1393 5921u32 => unsafe { core::mem::transmute::<u32, Decoration>(5921u32) },
1394 5944u32 => unsafe { core::mem::transmute::<u32, Decoration>(5944u32) },
1395 6080u32 => unsafe { core::mem::transmute::<u32, Decoration>(6080u32) },
1396 6085u32 => unsafe { core::mem::transmute::<u32, Decoration>(6085u32) },
1397 6087u32 => unsafe { core::mem::transmute::<u32, Decoration>(6087u32) },
1398 6140u32 => unsafe { core::mem::transmute::<u32, Decoration>(6140u32) },
1399 6147u32..=6148u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1400 6168u32 => unsafe { core::mem::transmute::<u32, Decoration>(6168u32) },
1401 6170u32 => unsafe { core::mem::transmute::<u32, Decoration>(6170u32) },
1402 6172u32..=6173u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1403 6175u32..=6183u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1404 6442u32..=6443u32 => unsafe { core::mem::transmute::<u32, Decoration>(n) },
1405 _ => return None,
1406 })
1407 }
1408}
1409#[allow(non_upper_case_globals)]
1410impl Decoration {
1411 pub const PerPrimitiveEXT: Self = Self::PerPrimitiveNV;
1412 pub const PerVertexNV: Self = Self::PerVertexKHR;
1413 pub const NonUniformEXT: Self = Self::NonUniform;
1414 pub const RestrictPointerEXT: Self = Self::RestrictPointer;
1415 pub const AliasedPointerEXT: Self = Self::AliasedPointer;
1416 pub const HlslCounterBufferGOOGLE: Self = Self::CounterBuffer;
1417 pub const HlslSemanticGOOGLE: Self = Self::UserSemantic;
1418}
1419impl core::str::FromStr for Decoration {
1420 type Err = ();
1421 fn from_str(s: &str) -> Result<Self, Self::Err> {
1422 match s {
1423 "RelaxedPrecision" => Ok(Self::RelaxedPrecision),
1424 "SpecId" => Ok(Self::SpecId),
1425 "Block" => Ok(Self::Block),
1426 "BufferBlock" => Ok(Self::BufferBlock),
1427 "RowMajor" => Ok(Self::RowMajor),
1428 "ColMajor" => Ok(Self::ColMajor),
1429 "ArrayStride" => Ok(Self::ArrayStride),
1430 "MatrixStride" => Ok(Self::MatrixStride),
1431 "GLSLShared" => Ok(Self::GLSLShared),
1432 "GLSLPacked" => Ok(Self::GLSLPacked),
1433 "CPacked" => Ok(Self::CPacked),
1434 "BuiltIn" => Ok(Self::BuiltIn),
1435 "NoPerspective" => Ok(Self::NoPerspective),
1436 "Flat" => Ok(Self::Flat),
1437 "Patch" => Ok(Self::Patch),
1438 "Centroid" => Ok(Self::Centroid),
1439 "Sample" => Ok(Self::Sample),
1440 "Invariant" => Ok(Self::Invariant),
1441 "Restrict" => Ok(Self::Restrict),
1442 "Aliased" => Ok(Self::Aliased),
1443 "Volatile" => Ok(Self::Volatile),
1444 "Constant" => Ok(Self::Constant),
1445 "Coherent" => Ok(Self::Coherent),
1446 "NonWritable" => Ok(Self::NonWritable),
1447 "NonReadable" => Ok(Self::NonReadable),
1448 "Uniform" => Ok(Self::Uniform),
1449 "UniformId" => Ok(Self::UniformId),
1450 "SaturatedConversion" => Ok(Self::SaturatedConversion),
1451 "Stream" => Ok(Self::Stream),
1452 "Location" => Ok(Self::Location),
1453 "Component" => Ok(Self::Component),
1454 "Index" => Ok(Self::Index),
1455 "Binding" => Ok(Self::Binding),
1456 "DescriptorSet" => Ok(Self::DescriptorSet),
1457 "Offset" => Ok(Self::Offset),
1458 "XfbBuffer" => Ok(Self::XfbBuffer),
1459 "XfbStride" => Ok(Self::XfbStride),
1460 "FuncParamAttr" => Ok(Self::FuncParamAttr),
1461 "FPRoundingMode" => Ok(Self::FPRoundingMode),
1462 "FPFastMathMode" => Ok(Self::FPFastMathMode),
1463 "LinkageAttributes" => Ok(Self::LinkageAttributes),
1464 "NoContraction" => Ok(Self::NoContraction),
1465 "InputAttachmentIndex" => Ok(Self::InputAttachmentIndex),
1466 "Alignment" => Ok(Self::Alignment),
1467 "MaxByteOffset" => Ok(Self::MaxByteOffset),
1468 "AlignmentId" => Ok(Self::AlignmentId),
1469 "MaxByteOffsetId" => Ok(Self::MaxByteOffsetId),
1470 "NoSignedWrap" => Ok(Self::NoSignedWrap),
1471 "NoUnsignedWrap" => Ok(Self::NoUnsignedWrap),
1472 "WeightTextureQCOM" => Ok(Self::WeightTextureQCOM),
1473 "BlockMatchTextureQCOM" => Ok(Self::BlockMatchTextureQCOM),
1474 "ExplicitInterpAMD" => Ok(Self::ExplicitInterpAMD),
1475 "NodeSharesPayloadLimitsWithAMDX" => Ok(Self::NodeSharesPayloadLimitsWithAMDX),
1476 "NodeMaxPayloadsAMDX" => Ok(Self::NodeMaxPayloadsAMDX),
1477 "TrackFinishWritingAMDX" => Ok(Self::TrackFinishWritingAMDX),
1478 "PayloadNodeNameAMDX" => Ok(Self::PayloadNodeNameAMDX),
1479 "OverrideCoverageNV" => Ok(Self::OverrideCoverageNV),
1480 "PassthroughNV" => Ok(Self::PassthroughNV),
1481 "ViewportRelativeNV" => Ok(Self::ViewportRelativeNV),
1482 "SecondaryViewportRelativeNV" => Ok(Self::SecondaryViewportRelativeNV),
1483 "PerPrimitiveNV" => Ok(Self::PerPrimitiveNV),
1484 "PerPrimitiveEXT" => Ok(Self::PerPrimitiveNV),
1485 "PerViewNV" => Ok(Self::PerViewNV),
1486 "PerTaskNV" => Ok(Self::PerTaskNV),
1487 "PerVertexKHR" => Ok(Self::PerVertexKHR),
1488 "PerVertexNV" => Ok(Self::PerVertexKHR),
1489 "NonUniform" => Ok(Self::NonUniform),
1490 "NonUniformEXT" => Ok(Self::NonUniform),
1491 "RestrictPointer" => Ok(Self::RestrictPointer),
1492 "RestrictPointerEXT" => Ok(Self::RestrictPointer),
1493 "AliasedPointer" => Ok(Self::AliasedPointer),
1494 "AliasedPointerEXT" => Ok(Self::AliasedPointer),
1495 "HitObjectShaderRecordBufferNV" => Ok(Self::HitObjectShaderRecordBufferNV),
1496 "BindlessSamplerNV" => Ok(Self::BindlessSamplerNV),
1497 "BindlessImageNV" => Ok(Self::BindlessImageNV),
1498 "BoundSamplerNV" => Ok(Self::BoundSamplerNV),
1499 "BoundImageNV" => Ok(Self::BoundImageNV),
1500 "SIMTCallINTEL" => Ok(Self::SIMTCallINTEL),
1501 "ReferencedIndirectlyINTEL" => Ok(Self::ReferencedIndirectlyINTEL),
1502 "ClobberINTEL" => Ok(Self::ClobberINTEL),
1503 "SideEffectsINTEL" => Ok(Self::SideEffectsINTEL),
1504 "VectorComputeVariableINTEL" => Ok(Self::VectorComputeVariableINTEL),
1505 "FuncParamIOKindINTEL" => Ok(Self::FuncParamIOKindINTEL),
1506 "VectorComputeFunctionINTEL" => Ok(Self::VectorComputeFunctionINTEL),
1507 "StackCallINTEL" => Ok(Self::StackCallINTEL),
1508 "GlobalVariableOffsetINTEL" => Ok(Self::GlobalVariableOffsetINTEL),
1509 "CounterBuffer" => Ok(Self::CounterBuffer),
1510 "HlslCounterBufferGOOGLE" => Ok(Self::CounterBuffer),
1511 "UserSemantic" => Ok(Self::UserSemantic),
1512 "HlslSemanticGOOGLE" => Ok(Self::UserSemantic),
1513 "UserTypeGOOGLE" => Ok(Self::UserTypeGOOGLE),
1514 "FunctionRoundingModeINTEL" => Ok(Self::FunctionRoundingModeINTEL),
1515 "FunctionDenormModeINTEL" => Ok(Self::FunctionDenormModeINTEL),
1516 "RegisterINTEL" => Ok(Self::RegisterINTEL),
1517 "MemoryINTEL" => Ok(Self::MemoryINTEL),
1518 "NumbanksINTEL" => Ok(Self::NumbanksINTEL),
1519 "BankwidthINTEL" => Ok(Self::BankwidthINTEL),
1520 "MaxPrivateCopiesINTEL" => Ok(Self::MaxPrivateCopiesINTEL),
1521 "SinglepumpINTEL" => Ok(Self::SinglepumpINTEL),
1522 "DoublepumpINTEL" => Ok(Self::DoublepumpINTEL),
1523 "MaxReplicatesINTEL" => Ok(Self::MaxReplicatesINTEL),
1524 "SimpleDualPortINTEL" => Ok(Self::SimpleDualPortINTEL),
1525 "MergeINTEL" => Ok(Self::MergeINTEL),
1526 "BankBitsINTEL" => Ok(Self::BankBitsINTEL),
1527 "ForcePow2DepthINTEL" => Ok(Self::ForcePow2DepthINTEL),
1528 "BurstCoalesceINTEL" => Ok(Self::BurstCoalesceINTEL),
1529 "CacheSizeINTEL" => Ok(Self::CacheSizeINTEL),
1530 "DontStaticallyCoalesceINTEL" => Ok(Self::DontStaticallyCoalesceINTEL),
1531 "PrefetchINTEL" => Ok(Self::PrefetchINTEL),
1532 "StallEnableINTEL" => Ok(Self::StallEnableINTEL),
1533 "FuseLoopsInFunctionINTEL" => Ok(Self::FuseLoopsInFunctionINTEL),
1534 "MathOpDSPModeINTEL" => Ok(Self::MathOpDSPModeINTEL),
1535 "AliasScopeINTEL" => Ok(Self::AliasScopeINTEL),
1536 "NoAliasINTEL" => Ok(Self::NoAliasINTEL),
1537 "InitiationIntervalINTEL" => Ok(Self::InitiationIntervalINTEL),
1538 "MaxConcurrencyINTEL" => Ok(Self::MaxConcurrencyINTEL),
1539 "PipelineEnableINTEL" => Ok(Self::PipelineEnableINTEL),
1540 "BufferLocationINTEL" => Ok(Self::BufferLocationINTEL),
1541 "IOPipeStorageINTEL" => Ok(Self::IOPipeStorageINTEL),
1542 "FunctionFloatingPointModeINTEL" => Ok(Self::FunctionFloatingPointModeINTEL),
1543 "SingleElementVectorINTEL" => Ok(Self::SingleElementVectorINTEL),
1544 "VectorComputeCallableFunctionINTEL" => Ok(Self::VectorComputeCallableFunctionINTEL),
1545 "MediaBlockIOINTEL" => Ok(Self::MediaBlockIOINTEL),
1546 "InitModeINTEL" => Ok(Self::InitModeINTEL),
1547 "ImplementInRegisterMapINTEL" => Ok(Self::ImplementInRegisterMapINTEL),
1548 "HostAccessINTEL" => Ok(Self::HostAccessINTEL),
1549 "FPMaxErrorDecorationINTEL" => Ok(Self::FPMaxErrorDecorationINTEL),
1550 "LatencyControlLabelINTEL" => Ok(Self::LatencyControlLabelINTEL),
1551 "LatencyControlConstraintINTEL" => Ok(Self::LatencyControlConstraintINTEL),
1552 "ConduitKernelArgumentINTEL" => Ok(Self::ConduitKernelArgumentINTEL),
1553 "RegisterMapKernelArgumentINTEL" => Ok(Self::RegisterMapKernelArgumentINTEL),
1554 "MMHostInterfaceAddressWidthINTEL" => Ok(Self::MMHostInterfaceAddressWidthINTEL),
1555 "MMHostInterfaceDataWidthINTEL" => Ok(Self::MMHostInterfaceDataWidthINTEL),
1556 "MMHostInterfaceLatencyINTEL" => Ok(Self::MMHostInterfaceLatencyINTEL),
1557 "MMHostInterfaceReadWriteModeINTEL" => Ok(Self::MMHostInterfaceReadWriteModeINTEL),
1558 "MMHostInterfaceMaxBurstINTEL" => Ok(Self::MMHostInterfaceMaxBurstINTEL),
1559 "MMHostInterfaceWaitRequestINTEL" => Ok(Self::MMHostInterfaceWaitRequestINTEL),
1560 "StableKernelArgumentINTEL" => Ok(Self::StableKernelArgumentINTEL),
1561 "CacheControlLoadINTEL" => Ok(Self::CacheControlLoadINTEL),
1562 "CacheControlStoreINTEL" => Ok(Self::CacheControlStoreINTEL),
1563 _ => Err(()),
1564 }
1565 }
1566}
1567#[doc = "SPIR-V operand kind: [BuiltIn](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_built_in_a_built_in)"]
1568#[repr(u32)]
1569#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1570#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
1571#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
1572#[allow(clippy::upper_case_acronyms)]
1573pub enum BuiltIn {
1574 Position = 0u32,
1575 PointSize = 1u32,
1576 ClipDistance = 3u32,
1577 CullDistance = 4u32,
1578 VertexId = 5u32,
1579 InstanceId = 6u32,
1580 PrimitiveId = 7u32,
1581 InvocationId = 8u32,
1582 Layer = 9u32,
1583 ViewportIndex = 10u32,
1584 TessLevelOuter = 11u32,
1585 TessLevelInner = 12u32,
1586 TessCoord = 13u32,
1587 PatchVertices = 14u32,
1588 FragCoord = 15u32,
1589 PointCoord = 16u32,
1590 FrontFacing = 17u32,
1591 SampleId = 18u32,
1592 SamplePosition = 19u32,
1593 SampleMask = 20u32,
1594 FragDepth = 22u32,
1595 HelperInvocation = 23u32,
1596 NumWorkgroups = 24u32,
1597 WorkgroupSize = 25u32,
1598 WorkgroupId = 26u32,
1599 LocalInvocationId = 27u32,
1600 GlobalInvocationId = 28u32,
1601 LocalInvocationIndex = 29u32,
1602 WorkDim = 30u32,
1603 GlobalSize = 31u32,
1604 EnqueuedWorkgroupSize = 32u32,
1605 GlobalOffset = 33u32,
1606 GlobalLinearId = 34u32,
1607 SubgroupSize = 36u32,
1608 SubgroupMaxSize = 37u32,
1609 NumSubgroups = 38u32,
1610 NumEnqueuedSubgroups = 39u32,
1611 SubgroupId = 40u32,
1612 SubgroupLocalInvocationId = 41u32,
1613 VertexIndex = 42u32,
1614 InstanceIndex = 43u32,
1615 CoreIDARM = 4160u32,
1616 CoreCountARM = 4161u32,
1617 CoreMaxIDARM = 4162u32,
1618 WarpIDARM = 4163u32,
1619 WarpMaxIDARM = 4164u32,
1620 SubgroupEqMask = 4416u32,
1621 SubgroupGeMask = 4417u32,
1622 SubgroupGtMask = 4418u32,
1623 SubgroupLeMask = 4419u32,
1624 SubgroupLtMask = 4420u32,
1625 BaseVertex = 4424u32,
1626 BaseInstance = 4425u32,
1627 DrawIndex = 4426u32,
1628 PrimitiveShadingRateKHR = 4432u32,
1629 DeviceIndex = 4438u32,
1630 ViewIndex = 4440u32,
1631 ShadingRateKHR = 4444u32,
1632 BaryCoordNoPerspAMD = 4992u32,
1633 BaryCoordNoPerspCentroidAMD = 4993u32,
1634 BaryCoordNoPerspSampleAMD = 4994u32,
1635 BaryCoordSmoothAMD = 4995u32,
1636 BaryCoordSmoothCentroidAMD = 4996u32,
1637 BaryCoordSmoothSampleAMD = 4997u32,
1638 BaryCoordPullModelAMD = 4998u32,
1639 FragStencilRefEXT = 5014u32,
1640 CoalescedInputCountAMDX = 5021u32,
1641 ShaderIndexAMDX = 5073u32,
1642 ViewportMaskNV = 5253u32,
1643 SecondaryPositionNV = 5257u32,
1644 SecondaryViewportMaskNV = 5258u32,
1645 PositionPerViewNV = 5261u32,
1646 ViewportMaskPerViewNV = 5262u32,
1647 FullyCoveredEXT = 5264u32,
1648 TaskCountNV = 5274u32,
1649 PrimitiveCountNV = 5275u32,
1650 PrimitiveIndicesNV = 5276u32,
1651 ClipDistancePerViewNV = 5277u32,
1652 CullDistancePerViewNV = 5278u32,
1653 LayerPerViewNV = 5279u32,
1654 MeshViewCountNV = 5280u32,
1655 MeshViewIndicesNV = 5281u32,
1656 BaryCoordKHR = 5286u32,
1657 BaryCoordNoPerspKHR = 5287u32,
1658 FragSizeEXT = 5292u32,
1659 FragInvocationCountEXT = 5293u32,
1660 PrimitivePointIndicesEXT = 5294u32,
1661 PrimitiveLineIndicesEXT = 5295u32,
1662 PrimitiveTriangleIndicesEXT = 5296u32,
1663 CullPrimitiveEXT = 5299u32,
1664 LaunchIdNV = 5319u32,
1665 LaunchSizeNV = 5320u32,
1666 WorldRayOriginNV = 5321u32,
1667 WorldRayDirectionNV = 5322u32,
1668 ObjectRayOriginNV = 5323u32,
1669 ObjectRayDirectionNV = 5324u32,
1670 RayTminNV = 5325u32,
1671 RayTmaxNV = 5326u32,
1672 InstanceCustomIndexNV = 5327u32,
1673 ObjectToWorldNV = 5330u32,
1674 WorldToObjectNV = 5331u32,
1675 HitTNV = 5332u32,
1676 HitKindNV = 5333u32,
1677 CurrentRayTimeNV = 5334u32,
1678 HitTriangleVertexPositionsKHR = 5335u32,
1679 HitMicroTriangleVertexPositionsNV = 5337u32,
1680 HitMicroTriangleVertexBarycentricsNV = 5344u32,
1681 IncomingRayFlagsNV = 5351u32,
1682 RayGeometryIndexKHR = 5352u32,
1683 WarpsPerSMNV = 5374u32,
1684 SMCountNV = 5375u32,
1685 WarpIDNV = 5376u32,
1686 SMIDNV = 5377u32,
1687 HitKindFrontFacingMicroTriangleNV = 5405u32,
1688 HitKindBackFacingMicroTriangleNV = 5406u32,
1689 CullMaskKHR = 6021u32,
1690}
1691impl BuiltIn {
1692 pub fn from_u32(n: u32) -> Option<Self> {
1693 Some(match n {
1694 0u32..=1u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1695 3u32..=20u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1696 22u32..=34u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1697 36u32..=43u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1698 4160u32..=4164u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1699 4416u32..=4420u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1700 4424u32..=4426u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1701 4432u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(4432u32) },
1702 4438u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(4438u32) },
1703 4440u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(4440u32) },
1704 4444u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(4444u32) },
1705 4992u32..=4998u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1706 5014u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5014u32) },
1707 5021u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5021u32) },
1708 5073u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5073u32) },
1709 5253u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5253u32) },
1710 5257u32..=5258u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1711 5261u32..=5262u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1712 5264u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5264u32) },
1713 5274u32..=5281u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1714 5286u32..=5287u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1715 5292u32..=5296u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1716 5299u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5299u32) },
1717 5319u32..=5327u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1718 5330u32..=5335u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1719 5337u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5337u32) },
1720 5344u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(5344u32) },
1721 5351u32..=5352u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1722 5374u32..=5377u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1723 5405u32..=5406u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(n) },
1724 6021u32 => unsafe { core::mem::transmute::<u32, BuiltIn>(6021u32) },
1725 _ => return None,
1726 })
1727 }
1728}
1729#[allow(non_upper_case_globals)]
1730impl BuiltIn {
1731 pub const SubgroupEqMaskKHR: Self = Self::SubgroupEqMask;
1732 pub const SubgroupGeMaskKHR: Self = Self::SubgroupGeMask;
1733 pub const SubgroupGtMaskKHR: Self = Self::SubgroupGtMask;
1734 pub const SubgroupLeMaskKHR: Self = Self::SubgroupLeMask;
1735 pub const SubgroupLtMaskKHR: Self = Self::SubgroupLtMask;
1736 pub const BaryCoordNV: Self = Self::BaryCoordKHR;
1737 pub const BaryCoordNoPerspNV: Self = Self::BaryCoordNoPerspKHR;
1738 pub const FragmentSizeNV: Self = Self::FragSizeEXT;
1739 pub const InvocationsPerPixelNV: Self = Self::FragInvocationCountEXT;
1740 pub const LaunchIdKHR: Self = Self::LaunchIdNV;
1741 pub const LaunchSizeKHR: Self = Self::LaunchSizeNV;
1742 pub const WorldRayOriginKHR: Self = Self::WorldRayOriginNV;
1743 pub const WorldRayDirectionKHR: Self = Self::WorldRayDirectionNV;
1744 pub const ObjectRayOriginKHR: Self = Self::ObjectRayOriginNV;
1745 pub const ObjectRayDirectionKHR: Self = Self::ObjectRayDirectionNV;
1746 pub const RayTminKHR: Self = Self::RayTminNV;
1747 pub const RayTmaxKHR: Self = Self::RayTmaxNV;
1748 pub const InstanceCustomIndexKHR: Self = Self::InstanceCustomIndexNV;
1749 pub const ObjectToWorldKHR: Self = Self::ObjectToWorldNV;
1750 pub const WorldToObjectKHR: Self = Self::WorldToObjectNV;
1751 pub const HitKindKHR: Self = Self::HitKindNV;
1752 pub const IncomingRayFlagsKHR: Self = Self::IncomingRayFlagsNV;
1753}
1754impl core::str::FromStr for BuiltIn {
1755 type Err = ();
1756 fn from_str(s: &str) -> Result<Self, Self::Err> {
1757 match s {
1758 "Position" => Ok(Self::Position),
1759 "PointSize" => Ok(Self::PointSize),
1760 "ClipDistance" => Ok(Self::ClipDistance),
1761 "CullDistance" => Ok(Self::CullDistance),
1762 "VertexId" => Ok(Self::VertexId),
1763 "InstanceId" => Ok(Self::InstanceId),
1764 "PrimitiveId" => Ok(Self::PrimitiveId),
1765 "InvocationId" => Ok(Self::InvocationId),
1766 "Layer" => Ok(Self::Layer),
1767 "ViewportIndex" => Ok(Self::ViewportIndex),
1768 "TessLevelOuter" => Ok(Self::TessLevelOuter),
1769 "TessLevelInner" => Ok(Self::TessLevelInner),
1770 "TessCoord" => Ok(Self::TessCoord),
1771 "PatchVertices" => Ok(Self::PatchVertices),
1772 "FragCoord" => Ok(Self::FragCoord),
1773 "PointCoord" => Ok(Self::PointCoord),
1774 "FrontFacing" => Ok(Self::FrontFacing),
1775 "SampleId" => Ok(Self::SampleId),
1776 "SamplePosition" => Ok(Self::SamplePosition),
1777 "SampleMask" => Ok(Self::SampleMask),
1778 "FragDepth" => Ok(Self::FragDepth),
1779 "HelperInvocation" => Ok(Self::HelperInvocation),
1780 "NumWorkgroups" => Ok(Self::NumWorkgroups),
1781 "WorkgroupSize" => Ok(Self::WorkgroupSize),
1782 "WorkgroupId" => Ok(Self::WorkgroupId),
1783 "LocalInvocationId" => Ok(Self::LocalInvocationId),
1784 "GlobalInvocationId" => Ok(Self::GlobalInvocationId),
1785 "LocalInvocationIndex" => Ok(Self::LocalInvocationIndex),
1786 "WorkDim" => Ok(Self::WorkDim),
1787 "GlobalSize" => Ok(Self::GlobalSize),
1788 "EnqueuedWorkgroupSize" => Ok(Self::EnqueuedWorkgroupSize),
1789 "GlobalOffset" => Ok(Self::GlobalOffset),
1790 "GlobalLinearId" => Ok(Self::GlobalLinearId),
1791 "SubgroupSize" => Ok(Self::SubgroupSize),
1792 "SubgroupMaxSize" => Ok(Self::SubgroupMaxSize),
1793 "NumSubgroups" => Ok(Self::NumSubgroups),
1794 "NumEnqueuedSubgroups" => Ok(Self::NumEnqueuedSubgroups),
1795 "SubgroupId" => Ok(Self::SubgroupId),
1796 "SubgroupLocalInvocationId" => Ok(Self::SubgroupLocalInvocationId),
1797 "VertexIndex" => Ok(Self::VertexIndex),
1798 "InstanceIndex" => Ok(Self::InstanceIndex),
1799 "CoreIDARM" => Ok(Self::CoreIDARM),
1800 "CoreCountARM" => Ok(Self::CoreCountARM),
1801 "CoreMaxIDARM" => Ok(Self::CoreMaxIDARM),
1802 "WarpIDARM" => Ok(Self::WarpIDARM),
1803 "WarpMaxIDARM" => Ok(Self::WarpMaxIDARM),
1804 "SubgroupEqMask" => Ok(Self::SubgroupEqMask),
1805 "SubgroupEqMaskKHR" => Ok(Self::SubgroupEqMask),
1806 "SubgroupGeMask" => Ok(Self::SubgroupGeMask),
1807 "SubgroupGeMaskKHR" => Ok(Self::SubgroupGeMask),
1808 "SubgroupGtMask" => Ok(Self::SubgroupGtMask),
1809 "SubgroupGtMaskKHR" => Ok(Self::SubgroupGtMask),
1810 "SubgroupLeMask" => Ok(Self::SubgroupLeMask),
1811 "SubgroupLeMaskKHR" => Ok(Self::SubgroupLeMask),
1812 "SubgroupLtMask" => Ok(Self::SubgroupLtMask),
1813 "SubgroupLtMaskKHR" => Ok(Self::SubgroupLtMask),
1814 "BaseVertex" => Ok(Self::BaseVertex),
1815 "BaseInstance" => Ok(Self::BaseInstance),
1816 "DrawIndex" => Ok(Self::DrawIndex),
1817 "PrimitiveShadingRateKHR" => Ok(Self::PrimitiveShadingRateKHR),
1818 "DeviceIndex" => Ok(Self::DeviceIndex),
1819 "ViewIndex" => Ok(Self::ViewIndex),
1820 "ShadingRateKHR" => Ok(Self::ShadingRateKHR),
1821 "BaryCoordNoPerspAMD" => Ok(Self::BaryCoordNoPerspAMD),
1822 "BaryCoordNoPerspCentroidAMD" => Ok(Self::BaryCoordNoPerspCentroidAMD),
1823 "BaryCoordNoPerspSampleAMD" => Ok(Self::BaryCoordNoPerspSampleAMD),
1824 "BaryCoordSmoothAMD" => Ok(Self::BaryCoordSmoothAMD),
1825 "BaryCoordSmoothCentroidAMD" => Ok(Self::BaryCoordSmoothCentroidAMD),
1826 "BaryCoordSmoothSampleAMD" => Ok(Self::BaryCoordSmoothSampleAMD),
1827 "BaryCoordPullModelAMD" => Ok(Self::BaryCoordPullModelAMD),
1828 "FragStencilRefEXT" => Ok(Self::FragStencilRefEXT),
1829 "CoalescedInputCountAMDX" => Ok(Self::CoalescedInputCountAMDX),
1830 "ShaderIndexAMDX" => Ok(Self::ShaderIndexAMDX),
1831 "ViewportMaskNV" => Ok(Self::ViewportMaskNV),
1832 "SecondaryPositionNV" => Ok(Self::SecondaryPositionNV),
1833 "SecondaryViewportMaskNV" => Ok(Self::SecondaryViewportMaskNV),
1834 "PositionPerViewNV" => Ok(Self::PositionPerViewNV),
1835 "ViewportMaskPerViewNV" => Ok(Self::ViewportMaskPerViewNV),
1836 "FullyCoveredEXT" => Ok(Self::FullyCoveredEXT),
1837 "TaskCountNV" => Ok(Self::TaskCountNV),
1838 "PrimitiveCountNV" => Ok(Self::PrimitiveCountNV),
1839 "PrimitiveIndicesNV" => Ok(Self::PrimitiveIndicesNV),
1840 "ClipDistancePerViewNV" => Ok(Self::ClipDistancePerViewNV),
1841 "CullDistancePerViewNV" => Ok(Self::CullDistancePerViewNV),
1842 "LayerPerViewNV" => Ok(Self::LayerPerViewNV),
1843 "MeshViewCountNV" => Ok(Self::MeshViewCountNV),
1844 "MeshViewIndicesNV" => Ok(Self::MeshViewIndicesNV),
1845 "BaryCoordKHR" => Ok(Self::BaryCoordKHR),
1846 "BaryCoordNV" => Ok(Self::BaryCoordKHR),
1847 "BaryCoordNoPerspKHR" => Ok(Self::BaryCoordNoPerspKHR),
1848 "BaryCoordNoPerspNV" => Ok(Self::BaryCoordNoPerspKHR),
1849 "FragSizeEXT" => Ok(Self::FragSizeEXT),
1850 "FragmentSizeNV" => Ok(Self::FragSizeEXT),
1851 "FragInvocationCountEXT" => Ok(Self::FragInvocationCountEXT),
1852 "InvocationsPerPixelNV" => Ok(Self::FragInvocationCountEXT),
1853 "PrimitivePointIndicesEXT" => Ok(Self::PrimitivePointIndicesEXT),
1854 "PrimitiveLineIndicesEXT" => Ok(Self::PrimitiveLineIndicesEXT),
1855 "PrimitiveTriangleIndicesEXT" => Ok(Self::PrimitiveTriangleIndicesEXT),
1856 "CullPrimitiveEXT" => Ok(Self::CullPrimitiveEXT),
1857 "LaunchIdNV" => Ok(Self::LaunchIdNV),
1858 "LaunchIdKHR" => Ok(Self::LaunchIdNV),
1859 "LaunchSizeNV" => Ok(Self::LaunchSizeNV),
1860 "LaunchSizeKHR" => Ok(Self::LaunchSizeNV),
1861 "WorldRayOriginNV" => Ok(Self::WorldRayOriginNV),
1862 "WorldRayOriginKHR" => Ok(Self::WorldRayOriginNV),
1863 "WorldRayDirectionNV" => Ok(Self::WorldRayDirectionNV),
1864 "WorldRayDirectionKHR" => Ok(Self::WorldRayDirectionNV),
1865 "ObjectRayOriginNV" => Ok(Self::ObjectRayOriginNV),
1866 "ObjectRayOriginKHR" => Ok(Self::ObjectRayOriginNV),
1867 "ObjectRayDirectionNV" => Ok(Self::ObjectRayDirectionNV),
1868 "ObjectRayDirectionKHR" => Ok(Self::ObjectRayDirectionNV),
1869 "RayTminNV" => Ok(Self::RayTminNV),
1870 "RayTminKHR" => Ok(Self::RayTminNV),
1871 "RayTmaxNV" => Ok(Self::RayTmaxNV),
1872 "RayTmaxKHR" => Ok(Self::RayTmaxNV),
1873 "InstanceCustomIndexNV" => Ok(Self::InstanceCustomIndexNV),
1874 "InstanceCustomIndexKHR" => Ok(Self::InstanceCustomIndexNV),
1875 "ObjectToWorldNV" => Ok(Self::ObjectToWorldNV),
1876 "ObjectToWorldKHR" => Ok(Self::ObjectToWorldNV),
1877 "WorldToObjectNV" => Ok(Self::WorldToObjectNV),
1878 "WorldToObjectKHR" => Ok(Self::WorldToObjectNV),
1879 "HitTNV" => Ok(Self::HitTNV),
1880 "HitKindNV" => Ok(Self::HitKindNV),
1881 "HitKindKHR" => Ok(Self::HitKindNV),
1882 "CurrentRayTimeNV" => Ok(Self::CurrentRayTimeNV),
1883 "HitTriangleVertexPositionsKHR" => Ok(Self::HitTriangleVertexPositionsKHR),
1884 "HitMicroTriangleVertexPositionsNV" => Ok(Self::HitMicroTriangleVertexPositionsNV),
1885 "HitMicroTriangleVertexBarycentricsNV" => {
1886 Ok(Self::HitMicroTriangleVertexBarycentricsNV)
1887 }
1888 "IncomingRayFlagsNV" => Ok(Self::IncomingRayFlagsNV),
1889 "IncomingRayFlagsKHR" => Ok(Self::IncomingRayFlagsNV),
1890 "RayGeometryIndexKHR" => Ok(Self::RayGeometryIndexKHR),
1891 "WarpsPerSMNV" => Ok(Self::WarpsPerSMNV),
1892 "SMCountNV" => Ok(Self::SMCountNV),
1893 "WarpIDNV" => Ok(Self::WarpIDNV),
1894 "SMIDNV" => Ok(Self::SMIDNV),
1895 "HitKindFrontFacingMicroTriangleNV" => Ok(Self::HitKindFrontFacingMicroTriangleNV),
1896 "HitKindBackFacingMicroTriangleNV" => Ok(Self::HitKindBackFacingMicroTriangleNV),
1897 "CullMaskKHR" => Ok(Self::CullMaskKHR),
1898 _ => Err(()),
1899 }
1900 }
1901}
1902#[doc = "SPIR-V operand kind: [Scope](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_scope_a_scope)"]
1903#[repr(u32)]
1904#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1905#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
1906#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
1907#[allow(clippy::upper_case_acronyms)]
1908pub enum Scope {
1909 CrossDevice = 0u32,
1910 Device = 1u32,
1911 Workgroup = 2u32,
1912 Subgroup = 3u32,
1913 Invocation = 4u32,
1914 QueueFamily = 5u32,
1915 ShaderCallKHR = 6u32,
1916}
1917impl Scope {
1918 pub fn from_u32(n: u32) -> Option<Self> {
1919 Some(match n {
1920 0u32..=6u32 => unsafe { core::mem::transmute::<u32, Scope>(n) },
1921 _ => return None,
1922 })
1923 }
1924}
1925#[allow(non_upper_case_globals)]
1926impl Scope {
1927 pub const QueueFamilyKHR: Self = Self::QueueFamily;
1928}
1929impl core::str::FromStr for Scope {
1930 type Err = ();
1931 fn from_str(s: &str) -> Result<Self, Self::Err> {
1932 match s {
1933 "CrossDevice" => Ok(Self::CrossDevice),
1934 "Device" => Ok(Self::Device),
1935 "Workgroup" => Ok(Self::Workgroup),
1936 "Subgroup" => Ok(Self::Subgroup),
1937 "Invocation" => Ok(Self::Invocation),
1938 "QueueFamily" => Ok(Self::QueueFamily),
1939 "QueueFamilyKHR" => Ok(Self::QueueFamily),
1940 "ShaderCallKHR" => Ok(Self::ShaderCallKHR),
1941 _ => Err(()),
1942 }
1943 }
1944}
1945#[doc = "SPIR-V operand kind: [GroupOperation](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_group_operation_a_group_operation)"]
1946#[repr(u32)]
1947#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1948#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
1949#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
1950#[allow(clippy::upper_case_acronyms)]
1951pub enum GroupOperation {
1952 Reduce = 0u32,
1953 InclusiveScan = 1u32,
1954 ExclusiveScan = 2u32,
1955 ClusteredReduce = 3u32,
1956 PartitionedReduceNV = 6u32,
1957 PartitionedInclusiveScanNV = 7u32,
1958 PartitionedExclusiveScanNV = 8u32,
1959}
1960impl GroupOperation {
1961 pub fn from_u32(n: u32) -> Option<Self> {
1962 Some(match n {
1963 0u32..=3u32 => unsafe { core::mem::transmute::<u32, GroupOperation>(n) },
1964 6u32..=8u32 => unsafe { core::mem::transmute::<u32, GroupOperation>(n) },
1965 _ => return None,
1966 })
1967 }
1968}
1969#[allow(non_upper_case_globals)]
1970impl GroupOperation {}
1971impl core::str::FromStr for GroupOperation {
1972 type Err = ();
1973 fn from_str(s: &str) -> Result<Self, Self::Err> {
1974 match s {
1975 "Reduce" => Ok(Self::Reduce),
1976 "InclusiveScan" => Ok(Self::InclusiveScan),
1977 "ExclusiveScan" => Ok(Self::ExclusiveScan),
1978 "ClusteredReduce" => Ok(Self::ClusteredReduce),
1979 "PartitionedReduceNV" => Ok(Self::PartitionedReduceNV),
1980 "PartitionedInclusiveScanNV" => Ok(Self::PartitionedInclusiveScanNV),
1981 "PartitionedExclusiveScanNV" => Ok(Self::PartitionedExclusiveScanNV),
1982 _ => Err(()),
1983 }
1984 }
1985}
1986#[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)"]
1987#[repr(u32)]
1988#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
1989#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
1990#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
1991#[allow(clippy::upper_case_acronyms)]
1992pub enum KernelEnqueueFlags {
1993 NoWait = 0u32,
1994 WaitKernel = 1u32,
1995 WaitWorkGroup = 2u32,
1996}
1997impl KernelEnqueueFlags {
1998 pub fn from_u32(n: u32) -> Option<Self> {
1999 Some(match n {
2000 0u32..=2u32 => unsafe { core::mem::transmute::<u32, KernelEnqueueFlags>(n) },
2001 _ => return None,
2002 })
2003 }
2004}
2005#[allow(non_upper_case_globals)]
2006impl KernelEnqueueFlags {}
2007impl core::str::FromStr for KernelEnqueueFlags {
2008 type Err = ();
2009 fn from_str(s: &str) -> Result<Self, Self::Err> {
2010 match s {
2011 "NoWait" => Ok(Self::NoWait),
2012 "WaitKernel" => Ok(Self::WaitKernel),
2013 "WaitWorkGroup" => Ok(Self::WaitWorkGroup),
2014 _ => Err(()),
2015 }
2016 }
2017}
2018#[doc = "SPIR-V operand kind: [Capability](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_capability_a_capability)"]
2019#[repr(u32)]
2020#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
2021#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
2022#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
2023#[allow(clippy::upper_case_acronyms)]
2024pub enum Capability {
2025 Matrix = 0u32,
2026 Shader = 1u32,
2027 Geometry = 2u32,
2028 Tessellation = 3u32,
2029 Addresses = 4u32,
2030 Linkage = 5u32,
2031 Kernel = 6u32,
2032 Vector16 = 7u32,
2033 Float16Buffer = 8u32,
2034 Float16 = 9u32,
2035 Float64 = 10u32,
2036 Int64 = 11u32,
2037 Int64Atomics = 12u32,
2038 ImageBasic = 13u32,
2039 ImageReadWrite = 14u32,
2040 ImageMipmap = 15u32,
2041 Pipes = 17u32,
2042 Groups = 18u32,
2043 DeviceEnqueue = 19u32,
2044 LiteralSampler = 20u32,
2045 AtomicStorage = 21u32,
2046 Int16 = 22u32,
2047 TessellationPointSize = 23u32,
2048 GeometryPointSize = 24u32,
2049 ImageGatherExtended = 25u32,
2050 StorageImageMultisample = 27u32,
2051 UniformBufferArrayDynamicIndexing = 28u32,
2052 SampledImageArrayDynamicIndexing = 29u32,
2053 StorageBufferArrayDynamicIndexing = 30u32,
2054 StorageImageArrayDynamicIndexing = 31u32,
2055 ClipDistance = 32u32,
2056 CullDistance = 33u32,
2057 ImageCubeArray = 34u32,
2058 SampleRateShading = 35u32,
2059 ImageRect = 36u32,
2060 SampledRect = 37u32,
2061 GenericPointer = 38u32,
2062 Int8 = 39u32,
2063 InputAttachment = 40u32,
2064 SparseResidency = 41u32,
2065 MinLod = 42u32,
2066 Sampled1D = 43u32,
2067 Image1D = 44u32,
2068 SampledCubeArray = 45u32,
2069 SampledBuffer = 46u32,
2070 ImageBuffer = 47u32,
2071 ImageMSArray = 48u32,
2072 StorageImageExtendedFormats = 49u32,
2073 ImageQuery = 50u32,
2074 DerivativeControl = 51u32,
2075 InterpolationFunction = 52u32,
2076 TransformFeedback = 53u32,
2077 GeometryStreams = 54u32,
2078 StorageImageReadWithoutFormat = 55u32,
2079 StorageImageWriteWithoutFormat = 56u32,
2080 MultiViewport = 57u32,
2081 SubgroupDispatch = 58u32,
2082 NamedBarrier = 59u32,
2083 PipeStorage = 60u32,
2084 GroupNonUniform = 61u32,
2085 GroupNonUniformVote = 62u32,
2086 GroupNonUniformArithmetic = 63u32,
2087 GroupNonUniformBallot = 64u32,
2088 GroupNonUniformShuffle = 65u32,
2089 GroupNonUniformShuffleRelative = 66u32,
2090 GroupNonUniformClustered = 67u32,
2091 GroupNonUniformQuad = 68u32,
2092 ShaderLayer = 69u32,
2093 ShaderViewportIndex = 70u32,
2094 UniformDecoration = 71u32,
2095 CoreBuiltinsARM = 4165u32,
2096 TileImageColorReadAccessEXT = 4166u32,
2097 TileImageDepthReadAccessEXT = 4167u32,
2098 TileImageStencilReadAccessEXT = 4168u32,
2099 FragmentShadingRateKHR = 4422u32,
2100 SubgroupBallotKHR = 4423u32,
2101 DrawParameters = 4427u32,
2102 WorkgroupMemoryExplicitLayoutKHR = 4428u32,
2103 WorkgroupMemoryExplicitLayout8BitAccessKHR = 4429u32,
2104 WorkgroupMemoryExplicitLayout16BitAccessKHR = 4430u32,
2105 SubgroupVoteKHR = 4431u32,
2106 StorageBuffer16BitAccess = 4433u32,
2107 UniformAndStorageBuffer16BitAccess = 4434u32,
2108 StoragePushConstant16 = 4435u32,
2109 StorageInputOutput16 = 4436u32,
2110 DeviceGroup = 4437u32,
2111 MultiView = 4439u32,
2112 VariablePointersStorageBuffer = 4441u32,
2113 VariablePointers = 4442u32,
2114 AtomicStorageOps = 4445u32,
2115 SampleMaskPostDepthCoverage = 4447u32,
2116 StorageBuffer8BitAccess = 4448u32,
2117 UniformAndStorageBuffer8BitAccess = 4449u32,
2118 StoragePushConstant8 = 4450u32,
2119 DenormPreserve = 4464u32,
2120 DenormFlushToZero = 4465u32,
2121 SignedZeroInfNanPreserve = 4466u32,
2122 RoundingModeRTE = 4467u32,
2123 RoundingModeRTZ = 4468u32,
2124 RayQueryProvisionalKHR = 4471u32,
2125 RayQueryKHR = 4472u32,
2126 RayTraversalPrimitiveCullingKHR = 4478u32,
2127 RayTracingKHR = 4479u32,
2128 TextureSampleWeightedQCOM = 4484u32,
2129 TextureBoxFilterQCOM = 4485u32,
2130 TextureBlockMatchQCOM = 4486u32,
2131 Float16ImageAMD = 5008u32,
2132 ImageGatherBiasLodAMD = 5009u32,
2133 FragmentMaskAMD = 5010u32,
2134 StencilExportEXT = 5013u32,
2135 ImageReadWriteLodAMD = 5015u32,
2136 Int64ImageEXT = 5016u32,
2137 ShaderClockKHR = 5055u32,
2138 ShaderEnqueueAMDX = 5067u32,
2139 SampleMaskOverrideCoverageNV = 5249u32,
2140 GeometryShaderPassthroughNV = 5251u32,
2141 ShaderViewportIndexLayerEXT = 5254u32,
2142 ShaderViewportMaskNV = 5255u32,
2143 ShaderStereoViewNV = 5259u32,
2144 PerViewAttributesNV = 5260u32,
2145 FragmentFullyCoveredEXT = 5265u32,
2146 MeshShadingNV = 5266u32,
2147 ImageFootprintNV = 5282u32,
2148 MeshShadingEXT = 5283u32,
2149 FragmentBarycentricKHR = 5284u32,
2150 ComputeDerivativeGroupQuadsNV = 5288u32,
2151 FragmentDensityEXT = 5291u32,
2152 GroupNonUniformPartitionedNV = 5297u32,
2153 ShaderNonUniform = 5301u32,
2154 RuntimeDescriptorArray = 5302u32,
2155 InputAttachmentArrayDynamicIndexing = 5303u32,
2156 UniformTexelBufferArrayDynamicIndexing = 5304u32,
2157 StorageTexelBufferArrayDynamicIndexing = 5305u32,
2158 UniformBufferArrayNonUniformIndexing = 5306u32,
2159 SampledImageArrayNonUniformIndexing = 5307u32,
2160 StorageBufferArrayNonUniformIndexing = 5308u32,
2161 StorageImageArrayNonUniformIndexing = 5309u32,
2162 InputAttachmentArrayNonUniformIndexing = 5310u32,
2163 UniformTexelBufferArrayNonUniformIndexing = 5311u32,
2164 StorageTexelBufferArrayNonUniformIndexing = 5312u32,
2165 RayTracingPositionFetchKHR = 5336u32,
2166 RayTracingNV = 5340u32,
2167 RayTracingMotionBlurNV = 5341u32,
2168 VulkanMemoryModel = 5345u32,
2169 VulkanMemoryModelDeviceScope = 5346u32,
2170 PhysicalStorageBufferAddresses = 5347u32,
2171 ComputeDerivativeGroupLinearNV = 5350u32,
2172 RayTracingProvisionalKHR = 5353u32,
2173 CooperativeMatrixNV = 5357u32,
2174 FragmentShaderSampleInterlockEXT = 5363u32,
2175 FragmentShaderShadingRateInterlockEXT = 5372u32,
2176 ShaderSMBuiltinsNV = 5373u32,
2177 FragmentShaderPixelInterlockEXT = 5378u32,
2178 DemoteToHelperInvocation = 5379u32,
2179 DisplacementMicromapNV = 5380u32,
2180 RayTracingOpacityMicromapEXT = 5381u32,
2181 ShaderInvocationReorderNV = 5383u32,
2182 BindlessTextureNV = 5390u32,
2183 RayQueryPositionFetchKHR = 5391u32,
2184 RayTracingDisplacementMicromapNV = 5409u32,
2185 SubgroupShuffleINTEL = 5568u32,
2186 SubgroupBufferBlockIOINTEL = 5569u32,
2187 SubgroupImageBlockIOINTEL = 5570u32,
2188 SubgroupImageMediaBlockIOINTEL = 5579u32,
2189 RoundToInfinityINTEL = 5582u32,
2190 FloatingPointModeINTEL = 5583u32,
2191 IntegerFunctions2INTEL = 5584u32,
2192 FunctionPointersINTEL = 5603u32,
2193 IndirectReferencesINTEL = 5604u32,
2194 AsmINTEL = 5606u32,
2195 AtomicFloat32MinMaxEXT = 5612u32,
2196 AtomicFloat64MinMaxEXT = 5613u32,
2197 AtomicFloat16MinMaxEXT = 5616u32,
2198 VectorComputeINTEL = 5617u32,
2199 VectorAnyINTEL = 5619u32,
2200 ExpectAssumeKHR = 5629u32,
2201 SubgroupAvcMotionEstimationINTEL = 5696u32,
2202 SubgroupAvcMotionEstimationIntraINTEL = 5697u32,
2203 SubgroupAvcMotionEstimationChromaINTEL = 5698u32,
2204 VariableLengthArrayINTEL = 5817u32,
2205 FunctionFloatControlINTEL = 5821u32,
2206 FPGAMemoryAttributesINTEL = 5824u32,
2207 FPFastMathModeINTEL = 5837u32,
2208 ArbitraryPrecisionIntegersINTEL = 5844u32,
2209 ArbitraryPrecisionFloatingPointINTEL = 5845u32,
2210 UnstructuredLoopControlsINTEL = 5886u32,
2211 FPGALoopControlsINTEL = 5888u32,
2212 KernelAttributesINTEL = 5892u32,
2213 FPGAKernelAttributesINTEL = 5897u32,
2214 FPGAMemoryAccessesINTEL = 5898u32,
2215 FPGAClusterAttributesINTEL = 5904u32,
2216 LoopFuseINTEL = 5906u32,
2217 FPGADSPControlINTEL = 5908u32,
2218 MemoryAccessAliasingINTEL = 5910u32,
2219 FPGAInvocationPipeliningAttributesINTEL = 5916u32,
2220 FPGABufferLocationINTEL = 5920u32,
2221 ArbitraryPrecisionFixedPointINTEL = 5922u32,
2222 USMStorageClassesINTEL = 5935u32,
2223 RuntimeAlignedAttributeINTEL = 5939u32,
2224 IOPipesINTEL = 5943u32,
2225 BlockingPipesINTEL = 5945u32,
2226 FPGARegINTEL = 5948u32,
2227 DotProductInputAll = 6016u32,
2228 DotProductInput4x8Bit = 6017u32,
2229 DotProductInput4x8BitPacked = 6018u32,
2230 DotProduct = 6019u32,
2231 RayCullMaskKHR = 6020u32,
2232 CooperativeMatrixKHR = 6022u32,
2233 BitInstructions = 6025u32,
2234 GroupNonUniformRotateKHR = 6026u32,
2235 AtomicFloat32AddEXT = 6033u32,
2236 AtomicFloat64AddEXT = 6034u32,
2237 LongConstantCompositeINTEL = 6089u32,
2238 OptNoneINTEL = 6094u32,
2239 AtomicFloat16AddEXT = 6095u32,
2240 DebugInfoModuleINTEL = 6114u32,
2241 BFloat16ConversionINTEL = 6115u32,
2242 SplitBarrierINTEL = 6141u32,
2243 GlobalVariableFPGADecorationsINTEL = 6146u32,
2244 FPGAKernelAttributesv2INTEL = 6161u32,
2245 GlobalVariableHostAccessINTEL = 6167u32,
2246 FPMaxErrorINTEL = 6169u32,
2247 FPGALatencyControlINTEL = 6171u32,
2248 FPGAArgumentInterfacesINTEL = 6174u32,
2249 GroupUniformArithmeticKHR = 6400u32,
2250 CacheControlsINTEL = 6441u32,
2251}
2252impl Capability {
2253 pub fn from_u32(n: u32) -> Option<Self> {
2254 Some(match n {
2255 0u32..=15u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2256 17u32..=25u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2257 27u32..=71u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2258 4165u32..=4168u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2259 4422u32..=4423u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2260 4427u32..=4431u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2261 4433u32..=4437u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2262 4439u32 => unsafe { core::mem::transmute::<u32, Capability>(4439u32) },
2263 4441u32..=4442u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2264 4445u32 => unsafe { core::mem::transmute::<u32, Capability>(4445u32) },
2265 4447u32..=4450u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2266 4464u32..=4468u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2267 4471u32..=4472u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2268 4478u32..=4479u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2269 4484u32..=4486u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2270 5008u32..=5010u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2271 5013u32 => unsafe { core::mem::transmute::<u32, Capability>(5013u32) },
2272 5015u32..=5016u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2273 5055u32 => unsafe { core::mem::transmute::<u32, Capability>(5055u32) },
2274 5067u32 => unsafe { core::mem::transmute::<u32, Capability>(5067u32) },
2275 5249u32 => unsafe { core::mem::transmute::<u32, Capability>(5249u32) },
2276 5251u32 => unsafe { core::mem::transmute::<u32, Capability>(5251u32) },
2277 5254u32..=5255u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2278 5259u32..=5260u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2279 5265u32..=5266u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2280 5282u32..=5284u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2281 5288u32 => unsafe { core::mem::transmute::<u32, Capability>(5288u32) },
2282 5291u32 => unsafe { core::mem::transmute::<u32, Capability>(5291u32) },
2283 5297u32 => unsafe { core::mem::transmute::<u32, Capability>(5297u32) },
2284 5301u32..=5312u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2285 5336u32 => unsafe { core::mem::transmute::<u32, Capability>(5336u32) },
2286 5340u32..=5341u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2287 5345u32..=5347u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2288 5350u32 => unsafe { core::mem::transmute::<u32, Capability>(5350u32) },
2289 5353u32 => unsafe { core::mem::transmute::<u32, Capability>(5353u32) },
2290 5357u32 => unsafe { core::mem::transmute::<u32, Capability>(5357u32) },
2291 5363u32 => unsafe { core::mem::transmute::<u32, Capability>(5363u32) },
2292 5372u32..=5373u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2293 5378u32..=5381u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2294 5383u32 => unsafe { core::mem::transmute::<u32, Capability>(5383u32) },
2295 5390u32..=5391u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2296 5409u32 => unsafe { core::mem::transmute::<u32, Capability>(5409u32) },
2297 5568u32..=5570u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2298 5579u32 => unsafe { core::mem::transmute::<u32, Capability>(5579u32) },
2299 5582u32..=5584u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2300 5603u32..=5604u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2301 5606u32 => unsafe { core::mem::transmute::<u32, Capability>(5606u32) },
2302 5612u32..=5613u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2303 5616u32..=5617u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2304 5619u32 => unsafe { core::mem::transmute::<u32, Capability>(5619u32) },
2305 5629u32 => unsafe { core::mem::transmute::<u32, Capability>(5629u32) },
2306 5696u32..=5698u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2307 5817u32 => unsafe { core::mem::transmute::<u32, Capability>(5817u32) },
2308 5821u32 => unsafe { core::mem::transmute::<u32, Capability>(5821u32) },
2309 5824u32 => unsafe { core::mem::transmute::<u32, Capability>(5824u32) },
2310 5837u32 => unsafe { core::mem::transmute::<u32, Capability>(5837u32) },
2311 5844u32..=5845u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2312 5886u32 => unsafe { core::mem::transmute::<u32, Capability>(5886u32) },
2313 5888u32 => unsafe { core::mem::transmute::<u32, Capability>(5888u32) },
2314 5892u32 => unsafe { core::mem::transmute::<u32, Capability>(5892u32) },
2315 5897u32..=5898u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2316 5904u32 => unsafe { core::mem::transmute::<u32, Capability>(5904u32) },
2317 5906u32 => unsafe { core::mem::transmute::<u32, Capability>(5906u32) },
2318 5908u32 => unsafe { core::mem::transmute::<u32, Capability>(5908u32) },
2319 5910u32 => unsafe { core::mem::transmute::<u32, Capability>(5910u32) },
2320 5916u32 => unsafe { core::mem::transmute::<u32, Capability>(5916u32) },
2321 5920u32 => unsafe { core::mem::transmute::<u32, Capability>(5920u32) },
2322 5922u32 => unsafe { core::mem::transmute::<u32, Capability>(5922u32) },
2323 5935u32 => unsafe { core::mem::transmute::<u32, Capability>(5935u32) },
2324 5939u32 => unsafe { core::mem::transmute::<u32, Capability>(5939u32) },
2325 5943u32 => unsafe { core::mem::transmute::<u32, Capability>(5943u32) },
2326 5945u32 => unsafe { core::mem::transmute::<u32, Capability>(5945u32) },
2327 5948u32 => unsafe { core::mem::transmute::<u32, Capability>(5948u32) },
2328 6016u32..=6020u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2329 6022u32 => unsafe { core::mem::transmute::<u32, Capability>(6022u32) },
2330 6025u32..=6026u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2331 6033u32..=6034u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2332 6089u32 => unsafe { core::mem::transmute::<u32, Capability>(6089u32) },
2333 6094u32..=6095u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2334 6114u32..=6115u32 => unsafe { core::mem::transmute::<u32, Capability>(n) },
2335 6141u32 => unsafe { core::mem::transmute::<u32, Capability>(6141u32) },
2336 6146u32 => unsafe { core::mem::transmute::<u32, Capability>(6146u32) },
2337 6161u32 => unsafe { core::mem::transmute::<u32, Capability>(6161u32) },
2338 6167u32 => unsafe { core::mem::transmute::<u32, Capability>(6167u32) },
2339 6169u32 => unsafe { core::mem::transmute::<u32, Capability>(6169u32) },
2340 6171u32 => unsafe { core::mem::transmute::<u32, Capability>(6171u32) },
2341 6174u32 => unsafe { core::mem::transmute::<u32, Capability>(6174u32) },
2342 6400u32 => unsafe { core::mem::transmute::<u32, Capability>(6400u32) },
2343 6441u32 => unsafe { core::mem::transmute::<u32, Capability>(6441u32) },
2344 _ => return None,
2345 })
2346 }
2347}
2348#[allow(non_upper_case_globals)]
2349impl Capability {
2350 pub const StorageUniformBufferBlock16: Self = Self::StorageBuffer16BitAccess;
2351 pub const StorageUniform16: Self = Self::UniformAndStorageBuffer16BitAccess;
2352 pub const ShaderViewportIndexLayerNV: Self = Self::ShaderViewportIndexLayerEXT;
2353 pub const FragmentBarycentricNV: Self = Self::FragmentBarycentricKHR;
2354 pub const ShadingRateNV: Self = Self::FragmentDensityEXT;
2355 pub const ShaderNonUniformEXT: Self = Self::ShaderNonUniform;
2356 pub const RuntimeDescriptorArrayEXT: Self = Self::RuntimeDescriptorArray;
2357 pub const InputAttachmentArrayDynamicIndexingEXT: Self =
2358 Self::InputAttachmentArrayDynamicIndexing;
2359 pub const UniformTexelBufferArrayDynamicIndexingEXT: Self =
2360 Self::UniformTexelBufferArrayDynamicIndexing;
2361 pub const StorageTexelBufferArrayDynamicIndexingEXT: Self =
2362 Self::StorageTexelBufferArrayDynamicIndexing;
2363 pub const UniformBufferArrayNonUniformIndexingEXT: Self =
2364 Self::UniformBufferArrayNonUniformIndexing;
2365 pub const SampledImageArrayNonUniformIndexingEXT: Self =
2366 Self::SampledImageArrayNonUniformIndexing;
2367 pub const StorageBufferArrayNonUniformIndexingEXT: Self =
2368 Self::StorageBufferArrayNonUniformIndexing;
2369 pub const StorageImageArrayNonUniformIndexingEXT: Self =
2370 Self::StorageImageArrayNonUniformIndexing;
2371 pub const InputAttachmentArrayNonUniformIndexingEXT: Self =
2372 Self::InputAttachmentArrayNonUniformIndexing;
2373 pub const UniformTexelBufferArrayNonUniformIndexingEXT: Self =
2374 Self::UniformTexelBufferArrayNonUniformIndexing;
2375 pub const StorageTexelBufferArrayNonUniformIndexingEXT: Self =
2376 Self::StorageTexelBufferArrayNonUniformIndexing;
2377 pub const VulkanMemoryModelKHR: Self = Self::VulkanMemoryModel;
2378 pub const VulkanMemoryModelDeviceScopeKHR: Self = Self::VulkanMemoryModelDeviceScope;
2379 pub const PhysicalStorageBufferAddressesEXT: Self = Self::PhysicalStorageBufferAddresses;
2380 pub const DemoteToHelperInvocationEXT: Self = Self::DemoteToHelperInvocation;
2381 pub const DotProductInputAllKHR: Self = Self::DotProductInputAll;
2382 pub const DotProductInput4x8BitKHR: Self = Self::DotProductInput4x8Bit;
2383 pub const DotProductInput4x8BitPackedKHR: Self = Self::DotProductInput4x8BitPacked;
2384 pub const DotProductKHR: Self = Self::DotProduct;
2385}
2386impl core::str::FromStr for Capability {
2387 type Err = ();
2388 fn from_str(s: &str) -> Result<Self, Self::Err> {
2389 match s {
2390 "Matrix" => Ok(Self::Matrix),
2391 "Shader" => Ok(Self::Shader),
2392 "Geometry" => Ok(Self::Geometry),
2393 "Tessellation" => Ok(Self::Tessellation),
2394 "Addresses" => Ok(Self::Addresses),
2395 "Linkage" => Ok(Self::Linkage),
2396 "Kernel" => Ok(Self::Kernel),
2397 "Vector16" => Ok(Self::Vector16),
2398 "Float16Buffer" => Ok(Self::Float16Buffer),
2399 "Float16" => Ok(Self::Float16),
2400 "Float64" => Ok(Self::Float64),
2401 "Int64" => Ok(Self::Int64),
2402 "Int64Atomics" => Ok(Self::Int64Atomics),
2403 "ImageBasic" => Ok(Self::ImageBasic),
2404 "ImageReadWrite" => Ok(Self::ImageReadWrite),
2405 "ImageMipmap" => Ok(Self::ImageMipmap),
2406 "Pipes" => Ok(Self::Pipes),
2407 "Groups" => Ok(Self::Groups),
2408 "DeviceEnqueue" => Ok(Self::DeviceEnqueue),
2409 "LiteralSampler" => Ok(Self::LiteralSampler),
2410 "AtomicStorage" => Ok(Self::AtomicStorage),
2411 "Int16" => Ok(Self::Int16),
2412 "TessellationPointSize" => Ok(Self::TessellationPointSize),
2413 "GeometryPointSize" => Ok(Self::GeometryPointSize),
2414 "ImageGatherExtended" => Ok(Self::ImageGatherExtended),
2415 "StorageImageMultisample" => Ok(Self::StorageImageMultisample),
2416 "UniformBufferArrayDynamicIndexing" => Ok(Self::UniformBufferArrayDynamicIndexing),
2417 "SampledImageArrayDynamicIndexing" => Ok(Self::SampledImageArrayDynamicIndexing),
2418 "StorageBufferArrayDynamicIndexing" => Ok(Self::StorageBufferArrayDynamicIndexing),
2419 "StorageImageArrayDynamicIndexing" => Ok(Self::StorageImageArrayDynamicIndexing),
2420 "ClipDistance" => Ok(Self::ClipDistance),
2421 "CullDistance" => Ok(Self::CullDistance),
2422 "ImageCubeArray" => Ok(Self::ImageCubeArray),
2423 "SampleRateShading" => Ok(Self::SampleRateShading),
2424 "ImageRect" => Ok(Self::ImageRect),
2425 "SampledRect" => Ok(Self::SampledRect),
2426 "GenericPointer" => Ok(Self::GenericPointer),
2427 "Int8" => Ok(Self::Int8),
2428 "InputAttachment" => Ok(Self::InputAttachment),
2429 "SparseResidency" => Ok(Self::SparseResidency),
2430 "MinLod" => Ok(Self::MinLod),
2431 "Sampled1D" => Ok(Self::Sampled1D),
2432 "Image1D" => Ok(Self::Image1D),
2433 "SampledCubeArray" => Ok(Self::SampledCubeArray),
2434 "SampledBuffer" => Ok(Self::SampledBuffer),
2435 "ImageBuffer" => Ok(Self::ImageBuffer),
2436 "ImageMSArray" => Ok(Self::ImageMSArray),
2437 "StorageImageExtendedFormats" => Ok(Self::StorageImageExtendedFormats),
2438 "ImageQuery" => Ok(Self::ImageQuery),
2439 "DerivativeControl" => Ok(Self::DerivativeControl),
2440 "InterpolationFunction" => Ok(Self::InterpolationFunction),
2441 "TransformFeedback" => Ok(Self::TransformFeedback),
2442 "GeometryStreams" => Ok(Self::GeometryStreams),
2443 "StorageImageReadWithoutFormat" => Ok(Self::StorageImageReadWithoutFormat),
2444 "StorageImageWriteWithoutFormat" => Ok(Self::StorageImageWriteWithoutFormat),
2445 "MultiViewport" => Ok(Self::MultiViewport),
2446 "SubgroupDispatch" => Ok(Self::SubgroupDispatch),
2447 "NamedBarrier" => Ok(Self::NamedBarrier),
2448 "PipeStorage" => Ok(Self::PipeStorage),
2449 "GroupNonUniform" => Ok(Self::GroupNonUniform),
2450 "GroupNonUniformVote" => Ok(Self::GroupNonUniformVote),
2451 "GroupNonUniformArithmetic" => Ok(Self::GroupNonUniformArithmetic),
2452 "GroupNonUniformBallot" => Ok(Self::GroupNonUniformBallot),
2453 "GroupNonUniformShuffle" => Ok(Self::GroupNonUniformShuffle),
2454 "GroupNonUniformShuffleRelative" => Ok(Self::GroupNonUniformShuffleRelative),
2455 "GroupNonUniformClustered" => Ok(Self::GroupNonUniformClustered),
2456 "GroupNonUniformQuad" => Ok(Self::GroupNonUniformQuad),
2457 "ShaderLayer" => Ok(Self::ShaderLayer),
2458 "ShaderViewportIndex" => Ok(Self::ShaderViewportIndex),
2459 "UniformDecoration" => Ok(Self::UniformDecoration),
2460 "CoreBuiltinsARM" => Ok(Self::CoreBuiltinsARM),
2461 "TileImageColorReadAccessEXT" => Ok(Self::TileImageColorReadAccessEXT),
2462 "TileImageDepthReadAccessEXT" => Ok(Self::TileImageDepthReadAccessEXT),
2463 "TileImageStencilReadAccessEXT" => Ok(Self::TileImageStencilReadAccessEXT),
2464 "FragmentShadingRateKHR" => Ok(Self::FragmentShadingRateKHR),
2465 "SubgroupBallotKHR" => Ok(Self::SubgroupBallotKHR),
2466 "DrawParameters" => Ok(Self::DrawParameters),
2467 "WorkgroupMemoryExplicitLayoutKHR" => Ok(Self::WorkgroupMemoryExplicitLayoutKHR),
2468 "WorkgroupMemoryExplicitLayout8BitAccessKHR" => {
2469 Ok(Self::WorkgroupMemoryExplicitLayout8BitAccessKHR)
2470 }
2471 "WorkgroupMemoryExplicitLayout16BitAccessKHR" => {
2472 Ok(Self::WorkgroupMemoryExplicitLayout16BitAccessKHR)
2473 }
2474 "SubgroupVoteKHR" => Ok(Self::SubgroupVoteKHR),
2475 "StorageBuffer16BitAccess" => Ok(Self::StorageBuffer16BitAccess),
2476 "StorageUniformBufferBlock16" => Ok(Self::StorageBuffer16BitAccess),
2477 "UniformAndStorageBuffer16BitAccess" => Ok(Self::UniformAndStorageBuffer16BitAccess),
2478 "StorageUniform16" => Ok(Self::UniformAndStorageBuffer16BitAccess),
2479 "StoragePushConstant16" => Ok(Self::StoragePushConstant16),
2480 "StorageInputOutput16" => Ok(Self::StorageInputOutput16),
2481 "DeviceGroup" => Ok(Self::DeviceGroup),
2482 "MultiView" => Ok(Self::MultiView),
2483 "VariablePointersStorageBuffer" => Ok(Self::VariablePointersStorageBuffer),
2484 "VariablePointers" => Ok(Self::VariablePointers),
2485 "AtomicStorageOps" => Ok(Self::AtomicStorageOps),
2486 "SampleMaskPostDepthCoverage" => Ok(Self::SampleMaskPostDepthCoverage),
2487 "StorageBuffer8BitAccess" => Ok(Self::StorageBuffer8BitAccess),
2488 "UniformAndStorageBuffer8BitAccess" => Ok(Self::UniformAndStorageBuffer8BitAccess),
2489 "StoragePushConstant8" => Ok(Self::StoragePushConstant8),
2490 "DenormPreserve" => Ok(Self::DenormPreserve),
2491 "DenormFlushToZero" => Ok(Self::DenormFlushToZero),
2492 "SignedZeroInfNanPreserve" => Ok(Self::SignedZeroInfNanPreserve),
2493 "RoundingModeRTE" => Ok(Self::RoundingModeRTE),
2494 "RoundingModeRTZ" => Ok(Self::RoundingModeRTZ),
2495 "RayQueryProvisionalKHR" => Ok(Self::RayQueryProvisionalKHR),
2496 "RayQueryKHR" => Ok(Self::RayQueryKHR),
2497 "RayTraversalPrimitiveCullingKHR" => Ok(Self::RayTraversalPrimitiveCullingKHR),
2498 "RayTracingKHR" => Ok(Self::RayTracingKHR),
2499 "TextureSampleWeightedQCOM" => Ok(Self::TextureSampleWeightedQCOM),
2500 "TextureBoxFilterQCOM" => Ok(Self::TextureBoxFilterQCOM),
2501 "TextureBlockMatchQCOM" => Ok(Self::TextureBlockMatchQCOM),
2502 "Float16ImageAMD" => Ok(Self::Float16ImageAMD),
2503 "ImageGatherBiasLodAMD" => Ok(Self::ImageGatherBiasLodAMD),
2504 "FragmentMaskAMD" => Ok(Self::FragmentMaskAMD),
2505 "StencilExportEXT" => Ok(Self::StencilExportEXT),
2506 "ImageReadWriteLodAMD" => Ok(Self::ImageReadWriteLodAMD),
2507 "Int64ImageEXT" => Ok(Self::Int64ImageEXT),
2508 "ShaderClockKHR" => Ok(Self::ShaderClockKHR),
2509 "ShaderEnqueueAMDX" => Ok(Self::ShaderEnqueueAMDX),
2510 "SampleMaskOverrideCoverageNV" => Ok(Self::SampleMaskOverrideCoverageNV),
2511 "GeometryShaderPassthroughNV" => Ok(Self::GeometryShaderPassthroughNV),
2512 "ShaderViewportIndexLayerEXT" => Ok(Self::ShaderViewportIndexLayerEXT),
2513 "ShaderViewportIndexLayerNV" => Ok(Self::ShaderViewportIndexLayerEXT),
2514 "ShaderViewportMaskNV" => Ok(Self::ShaderViewportMaskNV),
2515 "ShaderStereoViewNV" => Ok(Self::ShaderStereoViewNV),
2516 "PerViewAttributesNV" => Ok(Self::PerViewAttributesNV),
2517 "FragmentFullyCoveredEXT" => Ok(Self::FragmentFullyCoveredEXT),
2518 "MeshShadingNV" => Ok(Self::MeshShadingNV),
2519 "ImageFootprintNV" => Ok(Self::ImageFootprintNV),
2520 "MeshShadingEXT" => Ok(Self::MeshShadingEXT),
2521 "FragmentBarycentricKHR" => Ok(Self::FragmentBarycentricKHR),
2522 "FragmentBarycentricNV" => Ok(Self::FragmentBarycentricKHR),
2523 "ComputeDerivativeGroupQuadsNV" => Ok(Self::ComputeDerivativeGroupQuadsNV),
2524 "FragmentDensityEXT" => Ok(Self::FragmentDensityEXT),
2525 "ShadingRateNV" => Ok(Self::FragmentDensityEXT),
2526 "GroupNonUniformPartitionedNV" => Ok(Self::GroupNonUniformPartitionedNV),
2527 "ShaderNonUniform" => Ok(Self::ShaderNonUniform),
2528 "ShaderNonUniformEXT" => Ok(Self::ShaderNonUniform),
2529 "RuntimeDescriptorArray" => Ok(Self::RuntimeDescriptorArray),
2530 "RuntimeDescriptorArrayEXT" => Ok(Self::RuntimeDescriptorArray),
2531 "InputAttachmentArrayDynamicIndexing" => Ok(Self::InputAttachmentArrayDynamicIndexing),
2532 "InputAttachmentArrayDynamicIndexingEXT" => {
2533 Ok(Self::InputAttachmentArrayDynamicIndexing)
2534 }
2535 "UniformTexelBufferArrayDynamicIndexing" => {
2536 Ok(Self::UniformTexelBufferArrayDynamicIndexing)
2537 }
2538 "UniformTexelBufferArrayDynamicIndexingEXT" => {
2539 Ok(Self::UniformTexelBufferArrayDynamicIndexing)
2540 }
2541 "StorageTexelBufferArrayDynamicIndexing" => {
2542 Ok(Self::StorageTexelBufferArrayDynamicIndexing)
2543 }
2544 "StorageTexelBufferArrayDynamicIndexingEXT" => {
2545 Ok(Self::StorageTexelBufferArrayDynamicIndexing)
2546 }
2547 "UniformBufferArrayNonUniformIndexing" => {
2548 Ok(Self::UniformBufferArrayNonUniformIndexing)
2549 }
2550 "UniformBufferArrayNonUniformIndexingEXT" => {
2551 Ok(Self::UniformBufferArrayNonUniformIndexing)
2552 }
2553 "SampledImageArrayNonUniformIndexing" => Ok(Self::SampledImageArrayNonUniformIndexing),
2554 "SampledImageArrayNonUniformIndexingEXT" => {
2555 Ok(Self::SampledImageArrayNonUniformIndexing)
2556 }
2557 "StorageBufferArrayNonUniformIndexing" => {
2558 Ok(Self::StorageBufferArrayNonUniformIndexing)
2559 }
2560 "StorageBufferArrayNonUniformIndexingEXT" => {
2561 Ok(Self::StorageBufferArrayNonUniformIndexing)
2562 }
2563 "StorageImageArrayNonUniformIndexing" => Ok(Self::StorageImageArrayNonUniformIndexing),
2564 "StorageImageArrayNonUniformIndexingEXT" => {
2565 Ok(Self::StorageImageArrayNonUniformIndexing)
2566 }
2567 "InputAttachmentArrayNonUniformIndexing" => {
2568 Ok(Self::InputAttachmentArrayNonUniformIndexing)
2569 }
2570 "InputAttachmentArrayNonUniformIndexingEXT" => {
2571 Ok(Self::InputAttachmentArrayNonUniformIndexing)
2572 }
2573 "UniformTexelBufferArrayNonUniformIndexing" => {
2574 Ok(Self::UniformTexelBufferArrayNonUniformIndexing)
2575 }
2576 "UniformTexelBufferArrayNonUniformIndexingEXT" => {
2577 Ok(Self::UniformTexelBufferArrayNonUniformIndexing)
2578 }
2579 "StorageTexelBufferArrayNonUniformIndexing" => {
2580 Ok(Self::StorageTexelBufferArrayNonUniformIndexing)
2581 }
2582 "StorageTexelBufferArrayNonUniformIndexingEXT" => {
2583 Ok(Self::StorageTexelBufferArrayNonUniformIndexing)
2584 }
2585 "RayTracingPositionFetchKHR" => Ok(Self::RayTracingPositionFetchKHR),
2586 "RayTracingNV" => Ok(Self::RayTracingNV),
2587 "RayTracingMotionBlurNV" => Ok(Self::RayTracingMotionBlurNV),
2588 "VulkanMemoryModel" => Ok(Self::VulkanMemoryModel),
2589 "VulkanMemoryModelKHR" => Ok(Self::VulkanMemoryModel),
2590 "VulkanMemoryModelDeviceScope" => Ok(Self::VulkanMemoryModelDeviceScope),
2591 "VulkanMemoryModelDeviceScopeKHR" => Ok(Self::VulkanMemoryModelDeviceScope),
2592 "PhysicalStorageBufferAddresses" => Ok(Self::PhysicalStorageBufferAddresses),
2593 "PhysicalStorageBufferAddressesEXT" => Ok(Self::PhysicalStorageBufferAddresses),
2594 "ComputeDerivativeGroupLinearNV" => Ok(Self::ComputeDerivativeGroupLinearNV),
2595 "RayTracingProvisionalKHR" => Ok(Self::RayTracingProvisionalKHR),
2596 "CooperativeMatrixNV" => Ok(Self::CooperativeMatrixNV),
2597 "FragmentShaderSampleInterlockEXT" => Ok(Self::FragmentShaderSampleInterlockEXT),
2598 "FragmentShaderShadingRateInterlockEXT" => {
2599 Ok(Self::FragmentShaderShadingRateInterlockEXT)
2600 }
2601 "ShaderSMBuiltinsNV" => Ok(Self::ShaderSMBuiltinsNV),
2602 "FragmentShaderPixelInterlockEXT" => Ok(Self::FragmentShaderPixelInterlockEXT),
2603 "DemoteToHelperInvocation" => Ok(Self::DemoteToHelperInvocation),
2604 "DemoteToHelperInvocationEXT" => Ok(Self::DemoteToHelperInvocation),
2605 "DisplacementMicromapNV" => Ok(Self::DisplacementMicromapNV),
2606 "RayTracingOpacityMicromapEXT" => Ok(Self::RayTracingOpacityMicromapEXT),
2607 "ShaderInvocationReorderNV" => Ok(Self::ShaderInvocationReorderNV),
2608 "BindlessTextureNV" => Ok(Self::BindlessTextureNV),
2609 "RayQueryPositionFetchKHR" => Ok(Self::RayQueryPositionFetchKHR),
2610 "RayTracingDisplacementMicromapNV" => Ok(Self::RayTracingDisplacementMicromapNV),
2611 "SubgroupShuffleINTEL" => Ok(Self::SubgroupShuffleINTEL),
2612 "SubgroupBufferBlockIOINTEL" => Ok(Self::SubgroupBufferBlockIOINTEL),
2613 "SubgroupImageBlockIOINTEL" => Ok(Self::SubgroupImageBlockIOINTEL),
2614 "SubgroupImageMediaBlockIOINTEL" => Ok(Self::SubgroupImageMediaBlockIOINTEL),
2615 "RoundToInfinityINTEL" => Ok(Self::RoundToInfinityINTEL),
2616 "FloatingPointModeINTEL" => Ok(Self::FloatingPointModeINTEL),
2617 "IntegerFunctions2INTEL" => Ok(Self::IntegerFunctions2INTEL),
2618 "FunctionPointersINTEL" => Ok(Self::FunctionPointersINTEL),
2619 "IndirectReferencesINTEL" => Ok(Self::IndirectReferencesINTEL),
2620 "AsmINTEL" => Ok(Self::AsmINTEL),
2621 "AtomicFloat32MinMaxEXT" => Ok(Self::AtomicFloat32MinMaxEXT),
2622 "AtomicFloat64MinMaxEXT" => Ok(Self::AtomicFloat64MinMaxEXT),
2623 "AtomicFloat16MinMaxEXT" => Ok(Self::AtomicFloat16MinMaxEXT),
2624 "VectorComputeINTEL" => Ok(Self::VectorComputeINTEL),
2625 "VectorAnyINTEL" => Ok(Self::VectorAnyINTEL),
2626 "ExpectAssumeKHR" => Ok(Self::ExpectAssumeKHR),
2627 "SubgroupAvcMotionEstimationINTEL" => Ok(Self::SubgroupAvcMotionEstimationINTEL),
2628 "SubgroupAvcMotionEstimationIntraINTEL" => {
2629 Ok(Self::SubgroupAvcMotionEstimationIntraINTEL)
2630 }
2631 "SubgroupAvcMotionEstimationChromaINTEL" => {
2632 Ok(Self::SubgroupAvcMotionEstimationChromaINTEL)
2633 }
2634 "VariableLengthArrayINTEL" => Ok(Self::VariableLengthArrayINTEL),
2635 "FunctionFloatControlINTEL" => Ok(Self::FunctionFloatControlINTEL),
2636 "FPGAMemoryAttributesINTEL" => Ok(Self::FPGAMemoryAttributesINTEL),
2637 "FPFastMathModeINTEL" => Ok(Self::FPFastMathModeINTEL),
2638 "ArbitraryPrecisionIntegersINTEL" => Ok(Self::ArbitraryPrecisionIntegersINTEL),
2639 "ArbitraryPrecisionFloatingPointINTEL" => {
2640 Ok(Self::ArbitraryPrecisionFloatingPointINTEL)
2641 }
2642 "UnstructuredLoopControlsINTEL" => Ok(Self::UnstructuredLoopControlsINTEL),
2643 "FPGALoopControlsINTEL" => Ok(Self::FPGALoopControlsINTEL),
2644 "KernelAttributesINTEL" => Ok(Self::KernelAttributesINTEL),
2645 "FPGAKernelAttributesINTEL" => Ok(Self::FPGAKernelAttributesINTEL),
2646 "FPGAMemoryAccessesINTEL" => Ok(Self::FPGAMemoryAccessesINTEL),
2647 "FPGAClusterAttributesINTEL" => Ok(Self::FPGAClusterAttributesINTEL),
2648 "LoopFuseINTEL" => Ok(Self::LoopFuseINTEL),
2649 "FPGADSPControlINTEL" => Ok(Self::FPGADSPControlINTEL),
2650 "MemoryAccessAliasingINTEL" => Ok(Self::MemoryAccessAliasingINTEL),
2651 "FPGAInvocationPipeliningAttributesINTEL" => {
2652 Ok(Self::FPGAInvocationPipeliningAttributesINTEL)
2653 }
2654 "FPGABufferLocationINTEL" => Ok(Self::FPGABufferLocationINTEL),
2655 "ArbitraryPrecisionFixedPointINTEL" => Ok(Self::ArbitraryPrecisionFixedPointINTEL),
2656 "USMStorageClassesINTEL" => Ok(Self::USMStorageClassesINTEL),
2657 "RuntimeAlignedAttributeINTEL" => Ok(Self::RuntimeAlignedAttributeINTEL),
2658 "IOPipesINTEL" => Ok(Self::IOPipesINTEL),
2659 "BlockingPipesINTEL" => Ok(Self::BlockingPipesINTEL),
2660 "FPGARegINTEL" => Ok(Self::FPGARegINTEL),
2661 "DotProductInputAll" => Ok(Self::DotProductInputAll),
2662 "DotProductInputAllKHR" => Ok(Self::DotProductInputAll),
2663 "DotProductInput4x8Bit" => Ok(Self::DotProductInput4x8Bit),
2664 "DotProductInput4x8BitKHR" => Ok(Self::DotProductInput4x8Bit),
2665 "DotProductInput4x8BitPacked" => Ok(Self::DotProductInput4x8BitPacked),
2666 "DotProductInput4x8BitPackedKHR" => Ok(Self::DotProductInput4x8BitPacked),
2667 "DotProduct" => Ok(Self::DotProduct),
2668 "DotProductKHR" => Ok(Self::DotProduct),
2669 "RayCullMaskKHR" => Ok(Self::RayCullMaskKHR),
2670 "CooperativeMatrixKHR" => Ok(Self::CooperativeMatrixKHR),
2671 "BitInstructions" => Ok(Self::BitInstructions),
2672 "GroupNonUniformRotateKHR" => Ok(Self::GroupNonUniformRotateKHR),
2673 "AtomicFloat32AddEXT" => Ok(Self::AtomicFloat32AddEXT),
2674 "AtomicFloat64AddEXT" => Ok(Self::AtomicFloat64AddEXT),
2675 "LongConstantCompositeINTEL" => Ok(Self::LongConstantCompositeINTEL),
2676 "OptNoneINTEL" => Ok(Self::OptNoneINTEL),
2677 "AtomicFloat16AddEXT" => Ok(Self::AtomicFloat16AddEXT),
2678 "DebugInfoModuleINTEL" => Ok(Self::DebugInfoModuleINTEL),
2679 "BFloat16ConversionINTEL" => Ok(Self::BFloat16ConversionINTEL),
2680 "SplitBarrierINTEL" => Ok(Self::SplitBarrierINTEL),
2681 "GlobalVariableFPGADecorationsINTEL" => Ok(Self::GlobalVariableFPGADecorationsINTEL),
2682 "FPGAKernelAttributesv2INTEL" => Ok(Self::FPGAKernelAttributesv2INTEL),
2683 "GlobalVariableHostAccessINTEL" => Ok(Self::GlobalVariableHostAccessINTEL),
2684 "FPMaxErrorINTEL" => Ok(Self::FPMaxErrorINTEL),
2685 "FPGALatencyControlINTEL" => Ok(Self::FPGALatencyControlINTEL),
2686 "FPGAArgumentInterfacesINTEL" => Ok(Self::FPGAArgumentInterfacesINTEL),
2687 "GroupUniformArithmeticKHR" => Ok(Self::GroupUniformArithmeticKHR),
2688 "CacheControlsINTEL" => Ok(Self::CacheControlsINTEL),
2689 _ => Err(()),
2690 }
2691 }
2692}
2693#[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)"]
2694#[repr(u32)]
2695#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
2696#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
2697#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
2698#[allow(clippy::upper_case_acronyms)]
2699pub enum RayQueryIntersection {
2700 RayQueryCandidateIntersectionKHR = 0u32,
2701 RayQueryCommittedIntersectionKHR = 1u32,
2702}
2703impl RayQueryIntersection {
2704 pub fn from_u32(n: u32) -> Option<Self> {
2705 Some(match n {
2706 0u32..=1u32 => unsafe { core::mem::transmute::<u32, RayQueryIntersection>(n) },
2707 _ => return None,
2708 })
2709 }
2710}
2711#[allow(non_upper_case_globals)]
2712impl RayQueryIntersection {}
2713impl core::str::FromStr for RayQueryIntersection {
2714 type Err = ();
2715 fn from_str(s: &str) -> Result<Self, Self::Err> {
2716 match s {
2717 "RayQueryCandidateIntersectionKHR" => Ok(Self::RayQueryCandidateIntersectionKHR),
2718 "RayQueryCommittedIntersectionKHR" => Ok(Self::RayQueryCommittedIntersectionKHR),
2719 _ => Err(()),
2720 }
2721 }
2722}
2723#[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)"]
2724#[repr(u32)]
2725#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
2726#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
2727#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
2728#[allow(clippy::upper_case_acronyms)]
2729pub enum RayQueryCommittedIntersectionType {
2730 RayQueryCommittedIntersectionNoneKHR = 0u32,
2731 RayQueryCommittedIntersectionTriangleKHR = 1u32,
2732 RayQueryCommittedIntersectionGeneratedKHR = 2u32,
2733}
2734impl RayQueryCommittedIntersectionType {
2735 pub fn from_u32(n: u32) -> Option<Self> {
2736 Some(match n {
2737 0u32..=2u32 => unsafe {
2738 core::mem::transmute::<u32, RayQueryCommittedIntersectionType>(n)
2739 },
2740 _ => return None,
2741 })
2742 }
2743}
2744#[allow(non_upper_case_globals)]
2745impl RayQueryCommittedIntersectionType {}
2746impl core::str::FromStr for RayQueryCommittedIntersectionType {
2747 type Err = ();
2748 fn from_str(s: &str) -> Result<Self, Self::Err> {
2749 match s {
2750 "RayQueryCommittedIntersectionNoneKHR" => {
2751 Ok(Self::RayQueryCommittedIntersectionNoneKHR)
2752 }
2753 "RayQueryCommittedIntersectionTriangleKHR" => {
2754 Ok(Self::RayQueryCommittedIntersectionTriangleKHR)
2755 }
2756 "RayQueryCommittedIntersectionGeneratedKHR" => {
2757 Ok(Self::RayQueryCommittedIntersectionGeneratedKHR)
2758 }
2759 _ => Err(()),
2760 }
2761 }
2762}
2763#[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)"]
2764#[repr(u32)]
2765#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
2766#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
2767#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
2768#[allow(clippy::upper_case_acronyms)]
2769pub enum RayQueryCandidateIntersectionType {
2770 RayQueryCandidateIntersectionTriangleKHR = 0u32,
2771 RayQueryCandidateIntersectionAABBKHR = 1u32,
2772}
2773impl RayQueryCandidateIntersectionType {
2774 pub fn from_u32(n: u32) -> Option<Self> {
2775 Some(match n {
2776 0u32..=1u32 => unsafe {
2777 core::mem::transmute::<u32, RayQueryCandidateIntersectionType>(n)
2778 },
2779 _ => return None,
2780 })
2781 }
2782}
2783#[allow(non_upper_case_globals)]
2784impl RayQueryCandidateIntersectionType {}
2785impl core::str::FromStr for RayQueryCandidateIntersectionType {
2786 type Err = ();
2787 fn from_str(s: &str) -> Result<Self, Self::Err> {
2788 match s {
2789 "RayQueryCandidateIntersectionTriangleKHR" => {
2790 Ok(Self::RayQueryCandidateIntersectionTriangleKHR)
2791 }
2792 "RayQueryCandidateIntersectionAABBKHR" => {
2793 Ok(Self::RayQueryCandidateIntersectionAABBKHR)
2794 }
2795 _ => Err(()),
2796 }
2797 }
2798}
2799#[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)"]
2800#[repr(u32)]
2801#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
2802#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
2803#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
2804#[allow(clippy::upper_case_acronyms)]
2805pub enum PackedVectorFormat {
2806 PackedVectorFormat4x8Bit = 0u32,
2807}
2808impl PackedVectorFormat {
2809 pub fn from_u32(n: u32) -> Option<Self> {
2810 Some(match n {
2811 0u32 => unsafe { core::mem::transmute::<u32, PackedVectorFormat>(0u32) },
2812 _ => return None,
2813 })
2814 }
2815}
2816#[allow(non_upper_case_globals)]
2817impl PackedVectorFormat {
2818 pub const PackedVectorFormat4x8BitKHR: Self = Self::PackedVectorFormat4x8Bit;
2819}
2820impl core::str::FromStr for PackedVectorFormat {
2821 type Err = ();
2822 fn from_str(s: &str) -> Result<Self, Self::Err> {
2823 match s {
2824 "PackedVectorFormat4x8Bit" => Ok(Self::PackedVectorFormat4x8Bit),
2825 "PackedVectorFormat4x8BitKHR" => Ok(Self::PackedVectorFormat4x8Bit),
2826 _ => Err(()),
2827 }
2828 }
2829}
2830bitflags! { # [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 ; } }
2831#[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)"]
2832#[repr(u32)]
2833#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
2834#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
2835#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
2836#[allow(clippy::upper_case_acronyms)]
2837pub enum CooperativeMatrixLayout {
2838 RowMajorKHR = 0u32,
2839 ColumnMajorKHR = 1u32,
2840}
2841impl CooperativeMatrixLayout {
2842 pub fn from_u32(n: u32) -> Option<Self> {
2843 Some(match n {
2844 0u32..=1u32 => unsafe { core::mem::transmute::<u32, CooperativeMatrixLayout>(n) },
2845 _ => return None,
2846 })
2847 }
2848}
2849#[allow(non_upper_case_globals)]
2850impl CooperativeMatrixLayout {}
2851impl core::str::FromStr for CooperativeMatrixLayout {
2852 type Err = ();
2853 fn from_str(s: &str) -> Result<Self, Self::Err> {
2854 match s {
2855 "RowMajorKHR" => Ok(Self::RowMajorKHR),
2856 "ColumnMajorKHR" => Ok(Self::ColumnMajorKHR),
2857 _ => Err(()),
2858 }
2859 }
2860}
2861#[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)"]
2862#[repr(u32)]
2863#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
2864#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
2865#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
2866#[allow(clippy::upper_case_acronyms)]
2867pub enum CooperativeMatrixUse {
2868 MatrixAKHR = 0u32,
2869 MatrixBKHR = 1u32,
2870 MatrixAccumulatorKHR = 2u32,
2871}
2872impl CooperativeMatrixUse {
2873 pub fn from_u32(n: u32) -> Option<Self> {
2874 Some(match n {
2875 0u32..=2u32 => unsafe { core::mem::transmute::<u32, CooperativeMatrixUse>(n) },
2876 _ => return None,
2877 })
2878 }
2879}
2880#[allow(non_upper_case_globals)]
2881impl CooperativeMatrixUse {}
2882impl core::str::FromStr for CooperativeMatrixUse {
2883 type Err = ();
2884 fn from_str(s: &str) -> Result<Self, Self::Err> {
2885 match s {
2886 "MatrixAKHR" => Ok(Self::MatrixAKHR),
2887 "MatrixBKHR" => Ok(Self::MatrixBKHR),
2888 "MatrixAccumulatorKHR" => Ok(Self::MatrixAccumulatorKHR),
2889 _ => Err(()),
2890 }
2891 }
2892}
2893#[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)"]
2894#[repr(u32)]
2895#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
2896#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
2897#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
2898#[allow(clippy::upper_case_acronyms)]
2899pub enum InitializationModeQualifier {
2900 InitOnDeviceReprogramINTEL = 0u32,
2901 InitOnDeviceResetINTEL = 1u32,
2902}
2903impl InitializationModeQualifier {
2904 pub fn from_u32(n: u32) -> Option<Self> {
2905 Some(match n {
2906 0u32..=1u32 => unsafe { core::mem::transmute::<u32, InitializationModeQualifier>(n) },
2907 _ => return None,
2908 })
2909 }
2910}
2911#[allow(non_upper_case_globals)]
2912impl InitializationModeQualifier {}
2913impl core::str::FromStr for InitializationModeQualifier {
2914 type Err = ();
2915 fn from_str(s: &str) -> Result<Self, Self::Err> {
2916 match s {
2917 "InitOnDeviceReprogramINTEL" => Ok(Self::InitOnDeviceReprogramINTEL),
2918 "InitOnDeviceResetINTEL" => Ok(Self::InitOnDeviceResetINTEL),
2919 _ => Err(()),
2920 }
2921 }
2922}
2923#[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)"]
2924#[repr(u32)]
2925#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
2926#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
2927#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
2928#[allow(clippy::upper_case_acronyms)]
2929pub enum LoadCacheControl {
2930 UncachedINTEL = 0u32,
2931 CachedINTEL = 1u32,
2932 StreamingINTEL = 2u32,
2933 InvalidateAfterReadINTEL = 3u32,
2934 ConstCachedINTEL = 4u32,
2935}
2936impl LoadCacheControl {
2937 pub fn from_u32(n: u32) -> Option<Self> {
2938 Some(match n {
2939 0u32..=4u32 => unsafe { core::mem::transmute::<u32, LoadCacheControl>(n) },
2940 _ => return None,
2941 })
2942 }
2943}
2944#[allow(non_upper_case_globals)]
2945impl LoadCacheControl {}
2946impl core::str::FromStr for LoadCacheControl {
2947 type Err = ();
2948 fn from_str(s: &str) -> Result<Self, Self::Err> {
2949 match s {
2950 "UncachedINTEL" => Ok(Self::UncachedINTEL),
2951 "CachedINTEL" => Ok(Self::CachedINTEL),
2952 "StreamingINTEL" => Ok(Self::StreamingINTEL),
2953 "InvalidateAfterReadINTEL" => Ok(Self::InvalidateAfterReadINTEL),
2954 "ConstCachedINTEL" => Ok(Self::ConstCachedINTEL),
2955 _ => Err(()),
2956 }
2957 }
2958}
2959#[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)"]
2960#[repr(u32)]
2961#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
2962#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
2963#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
2964#[allow(clippy::upper_case_acronyms)]
2965pub enum StoreCacheControl {
2966 UncachedINTEL = 0u32,
2967 WriteThroughINTEL = 1u32,
2968 WriteBackINTEL = 2u32,
2969 StreamingINTEL = 3u32,
2970}
2971impl StoreCacheControl {
2972 pub fn from_u32(n: u32) -> Option<Self> {
2973 Some(match n {
2974 0u32..=3u32 => unsafe { core::mem::transmute::<u32, StoreCacheControl>(n) },
2975 _ => return None,
2976 })
2977 }
2978}
2979#[allow(non_upper_case_globals)]
2980impl StoreCacheControl {}
2981impl core::str::FromStr for StoreCacheControl {
2982 type Err = ();
2983 fn from_str(s: &str) -> Result<Self, Self::Err> {
2984 match s {
2985 "UncachedINTEL" => Ok(Self::UncachedINTEL),
2986 "WriteThroughINTEL" => Ok(Self::WriteThroughINTEL),
2987 "WriteBackINTEL" => Ok(Self::WriteBackINTEL),
2988 "StreamingINTEL" => Ok(Self::StreamingINTEL),
2989 _ => Err(()),
2990 }
2991 }
2992}
2993#[doc = "SPIR-V [instructions](https://www.khronos.org/registry/spir-v/specs/unified1/SPIRV.html#_a_id_instructions_a_instructions) opcodes"]
2994#[repr(u32)]
2995#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
2996#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
2997#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
2998#[allow(clippy::upper_case_acronyms)]
2999pub enum Op {
3000 Nop = 0u32,
3001 Undef = 1u32,
3002 SourceContinued = 2u32,
3003 Source = 3u32,
3004 SourceExtension = 4u32,
3005 Name = 5u32,
3006 MemberName = 6u32,
3007 String = 7u32,
3008 Line = 8u32,
3009 Extension = 10u32,
3010 ExtInstImport = 11u32,
3011 ExtInst = 12u32,
3012 MemoryModel = 14u32,
3013 EntryPoint = 15u32,
3014 ExecutionMode = 16u32,
3015 Capability = 17u32,
3016 TypeVoid = 19u32,
3017 TypeBool = 20u32,
3018 TypeInt = 21u32,
3019 TypeFloat = 22u32,
3020 TypeVector = 23u32,
3021 TypeMatrix = 24u32,
3022 TypeImage = 25u32,
3023 TypeSampler = 26u32,
3024 TypeSampledImage = 27u32,
3025 TypeArray = 28u32,
3026 TypeRuntimeArray = 29u32,
3027 TypeStruct = 30u32,
3028 TypeOpaque = 31u32,
3029 TypePointer = 32u32,
3030 TypeFunction = 33u32,
3031 TypeEvent = 34u32,
3032 TypeDeviceEvent = 35u32,
3033 TypeReserveId = 36u32,
3034 TypeQueue = 37u32,
3035 TypePipe = 38u32,
3036 TypeForwardPointer = 39u32,
3037 ConstantTrue = 41u32,
3038 ConstantFalse = 42u32,
3039 Constant = 43u32,
3040 ConstantComposite = 44u32,
3041 ConstantSampler = 45u32,
3042 ConstantNull = 46u32,
3043 SpecConstantTrue = 48u32,
3044 SpecConstantFalse = 49u32,
3045 SpecConstant = 50u32,
3046 SpecConstantComposite = 51u32,
3047 SpecConstantOp = 52u32,
3048 Function = 54u32,
3049 FunctionParameter = 55u32,
3050 FunctionEnd = 56u32,
3051 FunctionCall = 57u32,
3052 Variable = 59u32,
3053 ImageTexelPointer = 60u32,
3054 Load = 61u32,
3055 Store = 62u32,
3056 CopyMemory = 63u32,
3057 CopyMemorySized = 64u32,
3058 AccessChain = 65u32,
3059 InBoundsAccessChain = 66u32,
3060 PtrAccessChain = 67u32,
3061 ArrayLength = 68u32,
3062 GenericPtrMemSemantics = 69u32,
3063 InBoundsPtrAccessChain = 70u32,
3064 Decorate = 71u32,
3065 MemberDecorate = 72u32,
3066 DecorationGroup = 73u32,
3067 GroupDecorate = 74u32,
3068 GroupMemberDecorate = 75u32,
3069 VectorExtractDynamic = 77u32,
3070 VectorInsertDynamic = 78u32,
3071 VectorShuffle = 79u32,
3072 CompositeConstruct = 80u32,
3073 CompositeExtract = 81u32,
3074 CompositeInsert = 82u32,
3075 CopyObject = 83u32,
3076 Transpose = 84u32,
3077 SampledImage = 86u32,
3078 ImageSampleImplicitLod = 87u32,
3079 ImageSampleExplicitLod = 88u32,
3080 ImageSampleDrefImplicitLod = 89u32,
3081 ImageSampleDrefExplicitLod = 90u32,
3082 ImageSampleProjImplicitLod = 91u32,
3083 ImageSampleProjExplicitLod = 92u32,
3084 ImageSampleProjDrefImplicitLod = 93u32,
3085 ImageSampleProjDrefExplicitLod = 94u32,
3086 ImageFetch = 95u32,
3087 ImageGather = 96u32,
3088 ImageDrefGather = 97u32,
3089 ImageRead = 98u32,
3090 ImageWrite = 99u32,
3091 Image = 100u32,
3092 ImageQueryFormat = 101u32,
3093 ImageQueryOrder = 102u32,
3094 ImageQuerySizeLod = 103u32,
3095 ImageQuerySize = 104u32,
3096 ImageQueryLod = 105u32,
3097 ImageQueryLevels = 106u32,
3098 ImageQuerySamples = 107u32,
3099 ConvertFToU = 109u32,
3100 ConvertFToS = 110u32,
3101 ConvertSToF = 111u32,
3102 ConvertUToF = 112u32,
3103 UConvert = 113u32,
3104 SConvert = 114u32,
3105 FConvert = 115u32,
3106 QuantizeToF16 = 116u32,
3107 ConvertPtrToU = 117u32,
3108 SatConvertSToU = 118u32,
3109 SatConvertUToS = 119u32,
3110 ConvertUToPtr = 120u32,
3111 PtrCastToGeneric = 121u32,
3112 GenericCastToPtr = 122u32,
3113 GenericCastToPtrExplicit = 123u32,
3114 Bitcast = 124u32,
3115 SNegate = 126u32,
3116 FNegate = 127u32,
3117 IAdd = 128u32,
3118 FAdd = 129u32,
3119 ISub = 130u32,
3120 FSub = 131u32,
3121 IMul = 132u32,
3122 FMul = 133u32,
3123 UDiv = 134u32,
3124 SDiv = 135u32,
3125 FDiv = 136u32,
3126 UMod = 137u32,
3127 SRem = 138u32,
3128 SMod = 139u32,
3129 FRem = 140u32,
3130 FMod = 141u32,
3131 VectorTimesScalar = 142u32,
3132 MatrixTimesScalar = 143u32,
3133 VectorTimesMatrix = 144u32,
3134 MatrixTimesVector = 145u32,
3135 MatrixTimesMatrix = 146u32,
3136 OuterProduct = 147u32,
3137 Dot = 148u32,
3138 IAddCarry = 149u32,
3139 ISubBorrow = 150u32,
3140 UMulExtended = 151u32,
3141 SMulExtended = 152u32,
3142 Any = 154u32,
3143 All = 155u32,
3144 IsNan = 156u32,
3145 IsInf = 157u32,
3146 IsFinite = 158u32,
3147 IsNormal = 159u32,
3148 SignBitSet = 160u32,
3149 LessOrGreater = 161u32,
3150 Ordered = 162u32,
3151 Unordered = 163u32,
3152 LogicalEqual = 164u32,
3153 LogicalNotEqual = 165u32,
3154 LogicalOr = 166u32,
3155 LogicalAnd = 167u32,
3156 LogicalNot = 168u32,
3157 Select = 169u32,
3158 IEqual = 170u32,
3159 INotEqual = 171u32,
3160 UGreaterThan = 172u32,
3161 SGreaterThan = 173u32,
3162 UGreaterThanEqual = 174u32,
3163 SGreaterThanEqual = 175u32,
3164 ULessThan = 176u32,
3165 SLessThan = 177u32,
3166 ULessThanEqual = 178u32,
3167 SLessThanEqual = 179u32,
3168 FOrdEqual = 180u32,
3169 FUnordEqual = 181u32,
3170 FOrdNotEqual = 182u32,
3171 FUnordNotEqual = 183u32,
3172 FOrdLessThan = 184u32,
3173 FUnordLessThan = 185u32,
3174 FOrdGreaterThan = 186u32,
3175 FUnordGreaterThan = 187u32,
3176 FOrdLessThanEqual = 188u32,
3177 FUnordLessThanEqual = 189u32,
3178 FOrdGreaterThanEqual = 190u32,
3179 FUnordGreaterThanEqual = 191u32,
3180 ShiftRightLogical = 194u32,
3181 ShiftRightArithmetic = 195u32,
3182 ShiftLeftLogical = 196u32,
3183 BitwiseOr = 197u32,
3184 BitwiseXor = 198u32,
3185 BitwiseAnd = 199u32,
3186 Not = 200u32,
3187 BitFieldInsert = 201u32,
3188 BitFieldSExtract = 202u32,
3189 BitFieldUExtract = 203u32,
3190 BitReverse = 204u32,
3191 BitCount = 205u32,
3192 DPdx = 207u32,
3193 DPdy = 208u32,
3194 Fwidth = 209u32,
3195 DPdxFine = 210u32,
3196 DPdyFine = 211u32,
3197 FwidthFine = 212u32,
3198 DPdxCoarse = 213u32,
3199 DPdyCoarse = 214u32,
3200 FwidthCoarse = 215u32,
3201 EmitVertex = 218u32,
3202 EndPrimitive = 219u32,
3203 EmitStreamVertex = 220u32,
3204 EndStreamPrimitive = 221u32,
3205 ControlBarrier = 224u32,
3206 MemoryBarrier = 225u32,
3207 AtomicLoad = 227u32,
3208 AtomicStore = 228u32,
3209 AtomicExchange = 229u32,
3210 AtomicCompareExchange = 230u32,
3211 AtomicCompareExchangeWeak = 231u32,
3212 AtomicIIncrement = 232u32,
3213 AtomicIDecrement = 233u32,
3214 AtomicIAdd = 234u32,
3215 AtomicISub = 235u32,
3216 AtomicSMin = 236u32,
3217 AtomicUMin = 237u32,
3218 AtomicSMax = 238u32,
3219 AtomicUMax = 239u32,
3220 AtomicAnd = 240u32,
3221 AtomicOr = 241u32,
3222 AtomicXor = 242u32,
3223 Phi = 245u32,
3224 LoopMerge = 246u32,
3225 SelectionMerge = 247u32,
3226 Label = 248u32,
3227 Branch = 249u32,
3228 BranchConditional = 250u32,
3229 Switch = 251u32,
3230 Kill = 252u32,
3231 Return = 253u32,
3232 ReturnValue = 254u32,
3233 Unreachable = 255u32,
3234 LifetimeStart = 256u32,
3235 LifetimeStop = 257u32,
3236 GroupAsyncCopy = 259u32,
3237 GroupWaitEvents = 260u32,
3238 GroupAll = 261u32,
3239 GroupAny = 262u32,
3240 GroupBroadcast = 263u32,
3241 GroupIAdd = 264u32,
3242 GroupFAdd = 265u32,
3243 GroupFMin = 266u32,
3244 GroupUMin = 267u32,
3245 GroupSMin = 268u32,
3246 GroupFMax = 269u32,
3247 GroupUMax = 270u32,
3248 GroupSMax = 271u32,
3249 ReadPipe = 274u32,
3250 WritePipe = 275u32,
3251 ReservedReadPipe = 276u32,
3252 ReservedWritePipe = 277u32,
3253 ReserveReadPipePackets = 278u32,
3254 ReserveWritePipePackets = 279u32,
3255 CommitReadPipe = 280u32,
3256 CommitWritePipe = 281u32,
3257 IsValidReserveId = 282u32,
3258 GetNumPipePackets = 283u32,
3259 GetMaxPipePackets = 284u32,
3260 GroupReserveReadPipePackets = 285u32,
3261 GroupReserveWritePipePackets = 286u32,
3262 GroupCommitReadPipe = 287u32,
3263 GroupCommitWritePipe = 288u32,
3264 EnqueueMarker = 291u32,
3265 EnqueueKernel = 292u32,
3266 GetKernelNDrangeSubGroupCount = 293u32,
3267 GetKernelNDrangeMaxSubGroupSize = 294u32,
3268 GetKernelWorkGroupSize = 295u32,
3269 GetKernelPreferredWorkGroupSizeMultiple = 296u32,
3270 RetainEvent = 297u32,
3271 ReleaseEvent = 298u32,
3272 CreateUserEvent = 299u32,
3273 IsValidEvent = 300u32,
3274 SetUserEventStatus = 301u32,
3275 CaptureEventProfilingInfo = 302u32,
3276 GetDefaultQueue = 303u32,
3277 BuildNDRange = 304u32,
3278 ImageSparseSampleImplicitLod = 305u32,
3279 ImageSparseSampleExplicitLod = 306u32,
3280 ImageSparseSampleDrefImplicitLod = 307u32,
3281 ImageSparseSampleDrefExplicitLod = 308u32,
3282 ImageSparseSampleProjImplicitLod = 309u32,
3283 ImageSparseSampleProjExplicitLod = 310u32,
3284 ImageSparseSampleProjDrefImplicitLod = 311u32,
3285 ImageSparseSampleProjDrefExplicitLod = 312u32,
3286 ImageSparseFetch = 313u32,
3287 ImageSparseGather = 314u32,
3288 ImageSparseDrefGather = 315u32,
3289 ImageSparseTexelsResident = 316u32,
3290 NoLine = 317u32,
3291 AtomicFlagTestAndSet = 318u32,
3292 AtomicFlagClear = 319u32,
3293 ImageSparseRead = 320u32,
3294 SizeOf = 321u32,
3295 TypePipeStorage = 322u32,
3296 ConstantPipeStorage = 323u32,
3297 CreatePipeFromPipeStorage = 324u32,
3298 GetKernelLocalSizeForSubgroupCount = 325u32,
3299 GetKernelMaxNumSubgroups = 326u32,
3300 TypeNamedBarrier = 327u32,
3301 NamedBarrierInitialize = 328u32,
3302 MemoryNamedBarrier = 329u32,
3303 ModuleProcessed = 330u32,
3304 ExecutionModeId = 331u32,
3305 DecorateId = 332u32,
3306 GroupNonUniformElect = 333u32,
3307 GroupNonUniformAll = 334u32,
3308 GroupNonUniformAny = 335u32,
3309 GroupNonUniformAllEqual = 336u32,
3310 GroupNonUniformBroadcast = 337u32,
3311 GroupNonUniformBroadcastFirst = 338u32,
3312 GroupNonUniformBallot = 339u32,
3313 GroupNonUniformInverseBallot = 340u32,
3314 GroupNonUniformBallotBitExtract = 341u32,
3315 GroupNonUniformBallotBitCount = 342u32,
3316 GroupNonUniformBallotFindLSB = 343u32,
3317 GroupNonUniformBallotFindMSB = 344u32,
3318 GroupNonUniformShuffle = 345u32,
3319 GroupNonUniformShuffleXor = 346u32,
3320 GroupNonUniformShuffleUp = 347u32,
3321 GroupNonUniformShuffleDown = 348u32,
3322 GroupNonUniformIAdd = 349u32,
3323 GroupNonUniformFAdd = 350u32,
3324 GroupNonUniformIMul = 351u32,
3325 GroupNonUniformFMul = 352u32,
3326 GroupNonUniformSMin = 353u32,
3327 GroupNonUniformUMin = 354u32,
3328 GroupNonUniformFMin = 355u32,
3329 GroupNonUniformSMax = 356u32,
3330 GroupNonUniformUMax = 357u32,
3331 GroupNonUniformFMax = 358u32,
3332 GroupNonUniformBitwiseAnd = 359u32,
3333 GroupNonUniformBitwiseOr = 360u32,
3334 GroupNonUniformBitwiseXor = 361u32,
3335 GroupNonUniformLogicalAnd = 362u32,
3336 GroupNonUniformLogicalOr = 363u32,
3337 GroupNonUniformLogicalXor = 364u32,
3338 GroupNonUniformQuadBroadcast = 365u32,
3339 GroupNonUniformQuadSwap = 366u32,
3340 CopyLogical = 400u32,
3341 PtrEqual = 401u32,
3342 PtrNotEqual = 402u32,
3343 PtrDiff = 403u32,
3344 ColorAttachmentReadEXT = 4160u32,
3345 DepthAttachmentReadEXT = 4161u32,
3346 StencilAttachmentReadEXT = 4162u32,
3347 TerminateInvocation = 4416u32,
3348 SubgroupBallotKHR = 4421u32,
3349 SubgroupFirstInvocationKHR = 4422u32,
3350 SubgroupAllKHR = 4428u32,
3351 SubgroupAnyKHR = 4429u32,
3352 SubgroupAllEqualKHR = 4430u32,
3353 GroupNonUniformRotateKHR = 4431u32,
3354 SubgroupReadInvocationKHR = 4432u32,
3355 TraceRayKHR = 4445u32,
3356 ExecuteCallableKHR = 4446u32,
3357 ConvertUToAccelerationStructureKHR = 4447u32,
3358 IgnoreIntersectionKHR = 4448u32,
3359 TerminateRayKHR = 4449u32,
3360 SDot = 4450u32,
3361 UDot = 4451u32,
3362 SUDot = 4452u32,
3363 SDotAccSat = 4453u32,
3364 UDotAccSat = 4454u32,
3365 SUDotAccSat = 4455u32,
3366 TypeCooperativeMatrixKHR = 4456u32,
3367 CooperativeMatrixLoadKHR = 4457u32,
3368 CooperativeMatrixStoreKHR = 4458u32,
3369 CooperativeMatrixMulAddKHR = 4459u32,
3370 CooperativeMatrixLengthKHR = 4460u32,
3371 TypeRayQueryKHR = 4472u32,
3372 RayQueryInitializeKHR = 4473u32,
3373 RayQueryTerminateKHR = 4474u32,
3374 RayQueryGenerateIntersectionKHR = 4475u32,
3375 RayQueryConfirmIntersectionKHR = 4476u32,
3376 RayQueryProceedKHR = 4477u32,
3377 RayQueryGetIntersectionTypeKHR = 4479u32,
3378 ImageSampleWeightedQCOM = 4480u32,
3379 ImageBoxFilterQCOM = 4481u32,
3380 ImageBlockMatchSSDQCOM = 4482u32,
3381 ImageBlockMatchSADQCOM = 4483u32,
3382 GroupIAddNonUniformAMD = 5000u32,
3383 GroupFAddNonUniformAMD = 5001u32,
3384 GroupFMinNonUniformAMD = 5002u32,
3385 GroupUMinNonUniformAMD = 5003u32,
3386 GroupSMinNonUniformAMD = 5004u32,
3387 GroupFMaxNonUniformAMD = 5005u32,
3388 GroupUMaxNonUniformAMD = 5006u32,
3389 GroupSMaxNonUniformAMD = 5007u32,
3390 FragmentMaskFetchAMD = 5011u32,
3391 FragmentFetchAMD = 5012u32,
3392 ReadClockKHR = 5056u32,
3393 FinalizeNodePayloadsAMDX = 5075u32,
3394 FinishWritingNodePayloadAMDX = 5078u32,
3395 InitializeNodePayloadsAMDX = 5090u32,
3396 HitObjectRecordHitMotionNV = 5249u32,
3397 HitObjectRecordHitWithIndexMotionNV = 5250u32,
3398 HitObjectRecordMissMotionNV = 5251u32,
3399 HitObjectGetWorldToObjectNV = 5252u32,
3400 HitObjectGetObjectToWorldNV = 5253u32,
3401 HitObjectGetObjectRayDirectionNV = 5254u32,
3402 HitObjectGetObjectRayOriginNV = 5255u32,
3403 HitObjectTraceRayMotionNV = 5256u32,
3404 HitObjectGetShaderRecordBufferHandleNV = 5257u32,
3405 HitObjectGetShaderBindingTableRecordIndexNV = 5258u32,
3406 HitObjectRecordEmptyNV = 5259u32,
3407 HitObjectTraceRayNV = 5260u32,
3408 HitObjectRecordHitNV = 5261u32,
3409 HitObjectRecordHitWithIndexNV = 5262u32,
3410 HitObjectRecordMissNV = 5263u32,
3411 HitObjectExecuteShaderNV = 5264u32,
3412 HitObjectGetCurrentTimeNV = 5265u32,
3413 HitObjectGetAttributesNV = 5266u32,
3414 HitObjectGetHitKindNV = 5267u32,
3415 HitObjectGetPrimitiveIndexNV = 5268u32,
3416 HitObjectGetGeometryIndexNV = 5269u32,
3417 HitObjectGetInstanceIdNV = 5270u32,
3418 HitObjectGetInstanceCustomIndexNV = 5271u32,
3419 HitObjectGetWorldRayDirectionNV = 5272u32,
3420 HitObjectGetWorldRayOriginNV = 5273u32,
3421 HitObjectGetRayTMaxNV = 5274u32,
3422 HitObjectGetRayTMinNV = 5275u32,
3423 HitObjectIsEmptyNV = 5276u32,
3424 HitObjectIsHitNV = 5277u32,
3425 HitObjectIsMissNV = 5278u32,
3426 ReorderThreadWithHitObjectNV = 5279u32,
3427 ReorderThreadWithHintNV = 5280u32,
3428 TypeHitObjectNV = 5281u32,
3429 ImageSampleFootprintNV = 5283u32,
3430 EmitMeshTasksEXT = 5294u32,
3431 SetMeshOutputsEXT = 5295u32,
3432 GroupNonUniformPartitionNV = 5296u32,
3433 WritePackedPrimitiveIndices4x8NV = 5299u32,
3434 FetchMicroTriangleVertexPositionNV = 5300u32,
3435 FetchMicroTriangleVertexBarycentricNV = 5301u32,
3436 ReportIntersectionKHR = 5334u32,
3437 IgnoreIntersectionNV = 5335u32,
3438 TerminateRayNV = 5336u32,
3439 TraceNV = 5337u32,
3440 TraceMotionNV = 5338u32,
3441 TraceRayMotionNV = 5339u32,
3442 RayQueryGetIntersectionTriangleVertexPositionsKHR = 5340u32,
3443 TypeAccelerationStructureKHR = 5341u32,
3444 ExecuteCallableNV = 5344u32,
3445 TypeCooperativeMatrixNV = 5358u32,
3446 CooperativeMatrixLoadNV = 5359u32,
3447 CooperativeMatrixStoreNV = 5360u32,
3448 CooperativeMatrixMulAddNV = 5361u32,
3449 CooperativeMatrixLengthNV = 5362u32,
3450 BeginInvocationInterlockEXT = 5364u32,
3451 EndInvocationInterlockEXT = 5365u32,
3452 DemoteToHelperInvocation = 5380u32,
3453 IsHelperInvocationEXT = 5381u32,
3454 ConvertUToImageNV = 5391u32,
3455 ConvertUToSamplerNV = 5392u32,
3456 ConvertImageToUNV = 5393u32,
3457 ConvertSamplerToUNV = 5394u32,
3458 ConvertUToSampledImageNV = 5395u32,
3459 ConvertSampledImageToUNV = 5396u32,
3460 SamplerImageAddressingModeNV = 5397u32,
3461 SubgroupShuffleINTEL = 5571u32,
3462 SubgroupShuffleDownINTEL = 5572u32,
3463 SubgroupShuffleUpINTEL = 5573u32,
3464 SubgroupShuffleXorINTEL = 5574u32,
3465 SubgroupBlockReadINTEL = 5575u32,
3466 SubgroupBlockWriteINTEL = 5576u32,
3467 SubgroupImageBlockReadINTEL = 5577u32,
3468 SubgroupImageBlockWriteINTEL = 5578u32,
3469 SubgroupImageMediaBlockReadINTEL = 5580u32,
3470 SubgroupImageMediaBlockWriteINTEL = 5581u32,
3471 UCountLeadingZerosINTEL = 5585u32,
3472 UCountTrailingZerosINTEL = 5586u32,
3473 AbsISubINTEL = 5587u32,
3474 AbsUSubINTEL = 5588u32,
3475 IAddSatINTEL = 5589u32,
3476 UAddSatINTEL = 5590u32,
3477 IAverageINTEL = 5591u32,
3478 UAverageINTEL = 5592u32,
3479 IAverageRoundedINTEL = 5593u32,
3480 UAverageRoundedINTEL = 5594u32,
3481 ISubSatINTEL = 5595u32,
3482 USubSatINTEL = 5596u32,
3483 IMul32x16INTEL = 5597u32,
3484 UMul32x16INTEL = 5598u32,
3485 ConstantFunctionPointerINTEL = 5600u32,
3486 FunctionPointerCallINTEL = 5601u32,
3487 AsmTargetINTEL = 5609u32,
3488 AsmINTEL = 5610u32,
3489 AsmCallINTEL = 5611u32,
3490 AtomicFMinEXT = 5614u32,
3491 AtomicFMaxEXT = 5615u32,
3492 AssumeTrueKHR = 5630u32,
3493 ExpectKHR = 5631u32,
3494 DecorateString = 5632u32,
3495 MemberDecorateString = 5633u32,
3496 VmeImageINTEL = 5699u32,
3497 TypeVmeImageINTEL = 5700u32,
3498 TypeAvcImePayloadINTEL = 5701u32,
3499 TypeAvcRefPayloadINTEL = 5702u32,
3500 TypeAvcSicPayloadINTEL = 5703u32,
3501 TypeAvcMcePayloadINTEL = 5704u32,
3502 TypeAvcMceResultINTEL = 5705u32,
3503 TypeAvcImeResultINTEL = 5706u32,
3504 TypeAvcImeResultSingleReferenceStreamoutINTEL = 5707u32,
3505 TypeAvcImeResultDualReferenceStreamoutINTEL = 5708u32,
3506 TypeAvcImeSingleReferenceStreaminINTEL = 5709u32,
3507 TypeAvcImeDualReferenceStreaminINTEL = 5710u32,
3508 TypeAvcRefResultINTEL = 5711u32,
3509 TypeAvcSicResultINTEL = 5712u32,
3510 SubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713u32,
3511 SubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714u32,
3512 SubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715u32,
3513 SubgroupAvcMceSetInterShapePenaltyINTEL = 5716u32,
3514 SubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717u32,
3515 SubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718u32,
3516 SubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719u32,
3517 SubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720u32,
3518 SubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721u32,
3519 SubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722u32,
3520 SubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723u32,
3521 SubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724u32,
3522 SubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725u32,
3523 SubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726u32,
3524 SubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727u32,
3525 SubgroupAvcMceSetAcOnlyHaarINTEL = 5728u32,
3526 SubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729u32,
3527 SubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730u32,
3528 SubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731u32,
3529 SubgroupAvcMceConvertToImePayloadINTEL = 5732u32,
3530 SubgroupAvcMceConvertToImeResultINTEL = 5733u32,
3531 SubgroupAvcMceConvertToRefPayloadINTEL = 5734u32,
3532 SubgroupAvcMceConvertToRefResultINTEL = 5735u32,
3533 SubgroupAvcMceConvertToSicPayloadINTEL = 5736u32,
3534 SubgroupAvcMceConvertToSicResultINTEL = 5737u32,
3535 SubgroupAvcMceGetMotionVectorsINTEL = 5738u32,
3536 SubgroupAvcMceGetInterDistortionsINTEL = 5739u32,
3537 SubgroupAvcMceGetBestInterDistortionsINTEL = 5740u32,
3538 SubgroupAvcMceGetInterMajorShapeINTEL = 5741u32,
3539 SubgroupAvcMceGetInterMinorShapeINTEL = 5742u32,
3540 SubgroupAvcMceGetInterDirectionsINTEL = 5743u32,
3541 SubgroupAvcMceGetInterMotionVectorCountINTEL = 5744u32,
3542 SubgroupAvcMceGetInterReferenceIdsINTEL = 5745u32,
3543 SubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746u32,
3544 SubgroupAvcImeInitializeINTEL = 5747u32,
3545 SubgroupAvcImeSetSingleReferenceINTEL = 5748u32,
3546 SubgroupAvcImeSetDualReferenceINTEL = 5749u32,
3547 SubgroupAvcImeRefWindowSizeINTEL = 5750u32,
3548 SubgroupAvcImeAdjustRefOffsetINTEL = 5751u32,
3549 SubgroupAvcImeConvertToMcePayloadINTEL = 5752u32,
3550 SubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753u32,
3551 SubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754u32,
3552 SubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755u32,
3553 SubgroupAvcImeSetWeightedSadINTEL = 5756u32,
3554 SubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757u32,
3555 SubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758u32,
3556 SubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759u32,
3557 SubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760u32,
3558 SubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761u32,
3559 SubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762u32,
3560 SubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763u32,
3561 SubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764u32,
3562 SubgroupAvcImeConvertToMceResultINTEL = 5765u32,
3563 SubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766u32,
3564 SubgroupAvcImeGetDualReferenceStreaminINTEL = 5767u32,
3565 SubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768u32,
3566 SubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769u32,
3567 SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770u32,
3568 SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771u32,
3569 SubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772u32,
3570 SubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773u32,
3571 SubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774u32,
3572 SubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775u32,
3573 SubgroupAvcImeGetBorderReachedINTEL = 5776u32,
3574 SubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777u32,
3575 SubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778u32,
3576 SubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779u32,
3577 SubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780u32,
3578 SubgroupAvcFmeInitializeINTEL = 5781u32,
3579 SubgroupAvcBmeInitializeINTEL = 5782u32,
3580 SubgroupAvcRefConvertToMcePayloadINTEL = 5783u32,
3581 SubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784u32,
3582 SubgroupAvcRefSetBilinearFilterEnableINTEL = 5785u32,
3583 SubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786u32,
3584 SubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787u32,
3585 SubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788u32,
3586 SubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789u32,
3587 SubgroupAvcRefConvertToMceResultINTEL = 5790u32,
3588 SubgroupAvcSicInitializeINTEL = 5791u32,
3589 SubgroupAvcSicConfigureSkcINTEL = 5792u32,
3590 SubgroupAvcSicConfigureIpeLumaINTEL = 5793u32,
3591 SubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794u32,
3592 SubgroupAvcSicGetMotionVectorMaskINTEL = 5795u32,
3593 SubgroupAvcSicConvertToMcePayloadINTEL = 5796u32,
3594 SubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797u32,
3595 SubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798u32,
3596 SubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799u32,
3597 SubgroupAvcSicSetBilinearFilterEnableINTEL = 5800u32,
3598 SubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801u32,
3599 SubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802u32,
3600 SubgroupAvcSicEvaluateIpeINTEL = 5803u32,
3601 SubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804u32,
3602 SubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805u32,
3603 SubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806u32,
3604 SubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807u32,
3605 SubgroupAvcSicConvertToMceResultINTEL = 5808u32,
3606 SubgroupAvcSicGetIpeLumaShapeINTEL = 5809u32,
3607 SubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810u32,
3608 SubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811u32,
3609 SubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812u32,
3610 SubgroupAvcSicGetIpeChromaModeINTEL = 5813u32,
3611 SubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814u32,
3612 SubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815u32,
3613 SubgroupAvcSicGetInterRawSadsINTEL = 5816u32,
3614 VariableLengthArrayINTEL = 5818u32,
3615 SaveMemoryINTEL = 5819u32,
3616 RestoreMemoryINTEL = 5820u32,
3617 ArbitraryFloatSinCosPiINTEL = 5840u32,
3618 ArbitraryFloatCastINTEL = 5841u32,
3619 ArbitraryFloatCastFromIntINTEL = 5842u32,
3620 ArbitraryFloatCastToIntINTEL = 5843u32,
3621 ArbitraryFloatAddINTEL = 5846u32,
3622 ArbitraryFloatSubINTEL = 5847u32,
3623 ArbitraryFloatMulINTEL = 5848u32,
3624 ArbitraryFloatDivINTEL = 5849u32,
3625 ArbitraryFloatGTINTEL = 5850u32,
3626 ArbitraryFloatGEINTEL = 5851u32,
3627 ArbitraryFloatLTINTEL = 5852u32,
3628 ArbitraryFloatLEINTEL = 5853u32,
3629 ArbitraryFloatEQINTEL = 5854u32,
3630 ArbitraryFloatRecipINTEL = 5855u32,
3631 ArbitraryFloatRSqrtINTEL = 5856u32,
3632 ArbitraryFloatCbrtINTEL = 5857u32,
3633 ArbitraryFloatHypotINTEL = 5858u32,
3634 ArbitraryFloatSqrtINTEL = 5859u32,
3635 ArbitraryFloatLogINTEL = 5860u32,
3636 ArbitraryFloatLog2INTEL = 5861u32,
3637 ArbitraryFloatLog10INTEL = 5862u32,
3638 ArbitraryFloatLog1pINTEL = 5863u32,
3639 ArbitraryFloatExpINTEL = 5864u32,
3640 ArbitraryFloatExp2INTEL = 5865u32,
3641 ArbitraryFloatExp10INTEL = 5866u32,
3642 ArbitraryFloatExpm1INTEL = 5867u32,
3643 ArbitraryFloatSinINTEL = 5868u32,
3644 ArbitraryFloatCosINTEL = 5869u32,
3645 ArbitraryFloatSinCosINTEL = 5870u32,
3646 ArbitraryFloatSinPiINTEL = 5871u32,
3647 ArbitraryFloatCosPiINTEL = 5872u32,
3648 ArbitraryFloatASinINTEL = 5873u32,
3649 ArbitraryFloatASinPiINTEL = 5874u32,
3650 ArbitraryFloatACosINTEL = 5875u32,
3651 ArbitraryFloatACosPiINTEL = 5876u32,
3652 ArbitraryFloatATanINTEL = 5877u32,
3653 ArbitraryFloatATanPiINTEL = 5878u32,
3654 ArbitraryFloatATan2INTEL = 5879u32,
3655 ArbitraryFloatPowINTEL = 5880u32,
3656 ArbitraryFloatPowRINTEL = 5881u32,
3657 ArbitraryFloatPowNINTEL = 5882u32,
3658 LoopControlINTEL = 5887u32,
3659 AliasDomainDeclINTEL = 5911u32,
3660 AliasScopeDeclINTEL = 5912u32,
3661 AliasScopeListDeclINTEL = 5913u32,
3662 FixedSqrtINTEL = 5923u32,
3663 FixedRecipINTEL = 5924u32,
3664 FixedRsqrtINTEL = 5925u32,
3665 FixedSinINTEL = 5926u32,
3666 FixedCosINTEL = 5927u32,
3667 FixedSinCosINTEL = 5928u32,
3668 FixedSinPiINTEL = 5929u32,
3669 FixedCosPiINTEL = 5930u32,
3670 FixedSinCosPiINTEL = 5931u32,
3671 FixedLogINTEL = 5932u32,
3672 FixedExpINTEL = 5933u32,
3673 PtrCastToCrossWorkgroupINTEL = 5934u32,
3674 CrossWorkgroupCastToPtrINTEL = 5938u32,
3675 ReadPipeBlockingINTEL = 5946u32,
3676 WritePipeBlockingINTEL = 5947u32,
3677 FPGARegINTEL = 5949u32,
3678 RayQueryGetRayTMinKHR = 6016u32,
3679 RayQueryGetRayFlagsKHR = 6017u32,
3680 RayQueryGetIntersectionTKHR = 6018u32,
3681 RayQueryGetIntersectionInstanceCustomIndexKHR = 6019u32,
3682 RayQueryGetIntersectionInstanceIdKHR = 6020u32,
3683 RayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021u32,
3684 RayQueryGetIntersectionGeometryIndexKHR = 6022u32,
3685 RayQueryGetIntersectionPrimitiveIndexKHR = 6023u32,
3686 RayQueryGetIntersectionBarycentricsKHR = 6024u32,
3687 RayQueryGetIntersectionFrontFaceKHR = 6025u32,
3688 RayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026u32,
3689 RayQueryGetIntersectionObjectRayDirectionKHR = 6027u32,
3690 RayQueryGetIntersectionObjectRayOriginKHR = 6028u32,
3691 RayQueryGetWorldRayDirectionKHR = 6029u32,
3692 RayQueryGetWorldRayOriginKHR = 6030u32,
3693 RayQueryGetIntersectionObjectToWorldKHR = 6031u32,
3694 RayQueryGetIntersectionWorldToObjectKHR = 6032u32,
3695 AtomicFAddEXT = 6035u32,
3696 TypeBufferSurfaceINTEL = 6086u32,
3697 TypeStructContinuedINTEL = 6090u32,
3698 ConstantCompositeContinuedINTEL = 6091u32,
3699 SpecConstantCompositeContinuedINTEL = 6092u32,
3700 ConvertFToBF16INTEL = 6116u32,
3701 ConvertBF16ToFINTEL = 6117u32,
3702 ControlBarrierArriveINTEL = 6142u32,
3703 ControlBarrierWaitINTEL = 6143u32,
3704 GroupIMulKHR = 6401u32,
3705 GroupFMulKHR = 6402u32,
3706 GroupBitwiseAndKHR = 6403u32,
3707 GroupBitwiseOrKHR = 6404u32,
3708 GroupBitwiseXorKHR = 6405u32,
3709 GroupLogicalAndKHR = 6406u32,
3710 GroupLogicalOrKHR = 6407u32,
3711 GroupLogicalXorKHR = 6408u32,
3712}
3713impl Op {
3714 pub fn from_u32(n: u32) -> Option<Self> {
3715 Some(match n {
3716 0u32..=8u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3717 10u32..=12u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3718 14u32..=17u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3719 19u32..=39u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3720 41u32..=46u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3721 48u32..=52u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3722 54u32..=57u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3723 59u32..=75u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3724 77u32..=84u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3725 86u32..=107u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3726 109u32..=124u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3727 126u32..=152u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3728 154u32..=191u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3729 194u32..=205u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3730 207u32..=215u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3731 218u32..=221u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3732 224u32..=225u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3733 227u32..=242u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3734 245u32..=257u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3735 259u32..=271u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3736 274u32..=288u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3737 291u32..=366u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3738 400u32..=403u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3739 4160u32..=4162u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3740 4416u32 => unsafe { core::mem::transmute::<u32, Op>(4416u32) },
3741 4421u32..=4422u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3742 4428u32..=4432u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3743 4445u32..=4460u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3744 4472u32..=4477u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3745 4479u32..=4483u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3746 5000u32..=5007u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3747 5011u32..=5012u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3748 5056u32 => unsafe { core::mem::transmute::<u32, Op>(5056u32) },
3749 5075u32 => unsafe { core::mem::transmute::<u32, Op>(5075u32) },
3750 5078u32 => unsafe { core::mem::transmute::<u32, Op>(5078u32) },
3751 5090u32 => unsafe { core::mem::transmute::<u32, Op>(5090u32) },
3752 5249u32..=5281u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3753 5283u32 => unsafe { core::mem::transmute::<u32, Op>(5283u32) },
3754 5294u32..=5296u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3755 5299u32..=5301u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3756 5334u32..=5341u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3757 5344u32 => unsafe { core::mem::transmute::<u32, Op>(5344u32) },
3758 5358u32..=5362u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3759 5364u32..=5365u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3760 5380u32..=5381u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3761 5391u32..=5397u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3762 5571u32..=5578u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3763 5580u32..=5581u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3764 5585u32..=5598u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3765 5600u32..=5601u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3766 5609u32..=5611u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3767 5614u32..=5615u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3768 5630u32..=5633u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3769 5699u32..=5816u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3770 5818u32..=5820u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3771 5840u32..=5843u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3772 5846u32..=5882u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3773 5887u32 => unsafe { core::mem::transmute::<u32, Op>(5887u32) },
3774 5911u32..=5913u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3775 5923u32..=5934u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3776 5938u32 => unsafe { core::mem::transmute::<u32, Op>(5938u32) },
3777 5946u32..=5947u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3778 5949u32 => unsafe { core::mem::transmute::<u32, Op>(5949u32) },
3779 6016u32..=6032u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3780 6035u32 => unsafe { core::mem::transmute::<u32, Op>(6035u32) },
3781 6086u32 => unsafe { core::mem::transmute::<u32, Op>(6086u32) },
3782 6090u32..=6092u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3783 6116u32..=6117u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3784 6142u32..=6143u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3785 6401u32..=6408u32 => unsafe { core::mem::transmute::<u32, Op>(n) },
3786 _ => return None,
3787 })
3788 }
3789}
3790#[allow(clippy::upper_case_acronyms)]
3791#[allow(non_upper_case_globals)]
3792impl Op {
3793 pub const SDotKHR: Op = Op::SDot;
3794 pub const UDotKHR: Op = Op::UDot;
3795 pub const SUDotKHR: Op = Op::SUDot;
3796 pub const SDotAccSatKHR: Op = Op::SDotAccSat;
3797 pub const UDotAccSatKHR: Op = Op::UDotAccSat;
3798 pub const SUDotAccSatKHR: Op = Op::SUDotAccSat;
3799 pub const ReportIntersectionNV: Op = Op::ReportIntersectionKHR;
3800 pub const TypeAccelerationStructureNV: Op = Op::TypeAccelerationStructureKHR;
3801 pub const DemoteToHelperInvocationEXT: Op = Op::DemoteToHelperInvocation;
3802 pub const DecorateStringGOOGLE: Op = Op::DecorateString;
3803 pub const MemberDecorateStringGOOGLE: Op = Op::MemberDecorateString;
3804}
3805#[doc = "[GLSL.std.450](https://www.khronos.org/registry/spir-v/specs/unified1/GLSL.std.450.html) extended instruction opcode"]
3806#[repr(u32)]
3807#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
3808#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3809#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
3810#[allow(clippy::upper_case_acronyms)]
3811pub enum GLOp {
3812 Round = 1u32,
3813 RoundEven = 2u32,
3814 Trunc = 3u32,
3815 FAbs = 4u32,
3816 SAbs = 5u32,
3817 FSign = 6u32,
3818 SSign = 7u32,
3819 Floor = 8u32,
3820 Ceil = 9u32,
3821 Fract = 10u32,
3822 Radians = 11u32,
3823 Degrees = 12u32,
3824 Sin = 13u32,
3825 Cos = 14u32,
3826 Tan = 15u32,
3827 Asin = 16u32,
3828 Acos = 17u32,
3829 Atan = 18u32,
3830 Sinh = 19u32,
3831 Cosh = 20u32,
3832 Tanh = 21u32,
3833 Asinh = 22u32,
3834 Acosh = 23u32,
3835 Atanh = 24u32,
3836 Atan2 = 25u32,
3837 Pow = 26u32,
3838 Exp = 27u32,
3839 Log = 28u32,
3840 Exp2 = 29u32,
3841 Log2 = 30u32,
3842 Sqrt = 31u32,
3843 InverseSqrt = 32u32,
3844 Determinant = 33u32,
3845 MatrixInverse = 34u32,
3846 Modf = 35u32,
3847 ModfStruct = 36u32,
3848 FMin = 37u32,
3849 UMin = 38u32,
3850 SMin = 39u32,
3851 FMax = 40u32,
3852 UMax = 41u32,
3853 SMax = 42u32,
3854 FClamp = 43u32,
3855 UClamp = 44u32,
3856 SClamp = 45u32,
3857 FMix = 46u32,
3858 IMix = 47u32,
3859 Step = 48u32,
3860 SmoothStep = 49u32,
3861 Fma = 50u32,
3862 Frexp = 51u32,
3863 FrexpStruct = 52u32,
3864 Ldexp = 53u32,
3865 PackSnorm4x8 = 54u32,
3866 PackUnorm4x8 = 55u32,
3867 PackSnorm2x16 = 56u32,
3868 PackUnorm2x16 = 57u32,
3869 PackHalf2x16 = 58u32,
3870 PackDouble2x32 = 59u32,
3871 UnpackSnorm2x16 = 60u32,
3872 UnpackUnorm2x16 = 61u32,
3873 UnpackHalf2x16 = 62u32,
3874 UnpackSnorm4x8 = 63u32,
3875 UnpackUnorm4x8 = 64u32,
3876 UnpackDouble2x32 = 65u32,
3877 Length = 66u32,
3878 Distance = 67u32,
3879 Cross = 68u32,
3880 Normalize = 69u32,
3881 FaceForward = 70u32,
3882 Reflect = 71u32,
3883 Refract = 72u32,
3884 FindILsb = 73u32,
3885 FindSMsb = 74u32,
3886 FindUMsb = 75u32,
3887 InterpolateAtCentroid = 76u32,
3888 InterpolateAtSample = 77u32,
3889 InterpolateAtOffset = 78u32,
3890 NMin = 79u32,
3891 NMax = 80u32,
3892 NClamp = 81u32,
3893}
3894impl GLOp {
3895 pub fn from_u32(n: u32) -> Option<Self> {
3896 Some(match n {
3897 1u32..=81u32 => unsafe { core::mem::transmute::<u32, GLOp>(n) },
3898 _ => return None,
3899 })
3900 }
3901}
3902#[doc = "[OpenCL.std](https://www.khronos.org/registry/spir-v/specs/unified1/OpenCL.ExtendedInstructionSet.100.html) extended instruction opcode"]
3903#[repr(u32)]
3904#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
3905#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3906#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
3907#[allow(clippy::upper_case_acronyms)]
3908pub enum CLOp {
3909 acos = 0u32,
3910 acosh = 1u32,
3911 acospi = 2u32,
3912 asin = 3u32,
3913 asinh = 4u32,
3914 asinpi = 5u32,
3915 atan = 6u32,
3916 atan2 = 7u32,
3917 atanh = 8u32,
3918 atanpi = 9u32,
3919 atan2pi = 10u32,
3920 cbrt = 11u32,
3921 ceil = 12u32,
3922 copysign = 13u32,
3923 cos = 14u32,
3924 cosh = 15u32,
3925 cospi = 16u32,
3926 erfc = 17u32,
3927 erf = 18u32,
3928 exp = 19u32,
3929 exp2 = 20u32,
3930 exp10 = 21u32,
3931 expm1 = 22u32,
3932 fabs = 23u32,
3933 fdim = 24u32,
3934 floor = 25u32,
3935 fma = 26u32,
3936 fmax = 27u32,
3937 fmin = 28u32,
3938 fmod = 29u32,
3939 fract = 30u32,
3940 frexp = 31u32,
3941 hypot = 32u32,
3942 ilogb = 33u32,
3943 ldexp = 34u32,
3944 lgamma = 35u32,
3945 lgamma_r = 36u32,
3946 log = 37u32,
3947 log2 = 38u32,
3948 log10 = 39u32,
3949 log1p = 40u32,
3950 logb = 41u32,
3951 mad = 42u32,
3952 maxmag = 43u32,
3953 minmag = 44u32,
3954 modf = 45u32,
3955 nan = 46u32,
3956 nextafter = 47u32,
3957 pow = 48u32,
3958 pown = 49u32,
3959 powr = 50u32,
3960 remainder = 51u32,
3961 remquo = 52u32,
3962 rint = 53u32,
3963 rootn = 54u32,
3964 round = 55u32,
3965 rsqrt = 56u32,
3966 sin = 57u32,
3967 sincos = 58u32,
3968 sinh = 59u32,
3969 sinpi = 60u32,
3970 sqrt = 61u32,
3971 tan = 62u32,
3972 tanh = 63u32,
3973 tanpi = 64u32,
3974 tgamma = 65u32,
3975 trunc = 66u32,
3976 half_cos = 67u32,
3977 half_divide = 68u32,
3978 half_exp = 69u32,
3979 half_exp2 = 70u32,
3980 half_exp10 = 71u32,
3981 half_log = 72u32,
3982 half_log2 = 73u32,
3983 half_log10 = 74u32,
3984 half_powr = 75u32,
3985 half_recip = 76u32,
3986 half_rsqrt = 77u32,
3987 half_sin = 78u32,
3988 half_sqrt = 79u32,
3989 half_tan = 80u32,
3990 native_cos = 81u32,
3991 native_divide = 82u32,
3992 native_exp = 83u32,
3993 native_exp2 = 84u32,
3994 native_exp10 = 85u32,
3995 native_log = 86u32,
3996 native_log2 = 87u32,
3997 native_log10 = 88u32,
3998 native_powr = 89u32,
3999 native_recip = 90u32,
4000 native_rsqrt = 91u32,
4001 native_sin = 92u32,
4002 native_sqrt = 93u32,
4003 native_tan = 94u32,
4004 fclamp = 95u32,
4005 degrees = 96u32,
4006 fmax_common = 97u32,
4007 fmin_common = 98u32,
4008 mix = 99u32,
4009 radians = 100u32,
4010 step = 101u32,
4011 smoothstep = 102u32,
4012 sign = 103u32,
4013 cross = 104u32,
4014 distance = 105u32,
4015 length = 106u32,
4016 normalize = 107u32,
4017 fast_distance = 108u32,
4018 fast_length = 109u32,
4019 fast_normalize = 110u32,
4020 s_abs = 141u32,
4021 s_abs_diff = 142u32,
4022 s_add_sat = 143u32,
4023 u_add_sat = 144u32,
4024 s_hadd = 145u32,
4025 u_hadd = 146u32,
4026 s_rhadd = 147u32,
4027 u_rhadd = 148u32,
4028 s_clamp = 149u32,
4029 u_clamp = 150u32,
4030 clz = 151u32,
4031 ctz = 152u32,
4032 s_mad_hi = 153u32,
4033 u_mad_sat = 154u32,
4034 s_mad_sat = 155u32,
4035 s_max = 156u32,
4036 u_max = 157u32,
4037 s_min = 158u32,
4038 u_min = 159u32,
4039 s_mul_hi = 160u32,
4040 rotate = 161u32,
4041 s_sub_sat = 162u32,
4042 u_sub_sat = 163u32,
4043 u_upsample = 164u32,
4044 s_upsample = 165u32,
4045 popcount = 166u32,
4046 s_mad24 = 167u32,
4047 u_mad24 = 168u32,
4048 s_mul24 = 169u32,
4049 u_mul24 = 170u32,
4050 vloadn = 171u32,
4051 vstoren = 172u32,
4052 vload_half = 173u32,
4053 vload_halfn = 174u32,
4054 vstore_half = 175u32,
4055 vstore_half_r = 176u32,
4056 vstore_halfn = 177u32,
4057 vstore_halfn_r = 178u32,
4058 vloada_halfn = 179u32,
4059 vstorea_halfn = 180u32,
4060 vstorea_halfn_r = 181u32,
4061 shuffle = 182u32,
4062 shuffle2 = 183u32,
4063 printf = 184u32,
4064 prefetch = 185u32,
4065 bitselect = 186u32,
4066 select = 187u32,
4067 u_abs = 201u32,
4068 u_abs_diff = 202u32,
4069 u_mul_hi = 203u32,
4070 u_mad_hi = 204u32,
4071}
4072impl CLOp {
4073 pub fn from_u32(n: u32) -> Option<Self> {
4074 Some(match n {
4075 0u32..=110u32 => unsafe { core::mem::transmute::<u32, CLOp>(n) },
4076 141u32..=187u32 => unsafe { core::mem::transmute::<u32, CLOp>(n) },
4077 201u32..=204u32 => unsafe { core::mem::transmute::<u32, CLOp>(n) },
4078 _ => return None,
4079 })
4080 }
4081}