1pub const RTC_VERSION_MAJOR: u32 = 3;
4pub const RTC_VERSION_MINOR: u32 = 12;
5pub const RTC_VERSION_PATCH: u32 = 1;
6pub const RTC_VERSION: u32 = 31201;
7pub const RTC_VERSION_STRING: &'static [u8; 7usize] = b"3.12.1\0";
8pub const RTC_MAX_INSTANCE_LEVEL_COUNT: u32 = 1;
9pub const RTC_MIN_WIDTH: u32 = 0;
10pub const RTC_MAX_TIME_STEP_COUNT: u32 = 129;
11pub type size_t = usize;
12pub type __ssize_t = isize;
13pub type ssize_t = __ssize_t;
14#[repr(u32)]
15#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
16pub enum RTCFormat {
17 UNDEFINED = 0,
18 UCHAR = 4097,
19 UCHAR2 = 4098,
20 UCHAR3 = 4099,
21 UCHAR4 = 4100,
22 CHAR = 8193,
23 CHAR2 = 8194,
24 CHAR3 = 8195,
25 CHAR4 = 8196,
26 USHORT = 12289,
27 USHORT2 = 12290,
28 USHORT3 = 12291,
29 USHORT4 = 12292,
30 SHORT = 16385,
31 SHORT2 = 16386,
32 SHORT3 = 16387,
33 SHORT4 = 16388,
34 UINT = 20481,
35 UINT2 = 20482,
36 UINT3 = 20483,
37 UINT4 = 20484,
38 INT = 24577,
39 INT2 = 24578,
40 INT3 = 24579,
41 INT4 = 24580,
42 ULLONG = 28673,
43 ULLONG2 = 28674,
44 ULLONG3 = 28675,
45 ULLONG4 = 28676,
46 LLONG = 32769,
47 LLONG2 = 32770,
48 LLONG3 = 32771,
49 LLONG4 = 32772,
50 FLOAT = 36865,
51 FLOAT2 = 36866,
52 FLOAT3 = 36867,
53 FLOAT4 = 36868,
54 FLOAT5 = 36869,
55 FLOAT6 = 36870,
56 FLOAT7 = 36871,
57 FLOAT8 = 36872,
58 FLOAT9 = 36873,
59 FLOAT10 = 36874,
60 FLOAT11 = 36875,
61 FLOAT12 = 36876,
62 FLOAT13 = 36877,
63 FLOAT14 = 36878,
64 FLOAT15 = 36879,
65 FLOAT16 = 36880,
66 FLOAT2X2_ROW_MAJOR = 37154,
67 FLOAT2X3_ROW_MAJOR = 37155,
68 FLOAT2X4_ROW_MAJOR = 37156,
69 FLOAT3X2_ROW_MAJOR = 37170,
70 FLOAT3X3_ROW_MAJOR = 37171,
71 FLOAT3X4_ROW_MAJOR = 37172,
72 FLOAT4X2_ROW_MAJOR = 37186,
73 FLOAT4X3_ROW_MAJOR = 37187,
74 FLOAT4X4_ROW_MAJOR = 37188,
75 FLOAT2X2_COLUMN_MAJOR = 37410,
76 FLOAT2X3_COLUMN_MAJOR = 37411,
77 FLOAT2X4_COLUMN_MAJOR = 37412,
78 FLOAT3X2_COLUMN_MAJOR = 37426,
79 FLOAT3X3_COLUMN_MAJOR = 37427,
80 FLOAT3X4_COLUMN_MAJOR = 37428,
81 FLOAT4X2_COLUMN_MAJOR = 37442,
82 FLOAT4X3_COLUMN_MAJOR = 37443,
83 FLOAT4X4_COLUMN_MAJOR = 37444,
84 GRID = 40961,
85}
86#[repr(u32)]
87#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
88pub enum RTCBuildQuality {
89 LOW = 0,
90 MEDIUM = 1,
91 HIGH = 2,
92 REFIT = 3,
93}
94#[repr(C)]
95#[repr(align(16))]
96#[derive(Debug, Copy, Clone)]
97pub struct RTCBounds {
98 pub lower_x: f32,
99 pub lower_y: f32,
100 pub lower_z: f32,
101 pub align0: f32,
102 pub upper_x: f32,
103 pub upper_y: f32,
104 pub upper_z: f32,
105 pub align1: f32,
106}
107#[test]
108fn bindgen_test_layout_RTCBounds() {
109 assert_eq!(
110 ::std::mem::size_of::<RTCBounds>(),
111 32usize,
112 concat!("Size of: ", stringify!(RTCBounds))
113 );
114 assert_eq!(
115 ::std::mem::align_of::<RTCBounds>(),
116 16usize,
117 concat!("Alignment of ", stringify!(RTCBounds))
118 );
119 assert_eq!(
120 unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_x as *const _ as usize },
121 0usize,
122 concat!(
123 "Offset of field: ",
124 stringify!(RTCBounds),
125 "::",
126 stringify!(lower_x)
127 )
128 );
129 assert_eq!(
130 unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_y as *const _ as usize },
131 4usize,
132 concat!(
133 "Offset of field: ",
134 stringify!(RTCBounds),
135 "::",
136 stringify!(lower_y)
137 )
138 );
139 assert_eq!(
140 unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_z as *const _ as usize },
141 8usize,
142 concat!(
143 "Offset of field: ",
144 stringify!(RTCBounds),
145 "::",
146 stringify!(lower_z)
147 )
148 );
149 assert_eq!(
150 unsafe { &(*(::std::ptr::null::<RTCBounds>())).align0 as *const _ as usize },
151 12usize,
152 concat!(
153 "Offset of field: ",
154 stringify!(RTCBounds),
155 "::",
156 stringify!(align0)
157 )
158 );
159 assert_eq!(
160 unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_x as *const _ as usize },
161 16usize,
162 concat!(
163 "Offset of field: ",
164 stringify!(RTCBounds),
165 "::",
166 stringify!(upper_x)
167 )
168 );
169 assert_eq!(
170 unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_y as *const _ as usize },
171 20usize,
172 concat!(
173 "Offset of field: ",
174 stringify!(RTCBounds),
175 "::",
176 stringify!(upper_y)
177 )
178 );
179 assert_eq!(
180 unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_z as *const _ as usize },
181 24usize,
182 concat!(
183 "Offset of field: ",
184 stringify!(RTCBounds),
185 "::",
186 stringify!(upper_z)
187 )
188 );
189 assert_eq!(
190 unsafe { &(*(::std::ptr::null::<RTCBounds>())).align1 as *const _ as usize },
191 28usize,
192 concat!(
193 "Offset of field: ",
194 stringify!(RTCBounds),
195 "::",
196 stringify!(align1)
197 )
198 );
199}
200#[repr(C)]
201#[repr(align(16))]
202#[derive(Debug, Copy, Clone)]
203pub struct RTCLinearBounds {
204 pub bounds0: RTCBounds,
205 pub bounds1: RTCBounds,
206}
207#[test]
208fn bindgen_test_layout_RTCLinearBounds() {
209 assert_eq!(
210 ::std::mem::size_of::<RTCLinearBounds>(),
211 64usize,
212 concat!("Size of: ", stringify!(RTCLinearBounds))
213 );
214 assert_eq!(
215 ::std::mem::align_of::<RTCLinearBounds>(),
216 16usize,
217 concat!("Alignment of ", stringify!(RTCLinearBounds))
218 );
219 assert_eq!(
220 unsafe { &(*(::std::ptr::null::<RTCLinearBounds>())).bounds0 as *const _ as usize },
221 0usize,
222 concat!(
223 "Offset of field: ",
224 stringify!(RTCLinearBounds),
225 "::",
226 stringify!(bounds0)
227 )
228 );
229 assert_eq!(
230 unsafe { &(*(::std::ptr::null::<RTCLinearBounds>())).bounds1 as *const _ as usize },
231 32usize,
232 concat!(
233 "Offset of field: ",
234 stringify!(RTCLinearBounds),
235 "::",
236 stringify!(bounds1)
237 )
238 );
239}
240impl RTCIntersectContextFlags {
241 pub const NONE: RTCIntersectContextFlags = RTCIntersectContextFlags(0);
242}
243impl RTCIntersectContextFlags {
244 pub const INCOHERENT: RTCIntersectContextFlags = RTCIntersectContextFlags(0);
245}
246impl RTCIntersectContextFlags {
247 pub const COHERENT: RTCIntersectContextFlags = RTCIntersectContextFlags(1);
248}
249impl ::std::ops::BitOr<RTCIntersectContextFlags> for RTCIntersectContextFlags {
250 type Output = Self;
251 #[inline]
252 fn bitor(self, other: Self) -> Self {
253 RTCIntersectContextFlags(self.0 | other.0)
254 }
255}
256impl ::std::ops::BitOrAssign for RTCIntersectContextFlags {
257 #[inline]
258 fn bitor_assign(&mut self, rhs: RTCIntersectContextFlags) {
259 self.0 |= rhs.0;
260 }
261}
262impl ::std::ops::BitAnd<RTCIntersectContextFlags> for RTCIntersectContextFlags {
263 type Output = Self;
264 #[inline]
265 fn bitand(self, other: Self) -> Self {
266 RTCIntersectContextFlags(self.0 & other.0)
267 }
268}
269impl ::std::ops::BitAndAssign for RTCIntersectContextFlags {
270 #[inline]
271 fn bitand_assign(&mut self, rhs: RTCIntersectContextFlags) {
272 self.0 &= rhs.0;
273 }
274}
275#[repr(transparent)]
276#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
277pub struct RTCIntersectContextFlags(pub ::std::os::raw::c_uint);
278#[repr(C)]
279#[derive(Debug, Copy, Clone)]
280pub struct RTCFilterFunctionNArguments {
281 pub valid: *mut ::std::os::raw::c_int,
282 pub geometryUserPtr: *mut ::std::os::raw::c_void,
283 pub context: *mut RTCIntersectContext,
284 pub ray: *mut RTCRayN,
285 pub hit: *mut RTCHitN,
286 pub N: ::std::os::raw::c_uint,
287}
288#[test]
289fn bindgen_test_layout_RTCFilterFunctionNArguments() {
290 assert_eq!(
291 ::std::mem::size_of::<RTCFilterFunctionNArguments>(),
292 48usize,
293 concat!("Size of: ", stringify!(RTCFilterFunctionNArguments))
294 );
295 assert_eq!(
296 ::std::mem::align_of::<RTCFilterFunctionNArguments>(),
297 8usize,
298 concat!("Alignment of ", stringify!(RTCFilterFunctionNArguments))
299 );
300 assert_eq!(
301 unsafe {
302 &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).valid as *const _ as usize
303 },
304 0usize,
305 concat!(
306 "Offset of field: ",
307 stringify!(RTCFilterFunctionNArguments),
308 "::",
309 stringify!(valid)
310 )
311 );
312 assert_eq!(
313 unsafe {
314 &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).geometryUserPtr as *const _
315 as usize
316 },
317 8usize,
318 concat!(
319 "Offset of field: ",
320 stringify!(RTCFilterFunctionNArguments),
321 "::",
322 stringify!(geometryUserPtr)
323 )
324 );
325 assert_eq!(
326 unsafe {
327 &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).context as *const _ as usize
328 },
329 16usize,
330 concat!(
331 "Offset of field: ",
332 stringify!(RTCFilterFunctionNArguments),
333 "::",
334 stringify!(context)
335 )
336 );
337 assert_eq!(
338 unsafe { &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).ray as *const _ as usize },
339 24usize,
340 concat!(
341 "Offset of field: ",
342 stringify!(RTCFilterFunctionNArguments),
343 "::",
344 stringify!(ray)
345 )
346 );
347 assert_eq!(
348 unsafe { &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).hit as *const _ as usize },
349 32usize,
350 concat!(
351 "Offset of field: ",
352 stringify!(RTCFilterFunctionNArguments),
353 "::",
354 stringify!(hit)
355 )
356 );
357 assert_eq!(
358 unsafe { &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).N as *const _ as usize },
359 40usize,
360 concat!(
361 "Offset of field: ",
362 stringify!(RTCFilterFunctionNArguments),
363 "::",
364 stringify!(N)
365 )
366 );
367}
368pub type RTCFilterFunctionN =
369 ::std::option::Option<unsafe extern "C" fn(args: *const RTCFilterFunctionNArguments)>;
370#[repr(C)]
371#[derive(Debug, Copy, Clone)]
372pub struct RTCIntersectContext {
373 pub flags: RTCIntersectContextFlags,
374 pub filter: RTCFilterFunctionN,
375 pub instID: [::std::os::raw::c_uint; 1usize],
376}
377#[test]
378fn bindgen_test_layout_RTCIntersectContext() {
379 assert_eq!(
380 ::std::mem::size_of::<RTCIntersectContext>(),
381 24usize,
382 concat!("Size of: ", stringify!(RTCIntersectContext))
383 );
384 assert_eq!(
385 ::std::mem::align_of::<RTCIntersectContext>(),
386 8usize,
387 concat!("Alignment of ", stringify!(RTCIntersectContext))
388 );
389 assert_eq!(
390 unsafe { &(*(::std::ptr::null::<RTCIntersectContext>())).flags as *const _ as usize },
391 0usize,
392 concat!(
393 "Offset of field: ",
394 stringify!(RTCIntersectContext),
395 "::",
396 stringify!(flags)
397 )
398 );
399 assert_eq!(
400 unsafe { &(*(::std::ptr::null::<RTCIntersectContext>())).filter as *const _ as usize },
401 8usize,
402 concat!(
403 "Offset of field: ",
404 stringify!(RTCIntersectContext),
405 "::",
406 stringify!(filter)
407 )
408 );
409 assert_eq!(
410 unsafe { &(*(::std::ptr::null::<RTCIntersectContext>())).instID as *const _ as usize },
411 16usize,
412 concat!(
413 "Offset of field: ",
414 stringify!(RTCIntersectContext),
415 "::",
416 stringify!(instID)
417 )
418 );
419}
420#[repr(C)]
421#[repr(align(16))]
422#[derive(Debug, Copy, Clone)]
423pub struct RTCPointQuery {
424 pub x: f32,
425 pub y: f32,
426 pub z: f32,
427 pub time: f32,
428 pub radius: f32,
429}
430#[test]
431fn bindgen_test_layout_RTCPointQuery() {
432 assert_eq!(
433 ::std::mem::size_of::<RTCPointQuery>(),
434 32usize,
435 concat!("Size of: ", stringify!(RTCPointQuery))
436 );
437 assert_eq!(
438 ::std::mem::align_of::<RTCPointQuery>(),
439 16usize,
440 concat!("Alignment of ", stringify!(RTCPointQuery))
441 );
442 assert_eq!(
443 unsafe { &(*(::std::ptr::null::<RTCPointQuery>())).x as *const _ as usize },
444 0usize,
445 concat!(
446 "Offset of field: ",
447 stringify!(RTCPointQuery),
448 "::",
449 stringify!(x)
450 )
451 );
452 assert_eq!(
453 unsafe { &(*(::std::ptr::null::<RTCPointQuery>())).y as *const _ as usize },
454 4usize,
455 concat!(
456 "Offset of field: ",
457 stringify!(RTCPointQuery),
458 "::",
459 stringify!(y)
460 )
461 );
462 assert_eq!(
463 unsafe { &(*(::std::ptr::null::<RTCPointQuery>())).z as *const _ as usize },
464 8usize,
465 concat!(
466 "Offset of field: ",
467 stringify!(RTCPointQuery),
468 "::",
469 stringify!(z)
470 )
471 );
472 assert_eq!(
473 unsafe { &(*(::std::ptr::null::<RTCPointQuery>())).time as *const _ as usize },
474 12usize,
475 concat!(
476 "Offset of field: ",
477 stringify!(RTCPointQuery),
478 "::",
479 stringify!(time)
480 )
481 );
482 assert_eq!(
483 unsafe { &(*(::std::ptr::null::<RTCPointQuery>())).radius as *const _ as usize },
484 16usize,
485 concat!(
486 "Offset of field: ",
487 stringify!(RTCPointQuery),
488 "::",
489 stringify!(radius)
490 )
491 );
492}
493#[repr(C)]
494#[repr(align(16))]
495#[derive(Debug, Copy, Clone)]
496pub struct RTCPointQuery4 {
497 pub x: [f32; 4usize],
498 pub y: [f32; 4usize],
499 pub z: [f32; 4usize],
500 pub time: [f32; 4usize],
501 pub radius: [f32; 4usize],
502}
503#[test]
504fn bindgen_test_layout_RTCPointQuery4() {
505 assert_eq!(
506 ::std::mem::size_of::<RTCPointQuery4>(),
507 80usize,
508 concat!("Size of: ", stringify!(RTCPointQuery4))
509 );
510 assert_eq!(
511 ::std::mem::align_of::<RTCPointQuery4>(),
512 16usize,
513 concat!("Alignment of ", stringify!(RTCPointQuery4))
514 );
515 assert_eq!(
516 unsafe { &(*(::std::ptr::null::<RTCPointQuery4>())).x as *const _ as usize },
517 0usize,
518 concat!(
519 "Offset of field: ",
520 stringify!(RTCPointQuery4),
521 "::",
522 stringify!(x)
523 )
524 );
525 assert_eq!(
526 unsafe { &(*(::std::ptr::null::<RTCPointQuery4>())).y as *const _ as usize },
527 16usize,
528 concat!(
529 "Offset of field: ",
530 stringify!(RTCPointQuery4),
531 "::",
532 stringify!(y)
533 )
534 );
535 assert_eq!(
536 unsafe { &(*(::std::ptr::null::<RTCPointQuery4>())).z as *const _ as usize },
537 32usize,
538 concat!(
539 "Offset of field: ",
540 stringify!(RTCPointQuery4),
541 "::",
542 stringify!(z)
543 )
544 );
545 assert_eq!(
546 unsafe { &(*(::std::ptr::null::<RTCPointQuery4>())).time as *const _ as usize },
547 48usize,
548 concat!(
549 "Offset of field: ",
550 stringify!(RTCPointQuery4),
551 "::",
552 stringify!(time)
553 )
554 );
555 assert_eq!(
556 unsafe { &(*(::std::ptr::null::<RTCPointQuery4>())).radius as *const _ as usize },
557 64usize,
558 concat!(
559 "Offset of field: ",
560 stringify!(RTCPointQuery4),
561 "::",
562 stringify!(radius)
563 )
564 );
565}
566#[repr(C)]
567#[repr(align(32))]
568#[derive(Debug, Copy, Clone)]
569pub struct RTCPointQuery8 {
570 pub x: [f32; 8usize],
571 pub y: [f32; 8usize],
572 pub z: [f32; 8usize],
573 pub time: [f32; 8usize],
574 pub radius: [f32; 8usize],
575}
576#[test]
577fn bindgen_test_layout_RTCPointQuery8() {
578 assert_eq!(
579 ::std::mem::size_of::<RTCPointQuery8>(),
580 160usize,
581 concat!("Size of: ", stringify!(RTCPointQuery8))
582 );
583 assert_eq!(
584 ::std::mem::align_of::<RTCPointQuery8>(),
585 32usize,
586 concat!("Alignment of ", stringify!(RTCPointQuery8))
587 );
588 assert_eq!(
589 unsafe { &(*(::std::ptr::null::<RTCPointQuery8>())).x as *const _ as usize },
590 0usize,
591 concat!(
592 "Offset of field: ",
593 stringify!(RTCPointQuery8),
594 "::",
595 stringify!(x)
596 )
597 );
598 assert_eq!(
599 unsafe { &(*(::std::ptr::null::<RTCPointQuery8>())).y as *const _ as usize },
600 32usize,
601 concat!(
602 "Offset of field: ",
603 stringify!(RTCPointQuery8),
604 "::",
605 stringify!(y)
606 )
607 );
608 assert_eq!(
609 unsafe { &(*(::std::ptr::null::<RTCPointQuery8>())).z as *const _ as usize },
610 64usize,
611 concat!(
612 "Offset of field: ",
613 stringify!(RTCPointQuery8),
614 "::",
615 stringify!(z)
616 )
617 );
618 assert_eq!(
619 unsafe { &(*(::std::ptr::null::<RTCPointQuery8>())).time as *const _ as usize },
620 96usize,
621 concat!(
622 "Offset of field: ",
623 stringify!(RTCPointQuery8),
624 "::",
625 stringify!(time)
626 )
627 );
628 assert_eq!(
629 unsafe { &(*(::std::ptr::null::<RTCPointQuery8>())).radius as *const _ as usize },
630 128usize,
631 concat!(
632 "Offset of field: ",
633 stringify!(RTCPointQuery8),
634 "::",
635 stringify!(radius)
636 )
637 );
638}
639#[repr(C)]
640#[repr(align(64))]
641#[derive(Copy, Clone)]
642pub struct RTCPointQuery16 {
643 pub x: [f32; 16usize],
644 pub y: [f32; 16usize],
645 pub z: [f32; 16usize],
646 pub time: [f32; 16usize],
647 pub radius: [f32; 16usize],
648}
649#[test]
650fn bindgen_test_layout_RTCPointQuery16() {
651 assert_eq!(
652 ::std::mem::size_of::<RTCPointQuery16>(),
653 320usize,
654 concat!("Size of: ", stringify!(RTCPointQuery16))
655 );
656 assert_eq!(
657 ::std::mem::align_of::<RTCPointQuery16>(),
658 64usize,
659 concat!("Alignment of ", stringify!(RTCPointQuery16))
660 );
661 assert_eq!(
662 unsafe { &(*(::std::ptr::null::<RTCPointQuery16>())).x as *const _ as usize },
663 0usize,
664 concat!(
665 "Offset of field: ",
666 stringify!(RTCPointQuery16),
667 "::",
668 stringify!(x)
669 )
670 );
671 assert_eq!(
672 unsafe { &(*(::std::ptr::null::<RTCPointQuery16>())).y as *const _ as usize },
673 64usize,
674 concat!(
675 "Offset of field: ",
676 stringify!(RTCPointQuery16),
677 "::",
678 stringify!(y)
679 )
680 );
681 assert_eq!(
682 unsafe { &(*(::std::ptr::null::<RTCPointQuery16>())).z as *const _ as usize },
683 128usize,
684 concat!(
685 "Offset of field: ",
686 stringify!(RTCPointQuery16),
687 "::",
688 stringify!(z)
689 )
690 );
691 assert_eq!(
692 unsafe { &(*(::std::ptr::null::<RTCPointQuery16>())).time as *const _ as usize },
693 192usize,
694 concat!(
695 "Offset of field: ",
696 stringify!(RTCPointQuery16),
697 "::",
698 stringify!(time)
699 )
700 );
701 assert_eq!(
702 unsafe { &(*(::std::ptr::null::<RTCPointQuery16>())).radius as *const _ as usize },
703 256usize,
704 concat!(
705 "Offset of field: ",
706 stringify!(RTCPointQuery16),
707 "::",
708 stringify!(radius)
709 )
710 );
711}
712#[repr(C)]
713#[derive(Debug, Copy, Clone)]
714pub struct RTCPointQueryN {
715 _unused: [u8; 0],
716}
717#[repr(C)]
718#[repr(align(16))]
719#[derive(Debug, Copy, Clone)]
720pub struct RTCPointQueryContext {
721 pub world2inst: [[f32; 16usize]; 1usize],
722 pub inst2world: [[f32; 16usize]; 1usize],
723 pub instID: [::std::os::raw::c_uint; 1usize],
724 pub instStackSize: ::std::os::raw::c_uint,
725}
726#[test]
727fn bindgen_test_layout_RTCPointQueryContext() {
728 assert_eq!(
729 ::std::mem::size_of::<RTCPointQueryContext>(),
730 144usize,
731 concat!("Size of: ", stringify!(RTCPointQueryContext))
732 );
733 assert_eq!(
734 ::std::mem::align_of::<RTCPointQueryContext>(),
735 16usize,
736 concat!("Alignment of ", stringify!(RTCPointQueryContext))
737 );
738 assert_eq!(
739 unsafe { &(*(::std::ptr::null::<RTCPointQueryContext>())).world2inst as *const _ as usize },
740 0usize,
741 concat!(
742 "Offset of field: ",
743 stringify!(RTCPointQueryContext),
744 "::",
745 stringify!(world2inst)
746 )
747 );
748 assert_eq!(
749 unsafe { &(*(::std::ptr::null::<RTCPointQueryContext>())).inst2world as *const _ as usize },
750 64usize,
751 concat!(
752 "Offset of field: ",
753 stringify!(RTCPointQueryContext),
754 "::",
755 stringify!(inst2world)
756 )
757 );
758 assert_eq!(
759 unsafe { &(*(::std::ptr::null::<RTCPointQueryContext>())).instID as *const _ as usize },
760 128usize,
761 concat!(
762 "Offset of field: ",
763 stringify!(RTCPointQueryContext),
764 "::",
765 stringify!(instID)
766 )
767 );
768 assert_eq!(
769 unsafe {
770 &(*(::std::ptr::null::<RTCPointQueryContext>())).instStackSize as *const _ as usize
771 },
772 132usize,
773 concat!(
774 "Offset of field: ",
775 stringify!(RTCPointQueryContext),
776 "::",
777 stringify!(instStackSize)
778 )
779 );
780}
781#[repr(C)]
782#[repr(align(16))]
783#[derive(Debug, Copy, Clone)]
784pub struct RTCPointQueryFunctionArguments {
785 pub query: *mut RTCPointQuery,
786 pub userPtr: *mut ::std::os::raw::c_void,
787 pub primID: ::std::os::raw::c_uint,
788 pub geomID: ::std::os::raw::c_uint,
789 pub context: *mut RTCPointQueryContext,
790 pub similarityScale: f32,
791}
792#[test]
793fn bindgen_test_layout_RTCPointQueryFunctionArguments() {
794 assert_eq!(
795 ::std::mem::size_of::<RTCPointQueryFunctionArguments>(),
796 48usize,
797 concat!("Size of: ", stringify!(RTCPointQueryFunctionArguments))
798 );
799 assert_eq!(
800 ::std::mem::align_of::<RTCPointQueryFunctionArguments>(),
801 16usize,
802 concat!("Alignment of ", stringify!(RTCPointQueryFunctionArguments))
803 );
804 assert_eq!(
805 unsafe {
806 &(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).query as *const _ as usize
807 },
808 0usize,
809 concat!(
810 "Offset of field: ",
811 stringify!(RTCPointQueryFunctionArguments),
812 "::",
813 stringify!(query)
814 )
815 );
816 assert_eq!(
817 unsafe {
818 &(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).userPtr as *const _ as usize
819 },
820 8usize,
821 concat!(
822 "Offset of field: ",
823 stringify!(RTCPointQueryFunctionArguments),
824 "::",
825 stringify!(userPtr)
826 )
827 );
828 assert_eq!(
829 unsafe {
830 &(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).primID as *const _ as usize
831 },
832 16usize,
833 concat!(
834 "Offset of field: ",
835 stringify!(RTCPointQueryFunctionArguments),
836 "::",
837 stringify!(primID)
838 )
839 );
840 assert_eq!(
841 unsafe {
842 &(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).geomID as *const _ as usize
843 },
844 20usize,
845 concat!(
846 "Offset of field: ",
847 stringify!(RTCPointQueryFunctionArguments),
848 "::",
849 stringify!(geomID)
850 )
851 );
852 assert_eq!(
853 unsafe {
854 &(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).context as *const _ as usize
855 },
856 24usize,
857 concat!(
858 "Offset of field: ",
859 stringify!(RTCPointQueryFunctionArguments),
860 "::",
861 stringify!(context)
862 )
863 );
864 assert_eq!(
865 unsafe {
866 &(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).similarityScale as *const _
867 as usize
868 },
869 32usize,
870 concat!(
871 "Offset of field: ",
872 stringify!(RTCPointQueryFunctionArguments),
873 "::",
874 stringify!(similarityScale)
875 )
876 );
877}
878pub type RTCPointQueryFunction =
879 ::std::option::Option<unsafe extern "C" fn(args: *mut RTCPointQueryFunctionArguments) -> bool>;
880#[repr(C)]
881#[derive(Debug, Copy, Clone)]
882pub struct RTCDeviceTy {
883 _unused: [u8; 0],
884}
885pub type RTCDevice = *mut RTCDeviceTy;
886extern "C" {
887 pub fn rtcNewDevice(config: *const ::std::os::raw::c_char) -> RTCDevice;
888}
889extern "C" {
890 pub fn rtcRetainDevice(device: RTCDevice);
891}
892extern "C" {
893 pub fn rtcReleaseDevice(device: RTCDevice);
894}
895#[repr(u32)]
896#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
897pub enum RTCDeviceProperty {
898 VERSION = 0,
899 VERSION_MAJOR = 1,
900 VERSION_MINOR = 2,
901 VERSION_PATCH = 3,
902 NATIVE_RAY4_SUPPORTED = 32,
903 NATIVE_RAY8_SUPPORTED = 33,
904 NATIVE_RAY16_SUPPORTED = 34,
905 RAY_STREAM_SUPPORTED = 35,
906 BACKFACE_CULLING_CURVES_ENABLED = 63,
907 RAY_MASK_SUPPORTED = 64,
908 BACKFACE_CULLING_ENABLED = 65,
909 FILTER_FUNCTION_SUPPORTED = 66,
910 IGNORE_INVALID_RAYS_ENABLED = 67,
911 COMPACT_POLYS_ENABLED = 68,
912 TRIANGLE_GEOMETRY_SUPPORTED = 96,
913 QUAD_GEOMETRY_SUPPORTED = 97,
914 SUBDIVISION_GEOMETRY_SUPPORTED = 98,
915 CURVE_GEOMETRY_SUPPORTED = 99,
916 USER_GEOMETRY_SUPPORTED = 100,
917 POINT_GEOMETRY_SUPPORTED = 101,
918 TASKING_SYSTEM = 128,
919 JOIN_COMMIT_SUPPORTED = 129,
920 PARALLEL_COMMIT_SUPPORTED = 130,
921}
922extern "C" {
923 pub fn rtcGetDeviceProperty(device: RTCDevice, prop: RTCDeviceProperty) -> ssize_t;
924}
925extern "C" {
926 pub fn rtcSetDeviceProperty(device: RTCDevice, prop: RTCDeviceProperty, value: ssize_t);
927}
928#[repr(u32)]
929#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
930pub enum RTCError {
931 NONE = 0,
932 UNKNOWN = 1,
933 INVALID_ARGUMENT = 2,
934 INVALID_OPERATION = 3,
935 OUT_OF_MEMORY = 4,
936 UNSUPPORTED_CPU = 5,
937 CANCELLED = 6,
938}
939extern "C" {
940 pub fn rtcGetDeviceError(device: RTCDevice) -> RTCError;
941}
942pub type RTCErrorFunction = ::std::option::Option<
943 unsafe extern "C" fn(
944 userPtr: *mut ::std::os::raw::c_void,
945 code: RTCError,
946 str_: *const ::std::os::raw::c_char,
947 ),
948>;
949extern "C" {
950 pub fn rtcSetDeviceErrorFunction(
951 device: RTCDevice,
952 error: RTCErrorFunction,
953 userPtr: *mut ::std::os::raw::c_void,
954 );
955}
956pub type RTCMemoryMonitorFunction = ::std::option::Option<
957 unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void, bytes: ssize_t, post: bool) -> bool,
958>;
959extern "C" {
960 pub fn rtcSetDeviceMemoryMonitorFunction(
961 device: RTCDevice,
962 memoryMonitor: RTCMemoryMonitorFunction,
963 userPtr: *mut ::std::os::raw::c_void,
964 );
965}
966#[repr(u32)]
967#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
968pub enum RTCBufferType {
969 INDEX = 0,
970 VERTEX = 1,
971 VERTEX_ATTRIBUTE = 2,
972 NORMAL = 3,
973 TANGENT = 4,
974 NORMAL_DERIVATIVE = 5,
975 GRID = 8,
976 FACE = 16,
977 LEVEL = 17,
978 EDGE_CREASE_INDEX = 18,
979 EDGE_CREASE_WEIGHT = 19,
980 VERTEX_CREASE_INDEX = 20,
981 VERTEX_CREASE_WEIGHT = 21,
982 HOLE = 22,
983 FLAGS = 32,
984}
985#[repr(C)]
986#[derive(Debug, Copy, Clone)]
987pub struct RTCBufferTy {
988 _unused: [u8; 0],
989}
990pub type RTCBuffer = *mut RTCBufferTy;
991extern "C" {
992 pub fn rtcNewBuffer(device: RTCDevice, byteSize: size_t) -> RTCBuffer;
993}
994extern "C" {
995 pub fn rtcNewSharedBuffer(
996 device: RTCDevice,
997 ptr: *mut ::std::os::raw::c_void,
998 byteSize: size_t,
999 ) -> RTCBuffer;
1000}
1001extern "C" {
1002 pub fn rtcGetBufferData(buffer: RTCBuffer) -> *mut ::std::os::raw::c_void;
1003}
1004extern "C" {
1005 pub fn rtcRetainBuffer(buffer: RTCBuffer);
1006}
1007extern "C" {
1008 pub fn rtcReleaseBuffer(buffer: RTCBuffer);
1009}
1010#[repr(C)]
1011#[repr(align(16))]
1012#[derive(Debug, Copy, Clone)]
1013pub struct RTCRay {
1014 pub org_x: f32,
1015 pub org_y: f32,
1016 pub org_z: f32,
1017 pub tnear: f32,
1018 pub dir_x: f32,
1019 pub dir_y: f32,
1020 pub dir_z: f32,
1021 pub time: f32,
1022 pub tfar: f32,
1023 pub mask: ::std::os::raw::c_uint,
1024 pub id: ::std::os::raw::c_uint,
1025 pub flags: ::std::os::raw::c_uint,
1026}
1027#[test]
1028fn bindgen_test_layout_RTCRay() {
1029 assert_eq!(
1030 ::std::mem::size_of::<RTCRay>(),
1031 48usize,
1032 concat!("Size of: ", stringify!(RTCRay))
1033 );
1034 assert_eq!(
1035 ::std::mem::align_of::<RTCRay>(),
1036 16usize,
1037 concat!("Alignment of ", stringify!(RTCRay))
1038 );
1039 assert_eq!(
1040 unsafe { &(*(::std::ptr::null::<RTCRay>())).org_x as *const _ as usize },
1041 0usize,
1042 concat!(
1043 "Offset of field: ",
1044 stringify!(RTCRay),
1045 "::",
1046 stringify!(org_x)
1047 )
1048 );
1049 assert_eq!(
1050 unsafe { &(*(::std::ptr::null::<RTCRay>())).org_y as *const _ as usize },
1051 4usize,
1052 concat!(
1053 "Offset of field: ",
1054 stringify!(RTCRay),
1055 "::",
1056 stringify!(org_y)
1057 )
1058 );
1059 assert_eq!(
1060 unsafe { &(*(::std::ptr::null::<RTCRay>())).org_z as *const _ as usize },
1061 8usize,
1062 concat!(
1063 "Offset of field: ",
1064 stringify!(RTCRay),
1065 "::",
1066 stringify!(org_z)
1067 )
1068 );
1069 assert_eq!(
1070 unsafe { &(*(::std::ptr::null::<RTCRay>())).tnear as *const _ as usize },
1071 12usize,
1072 concat!(
1073 "Offset of field: ",
1074 stringify!(RTCRay),
1075 "::",
1076 stringify!(tnear)
1077 )
1078 );
1079 assert_eq!(
1080 unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_x as *const _ as usize },
1081 16usize,
1082 concat!(
1083 "Offset of field: ",
1084 stringify!(RTCRay),
1085 "::",
1086 stringify!(dir_x)
1087 )
1088 );
1089 assert_eq!(
1090 unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_y as *const _ as usize },
1091 20usize,
1092 concat!(
1093 "Offset of field: ",
1094 stringify!(RTCRay),
1095 "::",
1096 stringify!(dir_y)
1097 )
1098 );
1099 assert_eq!(
1100 unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_z as *const _ as usize },
1101 24usize,
1102 concat!(
1103 "Offset of field: ",
1104 stringify!(RTCRay),
1105 "::",
1106 stringify!(dir_z)
1107 )
1108 );
1109 assert_eq!(
1110 unsafe { &(*(::std::ptr::null::<RTCRay>())).time as *const _ as usize },
1111 28usize,
1112 concat!(
1113 "Offset of field: ",
1114 stringify!(RTCRay),
1115 "::",
1116 stringify!(time)
1117 )
1118 );
1119 assert_eq!(
1120 unsafe { &(*(::std::ptr::null::<RTCRay>())).tfar as *const _ as usize },
1121 32usize,
1122 concat!(
1123 "Offset of field: ",
1124 stringify!(RTCRay),
1125 "::",
1126 stringify!(tfar)
1127 )
1128 );
1129 assert_eq!(
1130 unsafe { &(*(::std::ptr::null::<RTCRay>())).mask as *const _ as usize },
1131 36usize,
1132 concat!(
1133 "Offset of field: ",
1134 stringify!(RTCRay),
1135 "::",
1136 stringify!(mask)
1137 )
1138 );
1139 assert_eq!(
1140 unsafe { &(*(::std::ptr::null::<RTCRay>())).id as *const _ as usize },
1141 40usize,
1142 concat!(
1143 "Offset of field: ",
1144 stringify!(RTCRay),
1145 "::",
1146 stringify!(id)
1147 )
1148 );
1149 assert_eq!(
1150 unsafe { &(*(::std::ptr::null::<RTCRay>())).flags as *const _ as usize },
1151 44usize,
1152 concat!(
1153 "Offset of field: ",
1154 stringify!(RTCRay),
1155 "::",
1156 stringify!(flags)
1157 )
1158 );
1159}
1160#[repr(C)]
1161#[repr(align(16))]
1162#[derive(Debug, Copy, Clone)]
1163pub struct RTCHit {
1164 pub Ng_x: f32,
1165 pub Ng_y: f32,
1166 pub Ng_z: f32,
1167 pub u: f32,
1168 pub v: f32,
1169 pub primID: ::std::os::raw::c_uint,
1170 pub geomID: ::std::os::raw::c_uint,
1171 pub instID: [::std::os::raw::c_uint; 1usize],
1172}
1173#[test]
1174fn bindgen_test_layout_RTCHit() {
1175 assert_eq!(
1176 ::std::mem::size_of::<RTCHit>(),
1177 32usize,
1178 concat!("Size of: ", stringify!(RTCHit))
1179 );
1180 assert_eq!(
1181 ::std::mem::align_of::<RTCHit>(),
1182 16usize,
1183 concat!("Alignment of ", stringify!(RTCHit))
1184 );
1185 assert_eq!(
1186 unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_x as *const _ as usize },
1187 0usize,
1188 concat!(
1189 "Offset of field: ",
1190 stringify!(RTCHit),
1191 "::",
1192 stringify!(Ng_x)
1193 )
1194 );
1195 assert_eq!(
1196 unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_y as *const _ as usize },
1197 4usize,
1198 concat!(
1199 "Offset of field: ",
1200 stringify!(RTCHit),
1201 "::",
1202 stringify!(Ng_y)
1203 )
1204 );
1205 assert_eq!(
1206 unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_z as *const _ as usize },
1207 8usize,
1208 concat!(
1209 "Offset of field: ",
1210 stringify!(RTCHit),
1211 "::",
1212 stringify!(Ng_z)
1213 )
1214 );
1215 assert_eq!(
1216 unsafe { &(*(::std::ptr::null::<RTCHit>())).u as *const _ as usize },
1217 12usize,
1218 concat!("Offset of field: ", stringify!(RTCHit), "::", stringify!(u))
1219 );
1220 assert_eq!(
1221 unsafe { &(*(::std::ptr::null::<RTCHit>())).v as *const _ as usize },
1222 16usize,
1223 concat!("Offset of field: ", stringify!(RTCHit), "::", stringify!(v))
1224 );
1225 assert_eq!(
1226 unsafe { &(*(::std::ptr::null::<RTCHit>())).primID as *const _ as usize },
1227 20usize,
1228 concat!(
1229 "Offset of field: ",
1230 stringify!(RTCHit),
1231 "::",
1232 stringify!(primID)
1233 )
1234 );
1235 assert_eq!(
1236 unsafe { &(*(::std::ptr::null::<RTCHit>())).geomID as *const _ as usize },
1237 24usize,
1238 concat!(
1239 "Offset of field: ",
1240 stringify!(RTCHit),
1241 "::",
1242 stringify!(geomID)
1243 )
1244 );
1245 assert_eq!(
1246 unsafe { &(*(::std::ptr::null::<RTCHit>())).instID as *const _ as usize },
1247 28usize,
1248 concat!(
1249 "Offset of field: ",
1250 stringify!(RTCHit),
1251 "::",
1252 stringify!(instID)
1253 )
1254 );
1255}
1256#[repr(C)]
1257#[repr(align(16))]
1258#[derive(Debug, Copy, Clone)]
1259pub struct RTCRayHit {
1260 pub ray: RTCRay,
1261 pub hit: RTCHit,
1262}
1263#[test]
1264fn bindgen_test_layout_RTCRayHit() {
1265 assert_eq!(
1266 ::std::mem::size_of::<RTCRayHit>(),
1267 80usize,
1268 concat!("Size of: ", stringify!(RTCRayHit))
1269 );
1270 assert_eq!(
1271 ::std::mem::align_of::<RTCRayHit>(),
1272 16usize,
1273 concat!("Alignment of ", stringify!(RTCRayHit))
1274 );
1275 assert_eq!(
1276 unsafe { &(*(::std::ptr::null::<RTCRayHit>())).ray as *const _ as usize },
1277 0usize,
1278 concat!(
1279 "Offset of field: ",
1280 stringify!(RTCRayHit),
1281 "::",
1282 stringify!(ray)
1283 )
1284 );
1285 assert_eq!(
1286 unsafe { &(*(::std::ptr::null::<RTCRayHit>())).hit as *const _ as usize },
1287 48usize,
1288 concat!(
1289 "Offset of field: ",
1290 stringify!(RTCRayHit),
1291 "::",
1292 stringify!(hit)
1293 )
1294 );
1295}
1296#[repr(C)]
1297#[repr(align(16))]
1298#[derive(Debug, Copy, Clone)]
1299pub struct RTCRay4 {
1300 pub org_x: [f32; 4usize],
1301 pub org_y: [f32; 4usize],
1302 pub org_z: [f32; 4usize],
1303 pub tnear: [f32; 4usize],
1304 pub dir_x: [f32; 4usize],
1305 pub dir_y: [f32; 4usize],
1306 pub dir_z: [f32; 4usize],
1307 pub time: [f32; 4usize],
1308 pub tfar: [f32; 4usize],
1309 pub mask: [::std::os::raw::c_uint; 4usize],
1310 pub id: [::std::os::raw::c_uint; 4usize],
1311 pub flags: [::std::os::raw::c_uint; 4usize],
1312}
1313#[test]
1314fn bindgen_test_layout_RTCRay4() {
1315 assert_eq!(
1316 ::std::mem::size_of::<RTCRay4>(),
1317 192usize,
1318 concat!("Size of: ", stringify!(RTCRay4))
1319 );
1320 assert_eq!(
1321 ::std::mem::align_of::<RTCRay4>(),
1322 16usize,
1323 concat!("Alignment of ", stringify!(RTCRay4))
1324 );
1325 assert_eq!(
1326 unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_x as *const _ as usize },
1327 0usize,
1328 concat!(
1329 "Offset of field: ",
1330 stringify!(RTCRay4),
1331 "::",
1332 stringify!(org_x)
1333 )
1334 );
1335 assert_eq!(
1336 unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_y as *const _ as usize },
1337 16usize,
1338 concat!(
1339 "Offset of field: ",
1340 stringify!(RTCRay4),
1341 "::",
1342 stringify!(org_y)
1343 )
1344 );
1345 assert_eq!(
1346 unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_z as *const _ as usize },
1347 32usize,
1348 concat!(
1349 "Offset of field: ",
1350 stringify!(RTCRay4),
1351 "::",
1352 stringify!(org_z)
1353 )
1354 );
1355 assert_eq!(
1356 unsafe { &(*(::std::ptr::null::<RTCRay4>())).tnear as *const _ as usize },
1357 48usize,
1358 concat!(
1359 "Offset of field: ",
1360 stringify!(RTCRay4),
1361 "::",
1362 stringify!(tnear)
1363 )
1364 );
1365 assert_eq!(
1366 unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_x as *const _ as usize },
1367 64usize,
1368 concat!(
1369 "Offset of field: ",
1370 stringify!(RTCRay4),
1371 "::",
1372 stringify!(dir_x)
1373 )
1374 );
1375 assert_eq!(
1376 unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_y as *const _ as usize },
1377 80usize,
1378 concat!(
1379 "Offset of field: ",
1380 stringify!(RTCRay4),
1381 "::",
1382 stringify!(dir_y)
1383 )
1384 );
1385 assert_eq!(
1386 unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_z as *const _ as usize },
1387 96usize,
1388 concat!(
1389 "Offset of field: ",
1390 stringify!(RTCRay4),
1391 "::",
1392 stringify!(dir_z)
1393 )
1394 );
1395 assert_eq!(
1396 unsafe { &(*(::std::ptr::null::<RTCRay4>())).time as *const _ as usize },
1397 112usize,
1398 concat!(
1399 "Offset of field: ",
1400 stringify!(RTCRay4),
1401 "::",
1402 stringify!(time)
1403 )
1404 );
1405 assert_eq!(
1406 unsafe { &(*(::std::ptr::null::<RTCRay4>())).tfar as *const _ as usize },
1407 128usize,
1408 concat!(
1409 "Offset of field: ",
1410 stringify!(RTCRay4),
1411 "::",
1412 stringify!(tfar)
1413 )
1414 );
1415 assert_eq!(
1416 unsafe { &(*(::std::ptr::null::<RTCRay4>())).mask as *const _ as usize },
1417 144usize,
1418 concat!(
1419 "Offset of field: ",
1420 stringify!(RTCRay4),
1421 "::",
1422 stringify!(mask)
1423 )
1424 );
1425 assert_eq!(
1426 unsafe { &(*(::std::ptr::null::<RTCRay4>())).id as *const _ as usize },
1427 160usize,
1428 concat!(
1429 "Offset of field: ",
1430 stringify!(RTCRay4),
1431 "::",
1432 stringify!(id)
1433 )
1434 );
1435 assert_eq!(
1436 unsafe { &(*(::std::ptr::null::<RTCRay4>())).flags as *const _ as usize },
1437 176usize,
1438 concat!(
1439 "Offset of field: ",
1440 stringify!(RTCRay4),
1441 "::",
1442 stringify!(flags)
1443 )
1444 );
1445}
1446#[repr(C)]
1447#[repr(align(16))]
1448#[derive(Debug, Copy, Clone)]
1449pub struct RTCHit4 {
1450 pub Ng_x: [f32; 4usize],
1451 pub Ng_y: [f32; 4usize],
1452 pub Ng_z: [f32; 4usize],
1453 pub u: [f32; 4usize],
1454 pub v: [f32; 4usize],
1455 pub primID: [::std::os::raw::c_uint; 4usize],
1456 pub geomID: [::std::os::raw::c_uint; 4usize],
1457 pub instID: [[::std::os::raw::c_uint; 4usize]; 1usize],
1458}
1459#[test]
1460fn bindgen_test_layout_RTCHit4() {
1461 assert_eq!(
1462 ::std::mem::size_of::<RTCHit4>(),
1463 128usize,
1464 concat!("Size of: ", stringify!(RTCHit4))
1465 );
1466 assert_eq!(
1467 ::std::mem::align_of::<RTCHit4>(),
1468 16usize,
1469 concat!("Alignment of ", stringify!(RTCHit4))
1470 );
1471 assert_eq!(
1472 unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_x as *const _ as usize },
1473 0usize,
1474 concat!(
1475 "Offset of field: ",
1476 stringify!(RTCHit4),
1477 "::",
1478 stringify!(Ng_x)
1479 )
1480 );
1481 assert_eq!(
1482 unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_y as *const _ as usize },
1483 16usize,
1484 concat!(
1485 "Offset of field: ",
1486 stringify!(RTCHit4),
1487 "::",
1488 stringify!(Ng_y)
1489 )
1490 );
1491 assert_eq!(
1492 unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_z as *const _ as usize },
1493 32usize,
1494 concat!(
1495 "Offset of field: ",
1496 stringify!(RTCHit4),
1497 "::",
1498 stringify!(Ng_z)
1499 )
1500 );
1501 assert_eq!(
1502 unsafe { &(*(::std::ptr::null::<RTCHit4>())).u as *const _ as usize },
1503 48usize,
1504 concat!(
1505 "Offset of field: ",
1506 stringify!(RTCHit4),
1507 "::",
1508 stringify!(u)
1509 )
1510 );
1511 assert_eq!(
1512 unsafe { &(*(::std::ptr::null::<RTCHit4>())).v as *const _ as usize },
1513 64usize,
1514 concat!(
1515 "Offset of field: ",
1516 stringify!(RTCHit4),
1517 "::",
1518 stringify!(v)
1519 )
1520 );
1521 assert_eq!(
1522 unsafe { &(*(::std::ptr::null::<RTCHit4>())).primID as *const _ as usize },
1523 80usize,
1524 concat!(
1525 "Offset of field: ",
1526 stringify!(RTCHit4),
1527 "::",
1528 stringify!(primID)
1529 )
1530 );
1531 assert_eq!(
1532 unsafe { &(*(::std::ptr::null::<RTCHit4>())).geomID as *const _ as usize },
1533 96usize,
1534 concat!(
1535 "Offset of field: ",
1536 stringify!(RTCHit4),
1537 "::",
1538 stringify!(geomID)
1539 )
1540 );
1541 assert_eq!(
1542 unsafe { &(*(::std::ptr::null::<RTCHit4>())).instID as *const _ as usize },
1543 112usize,
1544 concat!(
1545 "Offset of field: ",
1546 stringify!(RTCHit4),
1547 "::",
1548 stringify!(instID)
1549 )
1550 );
1551}
1552#[repr(C)]
1553#[repr(align(16))]
1554#[derive(Debug, Copy, Clone)]
1555pub struct RTCRayHit4 {
1556 pub ray: RTCRay4,
1557 pub hit: RTCHit4,
1558}
1559#[test]
1560fn bindgen_test_layout_RTCRayHit4() {
1561 assert_eq!(
1562 ::std::mem::size_of::<RTCRayHit4>(),
1563 320usize,
1564 concat!("Size of: ", stringify!(RTCRayHit4))
1565 );
1566 assert_eq!(
1567 ::std::mem::align_of::<RTCRayHit4>(),
1568 16usize,
1569 concat!("Alignment of ", stringify!(RTCRayHit4))
1570 );
1571 assert_eq!(
1572 unsafe { &(*(::std::ptr::null::<RTCRayHit4>())).ray as *const _ as usize },
1573 0usize,
1574 concat!(
1575 "Offset of field: ",
1576 stringify!(RTCRayHit4),
1577 "::",
1578 stringify!(ray)
1579 )
1580 );
1581 assert_eq!(
1582 unsafe { &(*(::std::ptr::null::<RTCRayHit4>())).hit as *const _ as usize },
1583 192usize,
1584 concat!(
1585 "Offset of field: ",
1586 stringify!(RTCRayHit4),
1587 "::",
1588 stringify!(hit)
1589 )
1590 );
1591}
1592#[repr(C)]
1593#[repr(align(32))]
1594#[derive(Debug, Copy, Clone)]
1595pub struct RTCRay8 {
1596 pub org_x: [f32; 8usize],
1597 pub org_y: [f32; 8usize],
1598 pub org_z: [f32; 8usize],
1599 pub tnear: [f32; 8usize],
1600 pub dir_x: [f32; 8usize],
1601 pub dir_y: [f32; 8usize],
1602 pub dir_z: [f32; 8usize],
1603 pub time: [f32; 8usize],
1604 pub tfar: [f32; 8usize],
1605 pub mask: [::std::os::raw::c_uint; 8usize],
1606 pub id: [::std::os::raw::c_uint; 8usize],
1607 pub flags: [::std::os::raw::c_uint; 8usize],
1608}
1609#[test]
1610fn bindgen_test_layout_RTCRay8() {
1611 assert_eq!(
1612 ::std::mem::size_of::<RTCRay8>(),
1613 384usize,
1614 concat!("Size of: ", stringify!(RTCRay8))
1615 );
1616 assert_eq!(
1617 ::std::mem::align_of::<RTCRay8>(),
1618 32usize,
1619 concat!("Alignment of ", stringify!(RTCRay8))
1620 );
1621 assert_eq!(
1622 unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_x as *const _ as usize },
1623 0usize,
1624 concat!(
1625 "Offset of field: ",
1626 stringify!(RTCRay8),
1627 "::",
1628 stringify!(org_x)
1629 )
1630 );
1631 assert_eq!(
1632 unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_y as *const _ as usize },
1633 32usize,
1634 concat!(
1635 "Offset of field: ",
1636 stringify!(RTCRay8),
1637 "::",
1638 stringify!(org_y)
1639 )
1640 );
1641 assert_eq!(
1642 unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_z as *const _ as usize },
1643 64usize,
1644 concat!(
1645 "Offset of field: ",
1646 stringify!(RTCRay8),
1647 "::",
1648 stringify!(org_z)
1649 )
1650 );
1651 assert_eq!(
1652 unsafe { &(*(::std::ptr::null::<RTCRay8>())).tnear as *const _ as usize },
1653 96usize,
1654 concat!(
1655 "Offset of field: ",
1656 stringify!(RTCRay8),
1657 "::",
1658 stringify!(tnear)
1659 )
1660 );
1661 assert_eq!(
1662 unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_x as *const _ as usize },
1663 128usize,
1664 concat!(
1665 "Offset of field: ",
1666 stringify!(RTCRay8),
1667 "::",
1668 stringify!(dir_x)
1669 )
1670 );
1671 assert_eq!(
1672 unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_y as *const _ as usize },
1673 160usize,
1674 concat!(
1675 "Offset of field: ",
1676 stringify!(RTCRay8),
1677 "::",
1678 stringify!(dir_y)
1679 )
1680 );
1681 assert_eq!(
1682 unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_z as *const _ as usize },
1683 192usize,
1684 concat!(
1685 "Offset of field: ",
1686 stringify!(RTCRay8),
1687 "::",
1688 stringify!(dir_z)
1689 )
1690 );
1691 assert_eq!(
1692 unsafe { &(*(::std::ptr::null::<RTCRay8>())).time as *const _ as usize },
1693 224usize,
1694 concat!(
1695 "Offset of field: ",
1696 stringify!(RTCRay8),
1697 "::",
1698 stringify!(time)
1699 )
1700 );
1701 assert_eq!(
1702 unsafe { &(*(::std::ptr::null::<RTCRay8>())).tfar as *const _ as usize },
1703 256usize,
1704 concat!(
1705 "Offset of field: ",
1706 stringify!(RTCRay8),
1707 "::",
1708 stringify!(tfar)
1709 )
1710 );
1711 assert_eq!(
1712 unsafe { &(*(::std::ptr::null::<RTCRay8>())).mask as *const _ as usize },
1713 288usize,
1714 concat!(
1715 "Offset of field: ",
1716 stringify!(RTCRay8),
1717 "::",
1718 stringify!(mask)
1719 )
1720 );
1721 assert_eq!(
1722 unsafe { &(*(::std::ptr::null::<RTCRay8>())).id as *const _ as usize },
1723 320usize,
1724 concat!(
1725 "Offset of field: ",
1726 stringify!(RTCRay8),
1727 "::",
1728 stringify!(id)
1729 )
1730 );
1731 assert_eq!(
1732 unsafe { &(*(::std::ptr::null::<RTCRay8>())).flags as *const _ as usize },
1733 352usize,
1734 concat!(
1735 "Offset of field: ",
1736 stringify!(RTCRay8),
1737 "::",
1738 stringify!(flags)
1739 )
1740 );
1741}
1742#[repr(C)]
1743#[repr(align(32))]
1744#[derive(Debug, Copy, Clone)]
1745pub struct RTCHit8 {
1746 pub Ng_x: [f32; 8usize],
1747 pub Ng_y: [f32; 8usize],
1748 pub Ng_z: [f32; 8usize],
1749 pub u: [f32; 8usize],
1750 pub v: [f32; 8usize],
1751 pub primID: [::std::os::raw::c_uint; 8usize],
1752 pub geomID: [::std::os::raw::c_uint; 8usize],
1753 pub instID: [[::std::os::raw::c_uint; 8usize]; 1usize],
1754}
1755#[test]
1756fn bindgen_test_layout_RTCHit8() {
1757 assert_eq!(
1758 ::std::mem::size_of::<RTCHit8>(),
1759 256usize,
1760 concat!("Size of: ", stringify!(RTCHit8))
1761 );
1762 assert_eq!(
1763 ::std::mem::align_of::<RTCHit8>(),
1764 32usize,
1765 concat!("Alignment of ", stringify!(RTCHit8))
1766 );
1767 assert_eq!(
1768 unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_x as *const _ as usize },
1769 0usize,
1770 concat!(
1771 "Offset of field: ",
1772 stringify!(RTCHit8),
1773 "::",
1774 stringify!(Ng_x)
1775 )
1776 );
1777 assert_eq!(
1778 unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_y as *const _ as usize },
1779 32usize,
1780 concat!(
1781 "Offset of field: ",
1782 stringify!(RTCHit8),
1783 "::",
1784 stringify!(Ng_y)
1785 )
1786 );
1787 assert_eq!(
1788 unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_z as *const _ as usize },
1789 64usize,
1790 concat!(
1791 "Offset of field: ",
1792 stringify!(RTCHit8),
1793 "::",
1794 stringify!(Ng_z)
1795 )
1796 );
1797 assert_eq!(
1798 unsafe { &(*(::std::ptr::null::<RTCHit8>())).u as *const _ as usize },
1799 96usize,
1800 concat!(
1801 "Offset of field: ",
1802 stringify!(RTCHit8),
1803 "::",
1804 stringify!(u)
1805 )
1806 );
1807 assert_eq!(
1808 unsafe { &(*(::std::ptr::null::<RTCHit8>())).v as *const _ as usize },
1809 128usize,
1810 concat!(
1811 "Offset of field: ",
1812 stringify!(RTCHit8),
1813 "::",
1814 stringify!(v)
1815 )
1816 );
1817 assert_eq!(
1818 unsafe { &(*(::std::ptr::null::<RTCHit8>())).primID as *const _ as usize },
1819 160usize,
1820 concat!(
1821 "Offset of field: ",
1822 stringify!(RTCHit8),
1823 "::",
1824 stringify!(primID)
1825 )
1826 );
1827 assert_eq!(
1828 unsafe { &(*(::std::ptr::null::<RTCHit8>())).geomID as *const _ as usize },
1829 192usize,
1830 concat!(
1831 "Offset of field: ",
1832 stringify!(RTCHit8),
1833 "::",
1834 stringify!(geomID)
1835 )
1836 );
1837 assert_eq!(
1838 unsafe { &(*(::std::ptr::null::<RTCHit8>())).instID as *const _ as usize },
1839 224usize,
1840 concat!(
1841 "Offset of field: ",
1842 stringify!(RTCHit8),
1843 "::",
1844 stringify!(instID)
1845 )
1846 );
1847}
1848#[repr(C)]
1849#[repr(align(32))]
1850#[derive(Debug, Copy, Clone)]
1851pub struct RTCRayHit8 {
1852 pub ray: RTCRay8,
1853 pub hit: RTCHit8,
1854}
1855#[test]
1856fn bindgen_test_layout_RTCRayHit8() {
1857 assert_eq!(
1858 ::std::mem::size_of::<RTCRayHit8>(),
1859 640usize,
1860 concat!("Size of: ", stringify!(RTCRayHit8))
1861 );
1862 assert_eq!(
1863 ::std::mem::align_of::<RTCRayHit8>(),
1864 32usize,
1865 concat!("Alignment of ", stringify!(RTCRayHit8))
1866 );
1867 assert_eq!(
1868 unsafe { &(*(::std::ptr::null::<RTCRayHit8>())).ray as *const _ as usize },
1869 0usize,
1870 concat!(
1871 "Offset of field: ",
1872 stringify!(RTCRayHit8),
1873 "::",
1874 stringify!(ray)
1875 )
1876 );
1877 assert_eq!(
1878 unsafe { &(*(::std::ptr::null::<RTCRayHit8>())).hit as *const _ as usize },
1879 384usize,
1880 concat!(
1881 "Offset of field: ",
1882 stringify!(RTCRayHit8),
1883 "::",
1884 stringify!(hit)
1885 )
1886 );
1887}
1888#[repr(C)]
1889#[repr(align(64))]
1890#[derive(Copy, Clone)]
1891pub struct RTCRay16 {
1892 pub org_x: [f32; 16usize],
1893 pub org_y: [f32; 16usize],
1894 pub org_z: [f32; 16usize],
1895 pub tnear: [f32; 16usize],
1896 pub dir_x: [f32; 16usize],
1897 pub dir_y: [f32; 16usize],
1898 pub dir_z: [f32; 16usize],
1899 pub time: [f32; 16usize],
1900 pub tfar: [f32; 16usize],
1901 pub mask: [::std::os::raw::c_uint; 16usize],
1902 pub id: [::std::os::raw::c_uint; 16usize],
1903 pub flags: [::std::os::raw::c_uint; 16usize],
1904}
1905#[test]
1906fn bindgen_test_layout_RTCRay16() {
1907 assert_eq!(
1908 ::std::mem::size_of::<RTCRay16>(),
1909 768usize,
1910 concat!("Size of: ", stringify!(RTCRay16))
1911 );
1912 assert_eq!(
1913 ::std::mem::align_of::<RTCRay16>(),
1914 64usize,
1915 concat!("Alignment of ", stringify!(RTCRay16))
1916 );
1917 assert_eq!(
1918 unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_x as *const _ as usize },
1919 0usize,
1920 concat!(
1921 "Offset of field: ",
1922 stringify!(RTCRay16),
1923 "::",
1924 stringify!(org_x)
1925 )
1926 );
1927 assert_eq!(
1928 unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_y as *const _ as usize },
1929 64usize,
1930 concat!(
1931 "Offset of field: ",
1932 stringify!(RTCRay16),
1933 "::",
1934 stringify!(org_y)
1935 )
1936 );
1937 assert_eq!(
1938 unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_z as *const _ as usize },
1939 128usize,
1940 concat!(
1941 "Offset of field: ",
1942 stringify!(RTCRay16),
1943 "::",
1944 stringify!(org_z)
1945 )
1946 );
1947 assert_eq!(
1948 unsafe { &(*(::std::ptr::null::<RTCRay16>())).tnear as *const _ as usize },
1949 192usize,
1950 concat!(
1951 "Offset of field: ",
1952 stringify!(RTCRay16),
1953 "::",
1954 stringify!(tnear)
1955 )
1956 );
1957 assert_eq!(
1958 unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_x as *const _ as usize },
1959 256usize,
1960 concat!(
1961 "Offset of field: ",
1962 stringify!(RTCRay16),
1963 "::",
1964 stringify!(dir_x)
1965 )
1966 );
1967 assert_eq!(
1968 unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_y as *const _ as usize },
1969 320usize,
1970 concat!(
1971 "Offset of field: ",
1972 stringify!(RTCRay16),
1973 "::",
1974 stringify!(dir_y)
1975 )
1976 );
1977 assert_eq!(
1978 unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_z as *const _ as usize },
1979 384usize,
1980 concat!(
1981 "Offset of field: ",
1982 stringify!(RTCRay16),
1983 "::",
1984 stringify!(dir_z)
1985 )
1986 );
1987 assert_eq!(
1988 unsafe { &(*(::std::ptr::null::<RTCRay16>())).time as *const _ as usize },
1989 448usize,
1990 concat!(
1991 "Offset of field: ",
1992 stringify!(RTCRay16),
1993 "::",
1994 stringify!(time)
1995 )
1996 );
1997 assert_eq!(
1998 unsafe { &(*(::std::ptr::null::<RTCRay16>())).tfar as *const _ as usize },
1999 512usize,
2000 concat!(
2001 "Offset of field: ",
2002 stringify!(RTCRay16),
2003 "::",
2004 stringify!(tfar)
2005 )
2006 );
2007 assert_eq!(
2008 unsafe { &(*(::std::ptr::null::<RTCRay16>())).mask as *const _ as usize },
2009 576usize,
2010 concat!(
2011 "Offset of field: ",
2012 stringify!(RTCRay16),
2013 "::",
2014 stringify!(mask)
2015 )
2016 );
2017 assert_eq!(
2018 unsafe { &(*(::std::ptr::null::<RTCRay16>())).id as *const _ as usize },
2019 640usize,
2020 concat!(
2021 "Offset of field: ",
2022 stringify!(RTCRay16),
2023 "::",
2024 stringify!(id)
2025 )
2026 );
2027 assert_eq!(
2028 unsafe { &(*(::std::ptr::null::<RTCRay16>())).flags as *const _ as usize },
2029 704usize,
2030 concat!(
2031 "Offset of field: ",
2032 stringify!(RTCRay16),
2033 "::",
2034 stringify!(flags)
2035 )
2036 );
2037}
2038#[repr(C)]
2039#[repr(align(64))]
2040#[derive(Copy, Clone)]
2041pub struct RTCHit16 {
2042 pub Ng_x: [f32; 16usize],
2043 pub Ng_y: [f32; 16usize],
2044 pub Ng_z: [f32; 16usize],
2045 pub u: [f32; 16usize],
2046 pub v: [f32; 16usize],
2047 pub primID: [::std::os::raw::c_uint; 16usize],
2048 pub geomID: [::std::os::raw::c_uint; 16usize],
2049 pub instID: [[::std::os::raw::c_uint; 16usize]; 1usize],
2050}
2051#[test]
2052fn bindgen_test_layout_RTCHit16() {
2053 assert_eq!(
2054 ::std::mem::size_of::<RTCHit16>(),
2055 512usize,
2056 concat!("Size of: ", stringify!(RTCHit16))
2057 );
2058 assert_eq!(
2059 ::std::mem::align_of::<RTCHit16>(),
2060 64usize,
2061 concat!("Alignment of ", stringify!(RTCHit16))
2062 );
2063 assert_eq!(
2064 unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_x as *const _ as usize },
2065 0usize,
2066 concat!(
2067 "Offset of field: ",
2068 stringify!(RTCHit16),
2069 "::",
2070 stringify!(Ng_x)
2071 )
2072 );
2073 assert_eq!(
2074 unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_y as *const _ as usize },
2075 64usize,
2076 concat!(
2077 "Offset of field: ",
2078 stringify!(RTCHit16),
2079 "::",
2080 stringify!(Ng_y)
2081 )
2082 );
2083 assert_eq!(
2084 unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_z as *const _ as usize },
2085 128usize,
2086 concat!(
2087 "Offset of field: ",
2088 stringify!(RTCHit16),
2089 "::",
2090 stringify!(Ng_z)
2091 )
2092 );
2093 assert_eq!(
2094 unsafe { &(*(::std::ptr::null::<RTCHit16>())).u as *const _ as usize },
2095 192usize,
2096 concat!(
2097 "Offset of field: ",
2098 stringify!(RTCHit16),
2099 "::",
2100 stringify!(u)
2101 )
2102 );
2103 assert_eq!(
2104 unsafe { &(*(::std::ptr::null::<RTCHit16>())).v as *const _ as usize },
2105 256usize,
2106 concat!(
2107 "Offset of field: ",
2108 stringify!(RTCHit16),
2109 "::",
2110 stringify!(v)
2111 )
2112 );
2113 assert_eq!(
2114 unsafe { &(*(::std::ptr::null::<RTCHit16>())).primID as *const _ as usize },
2115 320usize,
2116 concat!(
2117 "Offset of field: ",
2118 stringify!(RTCHit16),
2119 "::",
2120 stringify!(primID)
2121 )
2122 );
2123 assert_eq!(
2124 unsafe { &(*(::std::ptr::null::<RTCHit16>())).geomID as *const _ as usize },
2125 384usize,
2126 concat!(
2127 "Offset of field: ",
2128 stringify!(RTCHit16),
2129 "::",
2130 stringify!(geomID)
2131 )
2132 );
2133 assert_eq!(
2134 unsafe { &(*(::std::ptr::null::<RTCHit16>())).instID as *const _ as usize },
2135 448usize,
2136 concat!(
2137 "Offset of field: ",
2138 stringify!(RTCHit16),
2139 "::",
2140 stringify!(instID)
2141 )
2142 );
2143}
2144#[repr(C)]
2145#[repr(align(64))]
2146#[derive(Copy, Clone)]
2147pub struct RTCRayHit16 {
2148 pub ray: RTCRay16,
2149 pub hit: RTCHit16,
2150}
2151#[test]
2152fn bindgen_test_layout_RTCRayHit16() {
2153 assert_eq!(
2154 ::std::mem::size_of::<RTCRayHit16>(),
2155 1280usize,
2156 concat!("Size of: ", stringify!(RTCRayHit16))
2157 );
2158 assert_eq!(
2159 ::std::mem::align_of::<RTCRayHit16>(),
2160 64usize,
2161 concat!("Alignment of ", stringify!(RTCRayHit16))
2162 );
2163 assert_eq!(
2164 unsafe { &(*(::std::ptr::null::<RTCRayHit16>())).ray as *const _ as usize },
2165 0usize,
2166 concat!(
2167 "Offset of field: ",
2168 stringify!(RTCRayHit16),
2169 "::",
2170 stringify!(ray)
2171 )
2172 );
2173 assert_eq!(
2174 unsafe { &(*(::std::ptr::null::<RTCRayHit16>())).hit as *const _ as usize },
2175 768usize,
2176 concat!(
2177 "Offset of field: ",
2178 stringify!(RTCRayHit16),
2179 "::",
2180 stringify!(hit)
2181 )
2182 );
2183}
2184#[repr(C)]
2185#[derive(Debug, Copy, Clone)]
2186pub struct RTCRayNp {
2187 pub org_x: *mut f32,
2188 pub org_y: *mut f32,
2189 pub org_z: *mut f32,
2190 pub tnear: *mut f32,
2191 pub dir_x: *mut f32,
2192 pub dir_y: *mut f32,
2193 pub dir_z: *mut f32,
2194 pub time: *mut f32,
2195 pub tfar: *mut f32,
2196 pub mask: *mut ::std::os::raw::c_uint,
2197 pub id: *mut ::std::os::raw::c_uint,
2198 pub flags: *mut ::std::os::raw::c_uint,
2199}
2200#[test]
2201fn bindgen_test_layout_RTCRayNp() {
2202 assert_eq!(
2203 ::std::mem::size_of::<RTCRayNp>(),
2204 96usize,
2205 concat!("Size of: ", stringify!(RTCRayNp))
2206 );
2207 assert_eq!(
2208 ::std::mem::align_of::<RTCRayNp>(),
2209 8usize,
2210 concat!("Alignment of ", stringify!(RTCRayNp))
2211 );
2212 assert_eq!(
2213 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_x as *const _ as usize },
2214 0usize,
2215 concat!(
2216 "Offset of field: ",
2217 stringify!(RTCRayNp),
2218 "::",
2219 stringify!(org_x)
2220 )
2221 );
2222 assert_eq!(
2223 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_y as *const _ as usize },
2224 8usize,
2225 concat!(
2226 "Offset of field: ",
2227 stringify!(RTCRayNp),
2228 "::",
2229 stringify!(org_y)
2230 )
2231 );
2232 assert_eq!(
2233 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_z as *const _ as usize },
2234 16usize,
2235 concat!(
2236 "Offset of field: ",
2237 stringify!(RTCRayNp),
2238 "::",
2239 stringify!(org_z)
2240 )
2241 );
2242 assert_eq!(
2243 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).tnear as *const _ as usize },
2244 24usize,
2245 concat!(
2246 "Offset of field: ",
2247 stringify!(RTCRayNp),
2248 "::",
2249 stringify!(tnear)
2250 )
2251 );
2252 assert_eq!(
2253 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_x as *const _ as usize },
2254 32usize,
2255 concat!(
2256 "Offset of field: ",
2257 stringify!(RTCRayNp),
2258 "::",
2259 stringify!(dir_x)
2260 )
2261 );
2262 assert_eq!(
2263 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_y as *const _ as usize },
2264 40usize,
2265 concat!(
2266 "Offset of field: ",
2267 stringify!(RTCRayNp),
2268 "::",
2269 stringify!(dir_y)
2270 )
2271 );
2272 assert_eq!(
2273 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_z as *const _ as usize },
2274 48usize,
2275 concat!(
2276 "Offset of field: ",
2277 stringify!(RTCRayNp),
2278 "::",
2279 stringify!(dir_z)
2280 )
2281 );
2282 assert_eq!(
2283 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).time as *const _ as usize },
2284 56usize,
2285 concat!(
2286 "Offset of field: ",
2287 stringify!(RTCRayNp),
2288 "::",
2289 stringify!(time)
2290 )
2291 );
2292 assert_eq!(
2293 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).tfar as *const _ as usize },
2294 64usize,
2295 concat!(
2296 "Offset of field: ",
2297 stringify!(RTCRayNp),
2298 "::",
2299 stringify!(tfar)
2300 )
2301 );
2302 assert_eq!(
2303 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).mask as *const _ as usize },
2304 72usize,
2305 concat!(
2306 "Offset of field: ",
2307 stringify!(RTCRayNp),
2308 "::",
2309 stringify!(mask)
2310 )
2311 );
2312 assert_eq!(
2313 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).id as *const _ as usize },
2314 80usize,
2315 concat!(
2316 "Offset of field: ",
2317 stringify!(RTCRayNp),
2318 "::",
2319 stringify!(id)
2320 )
2321 );
2322 assert_eq!(
2323 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).flags as *const _ as usize },
2324 88usize,
2325 concat!(
2326 "Offset of field: ",
2327 stringify!(RTCRayNp),
2328 "::",
2329 stringify!(flags)
2330 )
2331 );
2332}
2333#[repr(C)]
2334#[derive(Debug, Copy, Clone)]
2335pub struct RTCHitNp {
2336 pub Ng_x: *mut f32,
2337 pub Ng_y: *mut f32,
2338 pub Ng_z: *mut f32,
2339 pub u: *mut f32,
2340 pub v: *mut f32,
2341 pub primID: *mut ::std::os::raw::c_uint,
2342 pub geomID: *mut ::std::os::raw::c_uint,
2343 pub instID: [*mut ::std::os::raw::c_uint; 1usize],
2344}
2345#[test]
2346fn bindgen_test_layout_RTCHitNp() {
2347 assert_eq!(
2348 ::std::mem::size_of::<RTCHitNp>(),
2349 64usize,
2350 concat!("Size of: ", stringify!(RTCHitNp))
2351 );
2352 assert_eq!(
2353 ::std::mem::align_of::<RTCHitNp>(),
2354 8usize,
2355 concat!("Alignment of ", stringify!(RTCHitNp))
2356 );
2357 assert_eq!(
2358 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_x as *const _ as usize },
2359 0usize,
2360 concat!(
2361 "Offset of field: ",
2362 stringify!(RTCHitNp),
2363 "::",
2364 stringify!(Ng_x)
2365 )
2366 );
2367 assert_eq!(
2368 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_y as *const _ as usize },
2369 8usize,
2370 concat!(
2371 "Offset of field: ",
2372 stringify!(RTCHitNp),
2373 "::",
2374 stringify!(Ng_y)
2375 )
2376 );
2377 assert_eq!(
2378 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_z as *const _ as usize },
2379 16usize,
2380 concat!(
2381 "Offset of field: ",
2382 stringify!(RTCHitNp),
2383 "::",
2384 stringify!(Ng_z)
2385 )
2386 );
2387 assert_eq!(
2388 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).u as *const _ as usize },
2389 24usize,
2390 concat!(
2391 "Offset of field: ",
2392 stringify!(RTCHitNp),
2393 "::",
2394 stringify!(u)
2395 )
2396 );
2397 assert_eq!(
2398 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).v as *const _ as usize },
2399 32usize,
2400 concat!(
2401 "Offset of field: ",
2402 stringify!(RTCHitNp),
2403 "::",
2404 stringify!(v)
2405 )
2406 );
2407 assert_eq!(
2408 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).primID as *const _ as usize },
2409 40usize,
2410 concat!(
2411 "Offset of field: ",
2412 stringify!(RTCHitNp),
2413 "::",
2414 stringify!(primID)
2415 )
2416 );
2417 assert_eq!(
2418 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).geomID as *const _ as usize },
2419 48usize,
2420 concat!(
2421 "Offset of field: ",
2422 stringify!(RTCHitNp),
2423 "::",
2424 stringify!(geomID)
2425 )
2426 );
2427 assert_eq!(
2428 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).instID as *const _ as usize },
2429 56usize,
2430 concat!(
2431 "Offset of field: ",
2432 stringify!(RTCHitNp),
2433 "::",
2434 stringify!(instID)
2435 )
2436 );
2437}
2438#[repr(C)]
2439#[derive(Debug, Copy, Clone)]
2440pub struct RTCRayHitNp {
2441 pub ray: RTCRayNp,
2442 pub hit: RTCHitNp,
2443}
2444#[test]
2445fn bindgen_test_layout_RTCRayHitNp() {
2446 assert_eq!(
2447 ::std::mem::size_of::<RTCRayHitNp>(),
2448 160usize,
2449 concat!("Size of: ", stringify!(RTCRayHitNp))
2450 );
2451 assert_eq!(
2452 ::std::mem::align_of::<RTCRayHitNp>(),
2453 8usize,
2454 concat!("Alignment of ", stringify!(RTCRayHitNp))
2455 );
2456 assert_eq!(
2457 unsafe { &(*(::std::ptr::null::<RTCRayHitNp>())).ray as *const _ as usize },
2458 0usize,
2459 concat!(
2460 "Offset of field: ",
2461 stringify!(RTCRayHitNp),
2462 "::",
2463 stringify!(ray)
2464 )
2465 );
2466 assert_eq!(
2467 unsafe { &(*(::std::ptr::null::<RTCRayHitNp>())).hit as *const _ as usize },
2468 96usize,
2469 concat!(
2470 "Offset of field: ",
2471 stringify!(RTCRayHitNp),
2472 "::",
2473 stringify!(hit)
2474 )
2475 );
2476}
2477#[repr(C)]
2478#[derive(Debug, Copy, Clone)]
2479pub struct RTCRayN {
2480 _unused: [u8; 0],
2481}
2482#[repr(C)]
2483#[derive(Debug, Copy, Clone)]
2484pub struct RTCHitN {
2485 _unused: [u8; 0],
2486}
2487#[repr(C)]
2488#[derive(Debug, Copy, Clone)]
2489pub struct RTCRayHitN {
2490 _unused: [u8; 0],
2491}
2492#[repr(C)]
2493#[repr(align(16))]
2494#[derive(Debug, Copy, Clone)]
2495pub struct RTCQuaternionDecomposition {
2496 pub scale_x: f32,
2497 pub scale_y: f32,
2498 pub scale_z: f32,
2499 pub skew_xy: f32,
2500 pub skew_xz: f32,
2501 pub skew_yz: f32,
2502 pub shift_x: f32,
2503 pub shift_y: f32,
2504 pub shift_z: f32,
2505 pub quaternion_r: f32,
2506 pub quaternion_i: f32,
2507 pub quaternion_j: f32,
2508 pub quaternion_k: f32,
2509 pub translation_x: f32,
2510 pub translation_y: f32,
2511 pub translation_z: f32,
2512}
2513#[test]
2514fn bindgen_test_layout_RTCQuaternionDecomposition() {
2515 assert_eq!(
2516 ::std::mem::size_of::<RTCQuaternionDecomposition>(),
2517 64usize,
2518 concat!("Size of: ", stringify!(RTCQuaternionDecomposition))
2519 );
2520 assert_eq!(
2521 ::std::mem::align_of::<RTCQuaternionDecomposition>(),
2522 16usize,
2523 concat!("Alignment of ", stringify!(RTCQuaternionDecomposition))
2524 );
2525 assert_eq!(
2526 unsafe {
2527 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).scale_x as *const _ as usize
2528 },
2529 0usize,
2530 concat!(
2531 "Offset of field: ",
2532 stringify!(RTCQuaternionDecomposition),
2533 "::",
2534 stringify!(scale_x)
2535 )
2536 );
2537 assert_eq!(
2538 unsafe {
2539 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).scale_y as *const _ as usize
2540 },
2541 4usize,
2542 concat!(
2543 "Offset of field: ",
2544 stringify!(RTCQuaternionDecomposition),
2545 "::",
2546 stringify!(scale_y)
2547 )
2548 );
2549 assert_eq!(
2550 unsafe {
2551 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).scale_z as *const _ as usize
2552 },
2553 8usize,
2554 concat!(
2555 "Offset of field: ",
2556 stringify!(RTCQuaternionDecomposition),
2557 "::",
2558 stringify!(scale_z)
2559 )
2560 );
2561 assert_eq!(
2562 unsafe {
2563 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).skew_xy as *const _ as usize
2564 },
2565 12usize,
2566 concat!(
2567 "Offset of field: ",
2568 stringify!(RTCQuaternionDecomposition),
2569 "::",
2570 stringify!(skew_xy)
2571 )
2572 );
2573 assert_eq!(
2574 unsafe {
2575 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).skew_xz as *const _ as usize
2576 },
2577 16usize,
2578 concat!(
2579 "Offset of field: ",
2580 stringify!(RTCQuaternionDecomposition),
2581 "::",
2582 stringify!(skew_xz)
2583 )
2584 );
2585 assert_eq!(
2586 unsafe {
2587 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).skew_yz as *const _ as usize
2588 },
2589 20usize,
2590 concat!(
2591 "Offset of field: ",
2592 stringify!(RTCQuaternionDecomposition),
2593 "::",
2594 stringify!(skew_yz)
2595 )
2596 );
2597 assert_eq!(
2598 unsafe {
2599 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).shift_x as *const _ as usize
2600 },
2601 24usize,
2602 concat!(
2603 "Offset of field: ",
2604 stringify!(RTCQuaternionDecomposition),
2605 "::",
2606 stringify!(shift_x)
2607 )
2608 );
2609 assert_eq!(
2610 unsafe {
2611 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).shift_y as *const _ as usize
2612 },
2613 28usize,
2614 concat!(
2615 "Offset of field: ",
2616 stringify!(RTCQuaternionDecomposition),
2617 "::",
2618 stringify!(shift_y)
2619 )
2620 );
2621 assert_eq!(
2622 unsafe {
2623 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).shift_z as *const _ as usize
2624 },
2625 32usize,
2626 concat!(
2627 "Offset of field: ",
2628 stringify!(RTCQuaternionDecomposition),
2629 "::",
2630 stringify!(shift_z)
2631 )
2632 );
2633 assert_eq!(
2634 unsafe {
2635 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).quaternion_r as *const _ as usize
2636 },
2637 36usize,
2638 concat!(
2639 "Offset of field: ",
2640 stringify!(RTCQuaternionDecomposition),
2641 "::",
2642 stringify!(quaternion_r)
2643 )
2644 );
2645 assert_eq!(
2646 unsafe {
2647 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).quaternion_i as *const _ as usize
2648 },
2649 40usize,
2650 concat!(
2651 "Offset of field: ",
2652 stringify!(RTCQuaternionDecomposition),
2653 "::",
2654 stringify!(quaternion_i)
2655 )
2656 );
2657 assert_eq!(
2658 unsafe {
2659 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).quaternion_j as *const _ as usize
2660 },
2661 44usize,
2662 concat!(
2663 "Offset of field: ",
2664 stringify!(RTCQuaternionDecomposition),
2665 "::",
2666 stringify!(quaternion_j)
2667 )
2668 );
2669 assert_eq!(
2670 unsafe {
2671 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).quaternion_k as *const _ as usize
2672 },
2673 48usize,
2674 concat!(
2675 "Offset of field: ",
2676 stringify!(RTCQuaternionDecomposition),
2677 "::",
2678 stringify!(quaternion_k)
2679 )
2680 );
2681 assert_eq!(
2682 unsafe {
2683 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).translation_x as *const _
2684 as usize
2685 },
2686 52usize,
2687 concat!(
2688 "Offset of field: ",
2689 stringify!(RTCQuaternionDecomposition),
2690 "::",
2691 stringify!(translation_x)
2692 )
2693 );
2694 assert_eq!(
2695 unsafe {
2696 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).translation_y as *const _
2697 as usize
2698 },
2699 56usize,
2700 concat!(
2701 "Offset of field: ",
2702 stringify!(RTCQuaternionDecomposition),
2703 "::",
2704 stringify!(translation_y)
2705 )
2706 );
2707 assert_eq!(
2708 unsafe {
2709 &(*(::std::ptr::null::<RTCQuaternionDecomposition>())).translation_z as *const _
2710 as usize
2711 },
2712 60usize,
2713 concat!(
2714 "Offset of field: ",
2715 stringify!(RTCQuaternionDecomposition),
2716 "::",
2717 stringify!(translation_z)
2718 )
2719 );
2720}
2721#[repr(C)]
2722#[derive(Debug, Copy, Clone)]
2723pub struct RTCSceneTy {
2724 _unused: [u8; 0],
2725}
2726pub type RTCScene = *mut RTCSceneTy;
2727#[repr(C)]
2728#[derive(Debug, Copy, Clone)]
2729pub struct RTCGeometryTy {
2730 _unused: [u8; 0],
2731}
2732pub type RTCGeometry = *mut RTCGeometryTy;
2733#[repr(u32)]
2734#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2735pub enum RTCGeometryType {
2736 TRIANGLE = 0,
2737 QUAD = 1,
2738 GRID = 2,
2739 SUBDIVISION = 8,
2740 CONE_LINEAR_CURVE = 15,
2741 ROUND_LINEAR_CURVE = 16,
2742 FLAT_LINEAR_CURVE = 17,
2743 ROUND_BEZIER_CURVE = 24,
2744 FLAT_BEZIER_CURVE = 25,
2745 NORMAL_ORIENTED_BEZIER_CURVE = 26,
2746 ROUND_BSPLINE_CURVE = 32,
2747 FLAT_BSPLINE_CURVE = 33,
2748 NORMAL_ORIENTED_BSPLINE_CURVE = 34,
2749 ROUND_HERMITE_CURVE = 40,
2750 FLAT_HERMITE_CURVE = 41,
2751 NORMAL_ORIENTED_HERMITE_CURVE = 42,
2752 SPHERE_POINT = 50,
2753 DISC_POINT = 51,
2754 ORIENTED_DISC_POINT = 52,
2755 ROUND_CATMULL_ROM_CURVE = 58,
2756 FLAT_CATMULL_ROM_CURVE = 59,
2757 NORMAL_ORIENTED_CATMULL_ROM_CURVE = 60,
2758 USER = 120,
2759 INSTANCE = 121,
2760}
2761#[repr(u32)]
2762#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2763pub enum RTCSubdivisionMode {
2764 NO_BOUNDARY = 0,
2765 SMOOTH_BOUNDARY = 1,
2766 PIN_CORNERS = 2,
2767 PIN_BOUNDARY = 3,
2768 PIN_ALL = 4,
2769}
2770impl RTCCurveFlags {
2771 pub const NEIGHBOR_LEFT: RTCCurveFlags = RTCCurveFlags(1);
2772}
2773impl RTCCurveFlags {
2774 pub const NEIGHBOR_RIGHT: RTCCurveFlags = RTCCurveFlags(2);
2775}
2776impl ::std::ops::BitOr<RTCCurveFlags> for RTCCurveFlags {
2777 type Output = Self;
2778 #[inline]
2779 fn bitor(self, other: Self) -> Self {
2780 RTCCurveFlags(self.0 | other.0)
2781 }
2782}
2783impl ::std::ops::BitOrAssign for RTCCurveFlags {
2784 #[inline]
2785 fn bitor_assign(&mut self, rhs: RTCCurveFlags) {
2786 self.0 |= rhs.0;
2787 }
2788}
2789impl ::std::ops::BitAnd<RTCCurveFlags> for RTCCurveFlags {
2790 type Output = Self;
2791 #[inline]
2792 fn bitand(self, other: Self) -> Self {
2793 RTCCurveFlags(self.0 & other.0)
2794 }
2795}
2796impl ::std::ops::BitAndAssign for RTCCurveFlags {
2797 #[inline]
2798 fn bitand_assign(&mut self, rhs: RTCCurveFlags) {
2799 self.0 &= rhs.0;
2800 }
2801}
2802#[repr(transparent)]
2803#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2804pub struct RTCCurveFlags(pub ::std::os::raw::c_uint);
2805#[repr(C)]
2806#[derive(Debug, Copy, Clone)]
2807pub struct RTCBoundsFunctionArguments {
2808 pub geometryUserPtr: *mut ::std::os::raw::c_void,
2809 pub primID: ::std::os::raw::c_uint,
2810 pub timeStep: ::std::os::raw::c_uint,
2811 pub bounds_o: *mut RTCBounds,
2812}
2813#[test]
2814fn bindgen_test_layout_RTCBoundsFunctionArguments() {
2815 assert_eq!(
2816 ::std::mem::size_of::<RTCBoundsFunctionArguments>(),
2817 24usize,
2818 concat!("Size of: ", stringify!(RTCBoundsFunctionArguments))
2819 );
2820 assert_eq!(
2821 ::std::mem::align_of::<RTCBoundsFunctionArguments>(),
2822 8usize,
2823 concat!("Alignment of ", stringify!(RTCBoundsFunctionArguments))
2824 );
2825 assert_eq!(
2826 unsafe {
2827 &(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).geometryUserPtr as *const _
2828 as usize
2829 },
2830 0usize,
2831 concat!(
2832 "Offset of field: ",
2833 stringify!(RTCBoundsFunctionArguments),
2834 "::",
2835 stringify!(geometryUserPtr)
2836 )
2837 );
2838 assert_eq!(
2839 unsafe {
2840 &(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).primID as *const _ as usize
2841 },
2842 8usize,
2843 concat!(
2844 "Offset of field: ",
2845 stringify!(RTCBoundsFunctionArguments),
2846 "::",
2847 stringify!(primID)
2848 )
2849 );
2850 assert_eq!(
2851 unsafe {
2852 &(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).timeStep as *const _ as usize
2853 },
2854 12usize,
2855 concat!(
2856 "Offset of field: ",
2857 stringify!(RTCBoundsFunctionArguments),
2858 "::",
2859 stringify!(timeStep)
2860 )
2861 );
2862 assert_eq!(
2863 unsafe {
2864 &(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).bounds_o as *const _ as usize
2865 },
2866 16usize,
2867 concat!(
2868 "Offset of field: ",
2869 stringify!(RTCBoundsFunctionArguments),
2870 "::",
2871 stringify!(bounds_o)
2872 )
2873 );
2874}
2875pub type RTCBoundsFunction =
2876 ::std::option::Option<unsafe extern "C" fn(args: *const RTCBoundsFunctionArguments)>;
2877#[repr(C)]
2878#[derive(Debug, Copy, Clone)]
2879pub struct RTCIntersectFunctionNArguments {
2880 pub valid: *mut ::std::os::raw::c_int,
2881 pub geometryUserPtr: *mut ::std::os::raw::c_void,
2882 pub primID: ::std::os::raw::c_uint,
2883 pub context: *mut RTCIntersectContext,
2884 pub rayhit: *mut RTCRayHitN,
2885 pub N: ::std::os::raw::c_uint,
2886 pub geomID: ::std::os::raw::c_uint,
2887}
2888#[test]
2889fn bindgen_test_layout_RTCIntersectFunctionNArguments() {
2890 assert_eq!(
2891 ::std::mem::size_of::<RTCIntersectFunctionNArguments>(),
2892 48usize,
2893 concat!("Size of: ", stringify!(RTCIntersectFunctionNArguments))
2894 );
2895 assert_eq!(
2896 ::std::mem::align_of::<RTCIntersectFunctionNArguments>(),
2897 8usize,
2898 concat!("Alignment of ", stringify!(RTCIntersectFunctionNArguments))
2899 );
2900 assert_eq!(
2901 unsafe {
2902 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).valid as *const _ as usize
2903 },
2904 0usize,
2905 concat!(
2906 "Offset of field: ",
2907 stringify!(RTCIntersectFunctionNArguments),
2908 "::",
2909 stringify!(valid)
2910 )
2911 );
2912 assert_eq!(
2913 unsafe {
2914 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).geometryUserPtr as *const _
2915 as usize
2916 },
2917 8usize,
2918 concat!(
2919 "Offset of field: ",
2920 stringify!(RTCIntersectFunctionNArguments),
2921 "::",
2922 stringify!(geometryUserPtr)
2923 )
2924 );
2925 assert_eq!(
2926 unsafe {
2927 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).primID as *const _ as usize
2928 },
2929 16usize,
2930 concat!(
2931 "Offset of field: ",
2932 stringify!(RTCIntersectFunctionNArguments),
2933 "::",
2934 stringify!(primID)
2935 )
2936 );
2937 assert_eq!(
2938 unsafe {
2939 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).context as *const _ as usize
2940 },
2941 24usize,
2942 concat!(
2943 "Offset of field: ",
2944 stringify!(RTCIntersectFunctionNArguments),
2945 "::",
2946 stringify!(context)
2947 )
2948 );
2949 assert_eq!(
2950 unsafe {
2951 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).rayhit as *const _ as usize
2952 },
2953 32usize,
2954 concat!(
2955 "Offset of field: ",
2956 stringify!(RTCIntersectFunctionNArguments),
2957 "::",
2958 stringify!(rayhit)
2959 )
2960 );
2961 assert_eq!(
2962 unsafe {
2963 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).N as *const _ as usize
2964 },
2965 40usize,
2966 concat!(
2967 "Offset of field: ",
2968 stringify!(RTCIntersectFunctionNArguments),
2969 "::",
2970 stringify!(N)
2971 )
2972 );
2973 assert_eq!(
2974 unsafe {
2975 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).geomID as *const _ as usize
2976 },
2977 44usize,
2978 concat!(
2979 "Offset of field: ",
2980 stringify!(RTCIntersectFunctionNArguments),
2981 "::",
2982 stringify!(geomID)
2983 )
2984 );
2985}
2986pub type RTCIntersectFunctionN =
2987 ::std::option::Option<unsafe extern "C" fn(args: *const RTCIntersectFunctionNArguments)>;
2988#[repr(C)]
2989#[derive(Debug, Copy, Clone)]
2990pub struct RTCOccludedFunctionNArguments {
2991 pub valid: *mut ::std::os::raw::c_int,
2992 pub geometryUserPtr: *mut ::std::os::raw::c_void,
2993 pub primID: ::std::os::raw::c_uint,
2994 pub context: *mut RTCIntersectContext,
2995 pub ray: *mut RTCRayN,
2996 pub N: ::std::os::raw::c_uint,
2997 pub geomID: ::std::os::raw::c_uint,
2998}
2999#[test]
3000fn bindgen_test_layout_RTCOccludedFunctionNArguments() {
3001 assert_eq!(
3002 ::std::mem::size_of::<RTCOccludedFunctionNArguments>(),
3003 48usize,
3004 concat!("Size of: ", stringify!(RTCOccludedFunctionNArguments))
3005 );
3006 assert_eq!(
3007 ::std::mem::align_of::<RTCOccludedFunctionNArguments>(),
3008 8usize,
3009 concat!("Alignment of ", stringify!(RTCOccludedFunctionNArguments))
3010 );
3011 assert_eq!(
3012 unsafe {
3013 &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).valid as *const _ as usize
3014 },
3015 0usize,
3016 concat!(
3017 "Offset of field: ",
3018 stringify!(RTCOccludedFunctionNArguments),
3019 "::",
3020 stringify!(valid)
3021 )
3022 );
3023 assert_eq!(
3024 unsafe {
3025 &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).geometryUserPtr as *const _
3026 as usize
3027 },
3028 8usize,
3029 concat!(
3030 "Offset of field: ",
3031 stringify!(RTCOccludedFunctionNArguments),
3032 "::",
3033 stringify!(geometryUserPtr)
3034 )
3035 );
3036 assert_eq!(
3037 unsafe {
3038 &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).primID as *const _ as usize
3039 },
3040 16usize,
3041 concat!(
3042 "Offset of field: ",
3043 stringify!(RTCOccludedFunctionNArguments),
3044 "::",
3045 stringify!(primID)
3046 )
3047 );
3048 assert_eq!(
3049 unsafe {
3050 &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).context as *const _ as usize
3051 },
3052 24usize,
3053 concat!(
3054 "Offset of field: ",
3055 stringify!(RTCOccludedFunctionNArguments),
3056 "::",
3057 stringify!(context)
3058 )
3059 );
3060 assert_eq!(
3061 unsafe {
3062 &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).ray as *const _ as usize
3063 },
3064 32usize,
3065 concat!(
3066 "Offset of field: ",
3067 stringify!(RTCOccludedFunctionNArguments),
3068 "::",
3069 stringify!(ray)
3070 )
3071 );
3072 assert_eq!(
3073 unsafe { &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).N as *const _ as usize },
3074 40usize,
3075 concat!(
3076 "Offset of field: ",
3077 stringify!(RTCOccludedFunctionNArguments),
3078 "::",
3079 stringify!(N)
3080 )
3081 );
3082 assert_eq!(
3083 unsafe {
3084 &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).geomID as *const _ as usize
3085 },
3086 44usize,
3087 concat!(
3088 "Offset of field: ",
3089 stringify!(RTCOccludedFunctionNArguments),
3090 "::",
3091 stringify!(geomID)
3092 )
3093 );
3094}
3095pub type RTCOccludedFunctionN =
3096 ::std::option::Option<unsafe extern "C" fn(args: *const RTCOccludedFunctionNArguments)>;
3097#[repr(C)]
3098#[derive(Debug, Copy, Clone)]
3099pub struct RTCDisplacementFunctionNArguments {
3100 pub geometryUserPtr: *mut ::std::os::raw::c_void,
3101 pub geometry: RTCGeometry,
3102 pub primID: ::std::os::raw::c_uint,
3103 pub timeStep: ::std::os::raw::c_uint,
3104 pub u: *const f32,
3105 pub v: *const f32,
3106 pub Ng_x: *const f32,
3107 pub Ng_y: *const f32,
3108 pub Ng_z: *const f32,
3109 pub P_x: *mut f32,
3110 pub P_y: *mut f32,
3111 pub P_z: *mut f32,
3112 pub N: ::std::os::raw::c_uint,
3113}
3114#[test]
3115fn bindgen_test_layout_RTCDisplacementFunctionNArguments() {
3116 assert_eq!(
3117 ::std::mem::size_of::<RTCDisplacementFunctionNArguments>(),
3118 96usize,
3119 concat!("Size of: ", stringify!(RTCDisplacementFunctionNArguments))
3120 );
3121 assert_eq!(
3122 ::std::mem::align_of::<RTCDisplacementFunctionNArguments>(),
3123 8usize,
3124 concat!(
3125 "Alignment of ",
3126 stringify!(RTCDisplacementFunctionNArguments)
3127 )
3128 );
3129 assert_eq!(
3130 unsafe {
3131 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).geometryUserPtr
3132 as *const _ as usize
3133 },
3134 0usize,
3135 concat!(
3136 "Offset of field: ",
3137 stringify!(RTCDisplacementFunctionNArguments),
3138 "::",
3139 stringify!(geometryUserPtr)
3140 )
3141 );
3142 assert_eq!(
3143 unsafe {
3144 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).geometry as *const _
3145 as usize
3146 },
3147 8usize,
3148 concat!(
3149 "Offset of field: ",
3150 stringify!(RTCDisplacementFunctionNArguments),
3151 "::",
3152 stringify!(geometry)
3153 )
3154 );
3155 assert_eq!(
3156 unsafe {
3157 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).primID as *const _
3158 as usize
3159 },
3160 16usize,
3161 concat!(
3162 "Offset of field: ",
3163 stringify!(RTCDisplacementFunctionNArguments),
3164 "::",
3165 stringify!(primID)
3166 )
3167 );
3168 assert_eq!(
3169 unsafe {
3170 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).timeStep as *const _
3171 as usize
3172 },
3173 20usize,
3174 concat!(
3175 "Offset of field: ",
3176 stringify!(RTCDisplacementFunctionNArguments),
3177 "::",
3178 stringify!(timeStep)
3179 )
3180 );
3181 assert_eq!(
3182 unsafe {
3183 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).u as *const _ as usize
3184 },
3185 24usize,
3186 concat!(
3187 "Offset of field: ",
3188 stringify!(RTCDisplacementFunctionNArguments),
3189 "::",
3190 stringify!(u)
3191 )
3192 );
3193 assert_eq!(
3194 unsafe {
3195 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).v as *const _ as usize
3196 },
3197 32usize,
3198 concat!(
3199 "Offset of field: ",
3200 stringify!(RTCDisplacementFunctionNArguments),
3201 "::",
3202 stringify!(v)
3203 )
3204 );
3205 assert_eq!(
3206 unsafe {
3207 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_x as *const _ as usize
3208 },
3209 40usize,
3210 concat!(
3211 "Offset of field: ",
3212 stringify!(RTCDisplacementFunctionNArguments),
3213 "::",
3214 stringify!(Ng_x)
3215 )
3216 );
3217 assert_eq!(
3218 unsafe {
3219 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_y as *const _ as usize
3220 },
3221 48usize,
3222 concat!(
3223 "Offset of field: ",
3224 stringify!(RTCDisplacementFunctionNArguments),
3225 "::",
3226 stringify!(Ng_y)
3227 )
3228 );
3229 assert_eq!(
3230 unsafe {
3231 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_z as *const _ as usize
3232 },
3233 56usize,
3234 concat!(
3235 "Offset of field: ",
3236 stringify!(RTCDisplacementFunctionNArguments),
3237 "::",
3238 stringify!(Ng_z)
3239 )
3240 );
3241 assert_eq!(
3242 unsafe {
3243 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_x as *const _ as usize
3244 },
3245 64usize,
3246 concat!(
3247 "Offset of field: ",
3248 stringify!(RTCDisplacementFunctionNArguments),
3249 "::",
3250 stringify!(P_x)
3251 )
3252 );
3253 assert_eq!(
3254 unsafe {
3255 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_y as *const _ as usize
3256 },
3257 72usize,
3258 concat!(
3259 "Offset of field: ",
3260 stringify!(RTCDisplacementFunctionNArguments),
3261 "::",
3262 stringify!(P_y)
3263 )
3264 );
3265 assert_eq!(
3266 unsafe {
3267 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_z as *const _ as usize
3268 },
3269 80usize,
3270 concat!(
3271 "Offset of field: ",
3272 stringify!(RTCDisplacementFunctionNArguments),
3273 "::",
3274 stringify!(P_z)
3275 )
3276 );
3277 assert_eq!(
3278 unsafe {
3279 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).N as *const _ as usize
3280 },
3281 88usize,
3282 concat!(
3283 "Offset of field: ",
3284 stringify!(RTCDisplacementFunctionNArguments),
3285 "::",
3286 stringify!(N)
3287 )
3288 );
3289}
3290pub type RTCDisplacementFunctionN =
3291 ::std::option::Option<unsafe extern "C" fn(args: *const RTCDisplacementFunctionNArguments)>;
3292extern "C" {
3293 pub fn rtcNewGeometry(device: RTCDevice, type_: RTCGeometryType) -> RTCGeometry;
3294}
3295extern "C" {
3296 pub fn rtcRetainGeometry(geometry: RTCGeometry);
3297}
3298extern "C" {
3299 pub fn rtcReleaseGeometry(geometry: RTCGeometry);
3300}
3301extern "C" {
3302 pub fn rtcCommitGeometry(geometry: RTCGeometry);
3303}
3304extern "C" {
3305 pub fn rtcEnableGeometry(geometry: RTCGeometry);
3306}
3307extern "C" {
3308 pub fn rtcDisableGeometry(geometry: RTCGeometry);
3309}
3310extern "C" {
3311 pub fn rtcSetGeometryTimeStepCount(
3312 geometry: RTCGeometry,
3313 timeStepCount: ::std::os::raw::c_uint,
3314 );
3315}
3316extern "C" {
3317 pub fn rtcSetGeometryTimeRange(geometry: RTCGeometry, startTime: f32, endTime: f32);
3318}
3319extern "C" {
3320 pub fn rtcSetGeometryVertexAttributeCount(
3321 geometry: RTCGeometry,
3322 vertexAttributeCount: ::std::os::raw::c_uint,
3323 );
3324}
3325extern "C" {
3326 pub fn rtcSetGeometryMask(geometry: RTCGeometry, mask: ::std::os::raw::c_uint);
3327}
3328extern "C" {
3329 pub fn rtcSetGeometryBuildQuality(geometry: RTCGeometry, quality: RTCBuildQuality);
3330}
3331extern "C" {
3332 pub fn rtcSetGeometryMaxRadiusScale(geometry: RTCGeometry, maxRadiusScale: f32);
3333}
3334extern "C" {
3335 pub fn rtcSetGeometryBuffer(
3336 geometry: RTCGeometry,
3337 type_: RTCBufferType,
3338 slot: ::std::os::raw::c_uint,
3339 format: RTCFormat,
3340 buffer: RTCBuffer,
3341 byteOffset: size_t,
3342 byteStride: size_t,
3343 itemCount: size_t,
3344 );
3345}
3346extern "C" {
3347 pub fn rtcSetSharedGeometryBuffer(
3348 geometry: RTCGeometry,
3349 type_: RTCBufferType,
3350 slot: ::std::os::raw::c_uint,
3351 format: RTCFormat,
3352 ptr: *const ::std::os::raw::c_void,
3353 byteOffset: size_t,
3354 byteStride: size_t,
3355 itemCount: size_t,
3356 );
3357}
3358extern "C" {
3359 pub fn rtcSetNewGeometryBuffer(
3360 geometry: RTCGeometry,
3361 type_: RTCBufferType,
3362 slot: ::std::os::raw::c_uint,
3363 format: RTCFormat,
3364 byteStride: size_t,
3365 itemCount: size_t,
3366 ) -> *mut ::std::os::raw::c_void;
3367}
3368extern "C" {
3369 pub fn rtcGetGeometryBufferData(
3370 geometry: RTCGeometry,
3371 type_: RTCBufferType,
3372 slot: ::std::os::raw::c_uint,
3373 ) -> *mut ::std::os::raw::c_void;
3374}
3375extern "C" {
3376 pub fn rtcUpdateGeometryBuffer(
3377 geometry: RTCGeometry,
3378 type_: RTCBufferType,
3379 slot: ::std::os::raw::c_uint,
3380 );
3381}
3382extern "C" {
3383 pub fn rtcSetGeometryIntersectFilterFunction(geometry: RTCGeometry, filter: RTCFilterFunctionN);
3384}
3385extern "C" {
3386 pub fn rtcSetGeometryOccludedFilterFunction(geometry: RTCGeometry, filter: RTCFilterFunctionN);
3387}
3388extern "C" {
3389 pub fn rtcSetGeometryUserData(geometry: RTCGeometry, ptr: *mut ::std::os::raw::c_void);
3390}
3391extern "C" {
3392 pub fn rtcGetGeometryUserData(geometry: RTCGeometry) -> *mut ::std::os::raw::c_void;
3393}
3394extern "C" {
3395 pub fn rtcSetGeometryPointQueryFunction(
3396 geometry: RTCGeometry,
3397 pointQuery: RTCPointQueryFunction,
3398 );
3399}
3400extern "C" {
3401 pub fn rtcSetGeometryUserPrimitiveCount(
3402 geometry: RTCGeometry,
3403 userPrimitiveCount: ::std::os::raw::c_uint,
3404 );
3405}
3406extern "C" {
3407 pub fn rtcSetGeometryBoundsFunction(
3408 geometry: RTCGeometry,
3409 bounds: RTCBoundsFunction,
3410 userPtr: *mut ::std::os::raw::c_void,
3411 );
3412}
3413extern "C" {
3414 pub fn rtcSetGeometryIntersectFunction(geometry: RTCGeometry, intersect: RTCIntersectFunctionN);
3415}
3416extern "C" {
3417 pub fn rtcSetGeometryOccludedFunction(geometry: RTCGeometry, occluded: RTCOccludedFunctionN);
3418}
3419extern "C" {
3420 pub fn rtcFilterIntersection(
3421 args: *const RTCIntersectFunctionNArguments,
3422 filterArgs: *const RTCFilterFunctionNArguments,
3423 );
3424}
3425extern "C" {
3426 pub fn rtcFilterOcclusion(
3427 args: *const RTCOccludedFunctionNArguments,
3428 filterArgs: *const RTCFilterFunctionNArguments,
3429 );
3430}
3431extern "C" {
3432 pub fn rtcSetGeometryInstancedScene(geometry: RTCGeometry, scene: RTCScene);
3433}
3434extern "C" {
3435 pub fn rtcSetGeometryTransform(
3436 geometry: RTCGeometry,
3437 timeStep: ::std::os::raw::c_uint,
3438 format: RTCFormat,
3439 xfm: *const ::std::os::raw::c_void,
3440 );
3441}
3442extern "C" {
3443 pub fn rtcSetGeometryTransformQuaternion(
3444 geometry: RTCGeometry,
3445 timeStep: ::std::os::raw::c_uint,
3446 qd: *const RTCQuaternionDecomposition,
3447 );
3448}
3449extern "C" {
3450 pub fn rtcGetGeometryTransform(
3451 geometry: RTCGeometry,
3452 time: f32,
3453 format: RTCFormat,
3454 xfm: *mut ::std::os::raw::c_void,
3455 );
3456}
3457extern "C" {
3458 pub fn rtcSetGeometryTessellationRate(geometry: RTCGeometry, tessellationRate: f32);
3459}
3460extern "C" {
3461 pub fn rtcSetGeometryTopologyCount(
3462 geometry: RTCGeometry,
3463 topologyCount: ::std::os::raw::c_uint,
3464 );
3465}
3466extern "C" {
3467 pub fn rtcSetGeometrySubdivisionMode(
3468 geometry: RTCGeometry,
3469 topologyID: ::std::os::raw::c_uint,
3470 mode: RTCSubdivisionMode,
3471 );
3472}
3473extern "C" {
3474 pub fn rtcSetGeometryVertexAttributeTopology(
3475 geometry: RTCGeometry,
3476 vertexAttributeID: ::std::os::raw::c_uint,
3477 topologyID: ::std::os::raw::c_uint,
3478 );
3479}
3480extern "C" {
3481 pub fn rtcSetGeometryDisplacementFunction(
3482 geometry: RTCGeometry,
3483 displacement: RTCDisplacementFunctionN,
3484 );
3485}
3486extern "C" {
3487 pub fn rtcGetGeometryFirstHalfEdge(
3488 geometry: RTCGeometry,
3489 faceID: ::std::os::raw::c_uint,
3490 ) -> ::std::os::raw::c_uint;
3491}
3492extern "C" {
3493 pub fn rtcGetGeometryFace(
3494 geometry: RTCGeometry,
3495 edgeID: ::std::os::raw::c_uint,
3496 ) -> ::std::os::raw::c_uint;
3497}
3498extern "C" {
3499 pub fn rtcGetGeometryNextHalfEdge(
3500 geometry: RTCGeometry,
3501 edgeID: ::std::os::raw::c_uint,
3502 ) -> ::std::os::raw::c_uint;
3503}
3504extern "C" {
3505 pub fn rtcGetGeometryPreviousHalfEdge(
3506 geometry: RTCGeometry,
3507 edgeID: ::std::os::raw::c_uint,
3508 ) -> ::std::os::raw::c_uint;
3509}
3510extern "C" {
3511 pub fn rtcGetGeometryOppositeHalfEdge(
3512 geometry: RTCGeometry,
3513 topologyID: ::std::os::raw::c_uint,
3514 edgeID: ::std::os::raw::c_uint,
3515 ) -> ::std::os::raw::c_uint;
3516}
3517#[repr(C)]
3518#[derive(Debug, Copy, Clone)]
3519pub struct RTCInterpolateArguments {
3520 pub geometry: RTCGeometry,
3521 pub primID: ::std::os::raw::c_uint,
3522 pub u: f32,
3523 pub v: f32,
3524 pub bufferType: RTCBufferType,
3525 pub bufferSlot: ::std::os::raw::c_uint,
3526 pub P: *mut f32,
3527 pub dPdu: *mut f32,
3528 pub dPdv: *mut f32,
3529 pub ddPdudu: *mut f32,
3530 pub ddPdvdv: *mut f32,
3531 pub ddPdudv: *mut f32,
3532 pub valueCount: ::std::os::raw::c_uint,
3533}
3534#[test]
3535fn bindgen_test_layout_RTCInterpolateArguments() {
3536 assert_eq!(
3537 ::std::mem::size_of::<RTCInterpolateArguments>(),
3538 88usize,
3539 concat!("Size of: ", stringify!(RTCInterpolateArguments))
3540 );
3541 assert_eq!(
3542 ::std::mem::align_of::<RTCInterpolateArguments>(),
3543 8usize,
3544 concat!("Alignment of ", stringify!(RTCInterpolateArguments))
3545 );
3546 assert_eq!(
3547 unsafe {
3548 &(*(::std::ptr::null::<RTCInterpolateArguments>())).geometry as *const _ as usize
3549 },
3550 0usize,
3551 concat!(
3552 "Offset of field: ",
3553 stringify!(RTCInterpolateArguments),
3554 "::",
3555 stringify!(geometry)
3556 )
3557 );
3558 assert_eq!(
3559 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).primID as *const _ as usize },
3560 8usize,
3561 concat!(
3562 "Offset of field: ",
3563 stringify!(RTCInterpolateArguments),
3564 "::",
3565 stringify!(primID)
3566 )
3567 );
3568 assert_eq!(
3569 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).u as *const _ as usize },
3570 12usize,
3571 concat!(
3572 "Offset of field: ",
3573 stringify!(RTCInterpolateArguments),
3574 "::",
3575 stringify!(u)
3576 )
3577 );
3578 assert_eq!(
3579 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).v as *const _ as usize },
3580 16usize,
3581 concat!(
3582 "Offset of field: ",
3583 stringify!(RTCInterpolateArguments),
3584 "::",
3585 stringify!(v)
3586 )
3587 );
3588 assert_eq!(
3589 unsafe {
3590 &(*(::std::ptr::null::<RTCInterpolateArguments>())).bufferType as *const _ as usize
3591 },
3592 20usize,
3593 concat!(
3594 "Offset of field: ",
3595 stringify!(RTCInterpolateArguments),
3596 "::",
3597 stringify!(bufferType)
3598 )
3599 );
3600 assert_eq!(
3601 unsafe {
3602 &(*(::std::ptr::null::<RTCInterpolateArguments>())).bufferSlot as *const _ as usize
3603 },
3604 24usize,
3605 concat!(
3606 "Offset of field: ",
3607 stringify!(RTCInterpolateArguments),
3608 "::",
3609 stringify!(bufferSlot)
3610 )
3611 );
3612 assert_eq!(
3613 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).P as *const _ as usize },
3614 32usize,
3615 concat!(
3616 "Offset of field: ",
3617 stringify!(RTCInterpolateArguments),
3618 "::",
3619 stringify!(P)
3620 )
3621 );
3622 assert_eq!(
3623 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).dPdu as *const _ as usize },
3624 40usize,
3625 concat!(
3626 "Offset of field: ",
3627 stringify!(RTCInterpolateArguments),
3628 "::",
3629 stringify!(dPdu)
3630 )
3631 );
3632 assert_eq!(
3633 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).dPdv as *const _ as usize },
3634 48usize,
3635 concat!(
3636 "Offset of field: ",
3637 stringify!(RTCInterpolateArguments),
3638 "::",
3639 stringify!(dPdv)
3640 )
3641 );
3642 assert_eq!(
3643 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdudu as *const _ as usize },
3644 56usize,
3645 concat!(
3646 "Offset of field: ",
3647 stringify!(RTCInterpolateArguments),
3648 "::",
3649 stringify!(ddPdudu)
3650 )
3651 );
3652 assert_eq!(
3653 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdvdv as *const _ as usize },
3654 64usize,
3655 concat!(
3656 "Offset of field: ",
3657 stringify!(RTCInterpolateArguments),
3658 "::",
3659 stringify!(ddPdvdv)
3660 )
3661 );
3662 assert_eq!(
3663 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdudv as *const _ as usize },
3664 72usize,
3665 concat!(
3666 "Offset of field: ",
3667 stringify!(RTCInterpolateArguments),
3668 "::",
3669 stringify!(ddPdudv)
3670 )
3671 );
3672 assert_eq!(
3673 unsafe {
3674 &(*(::std::ptr::null::<RTCInterpolateArguments>())).valueCount as *const _ as usize
3675 },
3676 80usize,
3677 concat!(
3678 "Offset of field: ",
3679 stringify!(RTCInterpolateArguments),
3680 "::",
3681 stringify!(valueCount)
3682 )
3683 );
3684}
3685extern "C" {
3686 pub fn rtcInterpolate(args: *const RTCInterpolateArguments);
3687}
3688#[repr(C)]
3689#[derive(Debug, Copy, Clone)]
3690pub struct RTCInterpolateNArguments {
3691 pub geometry: RTCGeometry,
3692 pub valid: *const ::std::os::raw::c_void,
3693 pub primIDs: *const ::std::os::raw::c_uint,
3694 pub u: *const f32,
3695 pub v: *const f32,
3696 pub N: ::std::os::raw::c_uint,
3697 pub bufferType: RTCBufferType,
3698 pub bufferSlot: ::std::os::raw::c_uint,
3699 pub P: *mut f32,
3700 pub dPdu: *mut f32,
3701 pub dPdv: *mut f32,
3702 pub ddPdudu: *mut f32,
3703 pub ddPdvdv: *mut f32,
3704 pub ddPdudv: *mut f32,
3705 pub valueCount: ::std::os::raw::c_uint,
3706}
3707#[test]
3708fn bindgen_test_layout_RTCInterpolateNArguments() {
3709 assert_eq!(
3710 ::std::mem::size_of::<RTCInterpolateNArguments>(),
3711 112usize,
3712 concat!("Size of: ", stringify!(RTCInterpolateNArguments))
3713 );
3714 assert_eq!(
3715 ::std::mem::align_of::<RTCInterpolateNArguments>(),
3716 8usize,
3717 concat!("Alignment of ", stringify!(RTCInterpolateNArguments))
3718 );
3719 assert_eq!(
3720 unsafe {
3721 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).geometry as *const _ as usize
3722 },
3723 0usize,
3724 concat!(
3725 "Offset of field: ",
3726 stringify!(RTCInterpolateNArguments),
3727 "::",
3728 stringify!(geometry)
3729 )
3730 );
3731 assert_eq!(
3732 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).valid as *const _ as usize },
3733 8usize,
3734 concat!(
3735 "Offset of field: ",
3736 stringify!(RTCInterpolateNArguments),
3737 "::",
3738 stringify!(valid)
3739 )
3740 );
3741 assert_eq!(
3742 unsafe {
3743 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).primIDs as *const _ as usize
3744 },
3745 16usize,
3746 concat!(
3747 "Offset of field: ",
3748 stringify!(RTCInterpolateNArguments),
3749 "::",
3750 stringify!(primIDs)
3751 )
3752 );
3753 assert_eq!(
3754 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).u as *const _ as usize },
3755 24usize,
3756 concat!(
3757 "Offset of field: ",
3758 stringify!(RTCInterpolateNArguments),
3759 "::",
3760 stringify!(u)
3761 )
3762 );
3763 assert_eq!(
3764 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).v as *const _ as usize },
3765 32usize,
3766 concat!(
3767 "Offset of field: ",
3768 stringify!(RTCInterpolateNArguments),
3769 "::",
3770 stringify!(v)
3771 )
3772 );
3773 assert_eq!(
3774 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).N as *const _ as usize },
3775 40usize,
3776 concat!(
3777 "Offset of field: ",
3778 stringify!(RTCInterpolateNArguments),
3779 "::",
3780 stringify!(N)
3781 )
3782 );
3783 assert_eq!(
3784 unsafe {
3785 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).bufferType as *const _ as usize
3786 },
3787 44usize,
3788 concat!(
3789 "Offset of field: ",
3790 stringify!(RTCInterpolateNArguments),
3791 "::",
3792 stringify!(bufferType)
3793 )
3794 );
3795 assert_eq!(
3796 unsafe {
3797 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).bufferSlot as *const _ as usize
3798 },
3799 48usize,
3800 concat!(
3801 "Offset of field: ",
3802 stringify!(RTCInterpolateNArguments),
3803 "::",
3804 stringify!(bufferSlot)
3805 )
3806 );
3807 assert_eq!(
3808 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).P as *const _ as usize },
3809 56usize,
3810 concat!(
3811 "Offset of field: ",
3812 stringify!(RTCInterpolateNArguments),
3813 "::",
3814 stringify!(P)
3815 )
3816 );
3817 assert_eq!(
3818 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).dPdu as *const _ as usize },
3819 64usize,
3820 concat!(
3821 "Offset of field: ",
3822 stringify!(RTCInterpolateNArguments),
3823 "::",
3824 stringify!(dPdu)
3825 )
3826 );
3827 assert_eq!(
3828 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).dPdv as *const _ as usize },
3829 72usize,
3830 concat!(
3831 "Offset of field: ",
3832 stringify!(RTCInterpolateNArguments),
3833 "::",
3834 stringify!(dPdv)
3835 )
3836 );
3837 assert_eq!(
3838 unsafe {
3839 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdudu as *const _ as usize
3840 },
3841 80usize,
3842 concat!(
3843 "Offset of field: ",
3844 stringify!(RTCInterpolateNArguments),
3845 "::",
3846 stringify!(ddPdudu)
3847 )
3848 );
3849 assert_eq!(
3850 unsafe {
3851 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdvdv as *const _ as usize
3852 },
3853 88usize,
3854 concat!(
3855 "Offset of field: ",
3856 stringify!(RTCInterpolateNArguments),
3857 "::",
3858 stringify!(ddPdvdv)
3859 )
3860 );
3861 assert_eq!(
3862 unsafe {
3863 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdudv as *const _ as usize
3864 },
3865 96usize,
3866 concat!(
3867 "Offset of field: ",
3868 stringify!(RTCInterpolateNArguments),
3869 "::",
3870 stringify!(ddPdudv)
3871 )
3872 );
3873 assert_eq!(
3874 unsafe {
3875 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).valueCount as *const _ as usize
3876 },
3877 104usize,
3878 concat!(
3879 "Offset of field: ",
3880 stringify!(RTCInterpolateNArguments),
3881 "::",
3882 stringify!(valueCount)
3883 )
3884 );
3885}
3886extern "C" {
3887 pub fn rtcInterpolateN(args: *const RTCInterpolateNArguments);
3888}
3889#[repr(C)]
3890#[derive(Debug, Copy, Clone)]
3891pub struct RTCGrid {
3892 pub startVertexID: ::std::os::raw::c_uint,
3893 pub stride: ::std::os::raw::c_uint,
3894 pub width: ::std::os::raw::c_ushort,
3895 pub height: ::std::os::raw::c_ushort,
3896}
3897#[test]
3898fn bindgen_test_layout_RTCGrid() {
3899 assert_eq!(
3900 ::std::mem::size_of::<RTCGrid>(),
3901 12usize,
3902 concat!("Size of: ", stringify!(RTCGrid))
3903 );
3904 assert_eq!(
3905 ::std::mem::align_of::<RTCGrid>(),
3906 4usize,
3907 concat!("Alignment of ", stringify!(RTCGrid))
3908 );
3909 assert_eq!(
3910 unsafe { &(*(::std::ptr::null::<RTCGrid>())).startVertexID as *const _ as usize },
3911 0usize,
3912 concat!(
3913 "Offset of field: ",
3914 stringify!(RTCGrid),
3915 "::",
3916 stringify!(startVertexID)
3917 )
3918 );
3919 assert_eq!(
3920 unsafe { &(*(::std::ptr::null::<RTCGrid>())).stride as *const _ as usize },
3921 4usize,
3922 concat!(
3923 "Offset of field: ",
3924 stringify!(RTCGrid),
3925 "::",
3926 stringify!(stride)
3927 )
3928 );
3929 assert_eq!(
3930 unsafe { &(*(::std::ptr::null::<RTCGrid>())).width as *const _ as usize },
3931 8usize,
3932 concat!(
3933 "Offset of field: ",
3934 stringify!(RTCGrid),
3935 "::",
3936 stringify!(width)
3937 )
3938 );
3939 assert_eq!(
3940 unsafe { &(*(::std::ptr::null::<RTCGrid>())).height as *const _ as usize },
3941 10usize,
3942 concat!(
3943 "Offset of field: ",
3944 stringify!(RTCGrid),
3945 "::",
3946 stringify!(height)
3947 )
3948 );
3949}
3950impl RTCSceneFlags {
3951 pub const NONE: RTCSceneFlags = RTCSceneFlags(0);
3952}
3953impl RTCSceneFlags {
3954 pub const DYNAMIC: RTCSceneFlags = RTCSceneFlags(1);
3955}
3956impl RTCSceneFlags {
3957 pub const COMPACT: RTCSceneFlags = RTCSceneFlags(2);
3958}
3959impl RTCSceneFlags {
3960 pub const ROBUST: RTCSceneFlags = RTCSceneFlags(4);
3961}
3962impl RTCSceneFlags {
3963 pub const CONTEXT_FILTER_FUNCTION: RTCSceneFlags = RTCSceneFlags(8);
3964}
3965impl ::std::ops::BitOr<RTCSceneFlags> for RTCSceneFlags {
3966 type Output = Self;
3967 #[inline]
3968 fn bitor(self, other: Self) -> Self {
3969 RTCSceneFlags(self.0 | other.0)
3970 }
3971}
3972impl ::std::ops::BitOrAssign for RTCSceneFlags {
3973 #[inline]
3974 fn bitor_assign(&mut self, rhs: RTCSceneFlags) {
3975 self.0 |= rhs.0;
3976 }
3977}
3978impl ::std::ops::BitAnd<RTCSceneFlags> for RTCSceneFlags {
3979 type Output = Self;
3980 #[inline]
3981 fn bitand(self, other: Self) -> Self {
3982 RTCSceneFlags(self.0 & other.0)
3983 }
3984}
3985impl ::std::ops::BitAndAssign for RTCSceneFlags {
3986 #[inline]
3987 fn bitand_assign(&mut self, rhs: RTCSceneFlags) {
3988 self.0 &= rhs.0;
3989 }
3990}
3991#[repr(transparent)]
3992#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3993pub struct RTCSceneFlags(pub ::std::os::raw::c_uint);
3994extern "C" {
3995 pub fn rtcNewScene(device: RTCDevice) -> RTCScene;
3996}
3997extern "C" {
3998 pub fn rtcGetSceneDevice(hscene: RTCScene) -> RTCDevice;
3999}
4000extern "C" {
4001 pub fn rtcRetainScene(scene: RTCScene);
4002}
4003extern "C" {
4004 pub fn rtcReleaseScene(scene: RTCScene);
4005}
4006extern "C" {
4007 pub fn rtcAttachGeometry(scene: RTCScene, geometry: RTCGeometry) -> ::std::os::raw::c_uint;
4008}
4009extern "C" {
4010 pub fn rtcAttachGeometryByID(
4011 scene: RTCScene,
4012 geometry: RTCGeometry,
4013 geomID: ::std::os::raw::c_uint,
4014 );
4015}
4016extern "C" {
4017 pub fn rtcDetachGeometry(scene: RTCScene, geomID: ::std::os::raw::c_uint);
4018}
4019extern "C" {
4020 pub fn rtcGetGeometry(scene: RTCScene, geomID: ::std::os::raw::c_uint) -> RTCGeometry;
4021}
4022extern "C" {
4023 pub fn rtcCommitScene(scene: RTCScene);
4024}
4025extern "C" {
4026 pub fn rtcJoinCommitScene(scene: RTCScene);
4027}
4028pub type RTCProgressMonitorFunction =
4029 ::std::option::Option<unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void, n: f64) -> bool>;
4030extern "C" {
4031 pub fn rtcSetSceneProgressMonitorFunction(
4032 scene: RTCScene,
4033 progress: RTCProgressMonitorFunction,
4034 ptr: *mut ::std::os::raw::c_void,
4035 );
4036}
4037extern "C" {
4038 pub fn rtcSetSceneBuildQuality(scene: RTCScene, quality: RTCBuildQuality);
4039}
4040extern "C" {
4041 pub fn rtcSetSceneFlags(scene: RTCScene, flags: RTCSceneFlags);
4042}
4043extern "C" {
4044 pub fn rtcGetSceneFlags(scene: RTCScene) -> RTCSceneFlags;
4045}
4046extern "C" {
4047 pub fn rtcGetSceneBounds(scene: RTCScene, bounds_o: *mut RTCBounds);
4048}
4049extern "C" {
4050 pub fn rtcGetSceneLinearBounds(scene: RTCScene, bounds_o: *mut RTCLinearBounds);
4051}
4052extern "C" {
4053 pub fn rtcPointQuery(
4054 scene: RTCScene,
4055 query: *mut RTCPointQuery,
4056 context: *mut RTCPointQueryContext,
4057 queryFunc: RTCPointQueryFunction,
4058 userPtr: *mut ::std::os::raw::c_void,
4059 ) -> bool;
4060}
4061extern "C" {
4062 pub fn rtcPointQuery4(
4063 valid: *const ::std::os::raw::c_int,
4064 scene: RTCScene,
4065 query: *mut RTCPointQuery4,
4066 context: *mut RTCPointQueryContext,
4067 queryFunc: RTCPointQueryFunction,
4068 userPtr: *mut *mut ::std::os::raw::c_void,
4069 ) -> bool;
4070}
4071extern "C" {
4072 pub fn rtcPointQuery8(
4073 valid: *const ::std::os::raw::c_int,
4074 scene: RTCScene,
4075 query: *mut RTCPointQuery8,
4076 context: *mut RTCPointQueryContext,
4077 queryFunc: RTCPointQueryFunction,
4078 userPtr: *mut *mut ::std::os::raw::c_void,
4079 ) -> bool;
4080}
4081extern "C" {
4082 pub fn rtcPointQuery16(
4083 valid: *const ::std::os::raw::c_int,
4084 scene: RTCScene,
4085 query: *mut RTCPointQuery16,
4086 context: *mut RTCPointQueryContext,
4087 queryFunc: RTCPointQueryFunction,
4088 userPtr: *mut *mut ::std::os::raw::c_void,
4089 ) -> bool;
4090}
4091extern "C" {
4092 pub fn rtcIntersect1(
4093 scene: RTCScene,
4094 context: *mut RTCIntersectContext,
4095 rayhit: *mut RTCRayHit,
4096 );
4097}
4098extern "C" {
4099 pub fn rtcIntersect4(
4100 valid: *const ::std::os::raw::c_int,
4101 scene: RTCScene,
4102 context: *mut RTCIntersectContext,
4103 rayhit: *mut RTCRayHit4,
4104 );
4105}
4106extern "C" {
4107 pub fn rtcIntersect8(
4108 valid: *const ::std::os::raw::c_int,
4109 scene: RTCScene,
4110 context: *mut RTCIntersectContext,
4111 rayhit: *mut RTCRayHit8,
4112 );
4113}
4114extern "C" {
4115 pub fn rtcIntersect16(
4116 valid: *const ::std::os::raw::c_int,
4117 scene: RTCScene,
4118 context: *mut RTCIntersectContext,
4119 rayhit: *mut RTCRayHit16,
4120 );
4121}
4122extern "C" {
4123 pub fn rtcIntersect1M(
4124 scene: RTCScene,
4125 context: *mut RTCIntersectContext,
4126 rayhit: *mut RTCRayHit,
4127 M: ::std::os::raw::c_uint,
4128 byteStride: size_t,
4129 );
4130}
4131extern "C" {
4132 pub fn rtcIntersect1Mp(
4133 scene: RTCScene,
4134 context: *mut RTCIntersectContext,
4135 rayhit: *mut *mut RTCRayHit,
4136 M: ::std::os::raw::c_uint,
4137 );
4138}
4139extern "C" {
4140 pub fn rtcIntersectNM(
4141 scene: RTCScene,
4142 context: *mut RTCIntersectContext,
4143 rayhit: *mut RTCRayHitN,
4144 N: ::std::os::raw::c_uint,
4145 M: ::std::os::raw::c_uint,
4146 byteStride: size_t,
4147 );
4148}
4149extern "C" {
4150 pub fn rtcIntersectNp(
4151 scene: RTCScene,
4152 context: *mut RTCIntersectContext,
4153 rayhit: *const RTCRayHitNp,
4154 N: ::std::os::raw::c_uint,
4155 );
4156}
4157extern "C" {
4158 pub fn rtcOccluded1(scene: RTCScene, context: *mut RTCIntersectContext, ray: *mut RTCRay);
4159}
4160extern "C" {
4161 pub fn rtcOccluded4(
4162 valid: *const ::std::os::raw::c_int,
4163 scene: RTCScene,
4164 context: *mut RTCIntersectContext,
4165 ray: *mut RTCRay4,
4166 );
4167}
4168extern "C" {
4169 pub fn rtcOccluded8(
4170 valid: *const ::std::os::raw::c_int,
4171 scene: RTCScene,
4172 context: *mut RTCIntersectContext,
4173 ray: *mut RTCRay8,
4174 );
4175}
4176extern "C" {
4177 pub fn rtcOccluded16(
4178 valid: *const ::std::os::raw::c_int,
4179 scene: RTCScene,
4180 context: *mut RTCIntersectContext,
4181 ray: *mut RTCRay16,
4182 );
4183}
4184extern "C" {
4185 pub fn rtcOccluded1M(
4186 scene: RTCScene,
4187 context: *mut RTCIntersectContext,
4188 ray: *mut RTCRay,
4189 M: ::std::os::raw::c_uint,
4190 byteStride: size_t,
4191 );
4192}
4193extern "C" {
4194 pub fn rtcOccluded1Mp(
4195 scene: RTCScene,
4196 context: *mut RTCIntersectContext,
4197 ray: *mut *mut RTCRay,
4198 M: ::std::os::raw::c_uint,
4199 );
4200}
4201extern "C" {
4202 pub fn rtcOccludedNM(
4203 scene: RTCScene,
4204 context: *mut RTCIntersectContext,
4205 ray: *mut RTCRayN,
4206 N: ::std::os::raw::c_uint,
4207 M: ::std::os::raw::c_uint,
4208 byteStride: size_t,
4209 );
4210}
4211extern "C" {
4212 pub fn rtcOccludedNp(
4213 scene: RTCScene,
4214 context: *mut RTCIntersectContext,
4215 ray: *const RTCRayNp,
4216 N: ::std::os::raw::c_uint,
4217 );
4218}
4219#[repr(C)]
4220#[derive(Debug, Copy, Clone)]
4221pub struct RTCCollision {
4222 pub geomID0: ::std::os::raw::c_uint,
4223 pub primID0: ::std::os::raw::c_uint,
4224 pub geomID1: ::std::os::raw::c_uint,
4225 pub primID1: ::std::os::raw::c_uint,
4226}
4227#[test]
4228fn bindgen_test_layout_RTCCollision() {
4229 assert_eq!(
4230 ::std::mem::size_of::<RTCCollision>(),
4231 16usize,
4232 concat!("Size of: ", stringify!(RTCCollision))
4233 );
4234 assert_eq!(
4235 ::std::mem::align_of::<RTCCollision>(),
4236 4usize,
4237 concat!("Alignment of ", stringify!(RTCCollision))
4238 );
4239 assert_eq!(
4240 unsafe { &(*(::std::ptr::null::<RTCCollision>())).geomID0 as *const _ as usize },
4241 0usize,
4242 concat!(
4243 "Offset of field: ",
4244 stringify!(RTCCollision),
4245 "::",
4246 stringify!(geomID0)
4247 )
4248 );
4249 assert_eq!(
4250 unsafe { &(*(::std::ptr::null::<RTCCollision>())).primID0 as *const _ as usize },
4251 4usize,
4252 concat!(
4253 "Offset of field: ",
4254 stringify!(RTCCollision),
4255 "::",
4256 stringify!(primID0)
4257 )
4258 );
4259 assert_eq!(
4260 unsafe { &(*(::std::ptr::null::<RTCCollision>())).geomID1 as *const _ as usize },
4261 8usize,
4262 concat!(
4263 "Offset of field: ",
4264 stringify!(RTCCollision),
4265 "::",
4266 stringify!(geomID1)
4267 )
4268 );
4269 assert_eq!(
4270 unsafe { &(*(::std::ptr::null::<RTCCollision>())).primID1 as *const _ as usize },
4271 12usize,
4272 concat!(
4273 "Offset of field: ",
4274 stringify!(RTCCollision),
4275 "::",
4276 stringify!(primID1)
4277 )
4278 );
4279}
4280pub type RTCCollideFunc = ::std::option::Option<
4281 unsafe extern "C" fn(
4282 userPtr: *mut ::std::os::raw::c_void,
4283 collisions: *mut RTCCollision,
4284 num_collisions: ::std::os::raw::c_uint,
4285 ),
4286>;
4287extern "C" {
4288 pub fn rtcCollide(
4289 scene0: RTCScene,
4290 scene1: RTCScene,
4291 callback: RTCCollideFunc,
4292 userPtr: *mut ::std::os::raw::c_void,
4293 );
4294}
4295#[repr(C)]
4296#[derive(Debug, Copy, Clone)]
4297pub struct RTCBVHTy {
4298 _unused: [u8; 0],
4299}
4300pub type RTCBVH = *mut RTCBVHTy;
4301#[repr(C)]
4302#[repr(align(32))]
4303#[derive(Debug, Copy, Clone)]
4304pub struct RTCBuildPrimitive {
4305 pub lower_x: f32,
4306 pub lower_y: f32,
4307 pub lower_z: f32,
4308 pub geomID: ::std::os::raw::c_uint,
4309 pub upper_x: f32,
4310 pub upper_y: f32,
4311 pub upper_z: f32,
4312 pub primID: ::std::os::raw::c_uint,
4313}
4314#[test]
4315fn bindgen_test_layout_RTCBuildPrimitive() {
4316 assert_eq!(
4317 ::std::mem::size_of::<RTCBuildPrimitive>(),
4318 32usize,
4319 concat!("Size of: ", stringify!(RTCBuildPrimitive))
4320 );
4321 assert_eq!(
4322 ::std::mem::align_of::<RTCBuildPrimitive>(),
4323 32usize,
4324 concat!("Alignment of ", stringify!(RTCBuildPrimitive))
4325 );
4326 assert_eq!(
4327 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_x as *const _ as usize },
4328 0usize,
4329 concat!(
4330 "Offset of field: ",
4331 stringify!(RTCBuildPrimitive),
4332 "::",
4333 stringify!(lower_x)
4334 )
4335 );
4336 assert_eq!(
4337 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_y as *const _ as usize },
4338 4usize,
4339 concat!(
4340 "Offset of field: ",
4341 stringify!(RTCBuildPrimitive),
4342 "::",
4343 stringify!(lower_y)
4344 )
4345 );
4346 assert_eq!(
4347 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_z as *const _ as usize },
4348 8usize,
4349 concat!(
4350 "Offset of field: ",
4351 stringify!(RTCBuildPrimitive),
4352 "::",
4353 stringify!(lower_z)
4354 )
4355 );
4356 assert_eq!(
4357 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).geomID as *const _ as usize },
4358 12usize,
4359 concat!(
4360 "Offset of field: ",
4361 stringify!(RTCBuildPrimitive),
4362 "::",
4363 stringify!(geomID)
4364 )
4365 );
4366 assert_eq!(
4367 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_x as *const _ as usize },
4368 16usize,
4369 concat!(
4370 "Offset of field: ",
4371 stringify!(RTCBuildPrimitive),
4372 "::",
4373 stringify!(upper_x)
4374 )
4375 );
4376 assert_eq!(
4377 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_y as *const _ as usize },
4378 20usize,
4379 concat!(
4380 "Offset of field: ",
4381 stringify!(RTCBuildPrimitive),
4382 "::",
4383 stringify!(upper_y)
4384 )
4385 );
4386 assert_eq!(
4387 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_z as *const _ as usize },
4388 24usize,
4389 concat!(
4390 "Offset of field: ",
4391 stringify!(RTCBuildPrimitive),
4392 "::",
4393 stringify!(upper_z)
4394 )
4395 );
4396 assert_eq!(
4397 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).primID as *const _ as usize },
4398 28usize,
4399 concat!(
4400 "Offset of field: ",
4401 stringify!(RTCBuildPrimitive),
4402 "::",
4403 stringify!(primID)
4404 )
4405 );
4406}
4407#[repr(C)]
4408#[derive(Debug, Copy, Clone)]
4409pub struct RTCThreadLocalAllocatorTy {
4410 _unused: [u8; 0],
4411}
4412pub type RTCThreadLocalAllocator = *mut RTCThreadLocalAllocatorTy;
4413pub type RTCCreateNodeFunction = ::std::option::Option<
4414 unsafe extern "C" fn(
4415 allocator: RTCThreadLocalAllocator,
4416 childCount: ::std::os::raw::c_uint,
4417 userPtr: *mut ::std::os::raw::c_void,
4418 ) -> *mut ::std::os::raw::c_void,
4419>;
4420pub type RTCSetNodeChildrenFunction = ::std::option::Option<
4421 unsafe extern "C" fn(
4422 nodePtr: *mut ::std::os::raw::c_void,
4423 children: *mut *mut ::std::os::raw::c_void,
4424 childCount: ::std::os::raw::c_uint,
4425 userPtr: *mut ::std::os::raw::c_void,
4426 ),
4427>;
4428pub type RTCSetNodeBoundsFunction = ::std::option::Option<
4429 unsafe extern "C" fn(
4430 nodePtr: *mut ::std::os::raw::c_void,
4431 bounds: *mut *const RTCBounds,
4432 childCount: ::std::os::raw::c_uint,
4433 userPtr: *mut ::std::os::raw::c_void,
4434 ),
4435>;
4436pub type RTCCreateLeafFunction = ::std::option::Option<
4437 unsafe extern "C" fn(
4438 allocator: RTCThreadLocalAllocator,
4439 primitives: *const RTCBuildPrimitive,
4440 primitiveCount: size_t,
4441 userPtr: *mut ::std::os::raw::c_void,
4442 ) -> *mut ::std::os::raw::c_void,
4443>;
4444pub type RTCSplitPrimitiveFunction = ::std::option::Option<
4445 unsafe extern "C" fn(
4446 primitive: *const RTCBuildPrimitive,
4447 dimension: ::std::os::raw::c_uint,
4448 position: f32,
4449 leftBounds: *mut RTCBounds,
4450 rightBounds: *mut RTCBounds,
4451 userPtr: *mut ::std::os::raw::c_void,
4452 ),
4453>;
4454impl RTCBuildFlags {
4455 pub const NONE: RTCBuildFlags = RTCBuildFlags(0);
4456}
4457impl RTCBuildFlags {
4458 pub const DYNAMIC: RTCBuildFlags = RTCBuildFlags(1);
4459}
4460impl ::std::ops::BitOr<RTCBuildFlags> for RTCBuildFlags {
4461 type Output = Self;
4462 #[inline]
4463 fn bitor(self, other: Self) -> Self {
4464 RTCBuildFlags(self.0 | other.0)
4465 }
4466}
4467impl ::std::ops::BitOrAssign for RTCBuildFlags {
4468 #[inline]
4469 fn bitor_assign(&mut self, rhs: RTCBuildFlags) {
4470 self.0 |= rhs.0;
4471 }
4472}
4473impl ::std::ops::BitAnd<RTCBuildFlags> for RTCBuildFlags {
4474 type Output = Self;
4475 #[inline]
4476 fn bitand(self, other: Self) -> Self {
4477 RTCBuildFlags(self.0 & other.0)
4478 }
4479}
4480impl ::std::ops::BitAndAssign for RTCBuildFlags {
4481 #[inline]
4482 fn bitand_assign(&mut self, rhs: RTCBuildFlags) {
4483 self.0 &= rhs.0;
4484 }
4485}
4486#[repr(transparent)]
4487#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
4488pub struct RTCBuildFlags(pub ::std::os::raw::c_uint);
4489pub const RTCBuildConstants_RTC_BUILD_MAX_PRIMITIVES_PER_LEAF: RTCBuildConstants = 32;
4490pub type RTCBuildConstants = ::std::os::raw::c_uint;
4491#[repr(C)]
4492#[derive(Debug, Copy, Clone)]
4493pub struct RTCBuildArguments {
4494 pub byteSize: size_t,
4495 pub buildQuality: RTCBuildQuality,
4496 pub buildFlags: RTCBuildFlags,
4497 pub maxBranchingFactor: ::std::os::raw::c_uint,
4498 pub maxDepth: ::std::os::raw::c_uint,
4499 pub sahBlockSize: ::std::os::raw::c_uint,
4500 pub minLeafSize: ::std::os::raw::c_uint,
4501 pub maxLeafSize: ::std::os::raw::c_uint,
4502 pub traversalCost: f32,
4503 pub intersectionCost: f32,
4504 pub bvh: RTCBVH,
4505 pub primitives: *mut RTCBuildPrimitive,
4506 pub primitiveCount: size_t,
4507 pub primitiveArrayCapacity: size_t,
4508 pub createNode: RTCCreateNodeFunction,
4509 pub setNodeChildren: RTCSetNodeChildrenFunction,
4510 pub setNodeBounds: RTCSetNodeBoundsFunction,
4511 pub createLeaf: RTCCreateLeafFunction,
4512 pub splitPrimitive: RTCSplitPrimitiveFunction,
4513 pub buildProgress: RTCProgressMonitorFunction,
4514 pub userPtr: *mut ::std::os::raw::c_void,
4515}
4516#[test]
4517fn bindgen_test_layout_RTCBuildArguments() {
4518 assert_eq!(
4519 ::std::mem::size_of::<RTCBuildArguments>(),
4520 136usize,
4521 concat!("Size of: ", stringify!(RTCBuildArguments))
4522 );
4523 assert_eq!(
4524 ::std::mem::align_of::<RTCBuildArguments>(),
4525 8usize,
4526 concat!("Alignment of ", stringify!(RTCBuildArguments))
4527 );
4528 assert_eq!(
4529 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).byteSize as *const _ as usize },
4530 0usize,
4531 concat!(
4532 "Offset of field: ",
4533 stringify!(RTCBuildArguments),
4534 "::",
4535 stringify!(byteSize)
4536 )
4537 );
4538 assert_eq!(
4539 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildQuality as *const _ as usize },
4540 8usize,
4541 concat!(
4542 "Offset of field: ",
4543 stringify!(RTCBuildArguments),
4544 "::",
4545 stringify!(buildQuality)
4546 )
4547 );
4548 assert_eq!(
4549 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildFlags as *const _ as usize },
4550 12usize,
4551 concat!(
4552 "Offset of field: ",
4553 stringify!(RTCBuildArguments),
4554 "::",
4555 stringify!(buildFlags)
4556 )
4557 );
4558 assert_eq!(
4559 unsafe {
4560 &(*(::std::ptr::null::<RTCBuildArguments>())).maxBranchingFactor as *const _ as usize
4561 },
4562 16usize,
4563 concat!(
4564 "Offset of field: ",
4565 stringify!(RTCBuildArguments),
4566 "::",
4567 stringify!(maxBranchingFactor)
4568 )
4569 );
4570 assert_eq!(
4571 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).maxDepth as *const _ as usize },
4572 20usize,
4573 concat!(
4574 "Offset of field: ",
4575 stringify!(RTCBuildArguments),
4576 "::",
4577 stringify!(maxDepth)
4578 )
4579 );
4580 assert_eq!(
4581 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).sahBlockSize as *const _ as usize },
4582 24usize,
4583 concat!(
4584 "Offset of field: ",
4585 stringify!(RTCBuildArguments),
4586 "::",
4587 stringify!(sahBlockSize)
4588 )
4589 );
4590 assert_eq!(
4591 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).minLeafSize as *const _ as usize },
4592 28usize,
4593 concat!(
4594 "Offset of field: ",
4595 stringify!(RTCBuildArguments),
4596 "::",
4597 stringify!(minLeafSize)
4598 )
4599 );
4600 assert_eq!(
4601 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).maxLeafSize as *const _ as usize },
4602 32usize,
4603 concat!(
4604 "Offset of field: ",
4605 stringify!(RTCBuildArguments),
4606 "::",
4607 stringify!(maxLeafSize)
4608 )
4609 );
4610 assert_eq!(
4611 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).traversalCost as *const _ as usize },
4612 36usize,
4613 concat!(
4614 "Offset of field: ",
4615 stringify!(RTCBuildArguments),
4616 "::",
4617 stringify!(traversalCost)
4618 )
4619 );
4620 assert_eq!(
4621 unsafe {
4622 &(*(::std::ptr::null::<RTCBuildArguments>())).intersectionCost as *const _ as usize
4623 },
4624 40usize,
4625 concat!(
4626 "Offset of field: ",
4627 stringify!(RTCBuildArguments),
4628 "::",
4629 stringify!(intersectionCost)
4630 )
4631 );
4632 assert_eq!(
4633 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).bvh as *const _ as usize },
4634 48usize,
4635 concat!(
4636 "Offset of field: ",
4637 stringify!(RTCBuildArguments),
4638 "::",
4639 stringify!(bvh)
4640 )
4641 );
4642 assert_eq!(
4643 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).primitives as *const _ as usize },
4644 56usize,
4645 concat!(
4646 "Offset of field: ",
4647 stringify!(RTCBuildArguments),
4648 "::",
4649 stringify!(primitives)
4650 )
4651 );
4652 assert_eq!(
4653 unsafe {
4654 &(*(::std::ptr::null::<RTCBuildArguments>())).primitiveCount as *const _ as usize
4655 },
4656 64usize,
4657 concat!(
4658 "Offset of field: ",
4659 stringify!(RTCBuildArguments),
4660 "::",
4661 stringify!(primitiveCount)
4662 )
4663 );
4664 assert_eq!(
4665 unsafe {
4666 &(*(::std::ptr::null::<RTCBuildArguments>())).primitiveArrayCapacity as *const _
4667 as usize
4668 },
4669 72usize,
4670 concat!(
4671 "Offset of field: ",
4672 stringify!(RTCBuildArguments),
4673 "::",
4674 stringify!(primitiveArrayCapacity)
4675 )
4676 );
4677 assert_eq!(
4678 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).createNode as *const _ as usize },
4679 80usize,
4680 concat!(
4681 "Offset of field: ",
4682 stringify!(RTCBuildArguments),
4683 "::",
4684 stringify!(createNode)
4685 )
4686 );
4687 assert_eq!(
4688 unsafe {
4689 &(*(::std::ptr::null::<RTCBuildArguments>())).setNodeChildren as *const _ as usize
4690 },
4691 88usize,
4692 concat!(
4693 "Offset of field: ",
4694 stringify!(RTCBuildArguments),
4695 "::",
4696 stringify!(setNodeChildren)
4697 )
4698 );
4699 assert_eq!(
4700 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).setNodeBounds as *const _ as usize },
4701 96usize,
4702 concat!(
4703 "Offset of field: ",
4704 stringify!(RTCBuildArguments),
4705 "::",
4706 stringify!(setNodeBounds)
4707 )
4708 );
4709 assert_eq!(
4710 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).createLeaf as *const _ as usize },
4711 104usize,
4712 concat!(
4713 "Offset of field: ",
4714 stringify!(RTCBuildArguments),
4715 "::",
4716 stringify!(createLeaf)
4717 )
4718 );
4719 assert_eq!(
4720 unsafe {
4721 &(*(::std::ptr::null::<RTCBuildArguments>())).splitPrimitive as *const _ as usize
4722 },
4723 112usize,
4724 concat!(
4725 "Offset of field: ",
4726 stringify!(RTCBuildArguments),
4727 "::",
4728 stringify!(splitPrimitive)
4729 )
4730 );
4731 assert_eq!(
4732 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildProgress as *const _ as usize },
4733 120usize,
4734 concat!(
4735 "Offset of field: ",
4736 stringify!(RTCBuildArguments),
4737 "::",
4738 stringify!(buildProgress)
4739 )
4740 );
4741 assert_eq!(
4742 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).userPtr as *const _ as usize },
4743 128usize,
4744 concat!(
4745 "Offset of field: ",
4746 stringify!(RTCBuildArguments),
4747 "::",
4748 stringify!(userPtr)
4749 )
4750 );
4751}
4752extern "C" {
4753 pub fn rtcNewBVH(device: RTCDevice) -> RTCBVH;
4754}
4755extern "C" {
4756 pub fn rtcBuildBVH(args: *const RTCBuildArguments) -> *mut ::std::os::raw::c_void;
4757}
4758extern "C" {
4759 pub fn rtcThreadLocalAlloc(
4760 allocator: RTCThreadLocalAllocator,
4761 bytes: size_t,
4762 align: size_t,
4763 ) -> *mut ::std::os::raw::c_void;
4764}
4765extern "C" {
4766 pub fn rtcRetainBVH(bvh: RTCBVH);
4767}
4768extern "C" {
4769 pub fn rtcReleaseBVH(bvh: RTCBVH);
4770}