1#[repr(C)]
4#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
5pub struct __BindgenBitfieldUnit<Storage> {
6 storage: Storage,
7}
8impl<Storage> __BindgenBitfieldUnit<Storage> {
9 #[inline]
10 pub const fn new(storage: Storage) -> Self {
11 Self { storage }
12 }
13}
14impl<Storage> __BindgenBitfieldUnit<Storage>
15where
16 Storage: AsRef<[u8]> + AsMut<[u8]>,
17{
18 #[inline]
19 fn extract_bit(byte: u8, index: usize) -> bool {
20 let bit_index = if cfg!(target_endian = "big") {
21 7 - (index % 8)
22 } else {
23 index % 8
24 };
25 let mask = 1 << bit_index;
26 byte & mask == mask
27 }
28 #[inline]
29 pub fn get_bit(&self, index: usize) -> bool {
30 debug_assert!(index / 8 < self.storage.as_ref().len());
31 let byte_index = index / 8;
32 let byte = self.storage.as_ref()[byte_index];
33 Self::extract_bit(byte, index)
34 }
35 #[inline]
36 pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
37 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
38 let byte_index = index / 8;
39 let byte = *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize);
40 Self::extract_bit(byte, index)
41 }
42 #[inline]
43 fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
44 let bit_index = if cfg!(target_endian = "big") {
45 7 - (index % 8)
46 } else {
47 index % 8
48 };
49 let mask = 1 << bit_index;
50 if val {
51 byte | mask
52 } else {
53 byte & !mask
54 }
55 }
56 #[inline]
57 pub fn set_bit(&mut self, index: usize, val: bool) {
58 debug_assert!(index / 8 < self.storage.as_ref().len());
59 let byte_index = index / 8;
60 let byte = &mut self.storage.as_mut()[byte_index];
61 *byte = Self::change_bit(*byte, index, val);
62 }
63 #[inline]
64 pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
65 debug_assert!(index / 8 < core::mem::size_of::<Storage>());
66 let byte_index = index / 8;
67 let byte =
68 (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize);
69 *byte = Self::change_bit(*byte, index, val);
70 }
71 #[inline]
72 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
73 debug_assert!(bit_width <= 64);
74 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
75 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
76 let mut val = 0;
77 for i in 0..(bit_width as usize) {
78 if self.get_bit(i + bit_offset) {
79 let index = if cfg!(target_endian = "big") {
80 bit_width as usize - 1 - i
81 } else {
82 i
83 };
84 val |= 1 << index;
85 }
86 }
87 val
88 }
89 #[inline]
90 pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
91 debug_assert!(bit_width <= 64);
92 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
93 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
94 let mut val = 0;
95 for i in 0..(bit_width as usize) {
96 if Self::raw_get_bit(this, i + bit_offset) {
97 let index = if cfg!(target_endian = "big") {
98 bit_width as usize - 1 - i
99 } else {
100 i
101 };
102 val |= 1 << index;
103 }
104 }
105 val
106 }
107 #[inline]
108 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
109 debug_assert!(bit_width <= 64);
110 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
111 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
112 for i in 0..(bit_width as usize) {
113 let mask = 1 << i;
114 let val_bit_is_set = val & mask == mask;
115 let index = if cfg!(target_endian = "big") {
116 bit_width as usize - 1 - i
117 } else {
118 i
119 };
120 self.set_bit(index + bit_offset, val_bit_is_set);
121 }
122 }
123 #[inline]
124 pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
125 debug_assert!(bit_width <= 64);
126 debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
127 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
128 for i in 0..(bit_width as usize) {
129 let mask = 1 << i;
130 let val_bit_is_set = val & mask == mask;
131 let index = if cfg!(target_endian = "big") {
132 bit_width as usize - 1 - i
133 } else {
134 i
135 };
136 Self::raw_set_bit(this, index + bit_offset, val_bit_is_set);
137 }
138 }
139}
140pub type uint = ::std::os::raw::c_uint;
141#[repr(C)]
142#[derive(Debug, Default, Copy, Clone)]
143pub struct MTLDispatchThreadgroupsIndirectArguments {
144 pub threadgroupsPerGrid: [u32; 3usize],
145}
146pub type resourceid_t = MTLResourceID;
147#[repr(C)]
148#[derive(Debug, Default, Copy, Clone)]
149pub struct IRDescriptorTableEntry {
150 pub gpuVA: u64,
151 pub textureViewID: u64,
152 pub metadata: u64,
153}
154pub const kIRRuntimeTessellatorTablesBindPoint: u64 = 7;
155pub const kIRRuntimeTessellatorTablesCountsAndOffsetLength: u32 = 32768;
156pub const kIRRuntimeTessellatorTablesLookupTableLength: u32 = 701114;
157#[repr(C)]
158#[derive(Debug, Default, Copy, Clone)]
159pub struct IRShaderIdentifier {
160 pub intersectionShaderHandle: u64,
161 pub shaderHandle: u64,
162 pub localRootSignatureSamplersBuffer: u64,
163 pub pad0: u64,
164}
165#[repr(C)]
166#[derive(Debug, Default, Copy, Clone)]
167pub struct IRVirtualAddressRange {
168 pub StartAddress: u64,
169 pub SizeInBytes: u64,
170}
171#[repr(C)]
172#[derive(Debug, Default, Copy, Clone)]
173pub struct IRVirtualAddressRangeAndStride {
174 pub StartAddress: u64,
175 pub SizeInBytes: u64,
176 pub StrideInBytes: u64,
177}
178#[repr(C)]
179#[derive(Debug, Default, Copy, Clone)]
180pub struct IRDispatchRaysDescriptor {
181 pub RayGenerationShaderRecord: IRVirtualAddressRange,
182 pub MissShaderTable: IRVirtualAddressRangeAndStride,
183 pub HitGroupTable: IRVirtualAddressRangeAndStride,
184 pub CallableShaderTable: IRVirtualAddressRangeAndStride,
185 pub Width: uint,
186 pub Height: uint,
187 pub Depth: uint,
188}
189#[repr(C)]
190pub struct IRDispatchRaysArgument {
191 pub DispatchRaysDesc: IRDispatchRaysDescriptor,
192 pub GRS: u64,
193 pub ResDescHeap: u64,
194 pub SmpDescHeap: u64,
195 pub VisibleFunctionTable: resourceid_t,
196 pub IntersectionFunctionTable: resourceid_t,
197 pub IntersectionFunctionTables: u64,
198}
199impl Default for IRDispatchRaysArgument {
200 fn default() -> Self {
201 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
202 unsafe {
203 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
204 s.assume_init()
205 }
206 }
207}
208pub type dispatchthreadgroupsindirectargs_t = MTLDispatchThreadgroupsIndirectArguments;
209#[repr(C)]
210#[derive(Debug, Default, Copy, Clone)]
211pub struct IRRaytracingAccelerationStructureGPUHeader {
212 pub accelerationStructureID: u64,
213 pub addressOfInstanceContributions: u64,
214 pub pad0: [u64; 4usize],
215 pub pad1: dispatchthreadgroupsindirectargs_t,
216}
217#[repr(C)]
218#[derive(Debug, Default, Copy, Clone)]
219pub struct IRRaytracingInstanceDescriptor {
220 pub Transform: [[f32; 4usize]; 3usize],
221 pub _bitfield_align_1: [u32; 0],
222 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 8usize]>,
223 pub AccelerationStructure: u64,
224}
225impl IRRaytracingInstanceDescriptor {
226 #[inline]
227 pub fn InstanceID(&self) -> u32 {
228 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 24u8) as u32) }
229 }
230 #[inline]
231 pub fn set_InstanceID(&mut self, val: u32) {
232 unsafe {
233 let val: u32 = ::std::mem::transmute(val);
234 self._bitfield_1.set(0usize, 24u8, val as u64)
235 }
236 }
237 #[inline]
238 pub unsafe fn InstanceID_raw(this: *const Self) -> u32 {
239 unsafe {
240 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
241 ::std::ptr::addr_of!((*this)._bitfield_1),
242 0usize,
243 24u8,
244 ) as u32)
245 }
246 }
247 #[inline]
248 pub unsafe fn set_InstanceID_raw(this: *mut Self, val: u32) {
249 unsafe {
250 let val: u32 = ::std::mem::transmute(val);
251 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
252 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
253 0usize,
254 24u8,
255 val as u64,
256 )
257 }
258 }
259 #[inline]
260 pub fn InstanceMask(&self) -> u32 {
261 unsafe { ::std::mem::transmute(self._bitfield_1.get(24usize, 8u8) as u32) }
262 }
263 #[inline]
264 pub fn set_InstanceMask(&mut self, val: u32) {
265 unsafe {
266 let val: u32 = ::std::mem::transmute(val);
267 self._bitfield_1.set(24usize, 8u8, val as u64)
268 }
269 }
270 #[inline]
271 pub unsafe fn InstanceMask_raw(this: *const Self) -> u32 {
272 unsafe {
273 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
274 ::std::ptr::addr_of!((*this)._bitfield_1),
275 24usize,
276 8u8,
277 ) as u32)
278 }
279 }
280 #[inline]
281 pub unsafe fn set_InstanceMask_raw(this: *mut Self, val: u32) {
282 unsafe {
283 let val: u32 = ::std::mem::transmute(val);
284 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
285 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
286 24usize,
287 8u8,
288 val as u64,
289 )
290 }
291 }
292 #[inline]
293 pub fn InstanceContributionToHitGroupIndex(&self) -> u32 {
294 unsafe { ::std::mem::transmute(self._bitfield_1.get(32usize, 24u8) as u32) }
295 }
296 #[inline]
297 pub fn set_InstanceContributionToHitGroupIndex(&mut self, val: u32) {
298 unsafe {
299 let val: u32 = ::std::mem::transmute(val);
300 self._bitfield_1.set(32usize, 24u8, val as u64)
301 }
302 }
303 #[inline]
304 pub unsafe fn InstanceContributionToHitGroupIndex_raw(this: *const Self) -> u32 {
305 unsafe {
306 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
307 ::std::ptr::addr_of!((*this)._bitfield_1),
308 32usize,
309 24u8,
310 ) as u32)
311 }
312 }
313 #[inline]
314 pub unsafe fn set_InstanceContributionToHitGroupIndex_raw(this: *mut Self, val: u32) {
315 unsafe {
316 let val: u32 = ::std::mem::transmute(val);
317 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
318 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
319 32usize,
320 24u8,
321 val as u64,
322 )
323 }
324 }
325 #[inline]
326 pub fn Flags(&self) -> u32 {
327 unsafe { ::std::mem::transmute(self._bitfield_1.get(56usize, 8u8) as u32) }
328 }
329 #[inline]
330 pub fn set_Flags(&mut self, val: u32) {
331 unsafe {
332 let val: u32 = ::std::mem::transmute(val);
333 self._bitfield_1.set(56usize, 8u8, val as u64)
334 }
335 }
336 #[inline]
337 pub unsafe fn Flags_raw(this: *const Self) -> u32 {
338 unsafe {
339 ::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 8usize]>>::raw_get(
340 ::std::ptr::addr_of!((*this)._bitfield_1),
341 56usize,
342 8u8,
343 ) as u32)
344 }
345 }
346 #[inline]
347 pub unsafe fn set_Flags_raw(this: *mut Self, val: u32) {
348 unsafe {
349 let val: u32 = ::std::mem::transmute(val);
350 <__BindgenBitfieldUnit<[u8; 8usize]>>::raw_set(
351 ::std::ptr::addr_of_mut!((*this)._bitfield_1),
352 56usize,
353 8u8,
354 val as u64,
355 )
356 }
357 }
358 #[inline]
359 pub fn new_bitfield_1(
360 InstanceID: u32,
361 InstanceMask: u32,
362 InstanceContributionToHitGroupIndex: u32,
363 Flags: u32,
364 ) -> __BindgenBitfieldUnit<[u8; 8usize]> {
365 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 8usize]> = Default::default();
366 __bindgen_bitfield_unit.set(0usize, 24u8, {
367 let InstanceID: u32 = unsafe { ::std::mem::transmute(InstanceID) };
368 InstanceID as u64
369 });
370 __bindgen_bitfield_unit.set(24usize, 8u8, {
371 let InstanceMask: u32 = unsafe { ::std::mem::transmute(InstanceMask) };
372 InstanceMask as u64
373 });
374 __bindgen_bitfield_unit.set(32usize, 24u8, {
375 let InstanceContributionToHitGroupIndex: u32 =
376 unsafe { ::std::mem::transmute(InstanceContributionToHitGroupIndex) };
377 InstanceContributionToHitGroupIndex as u64
378 });
379 __bindgen_bitfield_unit.set(56usize, 8u8, {
380 let Flags: u32 = unsafe { ::std::mem::transmute(Flags) };
381 Flags as u64
382 });
383 __bindgen_bitfield_unit
384 }
385}
386pub const kIRRayDispatchIndirectionKernelName: &[u8; 18] = b"RaygenIndirection\0";
387pub const kIRRayDispatchArgumentsBindPoint: u64 = 3;
388#[repr(u32)]
389#[non_exhaustive]
390#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
391pub enum IRRuntimeResourceType {
392 SRV = 0,
393 UAV = 1,
394 CBV = 2,
395 SMP = 3,
396 Count = 4,
397}
398impl IRRuntimePrimitiveType {
399 pub const _1ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
400}
401impl IRRuntimePrimitiveType {
402 pub const _2ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
403}
404impl IRRuntimePrimitiveType {
405 pub const _3ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
406}
407impl IRRuntimePrimitiveType {
408 pub const _4ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
409}
410impl IRRuntimePrimitiveType {
411 pub const _5ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
412}
413impl IRRuntimePrimitiveType {
414 pub const _6ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
415}
416impl IRRuntimePrimitiveType {
417 pub const _7ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
418}
419impl IRRuntimePrimitiveType {
420 pub const _8ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
421}
422impl IRRuntimePrimitiveType {
423 pub const _9ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
424}
425impl IRRuntimePrimitiveType {
426 pub const _10ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
427}
428impl IRRuntimePrimitiveType {
429 pub const _11ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
430}
431impl IRRuntimePrimitiveType {
432 pub const _12ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
433}
434impl IRRuntimePrimitiveType {
435 pub const _13ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
436}
437impl IRRuntimePrimitiveType {
438 pub const _14ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
439}
440impl IRRuntimePrimitiveType {
441 pub const _15ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
442}
443impl IRRuntimePrimitiveType {
444 pub const _16ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
445}
446impl IRRuntimePrimitiveType {
447 pub const _17ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
448}
449impl IRRuntimePrimitiveType {
450 pub const _18ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
451}
452impl IRRuntimePrimitiveType {
453 pub const _19ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
454}
455impl IRRuntimePrimitiveType {
456 pub const _20ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
457}
458impl IRRuntimePrimitiveType {
459 pub const _21ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
460}
461impl IRRuntimePrimitiveType {
462 pub const _22ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
463}
464impl IRRuntimePrimitiveType {
465 pub const _23ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
466}
467impl IRRuntimePrimitiveType {
468 pub const _24ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
469}
470impl IRRuntimePrimitiveType {
471 pub const _25ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
472}
473impl IRRuntimePrimitiveType {
474 pub const _26ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
475}
476impl IRRuntimePrimitiveType {
477 pub const _27ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
478}
479impl IRRuntimePrimitiveType {
480 pub const _28ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
481}
482impl IRRuntimePrimitiveType {
483 pub const _29ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
484}
485impl IRRuntimePrimitiveType {
486 pub const _30ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
487}
488impl IRRuntimePrimitiveType {
489 pub const _31ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
490}
491impl IRRuntimePrimitiveType {
492 pub const _32ControlPointPatchlist: IRRuntimePrimitiveType = IRRuntimePrimitiveType::Triangle;
493}
494#[repr(u32)]
495#[non_exhaustive]
496#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
497pub enum IRRuntimePrimitiveType {
498 Point = 0,
499 Line = 1,
500 LineStrip = 2,
501 Triangle = 3,
502 TriangleStrip = 4,
503 LineWithAdj = 5,
504 TriangleWithAdj = 6,
505}
506#[repr(C)]
507#[derive(Debug, Default, Copy, Clone)]
508pub struct IRRuntimeGeometryPipelineConfig {
509 pub gsVertexSizeInBytes: u32,
510 pub gsMaxInputPrimitivesPerMeshThreadgroup: u32,
511}
512#[repr(u32)]
513#[non_exhaustive]
514#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
515pub enum IRRuntimeTessellatorOutputPrimitive {
516 Undefined = 0,
517 Point = 1,
518 Line = 2,
519 TriangleCW = 3,
520 TriangleCCW = 4,
521}
522#[repr(C)]
523#[derive(Debug, Copy, Clone)]
524pub struct IRRuntimeTessellationPipelineConfig {
525 pub outputPrimitiveType: IRRuntimeTessellatorOutputPrimitive,
526 pub vsOutputSizeInBytes: u32,
527 pub gsMaxInputPrimitivesPerMeshThreadgroup: u32,
528 pub hsMaxPatchesPerObjectThreadgroup: u32,
529 pub hsInputControlPointCount: u32,
530 pub hsMaxObjectThreadsPerThreadgroup: u32,
531 pub hsMaxTessellationFactor: f32,
532 pub gsInstanceCount: u32,
533}
534impl Default for IRRuntimeTessellationPipelineConfig {
535 fn default() -> Self {
536 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
537 unsafe {
538 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
539 s.assume_init()
540 }
541 }
542}
543#[repr(C)]
544#[derive(Debug, Default, Copy, Clone)]
545pub struct IRRuntimeVertexBuffer {
546 pub addr: u64,
547 pub length: u32,
548 pub stride: u32,
549}
550pub type IRRuntimeVertexBuffers = [IRRuntimeVertexBuffer; 31usize];
551#[repr(C)]
552#[derive(Debug, Default, Copy, Clone)]
553pub struct IRRuntimeDrawArgument {
554 pub vertexCountPerInstance: uint,
555 pub instanceCount: uint,
556 pub startVertexLocation: uint,
557 pub startInstanceLocation: uint,
558}
559#[repr(C)]
560#[derive(Debug, Default, Copy, Clone)]
561pub struct IRRuntimeDrawIndexedArgument {
562 pub indexCountPerInstance: uint,
563 pub instanceCount: uint,
564 pub startIndexLocation: uint,
565 pub baseVertexLocation: ::std::os::raw::c_int,
566 pub startInstanceLocation: uint,
567}
568#[repr(C)]
569#[derive(Copy, Clone)]
570pub struct IRRuntimeDrawParams {
571 pub u_1: IRRuntimeDrawParams_u,
572}
573#[repr(C)]
574#[derive(Copy, Clone)]
575pub union IRRuntimeDrawParams_u {
576 pub draw: IRRuntimeDrawArgument,
577 pub drawIndexed: IRRuntimeDrawIndexedArgument,
578}
579impl Default for IRRuntimeDrawParams_u {
580 fn default() -> Self {
581 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
582 unsafe {
583 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
584 s.assume_init()
585 }
586 }
587}
588impl Default for IRRuntimeDrawParams {
589 fn default() -> Self {
590 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
591 unsafe {
592 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
593 s.assume_init()
594 }
595 }
596}
597#[repr(C)]
598#[derive(Debug, Default, Copy, Clone)]
599pub struct IRRuntimeDrawInfo {
600 pub indexType: u16,
601 pub primitiveTopology: u8,
602 pub threadsPerPatch: u8,
603 pub maxInputPrimitivesPerMeshThreadgroup: u16,
604 pub objectThreadgroupVertexStride: u16,
605 pub meshThreadgroupPrimitiveStride: u16,
606 pub gsInstanceCount: u16,
607 pub patchesPerObjectThreadgroup: u16,
608 pub inputControlPointsPerPatch: u16,
609 pub indexBuffer: u64,
610}
611pub const kIRArgumentBufferBindPoint: u64 = 2;
612pub const kIRArgumentBufferHullDomainBindPoint: u64 = 3;
613pub const kIRDescriptorHeapBindPoint: u64 = 0;
614pub const kIRSamplerHeapBindPoint: u64 = 1;
615pub const kIRArgumentBufferDrawArgumentsBindPoint: u64 = 4;
616pub const kIRArgumentBufferUniformsBindPoint: u64 = 5;
617pub const kIRVertexBufferBindPoint: u64 = 6;
618pub const kIRStageInAttributeStartIndex: u64 = 11;
619pub const kIRIndirectTriangleIntersectionFunctionName: &[u8; 51] =
620 b"irconverter.wrapper.intersection.function.triangle\0";
621pub const kIRIndirectProceduralIntersectionFunctionName: &[u8; 53] =
622 b"irconverter.wrapper.intersection.function.procedural\0";
623pub const kIRTrianglePassthroughGeometryShader: &[u8; 47] =
624 b"irconverter_domain_shader_triangle_passthrough\0";
625pub const kIRLinePassthroughGeometryShader: &[u8; 43] =
626 b"irconverter_domain_shader_line_passthrough\0";
627pub const kIRPointPassthroughGeometryShader: &[u8; 44] =
628 b"irconverter_domain_shader_point_passthrough\0";
629pub const kIRNonIndexedDraw: u16 = 0;
630pub const kIRFunctionGroupRayGeneration: &[u8; 7] = b"rayGen\0";
631pub const kIRFunctionGroupClosestHit: &[u8; 11] = b"closestHit\0";
632pub const kIRFunctionGroupMiss: &[u8; 5] = b"miss\0";
633pub const kIRBufSizeOffset: u64 = 0;
634pub const kIRBufSizeMask: u64 = 4294967295;
635pub const kIRTexViewOffset: u64 = 32;
636pub const kIRTexViewMask: u64 = 255;
637pub const kIRTypedBufferOffset: u64 = 63;