1pub const RTC_VERSION_MAJOR: u32 = 3;
4pub const RTC_VERSION_MINOR: u32 = 5;
5pub const RTC_VERSION_PATCH: u32 = 2;
6pub const RTC_VERSION: u32 = 30502;
7pub const RTC_VERSION_STRING: &'static [u8; 6usize] = b"3.5.2\0";
8pub const RTC_MAX_TIME_STEP_COUNT: u32 = 129;
9pub const RTC_MAX_INSTANCE_LEVEL_COUNT: u32 = 1;
10pub type __ssize_t = ::std::os::raw::c_long;
11#[repr(u32)]
12#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
13pub enum RTCFormat {
14 UNDEFINED = 0,
15 UCHAR = 4097,
16 UCHAR2 = 4098,
17 UCHAR3 = 4099,
18 UCHAR4 = 4100,
19 CHAR = 8193,
20 CHAR2 = 8194,
21 CHAR3 = 8195,
22 CHAR4 = 8196,
23 USHORT = 12289,
24 USHORT2 = 12290,
25 USHORT3 = 12291,
26 USHORT4 = 12292,
27 SHORT = 16385,
28 SHORT2 = 16386,
29 SHORT3 = 16387,
30 SHORT4 = 16388,
31 UINT = 20481,
32 UINT2 = 20482,
33 UINT3 = 20483,
34 UINT4 = 20484,
35 INT = 24577,
36 INT2 = 24578,
37 INT3 = 24579,
38 INT4 = 24580,
39 ULLONG = 28673,
40 ULLONG2 = 28674,
41 ULLONG3 = 28675,
42 ULLONG4 = 28676,
43 LLONG = 32769,
44 LLONG2 = 32770,
45 LLONG3 = 32771,
46 LLONG4 = 32772,
47 FLOAT = 36865,
48 FLOAT2 = 36866,
49 FLOAT3 = 36867,
50 FLOAT4 = 36868,
51 FLOAT5 = 36869,
52 FLOAT6 = 36870,
53 FLOAT7 = 36871,
54 FLOAT8 = 36872,
55 FLOAT9 = 36873,
56 FLOAT10 = 36874,
57 FLOAT11 = 36875,
58 FLOAT12 = 36876,
59 FLOAT13 = 36877,
60 FLOAT14 = 36878,
61 FLOAT15 = 36879,
62 FLOAT16 = 36880,
63 FLOAT2X2_ROW_MAJOR = 37154,
64 FLOAT2X3_ROW_MAJOR = 37155,
65 FLOAT2X4_ROW_MAJOR = 37156,
66 FLOAT3X2_ROW_MAJOR = 37170,
67 FLOAT3X3_ROW_MAJOR = 37171,
68 FLOAT3X4_ROW_MAJOR = 37172,
69 FLOAT4X2_ROW_MAJOR = 37186,
70 FLOAT4X3_ROW_MAJOR = 37187,
71 FLOAT4X4_ROW_MAJOR = 37188,
72 FLOAT2X2_COLUMN_MAJOR = 37410,
73 FLOAT2X3_COLUMN_MAJOR = 37411,
74 FLOAT2X4_COLUMN_MAJOR = 37412,
75 FLOAT3X2_COLUMN_MAJOR = 37426,
76 FLOAT3X3_COLUMN_MAJOR = 37427,
77 FLOAT3X4_COLUMN_MAJOR = 37428,
78 FLOAT4X2_COLUMN_MAJOR = 37442,
79 FLOAT4X3_COLUMN_MAJOR = 37443,
80 FLOAT4X4_COLUMN_MAJOR = 37444,
81 GRID = 40961,
82}
83#[repr(u32)]
84#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
85pub enum RTCBuildQuality {
86 LOW = 0,
87 MEDIUM = 1,
88 HIGH = 2,
89 REFIT = 3,
90}
91#[repr(C)]
92#[repr(align(16))]
93#[derive(Debug, Copy, Clone)]
94pub struct RTCBounds {
95 pub lower_x: f32,
96 pub lower_y: f32,
97 pub lower_z: f32,
98 pub align0: f32,
99 pub upper_x: f32,
100 pub upper_y: f32,
101 pub upper_z: f32,
102 pub align1: f32,
103}
104#[test]
105fn bindgen_test_layout_RTCBounds() {
106 assert_eq!(
107 ::std::mem::size_of::<RTCBounds>(),
108 32usize,
109 concat!("Size of: ", stringify!(RTCBounds))
110 );
111 assert_eq!(
112 ::std::mem::align_of::<RTCBounds>(),
113 16usize,
114 concat!("Alignment of ", stringify!(RTCBounds))
115 );
116 assert_eq!(
117 unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_x as *const _ as usize },
118 0usize,
119 concat!(
120 "Offset of field: ",
121 stringify!(RTCBounds),
122 "::",
123 stringify!(lower_x)
124 )
125 );
126 assert_eq!(
127 unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_y as *const _ as usize },
128 4usize,
129 concat!(
130 "Offset of field: ",
131 stringify!(RTCBounds),
132 "::",
133 stringify!(lower_y)
134 )
135 );
136 assert_eq!(
137 unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_z as *const _ as usize },
138 8usize,
139 concat!(
140 "Offset of field: ",
141 stringify!(RTCBounds),
142 "::",
143 stringify!(lower_z)
144 )
145 );
146 assert_eq!(
147 unsafe { &(*(::std::ptr::null::<RTCBounds>())).align0 as *const _ as usize },
148 12usize,
149 concat!(
150 "Offset of field: ",
151 stringify!(RTCBounds),
152 "::",
153 stringify!(align0)
154 )
155 );
156 assert_eq!(
157 unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_x as *const _ as usize },
158 16usize,
159 concat!(
160 "Offset of field: ",
161 stringify!(RTCBounds),
162 "::",
163 stringify!(upper_x)
164 )
165 );
166 assert_eq!(
167 unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_y as *const _ as usize },
168 20usize,
169 concat!(
170 "Offset of field: ",
171 stringify!(RTCBounds),
172 "::",
173 stringify!(upper_y)
174 )
175 );
176 assert_eq!(
177 unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_z as *const _ as usize },
178 24usize,
179 concat!(
180 "Offset of field: ",
181 stringify!(RTCBounds),
182 "::",
183 stringify!(upper_z)
184 )
185 );
186 assert_eq!(
187 unsafe { &(*(::std::ptr::null::<RTCBounds>())).align1 as *const _ as usize },
188 28usize,
189 concat!(
190 "Offset of field: ",
191 stringify!(RTCBounds),
192 "::",
193 stringify!(align1)
194 )
195 );
196}
197#[repr(C)]
198#[repr(align(16))]
199#[derive(Debug, Copy, Clone)]
200pub struct RTCLinearBounds {
201 pub bounds0: RTCBounds,
202 pub bounds1: RTCBounds,
203}
204#[test]
205fn bindgen_test_layout_RTCLinearBounds() {
206 assert_eq!(
207 ::std::mem::size_of::<RTCLinearBounds>(),
208 64usize,
209 concat!("Size of: ", stringify!(RTCLinearBounds))
210 );
211 assert_eq!(
212 ::std::mem::align_of::<RTCLinearBounds>(),
213 16usize,
214 concat!("Alignment of ", stringify!(RTCLinearBounds))
215 );
216 assert_eq!(
217 unsafe { &(*(::std::ptr::null::<RTCLinearBounds>())).bounds0 as *const _ as usize },
218 0usize,
219 concat!(
220 "Offset of field: ",
221 stringify!(RTCLinearBounds),
222 "::",
223 stringify!(bounds0)
224 )
225 );
226 assert_eq!(
227 unsafe { &(*(::std::ptr::null::<RTCLinearBounds>())).bounds1 as *const _ as usize },
228 32usize,
229 concat!(
230 "Offset of field: ",
231 stringify!(RTCLinearBounds),
232 "::",
233 stringify!(bounds1)
234 )
235 );
236}
237impl RTCIntersectContextFlags {
238 pub const NONE: RTCIntersectContextFlags =
239 RTCIntersectContextFlags(0);
240}
241impl RTCIntersectContextFlags {
242 pub const INCOHERENT: RTCIntersectContextFlags =
243 RTCIntersectContextFlags(0);
244}
245impl RTCIntersectContextFlags {
246 pub const COHERENT: RTCIntersectContextFlags =
247 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 u32);
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: *const 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#[derive(Debug, Copy, Clone)]
422pub struct RTCDeviceTy {
423 _unused: [u8; 0],
424}
425pub type RTCDevice = *mut RTCDeviceTy;
426extern "C" {
427 pub fn rtcNewDevice(config: *const ::std::os::raw::c_char) -> RTCDevice;
428}
429extern "C" {
430 pub fn rtcRetainDevice(device: RTCDevice);
431}
432extern "C" {
433 pub fn rtcReleaseDevice(device: RTCDevice);
434}
435#[repr(u32)]
436#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
437pub enum RTCDeviceProperty {
438 VERSION = 0,
439 VERSION_MAJOR = 1,
440 VERSION_MINOR = 2,
441 VERSION_PATCH = 3,
442 NATIVE_RAY4_SUPPORTED = 32,
443 NATIVE_RAY8_SUPPORTED = 33,
444 NATIVE_RAY16_SUPPORTED = 34,
445 RAY_STREAM_SUPPORTED = 35,
446 RAY_MASK_SUPPORTED = 64,
447 BACKFACE_CULLING_ENABLED = 65,
448 FILTER_FUNCTION_SUPPORTED = 66,
449 IGNORE_INVALID_RAYS_ENABLED = 67,
450 TRIANGLE_GEOMETRY_SUPPORTED = 96,
451 QUAD_GEOMETRY_SUPPORTED = 97,
452 SUBDIVISION_GEOMETRY_SUPPORTED = 98,
453 CURVE_GEOMETRY_SUPPORTED = 99,
454 USER_GEOMETRY_SUPPORTED = 100,
455 POINT_GEOMETRY_SUPPORTED = 101,
456 TASKING_SYSTEM = 128,
457 JOIN_COMMIT_SUPPORTED = 129,
458}
459extern "C" {
460 pub fn rtcGetDeviceProperty(device: RTCDevice, prop: RTCDeviceProperty) -> isize;
461}
462extern "C" {
463 pub fn rtcSetDeviceProperty(device: RTCDevice, prop: RTCDeviceProperty, value: isize);
464}
465#[repr(u32)]
466#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
467pub enum RTCError {
468 NONE = 0,
469 UNKNOWN = 1,
470 INVALID_ARGUMENT = 2,
471 INVALID_OPERATION = 3,
472 OUT_OF_MEMORY = 4,
473 UNSUPPORTED_CPU = 5,
474 CANCELLED = 6,
475}
476extern "C" {
477 pub fn rtcGetDeviceError(device: RTCDevice) -> RTCError;
478}
479pub type RTCErrorFunction = ::std::option::Option<
480 unsafe extern "C" fn(
481 userPtr: *mut ::std::os::raw::c_void,
482 code: RTCError,
483 str: *const ::std::os::raw::c_char,
484 ),
485>;
486extern "C" {
487 pub fn rtcSetDeviceErrorFunction(
488 device: RTCDevice,
489 error: RTCErrorFunction,
490 userPtr: *mut ::std::os::raw::c_void,
491 );
492}
493pub type RTCMemoryMonitorFunction = ::std::option::Option<
494 unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void, bytes: isize, post: bool) -> bool,
495>;
496extern "C" {
497 pub fn rtcSetDeviceMemoryMonitorFunction(
498 device: RTCDevice,
499 memoryMonitor: RTCMemoryMonitorFunction,
500 userPtr: *mut ::std::os::raw::c_void,
501 );
502}
503#[repr(u32)]
504#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
505pub enum RTCBufferType {
506 INDEX = 0,
507 VERTEX = 1,
508 VERTEX_ATTRIBUTE = 2,
509 NORMAL = 3,
510 TANGENT = 4,
511 NORMAL_DERIVATIVE = 5,
512 GRID = 8,
513 FACE = 16,
514 LEVEL = 17,
515 EDGE_CREASE_INDEX = 18,
516 EDGE_CREASE_WEIGHT = 19,
517 VERTEX_CREASE_INDEX = 20,
518 VERTEX_CREASE_WEIGHT = 21,
519 HOLE = 22,
520 FLAGS = 32,
521}
522#[repr(C)]
523#[derive(Debug, Copy, Clone)]
524pub struct RTCBufferTy {
525 _unused: [u8; 0],
526}
527pub type RTCBuffer = *mut RTCBufferTy;
528extern "C" {
529 pub fn rtcNewBuffer(device: RTCDevice, byteSize: usize) -> RTCBuffer;
530}
531extern "C" {
532 pub fn rtcNewSharedBuffer(
533 device: RTCDevice,
534 ptr: *mut ::std::os::raw::c_void,
535 byteSize: usize,
536 ) -> RTCBuffer;
537}
538extern "C" {
539 pub fn rtcGetBufferData(buffer: RTCBuffer) -> *mut ::std::os::raw::c_void;
540}
541extern "C" {
542 pub fn rtcRetainBuffer(buffer: RTCBuffer);
543}
544extern "C" {
545 pub fn rtcReleaseBuffer(buffer: RTCBuffer);
546}
547#[repr(C)]
548#[repr(align(16))]
549#[derive(Debug, Copy, Clone)]
550pub struct RTCRay {
551 pub org_x: f32,
552 pub org_y: f32,
553 pub org_z: f32,
554 pub tnear: f32,
555 pub dir_x: f32,
556 pub dir_y: f32,
557 pub dir_z: f32,
558 pub time: f32,
559 pub tfar: f32,
560 pub mask: ::std::os::raw::c_uint,
561 pub id: ::std::os::raw::c_uint,
562 pub flags: ::std::os::raw::c_uint,
563}
564#[test]
565fn bindgen_test_layout_RTCRay() {
566 assert_eq!(
567 ::std::mem::size_of::<RTCRay>(),
568 48usize,
569 concat!("Size of: ", stringify!(RTCRay))
570 );
571 assert_eq!(
572 ::std::mem::align_of::<RTCRay>(),
573 16usize,
574 concat!("Alignment of ", stringify!(RTCRay))
575 );
576 assert_eq!(
577 unsafe { &(*(::std::ptr::null::<RTCRay>())).org_x as *const _ as usize },
578 0usize,
579 concat!(
580 "Offset of field: ",
581 stringify!(RTCRay),
582 "::",
583 stringify!(org_x)
584 )
585 );
586 assert_eq!(
587 unsafe { &(*(::std::ptr::null::<RTCRay>())).org_y as *const _ as usize },
588 4usize,
589 concat!(
590 "Offset of field: ",
591 stringify!(RTCRay),
592 "::",
593 stringify!(org_y)
594 )
595 );
596 assert_eq!(
597 unsafe { &(*(::std::ptr::null::<RTCRay>())).org_z as *const _ as usize },
598 8usize,
599 concat!(
600 "Offset of field: ",
601 stringify!(RTCRay),
602 "::",
603 stringify!(org_z)
604 )
605 );
606 assert_eq!(
607 unsafe { &(*(::std::ptr::null::<RTCRay>())).tnear as *const _ as usize },
608 12usize,
609 concat!(
610 "Offset of field: ",
611 stringify!(RTCRay),
612 "::",
613 stringify!(tnear)
614 )
615 );
616 assert_eq!(
617 unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_x as *const _ as usize },
618 16usize,
619 concat!(
620 "Offset of field: ",
621 stringify!(RTCRay),
622 "::",
623 stringify!(dir_x)
624 )
625 );
626 assert_eq!(
627 unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_y as *const _ as usize },
628 20usize,
629 concat!(
630 "Offset of field: ",
631 stringify!(RTCRay),
632 "::",
633 stringify!(dir_y)
634 )
635 );
636 assert_eq!(
637 unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_z as *const _ as usize },
638 24usize,
639 concat!(
640 "Offset of field: ",
641 stringify!(RTCRay),
642 "::",
643 stringify!(dir_z)
644 )
645 );
646 assert_eq!(
647 unsafe { &(*(::std::ptr::null::<RTCRay>())).time as *const _ as usize },
648 28usize,
649 concat!(
650 "Offset of field: ",
651 stringify!(RTCRay),
652 "::",
653 stringify!(time)
654 )
655 );
656 assert_eq!(
657 unsafe { &(*(::std::ptr::null::<RTCRay>())).tfar as *const _ as usize },
658 32usize,
659 concat!(
660 "Offset of field: ",
661 stringify!(RTCRay),
662 "::",
663 stringify!(tfar)
664 )
665 );
666 assert_eq!(
667 unsafe { &(*(::std::ptr::null::<RTCRay>())).mask as *const _ as usize },
668 36usize,
669 concat!(
670 "Offset of field: ",
671 stringify!(RTCRay),
672 "::",
673 stringify!(mask)
674 )
675 );
676 assert_eq!(
677 unsafe { &(*(::std::ptr::null::<RTCRay>())).id as *const _ as usize },
678 40usize,
679 concat!(
680 "Offset of field: ",
681 stringify!(RTCRay),
682 "::",
683 stringify!(id)
684 )
685 );
686 assert_eq!(
687 unsafe { &(*(::std::ptr::null::<RTCRay>())).flags as *const _ as usize },
688 44usize,
689 concat!(
690 "Offset of field: ",
691 stringify!(RTCRay),
692 "::",
693 stringify!(flags)
694 )
695 );
696}
697#[repr(C)]
698#[derive(Debug, Copy, Clone)]
699pub struct RTCHit {
700 pub Ng_x: f32,
701 pub Ng_y: f32,
702 pub Ng_z: f32,
703 pub u: f32,
704 pub v: f32,
705 pub primID: ::std::os::raw::c_uint,
706 pub geomID: ::std::os::raw::c_uint,
707 pub instID: [::std::os::raw::c_uint; 1usize],
708}
709#[test]
710fn bindgen_test_layout_RTCHit() {
711 assert_eq!(
712 ::std::mem::size_of::<RTCHit>(),
713 32usize,
714 concat!("Size of: ", stringify!(RTCHit))
715 );
716 assert_eq!(
717 ::std::mem::align_of::<RTCHit>(),
718 4usize,
719 concat!("Alignment of ", stringify!(RTCHit))
720 );
721 assert_eq!(
722 unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_x as *const _ as usize },
723 0usize,
724 concat!(
725 "Offset of field: ",
726 stringify!(RTCHit),
727 "::",
728 stringify!(Ng_x)
729 )
730 );
731 assert_eq!(
732 unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_y as *const _ as usize },
733 4usize,
734 concat!(
735 "Offset of field: ",
736 stringify!(RTCHit),
737 "::",
738 stringify!(Ng_y)
739 )
740 );
741 assert_eq!(
742 unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_z as *const _ as usize },
743 8usize,
744 concat!(
745 "Offset of field: ",
746 stringify!(RTCHit),
747 "::",
748 stringify!(Ng_z)
749 )
750 );
751 assert_eq!(
752 unsafe { &(*(::std::ptr::null::<RTCHit>())).u as *const _ as usize },
753 12usize,
754 concat!("Offset of field: ", stringify!(RTCHit), "::", stringify!(u))
755 );
756 assert_eq!(
757 unsafe { &(*(::std::ptr::null::<RTCHit>())).v as *const _ as usize },
758 16usize,
759 concat!("Offset of field: ", stringify!(RTCHit), "::", stringify!(v))
760 );
761 assert_eq!(
762 unsafe { &(*(::std::ptr::null::<RTCHit>())).primID as *const _ as usize },
763 20usize,
764 concat!(
765 "Offset of field: ",
766 stringify!(RTCHit),
767 "::",
768 stringify!(primID)
769 )
770 );
771 assert_eq!(
772 unsafe { &(*(::std::ptr::null::<RTCHit>())).geomID as *const _ as usize },
773 24usize,
774 concat!(
775 "Offset of field: ",
776 stringify!(RTCHit),
777 "::",
778 stringify!(geomID)
779 )
780 );
781 assert_eq!(
782 unsafe { &(*(::std::ptr::null::<RTCHit>())).instID as *const _ as usize },
783 28usize,
784 concat!(
785 "Offset of field: ",
786 stringify!(RTCHit),
787 "::",
788 stringify!(instID)
789 )
790 );
791}
792#[repr(C)]
793#[repr(align(16))]
794#[derive(Debug, Copy, Clone)]
795pub struct RTCRayHit {
796 pub ray: RTCRay,
797 pub hit: RTCHit,
798}
799#[test]
800fn bindgen_test_layout_RTCRayHit() {
801 assert_eq!(
802 ::std::mem::size_of::<RTCRayHit>(),
803 80usize,
804 concat!("Size of: ", stringify!(RTCRayHit))
805 );
806 assert_eq!(
807 ::std::mem::align_of::<RTCRayHit>(),
808 16usize,
809 concat!("Alignment of ", stringify!(RTCRayHit))
810 );
811 assert_eq!(
812 unsafe { &(*(::std::ptr::null::<RTCRayHit>())).ray as *const _ as usize },
813 0usize,
814 concat!(
815 "Offset of field: ",
816 stringify!(RTCRayHit),
817 "::",
818 stringify!(ray)
819 )
820 );
821 assert_eq!(
822 unsafe { &(*(::std::ptr::null::<RTCRayHit>())).hit as *const _ as usize },
823 48usize,
824 concat!(
825 "Offset of field: ",
826 stringify!(RTCRayHit),
827 "::",
828 stringify!(hit)
829 )
830 );
831}
832#[repr(C)]
833#[repr(align(16))]
834#[derive(Debug, Copy, Clone)]
835pub struct RTCRay4 {
836 pub org_x: [f32; 4usize],
837 pub org_y: [f32; 4usize],
838 pub org_z: [f32; 4usize],
839 pub tnear: [f32; 4usize],
840 pub dir_x: [f32; 4usize],
841 pub dir_y: [f32; 4usize],
842 pub dir_z: [f32; 4usize],
843 pub time: [f32; 4usize],
844 pub tfar: [f32; 4usize],
845 pub mask: [::std::os::raw::c_uint; 4usize],
846 pub id: [::std::os::raw::c_uint; 4usize],
847 pub flags: [::std::os::raw::c_uint; 4usize],
848}
849#[test]
850fn bindgen_test_layout_RTCRay4() {
851 assert_eq!(
852 ::std::mem::size_of::<RTCRay4>(),
853 192usize,
854 concat!("Size of: ", stringify!(RTCRay4))
855 );
856 assert_eq!(
857 ::std::mem::align_of::<RTCRay4>(),
858 16usize,
859 concat!("Alignment of ", stringify!(RTCRay4))
860 );
861 assert_eq!(
862 unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_x as *const _ as usize },
863 0usize,
864 concat!(
865 "Offset of field: ",
866 stringify!(RTCRay4),
867 "::",
868 stringify!(org_x)
869 )
870 );
871 assert_eq!(
872 unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_y as *const _ as usize },
873 16usize,
874 concat!(
875 "Offset of field: ",
876 stringify!(RTCRay4),
877 "::",
878 stringify!(org_y)
879 )
880 );
881 assert_eq!(
882 unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_z as *const _ as usize },
883 32usize,
884 concat!(
885 "Offset of field: ",
886 stringify!(RTCRay4),
887 "::",
888 stringify!(org_z)
889 )
890 );
891 assert_eq!(
892 unsafe { &(*(::std::ptr::null::<RTCRay4>())).tnear as *const _ as usize },
893 48usize,
894 concat!(
895 "Offset of field: ",
896 stringify!(RTCRay4),
897 "::",
898 stringify!(tnear)
899 )
900 );
901 assert_eq!(
902 unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_x as *const _ as usize },
903 64usize,
904 concat!(
905 "Offset of field: ",
906 stringify!(RTCRay4),
907 "::",
908 stringify!(dir_x)
909 )
910 );
911 assert_eq!(
912 unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_y as *const _ as usize },
913 80usize,
914 concat!(
915 "Offset of field: ",
916 stringify!(RTCRay4),
917 "::",
918 stringify!(dir_y)
919 )
920 );
921 assert_eq!(
922 unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_z as *const _ as usize },
923 96usize,
924 concat!(
925 "Offset of field: ",
926 stringify!(RTCRay4),
927 "::",
928 stringify!(dir_z)
929 )
930 );
931 assert_eq!(
932 unsafe { &(*(::std::ptr::null::<RTCRay4>())).time as *const _ as usize },
933 112usize,
934 concat!(
935 "Offset of field: ",
936 stringify!(RTCRay4),
937 "::",
938 stringify!(time)
939 )
940 );
941 assert_eq!(
942 unsafe { &(*(::std::ptr::null::<RTCRay4>())).tfar as *const _ as usize },
943 128usize,
944 concat!(
945 "Offset of field: ",
946 stringify!(RTCRay4),
947 "::",
948 stringify!(tfar)
949 )
950 );
951 assert_eq!(
952 unsafe { &(*(::std::ptr::null::<RTCRay4>())).mask as *const _ as usize },
953 144usize,
954 concat!(
955 "Offset of field: ",
956 stringify!(RTCRay4),
957 "::",
958 stringify!(mask)
959 )
960 );
961 assert_eq!(
962 unsafe { &(*(::std::ptr::null::<RTCRay4>())).id as *const _ as usize },
963 160usize,
964 concat!(
965 "Offset of field: ",
966 stringify!(RTCRay4),
967 "::",
968 stringify!(id)
969 )
970 );
971 assert_eq!(
972 unsafe { &(*(::std::ptr::null::<RTCRay4>())).flags as *const _ as usize },
973 176usize,
974 concat!(
975 "Offset of field: ",
976 stringify!(RTCRay4),
977 "::",
978 stringify!(flags)
979 )
980 );
981}
982#[repr(C)]
983#[repr(align(16))]
984#[derive(Debug, Copy, Clone)]
985pub struct RTCHit4 {
986 pub Ng_x: [f32; 4usize],
987 pub Ng_y: [f32; 4usize],
988 pub Ng_z: [f32; 4usize],
989 pub u: [f32; 4usize],
990 pub v: [f32; 4usize],
991 pub primID: [::std::os::raw::c_uint; 4usize],
992 pub geomID: [::std::os::raw::c_uint; 4usize],
993 pub instID: [[::std::os::raw::c_uint; 4usize]; 1usize],
994}
995#[test]
996fn bindgen_test_layout_RTCHit4() {
997 assert_eq!(
998 ::std::mem::size_of::<RTCHit4>(),
999 128usize,
1000 concat!("Size of: ", stringify!(RTCHit4))
1001 );
1002 assert_eq!(
1003 ::std::mem::align_of::<RTCHit4>(),
1004 16usize,
1005 concat!("Alignment of ", stringify!(RTCHit4))
1006 );
1007 assert_eq!(
1008 unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_x as *const _ as usize },
1009 0usize,
1010 concat!(
1011 "Offset of field: ",
1012 stringify!(RTCHit4),
1013 "::",
1014 stringify!(Ng_x)
1015 )
1016 );
1017 assert_eq!(
1018 unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_y as *const _ as usize },
1019 16usize,
1020 concat!(
1021 "Offset of field: ",
1022 stringify!(RTCHit4),
1023 "::",
1024 stringify!(Ng_y)
1025 )
1026 );
1027 assert_eq!(
1028 unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_z as *const _ as usize },
1029 32usize,
1030 concat!(
1031 "Offset of field: ",
1032 stringify!(RTCHit4),
1033 "::",
1034 stringify!(Ng_z)
1035 )
1036 );
1037 assert_eq!(
1038 unsafe { &(*(::std::ptr::null::<RTCHit4>())).u as *const _ as usize },
1039 48usize,
1040 concat!(
1041 "Offset of field: ",
1042 stringify!(RTCHit4),
1043 "::",
1044 stringify!(u)
1045 )
1046 );
1047 assert_eq!(
1048 unsafe { &(*(::std::ptr::null::<RTCHit4>())).v as *const _ as usize },
1049 64usize,
1050 concat!(
1051 "Offset of field: ",
1052 stringify!(RTCHit4),
1053 "::",
1054 stringify!(v)
1055 )
1056 );
1057 assert_eq!(
1058 unsafe { &(*(::std::ptr::null::<RTCHit4>())).primID as *const _ as usize },
1059 80usize,
1060 concat!(
1061 "Offset of field: ",
1062 stringify!(RTCHit4),
1063 "::",
1064 stringify!(primID)
1065 )
1066 );
1067 assert_eq!(
1068 unsafe { &(*(::std::ptr::null::<RTCHit4>())).geomID as *const _ as usize },
1069 96usize,
1070 concat!(
1071 "Offset of field: ",
1072 stringify!(RTCHit4),
1073 "::",
1074 stringify!(geomID)
1075 )
1076 );
1077 assert_eq!(
1078 unsafe { &(*(::std::ptr::null::<RTCHit4>())).instID as *const _ as usize },
1079 112usize,
1080 concat!(
1081 "Offset of field: ",
1082 stringify!(RTCHit4),
1083 "::",
1084 stringify!(instID)
1085 )
1086 );
1087}
1088#[repr(C)]
1089#[repr(align(16))]
1090#[derive(Debug, Copy, Clone)]
1091pub struct RTCRayHit4 {
1092 pub ray: RTCRay4,
1093 pub hit: RTCHit4,
1094}
1095#[test]
1096fn bindgen_test_layout_RTCRayHit4() {
1097 assert_eq!(
1098 ::std::mem::size_of::<RTCRayHit4>(),
1099 320usize,
1100 concat!("Size of: ", stringify!(RTCRayHit4))
1101 );
1102 assert_eq!(
1103 ::std::mem::align_of::<RTCRayHit4>(),
1104 16usize,
1105 concat!("Alignment of ", stringify!(RTCRayHit4))
1106 );
1107 assert_eq!(
1108 unsafe { &(*(::std::ptr::null::<RTCRayHit4>())).ray as *const _ as usize },
1109 0usize,
1110 concat!(
1111 "Offset of field: ",
1112 stringify!(RTCRayHit4),
1113 "::",
1114 stringify!(ray)
1115 )
1116 );
1117 assert_eq!(
1118 unsafe { &(*(::std::ptr::null::<RTCRayHit4>())).hit as *const _ as usize },
1119 192usize,
1120 concat!(
1121 "Offset of field: ",
1122 stringify!(RTCRayHit4),
1123 "::",
1124 stringify!(hit)
1125 )
1126 );
1127}
1128#[repr(C)]
1129#[repr(align(32))]
1130#[derive(Debug, Copy, Clone)]
1131pub struct RTCRay8 {
1132 pub org_x: [f32; 8usize],
1133 pub org_y: [f32; 8usize],
1134 pub org_z: [f32; 8usize],
1135 pub tnear: [f32; 8usize],
1136 pub dir_x: [f32; 8usize],
1137 pub dir_y: [f32; 8usize],
1138 pub dir_z: [f32; 8usize],
1139 pub time: [f32; 8usize],
1140 pub tfar: [f32; 8usize],
1141 pub mask: [::std::os::raw::c_uint; 8usize],
1142 pub id: [::std::os::raw::c_uint; 8usize],
1143 pub flags: [::std::os::raw::c_uint; 8usize],
1144}
1145#[test]
1146fn bindgen_test_layout_RTCRay8() {
1147 assert_eq!(
1148 ::std::mem::size_of::<RTCRay8>(),
1149 384usize,
1150 concat!("Size of: ", stringify!(RTCRay8))
1151 );
1152 assert_eq!(
1153 ::std::mem::align_of::<RTCRay8>(),
1154 32usize,
1155 concat!("Alignment of ", stringify!(RTCRay8))
1156 );
1157 assert_eq!(
1158 unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_x as *const _ as usize },
1159 0usize,
1160 concat!(
1161 "Offset of field: ",
1162 stringify!(RTCRay8),
1163 "::",
1164 stringify!(org_x)
1165 )
1166 );
1167 assert_eq!(
1168 unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_y as *const _ as usize },
1169 32usize,
1170 concat!(
1171 "Offset of field: ",
1172 stringify!(RTCRay8),
1173 "::",
1174 stringify!(org_y)
1175 )
1176 );
1177 assert_eq!(
1178 unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_z as *const _ as usize },
1179 64usize,
1180 concat!(
1181 "Offset of field: ",
1182 stringify!(RTCRay8),
1183 "::",
1184 stringify!(org_z)
1185 )
1186 );
1187 assert_eq!(
1188 unsafe { &(*(::std::ptr::null::<RTCRay8>())).tnear as *const _ as usize },
1189 96usize,
1190 concat!(
1191 "Offset of field: ",
1192 stringify!(RTCRay8),
1193 "::",
1194 stringify!(tnear)
1195 )
1196 );
1197 assert_eq!(
1198 unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_x as *const _ as usize },
1199 128usize,
1200 concat!(
1201 "Offset of field: ",
1202 stringify!(RTCRay8),
1203 "::",
1204 stringify!(dir_x)
1205 )
1206 );
1207 assert_eq!(
1208 unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_y as *const _ as usize },
1209 160usize,
1210 concat!(
1211 "Offset of field: ",
1212 stringify!(RTCRay8),
1213 "::",
1214 stringify!(dir_y)
1215 )
1216 );
1217 assert_eq!(
1218 unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_z as *const _ as usize },
1219 192usize,
1220 concat!(
1221 "Offset of field: ",
1222 stringify!(RTCRay8),
1223 "::",
1224 stringify!(dir_z)
1225 )
1226 );
1227 assert_eq!(
1228 unsafe { &(*(::std::ptr::null::<RTCRay8>())).time as *const _ as usize },
1229 224usize,
1230 concat!(
1231 "Offset of field: ",
1232 stringify!(RTCRay8),
1233 "::",
1234 stringify!(time)
1235 )
1236 );
1237 assert_eq!(
1238 unsafe { &(*(::std::ptr::null::<RTCRay8>())).tfar as *const _ as usize },
1239 256usize,
1240 concat!(
1241 "Offset of field: ",
1242 stringify!(RTCRay8),
1243 "::",
1244 stringify!(tfar)
1245 )
1246 );
1247 assert_eq!(
1248 unsafe { &(*(::std::ptr::null::<RTCRay8>())).mask as *const _ as usize },
1249 288usize,
1250 concat!(
1251 "Offset of field: ",
1252 stringify!(RTCRay8),
1253 "::",
1254 stringify!(mask)
1255 )
1256 );
1257 assert_eq!(
1258 unsafe { &(*(::std::ptr::null::<RTCRay8>())).id as *const _ as usize },
1259 320usize,
1260 concat!(
1261 "Offset of field: ",
1262 stringify!(RTCRay8),
1263 "::",
1264 stringify!(id)
1265 )
1266 );
1267 assert_eq!(
1268 unsafe { &(*(::std::ptr::null::<RTCRay8>())).flags as *const _ as usize },
1269 352usize,
1270 concat!(
1271 "Offset of field: ",
1272 stringify!(RTCRay8),
1273 "::",
1274 stringify!(flags)
1275 )
1276 );
1277}
1278#[repr(C)]
1279#[repr(align(32))]
1280#[derive(Debug, Copy, Clone)]
1281pub struct RTCHit8 {
1282 pub Ng_x: [f32; 8usize],
1283 pub Ng_y: [f32; 8usize],
1284 pub Ng_z: [f32; 8usize],
1285 pub u: [f32; 8usize],
1286 pub v: [f32; 8usize],
1287 pub primID: [::std::os::raw::c_uint; 8usize],
1288 pub geomID: [::std::os::raw::c_uint; 8usize],
1289 pub instID: [[::std::os::raw::c_uint; 8usize]; 1usize],
1290}
1291#[test]
1292fn bindgen_test_layout_RTCHit8() {
1293 assert_eq!(
1294 ::std::mem::size_of::<RTCHit8>(),
1295 256usize,
1296 concat!("Size of: ", stringify!(RTCHit8))
1297 );
1298 assert_eq!(
1299 ::std::mem::align_of::<RTCHit8>(),
1300 32usize,
1301 concat!("Alignment of ", stringify!(RTCHit8))
1302 );
1303 assert_eq!(
1304 unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_x as *const _ as usize },
1305 0usize,
1306 concat!(
1307 "Offset of field: ",
1308 stringify!(RTCHit8),
1309 "::",
1310 stringify!(Ng_x)
1311 )
1312 );
1313 assert_eq!(
1314 unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_y as *const _ as usize },
1315 32usize,
1316 concat!(
1317 "Offset of field: ",
1318 stringify!(RTCHit8),
1319 "::",
1320 stringify!(Ng_y)
1321 )
1322 );
1323 assert_eq!(
1324 unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_z as *const _ as usize },
1325 64usize,
1326 concat!(
1327 "Offset of field: ",
1328 stringify!(RTCHit8),
1329 "::",
1330 stringify!(Ng_z)
1331 )
1332 );
1333 assert_eq!(
1334 unsafe { &(*(::std::ptr::null::<RTCHit8>())).u as *const _ as usize },
1335 96usize,
1336 concat!(
1337 "Offset of field: ",
1338 stringify!(RTCHit8),
1339 "::",
1340 stringify!(u)
1341 )
1342 );
1343 assert_eq!(
1344 unsafe { &(*(::std::ptr::null::<RTCHit8>())).v as *const _ as usize },
1345 128usize,
1346 concat!(
1347 "Offset of field: ",
1348 stringify!(RTCHit8),
1349 "::",
1350 stringify!(v)
1351 )
1352 );
1353 assert_eq!(
1354 unsafe { &(*(::std::ptr::null::<RTCHit8>())).primID as *const _ as usize },
1355 160usize,
1356 concat!(
1357 "Offset of field: ",
1358 stringify!(RTCHit8),
1359 "::",
1360 stringify!(primID)
1361 )
1362 );
1363 assert_eq!(
1364 unsafe { &(*(::std::ptr::null::<RTCHit8>())).geomID as *const _ as usize },
1365 192usize,
1366 concat!(
1367 "Offset of field: ",
1368 stringify!(RTCHit8),
1369 "::",
1370 stringify!(geomID)
1371 )
1372 );
1373 assert_eq!(
1374 unsafe { &(*(::std::ptr::null::<RTCHit8>())).instID as *const _ as usize },
1375 224usize,
1376 concat!(
1377 "Offset of field: ",
1378 stringify!(RTCHit8),
1379 "::",
1380 stringify!(instID)
1381 )
1382 );
1383}
1384#[repr(C)]
1385#[repr(align(32))]
1386#[derive(Debug, Copy, Clone)]
1387pub struct RTCRayHit8 {
1388 pub ray: RTCRay8,
1389 pub hit: RTCHit8,
1390}
1391#[test]
1392fn bindgen_test_layout_RTCRayHit8() {
1393 assert_eq!(
1394 ::std::mem::size_of::<RTCRayHit8>(),
1395 640usize,
1396 concat!("Size of: ", stringify!(RTCRayHit8))
1397 );
1398 assert_eq!(
1399 ::std::mem::align_of::<RTCRayHit8>(),
1400 32usize,
1401 concat!("Alignment of ", stringify!(RTCRayHit8))
1402 );
1403 assert_eq!(
1404 unsafe { &(*(::std::ptr::null::<RTCRayHit8>())).ray as *const _ as usize },
1405 0usize,
1406 concat!(
1407 "Offset of field: ",
1408 stringify!(RTCRayHit8),
1409 "::",
1410 stringify!(ray)
1411 )
1412 );
1413 assert_eq!(
1414 unsafe { &(*(::std::ptr::null::<RTCRayHit8>())).hit as *const _ as usize },
1415 384usize,
1416 concat!(
1417 "Offset of field: ",
1418 stringify!(RTCRayHit8),
1419 "::",
1420 stringify!(hit)
1421 )
1422 );
1423}
1424#[repr(C)]
1425#[repr(align(64))]
1426#[derive(Copy, Clone)]
1427pub struct RTCRay16 {
1428 pub org_x: [f32; 16usize],
1429 pub org_y: [f32; 16usize],
1430 pub org_z: [f32; 16usize],
1431 pub tnear: [f32; 16usize],
1432 pub dir_x: [f32; 16usize],
1433 pub dir_y: [f32; 16usize],
1434 pub dir_z: [f32; 16usize],
1435 pub time: [f32; 16usize],
1436 pub tfar: [f32; 16usize],
1437 pub mask: [::std::os::raw::c_uint; 16usize],
1438 pub id: [::std::os::raw::c_uint; 16usize],
1439 pub flags: [::std::os::raw::c_uint; 16usize],
1440}
1441#[test]
1442fn bindgen_test_layout_RTCRay16() {
1443 assert_eq!(
1444 ::std::mem::size_of::<RTCRay16>(),
1445 768usize,
1446 concat!("Size of: ", stringify!(RTCRay16))
1447 );
1448 assert_eq!(
1449 ::std::mem::align_of::<RTCRay16>(),
1450 64usize,
1451 concat!("Alignment of ", stringify!(RTCRay16))
1452 );
1453 assert_eq!(
1454 unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_x as *const _ as usize },
1455 0usize,
1456 concat!(
1457 "Offset of field: ",
1458 stringify!(RTCRay16),
1459 "::",
1460 stringify!(org_x)
1461 )
1462 );
1463 assert_eq!(
1464 unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_y as *const _ as usize },
1465 64usize,
1466 concat!(
1467 "Offset of field: ",
1468 stringify!(RTCRay16),
1469 "::",
1470 stringify!(org_y)
1471 )
1472 );
1473 assert_eq!(
1474 unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_z as *const _ as usize },
1475 128usize,
1476 concat!(
1477 "Offset of field: ",
1478 stringify!(RTCRay16),
1479 "::",
1480 stringify!(org_z)
1481 )
1482 );
1483 assert_eq!(
1484 unsafe { &(*(::std::ptr::null::<RTCRay16>())).tnear as *const _ as usize },
1485 192usize,
1486 concat!(
1487 "Offset of field: ",
1488 stringify!(RTCRay16),
1489 "::",
1490 stringify!(tnear)
1491 )
1492 );
1493 assert_eq!(
1494 unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_x as *const _ as usize },
1495 256usize,
1496 concat!(
1497 "Offset of field: ",
1498 stringify!(RTCRay16),
1499 "::",
1500 stringify!(dir_x)
1501 )
1502 );
1503 assert_eq!(
1504 unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_y as *const _ as usize },
1505 320usize,
1506 concat!(
1507 "Offset of field: ",
1508 stringify!(RTCRay16),
1509 "::",
1510 stringify!(dir_y)
1511 )
1512 );
1513 assert_eq!(
1514 unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_z as *const _ as usize },
1515 384usize,
1516 concat!(
1517 "Offset of field: ",
1518 stringify!(RTCRay16),
1519 "::",
1520 stringify!(dir_z)
1521 )
1522 );
1523 assert_eq!(
1524 unsafe { &(*(::std::ptr::null::<RTCRay16>())).time as *const _ as usize },
1525 448usize,
1526 concat!(
1527 "Offset of field: ",
1528 stringify!(RTCRay16),
1529 "::",
1530 stringify!(time)
1531 )
1532 );
1533 assert_eq!(
1534 unsafe { &(*(::std::ptr::null::<RTCRay16>())).tfar as *const _ as usize },
1535 512usize,
1536 concat!(
1537 "Offset of field: ",
1538 stringify!(RTCRay16),
1539 "::",
1540 stringify!(tfar)
1541 )
1542 );
1543 assert_eq!(
1544 unsafe { &(*(::std::ptr::null::<RTCRay16>())).mask as *const _ as usize },
1545 576usize,
1546 concat!(
1547 "Offset of field: ",
1548 stringify!(RTCRay16),
1549 "::",
1550 stringify!(mask)
1551 )
1552 );
1553 assert_eq!(
1554 unsafe { &(*(::std::ptr::null::<RTCRay16>())).id as *const _ as usize },
1555 640usize,
1556 concat!(
1557 "Offset of field: ",
1558 stringify!(RTCRay16),
1559 "::",
1560 stringify!(id)
1561 )
1562 );
1563 assert_eq!(
1564 unsafe { &(*(::std::ptr::null::<RTCRay16>())).flags as *const _ as usize },
1565 704usize,
1566 concat!(
1567 "Offset of field: ",
1568 stringify!(RTCRay16),
1569 "::",
1570 stringify!(flags)
1571 )
1572 );
1573}
1574#[repr(C)]
1575#[repr(align(64))]
1576#[derive(Copy, Clone)]
1577pub struct RTCHit16 {
1578 pub Ng_x: [f32; 16usize],
1579 pub Ng_y: [f32; 16usize],
1580 pub Ng_z: [f32; 16usize],
1581 pub u: [f32; 16usize],
1582 pub v: [f32; 16usize],
1583 pub primID: [::std::os::raw::c_uint; 16usize],
1584 pub geomID: [::std::os::raw::c_uint; 16usize],
1585 pub instID: [[::std::os::raw::c_uint; 16usize]; 1usize],
1586}
1587#[test]
1588fn bindgen_test_layout_RTCHit16() {
1589 assert_eq!(
1590 ::std::mem::size_of::<RTCHit16>(),
1591 512usize,
1592 concat!("Size of: ", stringify!(RTCHit16))
1593 );
1594 assert_eq!(
1595 ::std::mem::align_of::<RTCHit16>(),
1596 64usize,
1597 concat!("Alignment of ", stringify!(RTCHit16))
1598 );
1599 assert_eq!(
1600 unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_x as *const _ as usize },
1601 0usize,
1602 concat!(
1603 "Offset of field: ",
1604 stringify!(RTCHit16),
1605 "::",
1606 stringify!(Ng_x)
1607 )
1608 );
1609 assert_eq!(
1610 unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_y as *const _ as usize },
1611 64usize,
1612 concat!(
1613 "Offset of field: ",
1614 stringify!(RTCHit16),
1615 "::",
1616 stringify!(Ng_y)
1617 )
1618 );
1619 assert_eq!(
1620 unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_z as *const _ as usize },
1621 128usize,
1622 concat!(
1623 "Offset of field: ",
1624 stringify!(RTCHit16),
1625 "::",
1626 stringify!(Ng_z)
1627 )
1628 );
1629 assert_eq!(
1630 unsafe { &(*(::std::ptr::null::<RTCHit16>())).u as *const _ as usize },
1631 192usize,
1632 concat!(
1633 "Offset of field: ",
1634 stringify!(RTCHit16),
1635 "::",
1636 stringify!(u)
1637 )
1638 );
1639 assert_eq!(
1640 unsafe { &(*(::std::ptr::null::<RTCHit16>())).v as *const _ as usize },
1641 256usize,
1642 concat!(
1643 "Offset of field: ",
1644 stringify!(RTCHit16),
1645 "::",
1646 stringify!(v)
1647 )
1648 );
1649 assert_eq!(
1650 unsafe { &(*(::std::ptr::null::<RTCHit16>())).primID as *const _ as usize },
1651 320usize,
1652 concat!(
1653 "Offset of field: ",
1654 stringify!(RTCHit16),
1655 "::",
1656 stringify!(primID)
1657 )
1658 );
1659 assert_eq!(
1660 unsafe { &(*(::std::ptr::null::<RTCHit16>())).geomID as *const _ as usize },
1661 384usize,
1662 concat!(
1663 "Offset of field: ",
1664 stringify!(RTCHit16),
1665 "::",
1666 stringify!(geomID)
1667 )
1668 );
1669 assert_eq!(
1670 unsafe { &(*(::std::ptr::null::<RTCHit16>())).instID as *const _ as usize },
1671 448usize,
1672 concat!(
1673 "Offset of field: ",
1674 stringify!(RTCHit16),
1675 "::",
1676 stringify!(instID)
1677 )
1678 );
1679}
1680#[repr(C)]
1681#[repr(align(64))]
1682#[derive(Copy, Clone)]
1683pub struct RTCRayHit16 {
1684 pub ray: RTCRay16,
1685 pub hit: RTCHit16,
1686}
1687#[test]
1688fn bindgen_test_layout_RTCRayHit16() {
1689 assert_eq!(
1690 ::std::mem::size_of::<RTCRayHit16>(),
1691 1280usize,
1692 concat!("Size of: ", stringify!(RTCRayHit16))
1693 );
1694 assert_eq!(
1695 ::std::mem::align_of::<RTCRayHit16>(),
1696 64usize,
1697 concat!("Alignment of ", stringify!(RTCRayHit16))
1698 );
1699 assert_eq!(
1700 unsafe { &(*(::std::ptr::null::<RTCRayHit16>())).ray as *const _ as usize },
1701 0usize,
1702 concat!(
1703 "Offset of field: ",
1704 stringify!(RTCRayHit16),
1705 "::",
1706 stringify!(ray)
1707 )
1708 );
1709 assert_eq!(
1710 unsafe { &(*(::std::ptr::null::<RTCRayHit16>())).hit as *const _ as usize },
1711 768usize,
1712 concat!(
1713 "Offset of field: ",
1714 stringify!(RTCRayHit16),
1715 "::",
1716 stringify!(hit)
1717 )
1718 );
1719}
1720#[repr(C)]
1721#[derive(Debug, Copy, Clone)]
1722pub struct RTCRayNp {
1723 pub org_x: *mut f32,
1724 pub org_y: *mut f32,
1725 pub org_z: *mut f32,
1726 pub tnear: *mut f32,
1727 pub dir_x: *mut f32,
1728 pub dir_y: *mut f32,
1729 pub dir_z: *mut f32,
1730 pub time: *mut f32,
1731 pub tfar: *mut f32,
1732 pub mask: *mut ::std::os::raw::c_uint,
1733 pub id: *mut ::std::os::raw::c_uint,
1734 pub flags: *mut ::std::os::raw::c_uint,
1735}
1736#[test]
1737fn bindgen_test_layout_RTCRayNp() {
1738 assert_eq!(
1739 ::std::mem::size_of::<RTCRayNp>(),
1740 96usize,
1741 concat!("Size of: ", stringify!(RTCRayNp))
1742 );
1743 assert_eq!(
1744 ::std::mem::align_of::<RTCRayNp>(),
1745 8usize,
1746 concat!("Alignment of ", stringify!(RTCRayNp))
1747 );
1748 assert_eq!(
1749 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_x as *const _ as usize },
1750 0usize,
1751 concat!(
1752 "Offset of field: ",
1753 stringify!(RTCRayNp),
1754 "::",
1755 stringify!(org_x)
1756 )
1757 );
1758 assert_eq!(
1759 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_y as *const _ as usize },
1760 8usize,
1761 concat!(
1762 "Offset of field: ",
1763 stringify!(RTCRayNp),
1764 "::",
1765 stringify!(org_y)
1766 )
1767 );
1768 assert_eq!(
1769 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_z as *const _ as usize },
1770 16usize,
1771 concat!(
1772 "Offset of field: ",
1773 stringify!(RTCRayNp),
1774 "::",
1775 stringify!(org_z)
1776 )
1777 );
1778 assert_eq!(
1779 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).tnear as *const _ as usize },
1780 24usize,
1781 concat!(
1782 "Offset of field: ",
1783 stringify!(RTCRayNp),
1784 "::",
1785 stringify!(tnear)
1786 )
1787 );
1788 assert_eq!(
1789 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_x as *const _ as usize },
1790 32usize,
1791 concat!(
1792 "Offset of field: ",
1793 stringify!(RTCRayNp),
1794 "::",
1795 stringify!(dir_x)
1796 )
1797 );
1798 assert_eq!(
1799 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_y as *const _ as usize },
1800 40usize,
1801 concat!(
1802 "Offset of field: ",
1803 stringify!(RTCRayNp),
1804 "::",
1805 stringify!(dir_y)
1806 )
1807 );
1808 assert_eq!(
1809 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_z as *const _ as usize },
1810 48usize,
1811 concat!(
1812 "Offset of field: ",
1813 stringify!(RTCRayNp),
1814 "::",
1815 stringify!(dir_z)
1816 )
1817 );
1818 assert_eq!(
1819 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).time as *const _ as usize },
1820 56usize,
1821 concat!(
1822 "Offset of field: ",
1823 stringify!(RTCRayNp),
1824 "::",
1825 stringify!(time)
1826 )
1827 );
1828 assert_eq!(
1829 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).tfar as *const _ as usize },
1830 64usize,
1831 concat!(
1832 "Offset of field: ",
1833 stringify!(RTCRayNp),
1834 "::",
1835 stringify!(tfar)
1836 )
1837 );
1838 assert_eq!(
1839 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).mask as *const _ as usize },
1840 72usize,
1841 concat!(
1842 "Offset of field: ",
1843 stringify!(RTCRayNp),
1844 "::",
1845 stringify!(mask)
1846 )
1847 );
1848 assert_eq!(
1849 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).id as *const _ as usize },
1850 80usize,
1851 concat!(
1852 "Offset of field: ",
1853 stringify!(RTCRayNp),
1854 "::",
1855 stringify!(id)
1856 )
1857 );
1858 assert_eq!(
1859 unsafe { &(*(::std::ptr::null::<RTCRayNp>())).flags as *const _ as usize },
1860 88usize,
1861 concat!(
1862 "Offset of field: ",
1863 stringify!(RTCRayNp),
1864 "::",
1865 stringify!(flags)
1866 )
1867 );
1868}
1869#[repr(C)]
1870#[derive(Debug, Copy, Clone)]
1871pub struct RTCHitNp {
1872 pub Ng_x: *mut f32,
1873 pub Ng_y: *mut f32,
1874 pub Ng_z: *mut f32,
1875 pub u: *mut f32,
1876 pub v: *mut f32,
1877 pub primID: *mut ::std::os::raw::c_uint,
1878 pub geomID: *mut ::std::os::raw::c_uint,
1879 pub instID: [*mut ::std::os::raw::c_uint; 1usize],
1880}
1881#[test]
1882fn bindgen_test_layout_RTCHitNp() {
1883 assert_eq!(
1884 ::std::mem::size_of::<RTCHitNp>(),
1885 64usize,
1886 concat!("Size of: ", stringify!(RTCHitNp))
1887 );
1888 assert_eq!(
1889 ::std::mem::align_of::<RTCHitNp>(),
1890 8usize,
1891 concat!("Alignment of ", stringify!(RTCHitNp))
1892 );
1893 assert_eq!(
1894 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_x as *const _ as usize },
1895 0usize,
1896 concat!(
1897 "Offset of field: ",
1898 stringify!(RTCHitNp),
1899 "::",
1900 stringify!(Ng_x)
1901 )
1902 );
1903 assert_eq!(
1904 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_y as *const _ as usize },
1905 8usize,
1906 concat!(
1907 "Offset of field: ",
1908 stringify!(RTCHitNp),
1909 "::",
1910 stringify!(Ng_y)
1911 )
1912 );
1913 assert_eq!(
1914 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_z as *const _ as usize },
1915 16usize,
1916 concat!(
1917 "Offset of field: ",
1918 stringify!(RTCHitNp),
1919 "::",
1920 stringify!(Ng_z)
1921 )
1922 );
1923 assert_eq!(
1924 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).u as *const _ as usize },
1925 24usize,
1926 concat!(
1927 "Offset of field: ",
1928 stringify!(RTCHitNp),
1929 "::",
1930 stringify!(u)
1931 )
1932 );
1933 assert_eq!(
1934 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).v as *const _ as usize },
1935 32usize,
1936 concat!(
1937 "Offset of field: ",
1938 stringify!(RTCHitNp),
1939 "::",
1940 stringify!(v)
1941 )
1942 );
1943 assert_eq!(
1944 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).primID as *const _ as usize },
1945 40usize,
1946 concat!(
1947 "Offset of field: ",
1948 stringify!(RTCHitNp),
1949 "::",
1950 stringify!(primID)
1951 )
1952 );
1953 assert_eq!(
1954 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).geomID as *const _ as usize },
1955 48usize,
1956 concat!(
1957 "Offset of field: ",
1958 stringify!(RTCHitNp),
1959 "::",
1960 stringify!(geomID)
1961 )
1962 );
1963 assert_eq!(
1964 unsafe { &(*(::std::ptr::null::<RTCHitNp>())).instID as *const _ as usize },
1965 56usize,
1966 concat!(
1967 "Offset of field: ",
1968 stringify!(RTCHitNp),
1969 "::",
1970 stringify!(instID)
1971 )
1972 );
1973}
1974#[repr(C)]
1975#[derive(Debug, Copy, Clone)]
1976pub struct RTCRayHitNp {
1977 pub ray: RTCRayNp,
1978 pub hit: RTCHitNp,
1979}
1980#[test]
1981fn bindgen_test_layout_RTCRayHitNp() {
1982 assert_eq!(
1983 ::std::mem::size_of::<RTCRayHitNp>(),
1984 160usize,
1985 concat!("Size of: ", stringify!(RTCRayHitNp))
1986 );
1987 assert_eq!(
1988 ::std::mem::align_of::<RTCRayHitNp>(),
1989 8usize,
1990 concat!("Alignment of ", stringify!(RTCRayHitNp))
1991 );
1992 assert_eq!(
1993 unsafe { &(*(::std::ptr::null::<RTCRayHitNp>())).ray as *const _ as usize },
1994 0usize,
1995 concat!(
1996 "Offset of field: ",
1997 stringify!(RTCRayHitNp),
1998 "::",
1999 stringify!(ray)
2000 )
2001 );
2002 assert_eq!(
2003 unsafe { &(*(::std::ptr::null::<RTCRayHitNp>())).hit as *const _ as usize },
2004 96usize,
2005 concat!(
2006 "Offset of field: ",
2007 stringify!(RTCRayHitNp),
2008 "::",
2009 stringify!(hit)
2010 )
2011 );
2012}
2013#[repr(C)]
2014#[derive(Debug, Copy, Clone)]
2015pub struct RTCRayN {
2016 _unused: [u8; 0],
2017}
2018#[repr(C)]
2019#[derive(Debug, Copy, Clone)]
2020pub struct RTCHitN {
2021 _unused: [u8; 0],
2022}
2023#[repr(C)]
2024#[derive(Debug, Copy, Clone)]
2025pub struct RTCRayHitN {
2026 _unused: [u8; 0],
2027}
2028#[repr(C)]
2029#[derive(Debug, Copy, Clone)]
2030pub struct RTCSceneTy {
2031 _unused: [u8; 0],
2032}
2033pub type RTCScene = *mut RTCSceneTy;
2034#[repr(C)]
2035#[derive(Debug, Copy, Clone)]
2036pub struct RTCGeometryTy {
2037 _unused: [u8; 0],
2038}
2039pub type RTCGeometry = *mut RTCGeometryTy;
2040#[repr(u32)]
2041#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2042pub enum RTCGeometryType {
2043 TRIANGLE = 0,
2044 QUAD = 1,
2045 GRID = 2,
2046 SUBDIVISION = 8,
2047 FLAT_LINEAR_CURVE = 17,
2048 ROUND_BEZIER_CURVE = 24,
2049 FLAT_BEZIER_CURVE = 25,
2050 NORMAL_ORIENTED_BEZIER_CURVE = 26,
2051 ROUND_BSPLINE_CURVE = 32,
2052 FLAT_BSPLINE_CURVE = 33,
2053 NORMAL_ORIENTED_BSPLINE_CURVE = 34,
2054 ROUND_HERMITE_CURVE = 40,
2055 FLAT_HERMITE_CURVE = 41,
2056 NORMAL_ORIENTED_HERMITE_CURVE = 42,
2057 SPHERE_POINT = 50,
2058 DISC_POINT = 51,
2059 ORIENTED_DISC_POINT = 52,
2060 USER = 120,
2061 INSTANCE = 121,
2062}
2063#[repr(u32)]
2064#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2065pub enum RTCSubdivisionMode {
2066 NO_BOUNDARY = 0,
2067 SMOOTH_BOUNDARY = 1,
2068 PIN_CORNERS = 2,
2069 PIN_BOUNDARY = 3,
2070 PIN_ALL = 4,
2071}
2072impl RTCCurveFlags {
2073 pub const NEIGHBOR_LEFT: RTCCurveFlags = RTCCurveFlags(1);
2074}
2075impl RTCCurveFlags {
2076 pub const NEIGHBOR_RIGHT: RTCCurveFlags = RTCCurveFlags(2);
2077}
2078impl ::std::ops::BitOr<RTCCurveFlags> for RTCCurveFlags {
2079 type Output = Self;
2080 #[inline]
2081 fn bitor(self, other: Self) -> Self {
2082 RTCCurveFlags(self.0 | other.0)
2083 }
2084}
2085impl ::std::ops::BitOrAssign for RTCCurveFlags {
2086 #[inline]
2087 fn bitor_assign(&mut self, rhs: RTCCurveFlags) {
2088 self.0 |= rhs.0;
2089 }
2090}
2091impl ::std::ops::BitAnd<RTCCurveFlags> for RTCCurveFlags {
2092 type Output = Self;
2093 #[inline]
2094 fn bitand(self, other: Self) -> Self {
2095 RTCCurveFlags(self.0 & other.0)
2096 }
2097}
2098impl ::std::ops::BitAndAssign for RTCCurveFlags {
2099 #[inline]
2100 fn bitand_assign(&mut self, rhs: RTCCurveFlags) {
2101 self.0 &= rhs.0;
2102 }
2103}
2104#[repr(transparent)]
2105#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
2106pub struct RTCCurveFlags(pub u32);
2107#[repr(C)]
2108#[derive(Debug, Copy, Clone)]
2109pub struct RTCBoundsFunctionArguments {
2110 pub geometryUserPtr: *mut ::std::os::raw::c_void,
2111 pub primID: ::std::os::raw::c_uint,
2112 pub timeStep: ::std::os::raw::c_uint,
2113 pub bounds_o: *mut RTCBounds,
2114}
2115#[test]
2116fn bindgen_test_layout_RTCBoundsFunctionArguments() {
2117 assert_eq!(
2118 ::std::mem::size_of::<RTCBoundsFunctionArguments>(),
2119 24usize,
2120 concat!("Size of: ", stringify!(RTCBoundsFunctionArguments))
2121 );
2122 assert_eq!(
2123 ::std::mem::align_of::<RTCBoundsFunctionArguments>(),
2124 8usize,
2125 concat!("Alignment of ", stringify!(RTCBoundsFunctionArguments))
2126 );
2127 assert_eq!(
2128 unsafe {
2129 &(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).geometryUserPtr as *const _
2130 as usize
2131 },
2132 0usize,
2133 concat!(
2134 "Offset of field: ",
2135 stringify!(RTCBoundsFunctionArguments),
2136 "::",
2137 stringify!(geometryUserPtr)
2138 )
2139 );
2140 assert_eq!(
2141 unsafe {
2142 &(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).primID as *const _ as usize
2143 },
2144 8usize,
2145 concat!(
2146 "Offset of field: ",
2147 stringify!(RTCBoundsFunctionArguments),
2148 "::",
2149 stringify!(primID)
2150 )
2151 );
2152 assert_eq!(
2153 unsafe {
2154 &(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).timeStep as *const _ as usize
2155 },
2156 12usize,
2157 concat!(
2158 "Offset of field: ",
2159 stringify!(RTCBoundsFunctionArguments),
2160 "::",
2161 stringify!(timeStep)
2162 )
2163 );
2164 assert_eq!(
2165 unsafe {
2166 &(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).bounds_o as *const _ as usize
2167 },
2168 16usize,
2169 concat!(
2170 "Offset of field: ",
2171 stringify!(RTCBoundsFunctionArguments),
2172 "::",
2173 stringify!(bounds_o)
2174 )
2175 );
2176}
2177pub type RTCBoundsFunction =
2178 ::std::option::Option<unsafe extern "C" fn(args: *const RTCBoundsFunctionArguments)>;
2179#[repr(C)]
2180#[derive(Debug, Copy, Clone)]
2181pub struct RTCIntersectFunctionNArguments {
2182 pub valid: *mut ::std::os::raw::c_int,
2183 pub geometryUserPtr: *mut ::std::os::raw::c_void,
2184 pub primID: ::std::os::raw::c_uint,
2185 pub context: *mut RTCIntersectContext,
2186 pub rayhit: *mut RTCRayHitN,
2187 pub N: ::std::os::raw::c_uint,
2188}
2189#[test]
2190fn bindgen_test_layout_RTCIntersectFunctionNArguments() {
2191 assert_eq!(
2192 ::std::mem::size_of::<RTCIntersectFunctionNArguments>(),
2193 48usize,
2194 concat!("Size of: ", stringify!(RTCIntersectFunctionNArguments))
2195 );
2196 assert_eq!(
2197 ::std::mem::align_of::<RTCIntersectFunctionNArguments>(),
2198 8usize,
2199 concat!("Alignment of ", stringify!(RTCIntersectFunctionNArguments))
2200 );
2201 assert_eq!(
2202 unsafe {
2203 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).valid as *const _ as usize
2204 },
2205 0usize,
2206 concat!(
2207 "Offset of field: ",
2208 stringify!(RTCIntersectFunctionNArguments),
2209 "::",
2210 stringify!(valid)
2211 )
2212 );
2213 assert_eq!(
2214 unsafe {
2215 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).geometryUserPtr as *const _
2216 as usize
2217 },
2218 8usize,
2219 concat!(
2220 "Offset of field: ",
2221 stringify!(RTCIntersectFunctionNArguments),
2222 "::",
2223 stringify!(geometryUserPtr)
2224 )
2225 );
2226 assert_eq!(
2227 unsafe {
2228 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).primID as *const _ as usize
2229 },
2230 16usize,
2231 concat!(
2232 "Offset of field: ",
2233 stringify!(RTCIntersectFunctionNArguments),
2234 "::",
2235 stringify!(primID)
2236 )
2237 );
2238 assert_eq!(
2239 unsafe {
2240 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).context as *const _ as usize
2241 },
2242 24usize,
2243 concat!(
2244 "Offset of field: ",
2245 stringify!(RTCIntersectFunctionNArguments),
2246 "::",
2247 stringify!(context)
2248 )
2249 );
2250 assert_eq!(
2251 unsafe {
2252 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).rayhit as *const _ as usize
2253 },
2254 32usize,
2255 concat!(
2256 "Offset of field: ",
2257 stringify!(RTCIntersectFunctionNArguments),
2258 "::",
2259 stringify!(rayhit)
2260 )
2261 );
2262 assert_eq!(
2263 unsafe {
2264 &(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).N as *const _ as usize
2265 },
2266 40usize,
2267 concat!(
2268 "Offset of field: ",
2269 stringify!(RTCIntersectFunctionNArguments),
2270 "::",
2271 stringify!(N)
2272 )
2273 );
2274}
2275pub type RTCIntersectFunctionN =
2276 ::std::option::Option<unsafe extern "C" fn(args: *const RTCIntersectFunctionNArguments)>;
2277#[repr(C)]
2278#[derive(Debug, Copy, Clone)]
2279pub struct RTCOccludedFunctionNArguments {
2280 pub valid: *mut ::std::os::raw::c_int,
2281 pub geometryUserPtr: *mut ::std::os::raw::c_void,
2282 pub primID: ::std::os::raw::c_uint,
2283 pub context: *mut RTCIntersectContext,
2284 pub ray: *mut RTCRayN,
2285 pub N: ::std::os::raw::c_uint,
2286}
2287#[test]
2288fn bindgen_test_layout_RTCOccludedFunctionNArguments() {
2289 assert_eq!(
2290 ::std::mem::size_of::<RTCOccludedFunctionNArguments>(),
2291 48usize,
2292 concat!("Size of: ", stringify!(RTCOccludedFunctionNArguments))
2293 );
2294 assert_eq!(
2295 ::std::mem::align_of::<RTCOccludedFunctionNArguments>(),
2296 8usize,
2297 concat!("Alignment of ", stringify!(RTCOccludedFunctionNArguments))
2298 );
2299 assert_eq!(
2300 unsafe {
2301 &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).valid as *const _ as usize
2302 },
2303 0usize,
2304 concat!(
2305 "Offset of field: ",
2306 stringify!(RTCOccludedFunctionNArguments),
2307 "::",
2308 stringify!(valid)
2309 )
2310 );
2311 assert_eq!(
2312 unsafe {
2313 &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).geometryUserPtr as *const _
2314 as usize
2315 },
2316 8usize,
2317 concat!(
2318 "Offset of field: ",
2319 stringify!(RTCOccludedFunctionNArguments),
2320 "::",
2321 stringify!(geometryUserPtr)
2322 )
2323 );
2324 assert_eq!(
2325 unsafe {
2326 &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).primID as *const _ as usize
2327 },
2328 16usize,
2329 concat!(
2330 "Offset of field: ",
2331 stringify!(RTCOccludedFunctionNArguments),
2332 "::",
2333 stringify!(primID)
2334 )
2335 );
2336 assert_eq!(
2337 unsafe {
2338 &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).context as *const _ as usize
2339 },
2340 24usize,
2341 concat!(
2342 "Offset of field: ",
2343 stringify!(RTCOccludedFunctionNArguments),
2344 "::",
2345 stringify!(context)
2346 )
2347 );
2348 assert_eq!(
2349 unsafe {
2350 &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).ray as *const _ as usize
2351 },
2352 32usize,
2353 concat!(
2354 "Offset of field: ",
2355 stringify!(RTCOccludedFunctionNArguments),
2356 "::",
2357 stringify!(ray)
2358 )
2359 );
2360 assert_eq!(
2361 unsafe { &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).N as *const _ as usize },
2362 40usize,
2363 concat!(
2364 "Offset of field: ",
2365 stringify!(RTCOccludedFunctionNArguments),
2366 "::",
2367 stringify!(N)
2368 )
2369 );
2370}
2371pub type RTCOccludedFunctionN =
2372 ::std::option::Option<unsafe extern "C" fn(args: *const RTCOccludedFunctionNArguments)>;
2373#[repr(C)]
2374#[derive(Debug, Copy, Clone)]
2375pub struct RTCDisplacementFunctionNArguments {
2376 pub geometryUserPtr: *mut ::std::os::raw::c_void,
2377 pub geometry: RTCGeometry,
2378 pub primID: ::std::os::raw::c_uint,
2379 pub timeStep: ::std::os::raw::c_uint,
2380 pub u: *const f32,
2381 pub v: *const f32,
2382 pub Ng_x: *const f32,
2383 pub Ng_y: *const f32,
2384 pub Ng_z: *const f32,
2385 pub P_x: *mut f32,
2386 pub P_y: *mut f32,
2387 pub P_z: *mut f32,
2388 pub N: ::std::os::raw::c_uint,
2389}
2390#[test]
2391fn bindgen_test_layout_RTCDisplacementFunctionNArguments() {
2392 assert_eq!(
2393 ::std::mem::size_of::<RTCDisplacementFunctionNArguments>(),
2394 96usize,
2395 concat!("Size of: ", stringify!(RTCDisplacementFunctionNArguments))
2396 );
2397 assert_eq!(
2398 ::std::mem::align_of::<RTCDisplacementFunctionNArguments>(),
2399 8usize,
2400 concat!(
2401 "Alignment of ",
2402 stringify!(RTCDisplacementFunctionNArguments)
2403 )
2404 );
2405 assert_eq!(
2406 unsafe {
2407 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).geometryUserPtr
2408 as *const _ as usize
2409 },
2410 0usize,
2411 concat!(
2412 "Offset of field: ",
2413 stringify!(RTCDisplacementFunctionNArguments),
2414 "::",
2415 stringify!(geometryUserPtr)
2416 )
2417 );
2418 assert_eq!(
2419 unsafe {
2420 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).geometry as *const _
2421 as usize
2422 },
2423 8usize,
2424 concat!(
2425 "Offset of field: ",
2426 stringify!(RTCDisplacementFunctionNArguments),
2427 "::",
2428 stringify!(geometry)
2429 )
2430 );
2431 assert_eq!(
2432 unsafe {
2433 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).primID as *const _
2434 as usize
2435 },
2436 16usize,
2437 concat!(
2438 "Offset of field: ",
2439 stringify!(RTCDisplacementFunctionNArguments),
2440 "::",
2441 stringify!(primID)
2442 )
2443 );
2444 assert_eq!(
2445 unsafe {
2446 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).timeStep as *const _
2447 as usize
2448 },
2449 20usize,
2450 concat!(
2451 "Offset of field: ",
2452 stringify!(RTCDisplacementFunctionNArguments),
2453 "::",
2454 stringify!(timeStep)
2455 )
2456 );
2457 assert_eq!(
2458 unsafe {
2459 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).u as *const _ as usize
2460 },
2461 24usize,
2462 concat!(
2463 "Offset of field: ",
2464 stringify!(RTCDisplacementFunctionNArguments),
2465 "::",
2466 stringify!(u)
2467 )
2468 );
2469 assert_eq!(
2470 unsafe {
2471 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).v as *const _ as usize
2472 },
2473 32usize,
2474 concat!(
2475 "Offset of field: ",
2476 stringify!(RTCDisplacementFunctionNArguments),
2477 "::",
2478 stringify!(v)
2479 )
2480 );
2481 assert_eq!(
2482 unsafe {
2483 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_x as *const _ as usize
2484 },
2485 40usize,
2486 concat!(
2487 "Offset of field: ",
2488 stringify!(RTCDisplacementFunctionNArguments),
2489 "::",
2490 stringify!(Ng_x)
2491 )
2492 );
2493 assert_eq!(
2494 unsafe {
2495 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_y as *const _ as usize
2496 },
2497 48usize,
2498 concat!(
2499 "Offset of field: ",
2500 stringify!(RTCDisplacementFunctionNArguments),
2501 "::",
2502 stringify!(Ng_y)
2503 )
2504 );
2505 assert_eq!(
2506 unsafe {
2507 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_z as *const _ as usize
2508 },
2509 56usize,
2510 concat!(
2511 "Offset of field: ",
2512 stringify!(RTCDisplacementFunctionNArguments),
2513 "::",
2514 stringify!(Ng_z)
2515 )
2516 );
2517 assert_eq!(
2518 unsafe {
2519 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_x as *const _ as usize
2520 },
2521 64usize,
2522 concat!(
2523 "Offset of field: ",
2524 stringify!(RTCDisplacementFunctionNArguments),
2525 "::",
2526 stringify!(P_x)
2527 )
2528 );
2529 assert_eq!(
2530 unsafe {
2531 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_y as *const _ as usize
2532 },
2533 72usize,
2534 concat!(
2535 "Offset of field: ",
2536 stringify!(RTCDisplacementFunctionNArguments),
2537 "::",
2538 stringify!(P_y)
2539 )
2540 );
2541 assert_eq!(
2542 unsafe {
2543 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_z as *const _ as usize
2544 },
2545 80usize,
2546 concat!(
2547 "Offset of field: ",
2548 stringify!(RTCDisplacementFunctionNArguments),
2549 "::",
2550 stringify!(P_z)
2551 )
2552 );
2553 assert_eq!(
2554 unsafe {
2555 &(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).N as *const _ as usize
2556 },
2557 88usize,
2558 concat!(
2559 "Offset of field: ",
2560 stringify!(RTCDisplacementFunctionNArguments),
2561 "::",
2562 stringify!(N)
2563 )
2564 );
2565}
2566pub type RTCDisplacementFunctionN =
2567 ::std::option::Option<unsafe extern "C" fn(args: *const RTCDisplacementFunctionNArguments)>;
2568extern "C" {
2569 pub fn rtcNewGeometry(device: RTCDevice, type_: RTCGeometryType) -> RTCGeometry;
2570}
2571extern "C" {
2572 pub fn rtcRetainGeometry(geometry: RTCGeometry);
2573}
2574extern "C" {
2575 pub fn rtcReleaseGeometry(geometry: RTCGeometry);
2576}
2577extern "C" {
2578 pub fn rtcCommitGeometry(geometry: RTCGeometry);
2579}
2580extern "C" {
2581 pub fn rtcEnableGeometry(geometry: RTCGeometry);
2582}
2583extern "C" {
2584 pub fn rtcDisableGeometry(geometry: RTCGeometry);
2585}
2586extern "C" {
2587 pub fn rtcSetGeometryTimeStepCount(
2588 geometry: RTCGeometry,
2589 timeStepCount: ::std::os::raw::c_uint,
2590 );
2591}
2592extern "C" {
2593 pub fn rtcSetGeometryTimeRange(geometry: RTCGeometry, startTime: f32, endTime: f32);
2594}
2595extern "C" {
2596 pub fn rtcSetGeometryVertexAttributeCount(
2597 geometry: RTCGeometry,
2598 vertexAttributeCount: ::std::os::raw::c_uint,
2599 );
2600}
2601extern "C" {
2602 pub fn rtcSetGeometryMask(geometry: RTCGeometry, mask: ::std::os::raw::c_uint);
2603}
2604extern "C" {
2605 pub fn rtcSetGeometryBuildQuality(geometry: RTCGeometry, quality: RTCBuildQuality);
2606}
2607extern "C" {
2608 pub fn rtcSetGeometryBuffer(
2609 geometry: RTCGeometry,
2610 type_: RTCBufferType,
2611 slot: ::std::os::raw::c_uint,
2612 format: RTCFormat,
2613 buffer: RTCBuffer,
2614 byteOffset: usize,
2615 byteStride: usize,
2616 itemCount: usize,
2617 );
2618}
2619extern "C" {
2620 pub fn rtcSetSharedGeometryBuffer(
2621 geometry: RTCGeometry,
2622 type_: RTCBufferType,
2623 slot: ::std::os::raw::c_uint,
2624 format: RTCFormat,
2625 ptr: *const ::std::os::raw::c_void,
2626 byteOffset: usize,
2627 byteStride: usize,
2628 itemCount: usize,
2629 );
2630}
2631extern "C" {
2632 pub fn rtcSetNewGeometryBuffer(
2633 geometry: RTCGeometry,
2634 type_: RTCBufferType,
2635 slot: ::std::os::raw::c_uint,
2636 format: RTCFormat,
2637 byteStride: usize,
2638 itemCount: usize,
2639 ) -> *mut ::std::os::raw::c_void;
2640}
2641extern "C" {
2642 pub fn rtcGetGeometryBufferData(
2643 geometry: RTCGeometry,
2644 type_: RTCBufferType,
2645 slot: ::std::os::raw::c_uint,
2646 ) -> *mut ::std::os::raw::c_void;
2647}
2648extern "C" {
2649 pub fn rtcUpdateGeometryBuffer(
2650 geometry: RTCGeometry,
2651 type_: RTCBufferType,
2652 slot: ::std::os::raw::c_uint,
2653 );
2654}
2655extern "C" {
2656 pub fn rtcSetGeometryIntersectFilterFunction(geometry: RTCGeometry, filter: RTCFilterFunctionN);
2657}
2658extern "C" {
2659 pub fn rtcSetGeometryOccludedFilterFunction(geometry: RTCGeometry, filter: RTCFilterFunctionN);
2660}
2661extern "C" {
2662 pub fn rtcSetGeometryUserData(geometry: RTCGeometry, ptr: *mut ::std::os::raw::c_void);
2663}
2664extern "C" {
2665 pub fn rtcGetGeometryUserData(geometry: RTCGeometry) -> *mut ::std::os::raw::c_void;
2666}
2667extern "C" {
2668 pub fn rtcSetGeometryUserPrimitiveCount(
2669 geometry: RTCGeometry,
2670 userPrimitiveCount: ::std::os::raw::c_uint,
2671 );
2672}
2673extern "C" {
2674 pub fn rtcSetGeometryBoundsFunction(
2675 geometry: RTCGeometry,
2676 bounds: RTCBoundsFunction,
2677 userPtr: *mut ::std::os::raw::c_void,
2678 );
2679}
2680extern "C" {
2681 pub fn rtcSetGeometryIntersectFunction(geometry: RTCGeometry, intersect: RTCIntersectFunctionN);
2682}
2683extern "C" {
2684 pub fn rtcSetGeometryOccludedFunction(geometry: RTCGeometry, occluded: RTCOccludedFunctionN);
2685}
2686extern "C" {
2687 pub fn rtcFilterIntersection(
2688 args: *const RTCIntersectFunctionNArguments,
2689 filterArgs: *const RTCFilterFunctionNArguments,
2690 );
2691}
2692extern "C" {
2693 pub fn rtcFilterOcclusion(
2694 args: *const RTCOccludedFunctionNArguments,
2695 filterArgs: *const RTCFilterFunctionNArguments,
2696 );
2697}
2698extern "C" {
2699 pub fn rtcSetGeometryInstancedScene(geometry: RTCGeometry, scene: RTCScene);
2700}
2701extern "C" {
2702 pub fn rtcSetGeometryTransform(
2703 geometry: RTCGeometry,
2704 timeStep: ::std::os::raw::c_uint,
2705 format: RTCFormat,
2706 xfm: *const ::std::os::raw::c_void,
2707 );
2708}
2709extern "C" {
2710 pub fn rtcGetGeometryTransform(
2711 geometry: RTCGeometry,
2712 time: f32,
2713 format: RTCFormat,
2714 xfm: *mut ::std::os::raw::c_void,
2715 );
2716}
2717extern "C" {
2718 pub fn rtcSetGeometryTessellationRate(geometry: RTCGeometry, tessellationRate: f32);
2719}
2720extern "C" {
2721 pub fn rtcSetGeometryTopologyCount(
2722 geometry: RTCGeometry,
2723 topologyCount: ::std::os::raw::c_uint,
2724 );
2725}
2726extern "C" {
2727 pub fn rtcSetGeometrySubdivisionMode(
2728 geometry: RTCGeometry,
2729 topologyID: ::std::os::raw::c_uint,
2730 mode: RTCSubdivisionMode,
2731 );
2732}
2733extern "C" {
2734 pub fn rtcSetGeometryVertexAttributeTopology(
2735 geometry: RTCGeometry,
2736 vertexAttributeID: ::std::os::raw::c_uint,
2737 topologyID: ::std::os::raw::c_uint,
2738 );
2739}
2740extern "C" {
2741 pub fn rtcSetGeometryDisplacementFunction(
2742 geometry: RTCGeometry,
2743 displacement: RTCDisplacementFunctionN,
2744 );
2745}
2746extern "C" {
2747 pub fn rtcGetGeometryFirstHalfEdge(
2748 geometry: RTCGeometry,
2749 faceID: ::std::os::raw::c_uint,
2750 ) -> ::std::os::raw::c_uint;
2751}
2752extern "C" {
2753 pub fn rtcGetGeometryFace(
2754 geometry: RTCGeometry,
2755 edgeID: ::std::os::raw::c_uint,
2756 ) -> ::std::os::raw::c_uint;
2757}
2758extern "C" {
2759 pub fn rtcGetGeometryNextHalfEdge(
2760 geometry: RTCGeometry,
2761 edgeID: ::std::os::raw::c_uint,
2762 ) -> ::std::os::raw::c_uint;
2763}
2764extern "C" {
2765 pub fn rtcGetGeometryPreviousHalfEdge(
2766 geometry: RTCGeometry,
2767 edgeID: ::std::os::raw::c_uint,
2768 ) -> ::std::os::raw::c_uint;
2769}
2770extern "C" {
2771 pub fn rtcGetGeometryOppositeHalfEdge(
2772 geometry: RTCGeometry,
2773 topologyID: ::std::os::raw::c_uint,
2774 edgeID: ::std::os::raw::c_uint,
2775 ) -> ::std::os::raw::c_uint;
2776}
2777#[repr(C)]
2778#[derive(Debug, Copy, Clone)]
2779pub struct RTCInterpolateArguments {
2780 pub geometry: RTCGeometry,
2781 pub primID: ::std::os::raw::c_uint,
2782 pub u: f32,
2783 pub v: f32,
2784 pub bufferType: RTCBufferType,
2785 pub bufferSlot: ::std::os::raw::c_uint,
2786 pub P: *mut f32,
2787 pub dPdu: *mut f32,
2788 pub dPdv: *mut f32,
2789 pub ddPdudu: *mut f32,
2790 pub ddPdvdv: *mut f32,
2791 pub ddPdudv: *mut f32,
2792 pub valueCount: ::std::os::raw::c_uint,
2793}
2794#[test]
2795fn bindgen_test_layout_RTCInterpolateArguments() {
2796 assert_eq!(
2797 ::std::mem::size_of::<RTCInterpolateArguments>(),
2798 88usize,
2799 concat!("Size of: ", stringify!(RTCInterpolateArguments))
2800 );
2801 assert_eq!(
2802 ::std::mem::align_of::<RTCInterpolateArguments>(),
2803 8usize,
2804 concat!("Alignment of ", stringify!(RTCInterpolateArguments))
2805 );
2806 assert_eq!(
2807 unsafe {
2808 &(*(::std::ptr::null::<RTCInterpolateArguments>())).geometry as *const _ as usize
2809 },
2810 0usize,
2811 concat!(
2812 "Offset of field: ",
2813 stringify!(RTCInterpolateArguments),
2814 "::",
2815 stringify!(geometry)
2816 )
2817 );
2818 assert_eq!(
2819 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).primID as *const _ as usize },
2820 8usize,
2821 concat!(
2822 "Offset of field: ",
2823 stringify!(RTCInterpolateArguments),
2824 "::",
2825 stringify!(primID)
2826 )
2827 );
2828 assert_eq!(
2829 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).u as *const _ as usize },
2830 12usize,
2831 concat!(
2832 "Offset of field: ",
2833 stringify!(RTCInterpolateArguments),
2834 "::",
2835 stringify!(u)
2836 )
2837 );
2838 assert_eq!(
2839 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).v as *const _ as usize },
2840 16usize,
2841 concat!(
2842 "Offset of field: ",
2843 stringify!(RTCInterpolateArguments),
2844 "::",
2845 stringify!(v)
2846 )
2847 );
2848 assert_eq!(
2849 unsafe {
2850 &(*(::std::ptr::null::<RTCInterpolateArguments>())).bufferType as *const _ as usize
2851 },
2852 20usize,
2853 concat!(
2854 "Offset of field: ",
2855 stringify!(RTCInterpolateArguments),
2856 "::",
2857 stringify!(bufferType)
2858 )
2859 );
2860 assert_eq!(
2861 unsafe {
2862 &(*(::std::ptr::null::<RTCInterpolateArguments>())).bufferSlot as *const _ as usize
2863 },
2864 24usize,
2865 concat!(
2866 "Offset of field: ",
2867 stringify!(RTCInterpolateArguments),
2868 "::",
2869 stringify!(bufferSlot)
2870 )
2871 );
2872 assert_eq!(
2873 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).P as *const _ as usize },
2874 32usize,
2875 concat!(
2876 "Offset of field: ",
2877 stringify!(RTCInterpolateArguments),
2878 "::",
2879 stringify!(P)
2880 )
2881 );
2882 assert_eq!(
2883 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).dPdu as *const _ as usize },
2884 40usize,
2885 concat!(
2886 "Offset of field: ",
2887 stringify!(RTCInterpolateArguments),
2888 "::",
2889 stringify!(dPdu)
2890 )
2891 );
2892 assert_eq!(
2893 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).dPdv as *const _ as usize },
2894 48usize,
2895 concat!(
2896 "Offset of field: ",
2897 stringify!(RTCInterpolateArguments),
2898 "::",
2899 stringify!(dPdv)
2900 )
2901 );
2902 assert_eq!(
2903 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdudu as *const _ as usize },
2904 56usize,
2905 concat!(
2906 "Offset of field: ",
2907 stringify!(RTCInterpolateArguments),
2908 "::",
2909 stringify!(ddPdudu)
2910 )
2911 );
2912 assert_eq!(
2913 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdvdv as *const _ as usize },
2914 64usize,
2915 concat!(
2916 "Offset of field: ",
2917 stringify!(RTCInterpolateArguments),
2918 "::",
2919 stringify!(ddPdvdv)
2920 )
2921 );
2922 assert_eq!(
2923 unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdudv as *const _ as usize },
2924 72usize,
2925 concat!(
2926 "Offset of field: ",
2927 stringify!(RTCInterpolateArguments),
2928 "::",
2929 stringify!(ddPdudv)
2930 )
2931 );
2932 assert_eq!(
2933 unsafe {
2934 &(*(::std::ptr::null::<RTCInterpolateArguments>())).valueCount as *const _ as usize
2935 },
2936 80usize,
2937 concat!(
2938 "Offset of field: ",
2939 stringify!(RTCInterpolateArguments),
2940 "::",
2941 stringify!(valueCount)
2942 )
2943 );
2944}
2945extern "C" {
2946 pub fn rtcInterpolate(args: *const RTCInterpolateArguments);
2947}
2948#[repr(C)]
2949#[derive(Debug, Copy, Clone)]
2950pub struct RTCInterpolateNArguments {
2951 pub geometry: RTCGeometry,
2952 pub valid: *const ::std::os::raw::c_void,
2953 pub primIDs: *const ::std::os::raw::c_uint,
2954 pub u: *const f32,
2955 pub v: *const f32,
2956 pub N: ::std::os::raw::c_uint,
2957 pub bufferType: RTCBufferType,
2958 pub bufferSlot: ::std::os::raw::c_uint,
2959 pub P: *mut f32,
2960 pub dPdu: *mut f32,
2961 pub dPdv: *mut f32,
2962 pub ddPdudu: *mut f32,
2963 pub ddPdvdv: *mut f32,
2964 pub ddPdudv: *mut f32,
2965 pub valueCount: ::std::os::raw::c_uint,
2966}
2967#[test]
2968fn bindgen_test_layout_RTCInterpolateNArguments() {
2969 assert_eq!(
2970 ::std::mem::size_of::<RTCInterpolateNArguments>(),
2971 112usize,
2972 concat!("Size of: ", stringify!(RTCInterpolateNArguments))
2973 );
2974 assert_eq!(
2975 ::std::mem::align_of::<RTCInterpolateNArguments>(),
2976 8usize,
2977 concat!("Alignment of ", stringify!(RTCInterpolateNArguments))
2978 );
2979 assert_eq!(
2980 unsafe {
2981 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).geometry as *const _ as usize
2982 },
2983 0usize,
2984 concat!(
2985 "Offset of field: ",
2986 stringify!(RTCInterpolateNArguments),
2987 "::",
2988 stringify!(geometry)
2989 )
2990 );
2991 assert_eq!(
2992 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).valid as *const _ as usize },
2993 8usize,
2994 concat!(
2995 "Offset of field: ",
2996 stringify!(RTCInterpolateNArguments),
2997 "::",
2998 stringify!(valid)
2999 )
3000 );
3001 assert_eq!(
3002 unsafe {
3003 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).primIDs as *const _ as usize
3004 },
3005 16usize,
3006 concat!(
3007 "Offset of field: ",
3008 stringify!(RTCInterpolateNArguments),
3009 "::",
3010 stringify!(primIDs)
3011 )
3012 );
3013 assert_eq!(
3014 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).u as *const _ as usize },
3015 24usize,
3016 concat!(
3017 "Offset of field: ",
3018 stringify!(RTCInterpolateNArguments),
3019 "::",
3020 stringify!(u)
3021 )
3022 );
3023 assert_eq!(
3024 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).v as *const _ as usize },
3025 32usize,
3026 concat!(
3027 "Offset of field: ",
3028 stringify!(RTCInterpolateNArguments),
3029 "::",
3030 stringify!(v)
3031 )
3032 );
3033 assert_eq!(
3034 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).N as *const _ as usize },
3035 40usize,
3036 concat!(
3037 "Offset of field: ",
3038 stringify!(RTCInterpolateNArguments),
3039 "::",
3040 stringify!(N)
3041 )
3042 );
3043 assert_eq!(
3044 unsafe {
3045 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).bufferType as *const _ as usize
3046 },
3047 44usize,
3048 concat!(
3049 "Offset of field: ",
3050 stringify!(RTCInterpolateNArguments),
3051 "::",
3052 stringify!(bufferType)
3053 )
3054 );
3055 assert_eq!(
3056 unsafe {
3057 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).bufferSlot as *const _ as usize
3058 },
3059 48usize,
3060 concat!(
3061 "Offset of field: ",
3062 stringify!(RTCInterpolateNArguments),
3063 "::",
3064 stringify!(bufferSlot)
3065 )
3066 );
3067 assert_eq!(
3068 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).P as *const _ as usize },
3069 56usize,
3070 concat!(
3071 "Offset of field: ",
3072 stringify!(RTCInterpolateNArguments),
3073 "::",
3074 stringify!(P)
3075 )
3076 );
3077 assert_eq!(
3078 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).dPdu as *const _ as usize },
3079 64usize,
3080 concat!(
3081 "Offset of field: ",
3082 stringify!(RTCInterpolateNArguments),
3083 "::",
3084 stringify!(dPdu)
3085 )
3086 );
3087 assert_eq!(
3088 unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).dPdv as *const _ as usize },
3089 72usize,
3090 concat!(
3091 "Offset of field: ",
3092 stringify!(RTCInterpolateNArguments),
3093 "::",
3094 stringify!(dPdv)
3095 )
3096 );
3097 assert_eq!(
3098 unsafe {
3099 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdudu as *const _ as usize
3100 },
3101 80usize,
3102 concat!(
3103 "Offset of field: ",
3104 stringify!(RTCInterpolateNArguments),
3105 "::",
3106 stringify!(ddPdudu)
3107 )
3108 );
3109 assert_eq!(
3110 unsafe {
3111 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdvdv as *const _ as usize
3112 },
3113 88usize,
3114 concat!(
3115 "Offset of field: ",
3116 stringify!(RTCInterpolateNArguments),
3117 "::",
3118 stringify!(ddPdvdv)
3119 )
3120 );
3121 assert_eq!(
3122 unsafe {
3123 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdudv as *const _ as usize
3124 },
3125 96usize,
3126 concat!(
3127 "Offset of field: ",
3128 stringify!(RTCInterpolateNArguments),
3129 "::",
3130 stringify!(ddPdudv)
3131 )
3132 );
3133 assert_eq!(
3134 unsafe {
3135 &(*(::std::ptr::null::<RTCInterpolateNArguments>())).valueCount as *const _ as usize
3136 },
3137 104usize,
3138 concat!(
3139 "Offset of field: ",
3140 stringify!(RTCInterpolateNArguments),
3141 "::",
3142 stringify!(valueCount)
3143 )
3144 );
3145}
3146extern "C" {
3147 pub fn rtcInterpolateN(args: *const RTCInterpolateNArguments);
3148}
3149#[repr(C)]
3150#[derive(Debug, Copy, Clone)]
3151pub struct RTCGrid {
3152 pub startVertexID: ::std::os::raw::c_uint,
3153 pub stride: ::std::os::raw::c_uint,
3154 pub width: ::std::os::raw::c_ushort,
3155 pub height: ::std::os::raw::c_ushort,
3156}
3157#[test]
3158fn bindgen_test_layout_RTCGrid() {
3159 assert_eq!(
3160 ::std::mem::size_of::<RTCGrid>(),
3161 12usize,
3162 concat!("Size of: ", stringify!(RTCGrid))
3163 );
3164 assert_eq!(
3165 ::std::mem::align_of::<RTCGrid>(),
3166 4usize,
3167 concat!("Alignment of ", stringify!(RTCGrid))
3168 );
3169 assert_eq!(
3170 unsafe { &(*(::std::ptr::null::<RTCGrid>())).startVertexID as *const _ as usize },
3171 0usize,
3172 concat!(
3173 "Offset of field: ",
3174 stringify!(RTCGrid),
3175 "::",
3176 stringify!(startVertexID)
3177 )
3178 );
3179 assert_eq!(
3180 unsafe { &(*(::std::ptr::null::<RTCGrid>())).stride as *const _ as usize },
3181 4usize,
3182 concat!(
3183 "Offset of field: ",
3184 stringify!(RTCGrid),
3185 "::",
3186 stringify!(stride)
3187 )
3188 );
3189 assert_eq!(
3190 unsafe { &(*(::std::ptr::null::<RTCGrid>())).width as *const _ as usize },
3191 8usize,
3192 concat!(
3193 "Offset of field: ",
3194 stringify!(RTCGrid),
3195 "::",
3196 stringify!(width)
3197 )
3198 );
3199 assert_eq!(
3200 unsafe { &(*(::std::ptr::null::<RTCGrid>())).height as *const _ as usize },
3201 10usize,
3202 concat!(
3203 "Offset of field: ",
3204 stringify!(RTCGrid),
3205 "::",
3206 stringify!(height)
3207 )
3208 );
3209}
3210impl RTCSceneFlags {
3211 pub const NONE: RTCSceneFlags = RTCSceneFlags(0);
3212}
3213impl RTCSceneFlags {
3214 pub const DYNAMIC: RTCSceneFlags = RTCSceneFlags(1);
3215}
3216impl RTCSceneFlags {
3217 pub const COMPACT: RTCSceneFlags = RTCSceneFlags(2);
3218}
3219impl RTCSceneFlags {
3220 pub const ROBUST: RTCSceneFlags = RTCSceneFlags(4);
3221}
3222impl RTCSceneFlags {
3223 pub const CONTEXT_FILTER_FUNCTION: RTCSceneFlags = RTCSceneFlags(8);
3224}
3225impl ::std::ops::BitOr<RTCSceneFlags> for RTCSceneFlags {
3226 type Output = Self;
3227 #[inline]
3228 fn bitor(self, other: Self) -> Self {
3229 RTCSceneFlags(self.0 | other.0)
3230 }
3231}
3232impl ::std::ops::BitOrAssign for RTCSceneFlags {
3233 #[inline]
3234 fn bitor_assign(&mut self, rhs: RTCSceneFlags) {
3235 self.0 |= rhs.0;
3236 }
3237}
3238impl ::std::ops::BitAnd<RTCSceneFlags> for RTCSceneFlags {
3239 type Output = Self;
3240 #[inline]
3241 fn bitand(self, other: Self) -> Self {
3242 RTCSceneFlags(self.0 & other.0)
3243 }
3244}
3245impl ::std::ops::BitAndAssign for RTCSceneFlags {
3246 #[inline]
3247 fn bitand_assign(&mut self, rhs: RTCSceneFlags) {
3248 self.0 &= rhs.0;
3249 }
3250}
3251#[repr(transparent)]
3252#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3253pub struct RTCSceneFlags(pub u32);
3254extern "C" {
3255 pub fn rtcNewScene(device: RTCDevice) -> RTCScene;
3256}
3257extern "C" {
3258 pub fn rtcRetainScene(scene: RTCScene);
3259}
3260extern "C" {
3261 pub fn rtcReleaseScene(scene: RTCScene);
3262}
3263extern "C" {
3264 pub fn rtcAttachGeometry(scene: RTCScene, geometry: RTCGeometry) -> ::std::os::raw::c_uint;
3265}
3266extern "C" {
3267 pub fn rtcAttachGeometryByID(
3268 scene: RTCScene,
3269 geometry: RTCGeometry,
3270 geomID: ::std::os::raw::c_uint,
3271 );
3272}
3273extern "C" {
3274 pub fn rtcDetachGeometry(scene: RTCScene, geomID: ::std::os::raw::c_uint);
3275}
3276extern "C" {
3277 pub fn rtcGetGeometry(scene: RTCScene, geomID: ::std::os::raw::c_uint) -> RTCGeometry;
3278}
3279extern "C" {
3280 pub fn rtcCommitScene(scene: RTCScene);
3281}
3282extern "C" {
3283 pub fn rtcJoinCommitScene(scene: RTCScene);
3284}
3285pub type RTCProgressMonitorFunction =
3286 ::std::option::Option<unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void, n: f64) -> bool>;
3287extern "C" {
3288 pub fn rtcSetSceneProgressMonitorFunction(
3289 scene: RTCScene,
3290 progress: RTCProgressMonitorFunction,
3291 ptr: *mut ::std::os::raw::c_void,
3292 );
3293}
3294extern "C" {
3295 pub fn rtcSetSceneBuildQuality(scene: RTCScene, quality: RTCBuildQuality);
3296}
3297extern "C" {
3298 pub fn rtcSetSceneFlags(scene: RTCScene, flags: RTCSceneFlags);
3299}
3300extern "C" {
3301 pub fn rtcGetSceneFlags(scene: RTCScene) -> RTCSceneFlags;
3302}
3303extern "C" {
3304 pub fn rtcGetSceneBounds(scene: RTCScene, bounds_o: *mut RTCBounds);
3305}
3306extern "C" {
3307 pub fn rtcGetSceneLinearBounds(scene: RTCScene, bounds_o: *mut RTCLinearBounds);
3308}
3309extern "C" {
3310 pub fn rtcIntersect1(
3311 scene: RTCScene,
3312 context: *mut RTCIntersectContext,
3313 rayhit: *mut RTCRayHit,
3314 );
3315}
3316extern "C" {
3317 pub fn rtcIntersect4(
3318 valid: *const ::std::os::raw::c_int,
3319 scene: RTCScene,
3320 context: *mut RTCIntersectContext,
3321 rayhit: *mut RTCRayHit4,
3322 );
3323}
3324extern "C" {
3325 pub fn rtcIntersect8(
3326 valid: *const ::std::os::raw::c_int,
3327 scene: RTCScene,
3328 context: *mut RTCIntersectContext,
3329 rayhit: *mut RTCRayHit8,
3330 );
3331}
3332extern "C" {
3333 pub fn rtcIntersect16(
3334 valid: *const ::std::os::raw::c_int,
3335 scene: RTCScene,
3336 context: *mut RTCIntersectContext,
3337 rayhit: *mut RTCRayHit16,
3338 );
3339}
3340extern "C" {
3341 pub fn rtcIntersect1M(
3342 scene: RTCScene,
3343 context: *mut RTCIntersectContext,
3344 rayhit: *mut RTCRayHit,
3345 M: ::std::os::raw::c_uint,
3346 byteStride: usize,
3347 );
3348}
3349extern "C" {
3350 pub fn rtcIntersect1Mp(
3351 scene: RTCScene,
3352 context: *mut RTCIntersectContext,
3353 rayhit: *mut *mut RTCRayHit,
3354 M: ::std::os::raw::c_uint,
3355 );
3356}
3357extern "C" {
3358 pub fn rtcIntersectNM(
3359 scene: RTCScene,
3360 context: *mut RTCIntersectContext,
3361 rayhit: *mut RTCRayHitN,
3362 N: ::std::os::raw::c_uint,
3363 M: ::std::os::raw::c_uint,
3364 byteStride: usize,
3365 );
3366}
3367extern "C" {
3368 pub fn rtcIntersectNp(
3369 scene: RTCScene,
3370 context: *mut RTCIntersectContext,
3371 rayhit: *const RTCRayHitNp,
3372 N: ::std::os::raw::c_uint,
3373 );
3374}
3375extern "C" {
3376 pub fn rtcOccluded1(scene: RTCScene, context: *mut RTCIntersectContext, ray: *mut RTCRay);
3377}
3378extern "C" {
3379 pub fn rtcOccluded4(
3380 valid: *const ::std::os::raw::c_int,
3381 scene: RTCScene,
3382 context: *mut RTCIntersectContext,
3383 ray: *mut RTCRay4,
3384 );
3385}
3386extern "C" {
3387 pub fn rtcOccluded8(
3388 valid: *const ::std::os::raw::c_int,
3389 scene: RTCScene,
3390 context: *mut RTCIntersectContext,
3391 ray: *mut RTCRay8,
3392 );
3393}
3394extern "C" {
3395 pub fn rtcOccluded16(
3396 valid: *const ::std::os::raw::c_int,
3397 scene: RTCScene,
3398 context: *mut RTCIntersectContext,
3399 ray: *mut RTCRay16,
3400 );
3401}
3402extern "C" {
3403 pub fn rtcOccluded1M(
3404 scene: RTCScene,
3405 context: *mut RTCIntersectContext,
3406 ray: *mut RTCRay,
3407 M: ::std::os::raw::c_uint,
3408 byteStride: usize,
3409 );
3410}
3411extern "C" {
3412 pub fn rtcOccluded1Mp(
3413 scene: RTCScene,
3414 context: *mut RTCIntersectContext,
3415 ray: *mut *mut RTCRay,
3416 M: ::std::os::raw::c_uint,
3417 );
3418}
3419extern "C" {
3420 pub fn rtcOccludedNM(
3421 scene: RTCScene,
3422 context: *mut RTCIntersectContext,
3423 ray: *mut RTCRayN,
3424 N: ::std::os::raw::c_uint,
3425 M: ::std::os::raw::c_uint,
3426 byteStride: usize,
3427 );
3428}
3429extern "C" {
3430 pub fn rtcOccludedNp(
3431 scene: RTCScene,
3432 context: *mut RTCIntersectContext,
3433 ray: *const RTCRayNp,
3434 N: ::std::os::raw::c_uint,
3435 );
3436}
3437#[repr(C)]
3438#[derive(Debug, Copy, Clone)]
3439pub struct RTCBVHTy {
3440 _unused: [u8; 0],
3441}
3442pub type RTCBVH = *mut RTCBVHTy;
3443#[repr(C)]
3444#[repr(align(32))]
3445#[derive(Debug, Copy, Clone)]
3446pub struct RTCBuildPrimitive {
3447 pub lower_x: f32,
3448 pub lower_y: f32,
3449 pub lower_z: f32,
3450 pub geomID: ::std::os::raw::c_uint,
3451 pub upper_x: f32,
3452 pub upper_y: f32,
3453 pub upper_z: f32,
3454 pub primID: ::std::os::raw::c_uint,
3455}
3456#[test]
3457fn bindgen_test_layout_RTCBuildPrimitive() {
3458 assert_eq!(
3459 ::std::mem::size_of::<RTCBuildPrimitive>(),
3460 32usize,
3461 concat!("Size of: ", stringify!(RTCBuildPrimitive))
3462 );
3463 assert_eq!(
3464 ::std::mem::align_of::<RTCBuildPrimitive>(),
3465 32usize,
3466 concat!("Alignment of ", stringify!(RTCBuildPrimitive))
3467 );
3468 assert_eq!(
3469 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_x as *const _ as usize },
3470 0usize,
3471 concat!(
3472 "Offset of field: ",
3473 stringify!(RTCBuildPrimitive),
3474 "::",
3475 stringify!(lower_x)
3476 )
3477 );
3478 assert_eq!(
3479 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_y as *const _ as usize },
3480 4usize,
3481 concat!(
3482 "Offset of field: ",
3483 stringify!(RTCBuildPrimitive),
3484 "::",
3485 stringify!(lower_y)
3486 )
3487 );
3488 assert_eq!(
3489 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_z as *const _ as usize },
3490 8usize,
3491 concat!(
3492 "Offset of field: ",
3493 stringify!(RTCBuildPrimitive),
3494 "::",
3495 stringify!(lower_z)
3496 )
3497 );
3498 assert_eq!(
3499 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).geomID as *const _ as usize },
3500 12usize,
3501 concat!(
3502 "Offset of field: ",
3503 stringify!(RTCBuildPrimitive),
3504 "::",
3505 stringify!(geomID)
3506 )
3507 );
3508 assert_eq!(
3509 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_x as *const _ as usize },
3510 16usize,
3511 concat!(
3512 "Offset of field: ",
3513 stringify!(RTCBuildPrimitive),
3514 "::",
3515 stringify!(upper_x)
3516 )
3517 );
3518 assert_eq!(
3519 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_y as *const _ as usize },
3520 20usize,
3521 concat!(
3522 "Offset of field: ",
3523 stringify!(RTCBuildPrimitive),
3524 "::",
3525 stringify!(upper_y)
3526 )
3527 );
3528 assert_eq!(
3529 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_z as *const _ as usize },
3530 24usize,
3531 concat!(
3532 "Offset of field: ",
3533 stringify!(RTCBuildPrimitive),
3534 "::",
3535 stringify!(upper_z)
3536 )
3537 );
3538 assert_eq!(
3539 unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).primID as *const _ as usize },
3540 28usize,
3541 concat!(
3542 "Offset of field: ",
3543 stringify!(RTCBuildPrimitive),
3544 "::",
3545 stringify!(primID)
3546 )
3547 );
3548}
3549#[repr(C)]
3550#[derive(Debug, Copy, Clone)]
3551pub struct RTCThreadLocalAllocatorTy {
3552 _unused: [u8; 0],
3553}
3554pub type RTCThreadLocalAllocator = *mut RTCThreadLocalAllocatorTy;
3555pub type RTCCreateNodeFunction = ::std::option::Option<
3556 unsafe extern "C" fn(
3557 allocator: RTCThreadLocalAllocator,
3558 childCount: ::std::os::raw::c_uint,
3559 userPtr: *mut ::std::os::raw::c_void,
3560 ) -> *mut ::std::os::raw::c_void,
3561>;
3562pub type RTCSetNodeChildrenFunction = ::std::option::Option<
3563 unsafe extern "C" fn(
3564 nodePtr: *mut ::std::os::raw::c_void,
3565 children: *mut *mut ::std::os::raw::c_void,
3566 childCount: ::std::os::raw::c_uint,
3567 userPtr: *mut ::std::os::raw::c_void,
3568 ),
3569>;
3570pub type RTCSetNodeBoundsFunction = ::std::option::Option<
3571 unsafe extern "C" fn(
3572 nodePtr: *mut ::std::os::raw::c_void,
3573 bounds: *mut *const RTCBounds,
3574 childCount: ::std::os::raw::c_uint,
3575 userPtr: *mut ::std::os::raw::c_void,
3576 ),
3577>;
3578pub type RTCCreateLeafFunction = ::std::option::Option<
3579 unsafe extern "C" fn(
3580 allocator: RTCThreadLocalAllocator,
3581 primitives: *const RTCBuildPrimitive,
3582 primitiveCount: usize,
3583 userPtr: *mut ::std::os::raw::c_void,
3584 ) -> *mut ::std::os::raw::c_void,
3585>;
3586pub type RTCSplitPrimitiveFunction = ::std::option::Option<
3587 unsafe extern "C" fn(
3588 primitive: *const RTCBuildPrimitive,
3589 dimension: ::std::os::raw::c_uint,
3590 position: f32,
3591 leftBounds: *mut RTCBounds,
3592 rightBounds: *mut RTCBounds,
3593 userPtr: *mut ::std::os::raw::c_void,
3594 ),
3595>;
3596impl RTCBuildFlags {
3597 pub const NONE: RTCBuildFlags = RTCBuildFlags(0);
3598}
3599impl RTCBuildFlags {
3600 pub const DYNAMIC: RTCBuildFlags = RTCBuildFlags(1);
3601}
3602impl ::std::ops::BitOr<RTCBuildFlags> for RTCBuildFlags {
3603 type Output = Self;
3604 #[inline]
3605 fn bitor(self, other: Self) -> Self {
3606 RTCBuildFlags(self.0 | other.0)
3607 }
3608}
3609impl ::std::ops::BitOrAssign for RTCBuildFlags {
3610 #[inline]
3611 fn bitor_assign(&mut self, rhs: RTCBuildFlags) {
3612 self.0 |= rhs.0;
3613 }
3614}
3615impl ::std::ops::BitAnd<RTCBuildFlags> for RTCBuildFlags {
3616 type Output = Self;
3617 #[inline]
3618 fn bitand(self, other: Self) -> Self {
3619 RTCBuildFlags(self.0 & other.0)
3620 }
3621}
3622impl ::std::ops::BitAndAssign for RTCBuildFlags {
3623 #[inline]
3624 fn bitand_assign(&mut self, rhs: RTCBuildFlags) {
3625 self.0 &= rhs.0;
3626 }
3627}
3628#[repr(transparent)]
3629#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
3630pub struct RTCBuildFlags(pub u32);
3631#[repr(C)]
3632#[derive(Debug, Copy, Clone)]
3633pub struct RTCBuildArguments {
3634 pub byteSize: usize,
3635 pub buildQuality: RTCBuildQuality,
3636 pub buildFlags: RTCBuildFlags,
3637 pub maxBranchingFactor: ::std::os::raw::c_uint,
3638 pub maxDepth: ::std::os::raw::c_uint,
3639 pub sahBlockSize: ::std::os::raw::c_uint,
3640 pub minLeafSize: ::std::os::raw::c_uint,
3641 pub maxLeafSize: ::std::os::raw::c_uint,
3642 pub traversalCost: f32,
3643 pub intersectionCost: f32,
3644 pub bvh: RTCBVH,
3645 pub primitives: *mut RTCBuildPrimitive,
3646 pub primitiveCount: usize,
3647 pub primitiveArrayCapacity: usize,
3648 pub createNode: RTCCreateNodeFunction,
3649 pub setNodeChildren: RTCSetNodeChildrenFunction,
3650 pub setNodeBounds: RTCSetNodeBoundsFunction,
3651 pub createLeaf: RTCCreateLeafFunction,
3652 pub splitPrimitive: RTCSplitPrimitiveFunction,
3653 pub buildProgress: RTCProgressMonitorFunction,
3654 pub userPtr: *mut ::std::os::raw::c_void,
3655}
3656#[test]
3657fn bindgen_test_layout_RTCBuildArguments() {
3658 assert_eq!(
3659 ::std::mem::size_of::<RTCBuildArguments>(),
3660 136usize,
3661 concat!("Size of: ", stringify!(RTCBuildArguments))
3662 );
3663 assert_eq!(
3664 ::std::mem::align_of::<RTCBuildArguments>(),
3665 8usize,
3666 concat!("Alignment of ", stringify!(RTCBuildArguments))
3667 );
3668 assert_eq!(
3669 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).byteSize as *const _ as usize },
3670 0usize,
3671 concat!(
3672 "Offset of field: ",
3673 stringify!(RTCBuildArguments),
3674 "::",
3675 stringify!(byteSize)
3676 )
3677 );
3678 assert_eq!(
3679 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildQuality as *const _ as usize },
3680 8usize,
3681 concat!(
3682 "Offset of field: ",
3683 stringify!(RTCBuildArguments),
3684 "::",
3685 stringify!(buildQuality)
3686 )
3687 );
3688 assert_eq!(
3689 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildFlags as *const _ as usize },
3690 12usize,
3691 concat!(
3692 "Offset of field: ",
3693 stringify!(RTCBuildArguments),
3694 "::",
3695 stringify!(buildFlags)
3696 )
3697 );
3698 assert_eq!(
3699 unsafe {
3700 &(*(::std::ptr::null::<RTCBuildArguments>())).maxBranchingFactor as *const _ as usize
3701 },
3702 16usize,
3703 concat!(
3704 "Offset of field: ",
3705 stringify!(RTCBuildArguments),
3706 "::",
3707 stringify!(maxBranchingFactor)
3708 )
3709 );
3710 assert_eq!(
3711 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).maxDepth as *const _ as usize },
3712 20usize,
3713 concat!(
3714 "Offset of field: ",
3715 stringify!(RTCBuildArguments),
3716 "::",
3717 stringify!(maxDepth)
3718 )
3719 );
3720 assert_eq!(
3721 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).sahBlockSize as *const _ as usize },
3722 24usize,
3723 concat!(
3724 "Offset of field: ",
3725 stringify!(RTCBuildArguments),
3726 "::",
3727 stringify!(sahBlockSize)
3728 )
3729 );
3730 assert_eq!(
3731 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).minLeafSize as *const _ as usize },
3732 28usize,
3733 concat!(
3734 "Offset of field: ",
3735 stringify!(RTCBuildArguments),
3736 "::",
3737 stringify!(minLeafSize)
3738 )
3739 );
3740 assert_eq!(
3741 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).maxLeafSize as *const _ as usize },
3742 32usize,
3743 concat!(
3744 "Offset of field: ",
3745 stringify!(RTCBuildArguments),
3746 "::",
3747 stringify!(maxLeafSize)
3748 )
3749 );
3750 assert_eq!(
3751 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).traversalCost as *const _ as usize },
3752 36usize,
3753 concat!(
3754 "Offset of field: ",
3755 stringify!(RTCBuildArguments),
3756 "::",
3757 stringify!(traversalCost)
3758 )
3759 );
3760 assert_eq!(
3761 unsafe {
3762 &(*(::std::ptr::null::<RTCBuildArguments>())).intersectionCost as *const _ as usize
3763 },
3764 40usize,
3765 concat!(
3766 "Offset of field: ",
3767 stringify!(RTCBuildArguments),
3768 "::",
3769 stringify!(intersectionCost)
3770 )
3771 );
3772 assert_eq!(
3773 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).bvh as *const _ as usize },
3774 48usize,
3775 concat!(
3776 "Offset of field: ",
3777 stringify!(RTCBuildArguments),
3778 "::",
3779 stringify!(bvh)
3780 )
3781 );
3782 assert_eq!(
3783 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).primitives as *const _ as usize },
3784 56usize,
3785 concat!(
3786 "Offset of field: ",
3787 stringify!(RTCBuildArguments),
3788 "::",
3789 stringify!(primitives)
3790 )
3791 );
3792 assert_eq!(
3793 unsafe {
3794 &(*(::std::ptr::null::<RTCBuildArguments>())).primitiveCount as *const _ as usize
3795 },
3796 64usize,
3797 concat!(
3798 "Offset of field: ",
3799 stringify!(RTCBuildArguments),
3800 "::",
3801 stringify!(primitiveCount)
3802 )
3803 );
3804 assert_eq!(
3805 unsafe {
3806 &(*(::std::ptr::null::<RTCBuildArguments>())).primitiveArrayCapacity as *const _
3807 as usize
3808 },
3809 72usize,
3810 concat!(
3811 "Offset of field: ",
3812 stringify!(RTCBuildArguments),
3813 "::",
3814 stringify!(primitiveArrayCapacity)
3815 )
3816 );
3817 assert_eq!(
3818 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).createNode as *const _ as usize },
3819 80usize,
3820 concat!(
3821 "Offset of field: ",
3822 stringify!(RTCBuildArguments),
3823 "::",
3824 stringify!(createNode)
3825 )
3826 );
3827 assert_eq!(
3828 unsafe {
3829 &(*(::std::ptr::null::<RTCBuildArguments>())).setNodeChildren as *const _ as usize
3830 },
3831 88usize,
3832 concat!(
3833 "Offset of field: ",
3834 stringify!(RTCBuildArguments),
3835 "::",
3836 stringify!(setNodeChildren)
3837 )
3838 );
3839 assert_eq!(
3840 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).setNodeBounds as *const _ as usize },
3841 96usize,
3842 concat!(
3843 "Offset of field: ",
3844 stringify!(RTCBuildArguments),
3845 "::",
3846 stringify!(setNodeBounds)
3847 )
3848 );
3849 assert_eq!(
3850 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).createLeaf as *const _ as usize },
3851 104usize,
3852 concat!(
3853 "Offset of field: ",
3854 stringify!(RTCBuildArguments),
3855 "::",
3856 stringify!(createLeaf)
3857 )
3858 );
3859 assert_eq!(
3860 unsafe {
3861 &(*(::std::ptr::null::<RTCBuildArguments>())).splitPrimitive as *const _ as usize
3862 },
3863 112usize,
3864 concat!(
3865 "Offset of field: ",
3866 stringify!(RTCBuildArguments),
3867 "::",
3868 stringify!(splitPrimitive)
3869 )
3870 );
3871 assert_eq!(
3872 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildProgress as *const _ as usize },
3873 120usize,
3874 concat!(
3875 "Offset of field: ",
3876 stringify!(RTCBuildArguments),
3877 "::",
3878 stringify!(buildProgress)
3879 )
3880 );
3881 assert_eq!(
3882 unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).userPtr as *const _ as usize },
3883 128usize,
3884 concat!(
3885 "Offset of field: ",
3886 stringify!(RTCBuildArguments),
3887 "::",
3888 stringify!(userPtr)
3889 )
3890 );
3891}
3892extern "C" {
3893 pub fn rtcNewBVH(device: RTCDevice) -> RTCBVH;
3894}
3895extern "C" {
3896 pub fn rtcBuildBVH(args: *const RTCBuildArguments) -> *mut ::std::os::raw::c_void;
3897}
3898extern "C" {
3899 pub fn rtcThreadLocalAlloc(
3900 allocator: RTCThreadLocalAllocator,
3901 bytes: usize,
3902 align: usize,
3903 ) -> *mut ::std::os::raw::c_void;
3904}
3905extern "C" {
3906 pub fn rtcRetainBVH(bvh: RTCBVH);
3907}
3908extern "C" {
3909 pub fn rtcReleaseBVH(bvh: RTCBVH);
3910}