pub const RTC_VERSION_MAJOR: u32 = 3;
pub const RTC_VERSION_MINOR: u32 = 12;
pub const RTC_VERSION_PATCH: u32 = 1;
pub const RTC_VERSION: u32 = 31201;
pub const RTC_VERSION_STRING: &'static [u8; 7usize] = b"3.12.1\0";
pub const RTC_MAX_INSTANCE_LEVEL_COUNT: u32 = 1;
pub const RTC_MIN_WIDTH: u32 = 0;
pub const RTC_MAX_TIME_STEP_COUNT: u32 = 129;
pub type size_t = usize;
pub type __ssize_t = isize;
pub type ssize_t = __ssize_t;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCFormat {
UNDEFINED = 0,
UCHAR = 4097,
UCHAR2 = 4098,
UCHAR3 = 4099,
UCHAR4 = 4100,
CHAR = 8193,
CHAR2 = 8194,
CHAR3 = 8195,
CHAR4 = 8196,
USHORT = 12289,
USHORT2 = 12290,
USHORT3 = 12291,
USHORT4 = 12292,
SHORT = 16385,
SHORT2 = 16386,
SHORT3 = 16387,
SHORT4 = 16388,
UINT = 20481,
UINT2 = 20482,
UINT3 = 20483,
UINT4 = 20484,
INT = 24577,
INT2 = 24578,
INT3 = 24579,
INT4 = 24580,
ULLONG = 28673,
ULLONG2 = 28674,
ULLONG3 = 28675,
ULLONG4 = 28676,
LLONG = 32769,
LLONG2 = 32770,
LLONG3 = 32771,
LLONG4 = 32772,
FLOAT = 36865,
FLOAT2 = 36866,
FLOAT3 = 36867,
FLOAT4 = 36868,
FLOAT5 = 36869,
FLOAT6 = 36870,
FLOAT7 = 36871,
FLOAT8 = 36872,
FLOAT9 = 36873,
FLOAT10 = 36874,
FLOAT11 = 36875,
FLOAT12 = 36876,
FLOAT13 = 36877,
FLOAT14 = 36878,
FLOAT15 = 36879,
FLOAT16 = 36880,
FLOAT2X2_ROW_MAJOR = 37154,
FLOAT2X3_ROW_MAJOR = 37155,
FLOAT2X4_ROW_MAJOR = 37156,
FLOAT3X2_ROW_MAJOR = 37170,
FLOAT3X3_ROW_MAJOR = 37171,
FLOAT3X4_ROW_MAJOR = 37172,
FLOAT4X2_ROW_MAJOR = 37186,
FLOAT4X3_ROW_MAJOR = 37187,
FLOAT4X4_ROW_MAJOR = 37188,
FLOAT2X2_COLUMN_MAJOR = 37410,
FLOAT2X3_COLUMN_MAJOR = 37411,
FLOAT2X4_COLUMN_MAJOR = 37412,
FLOAT3X2_COLUMN_MAJOR = 37426,
FLOAT3X3_COLUMN_MAJOR = 37427,
FLOAT3X4_COLUMN_MAJOR = 37428,
FLOAT4X2_COLUMN_MAJOR = 37442,
FLOAT4X3_COLUMN_MAJOR = 37443,
FLOAT4X4_COLUMN_MAJOR = 37444,
GRID = 40961,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCBuildQuality {
LOW = 0,
MEDIUM = 1,
HIGH = 2,
REFIT = 3,
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCBounds {
pub lower_x: f32,
pub lower_y: f32,
pub lower_z: f32,
pub align0: f32,
pub upper_x: f32,
pub upper_y: f32,
pub upper_z: f32,
pub align1: f32,
}
#[test]
fn bindgen_test_layout_RTCBounds() {
assert_eq!(
::std::mem::size_of::<RTCBounds>(),
32usize,
concat!("Size of: ", stringify!(RTCBounds))
);
assert_eq!(
::std::mem::align_of::<RTCBounds>(),
16usize,
concat!("Alignment of ", stringify!(RTCBounds))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(lower_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(lower_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(lower_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).align0 as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(align0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_x as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(upper_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_y as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(upper_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_z as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(upper_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).align1 as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(align1)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCLinearBounds {
pub bounds0: RTCBounds,
pub bounds1: RTCBounds,
}
#[test]
fn bindgen_test_layout_RTCLinearBounds() {
assert_eq!(
::std::mem::size_of::<RTCLinearBounds>(),
64usize,
concat!("Size of: ", stringify!(RTCLinearBounds))
);
assert_eq!(
::std::mem::align_of::<RTCLinearBounds>(),
16usize,
concat!("Alignment of ", stringify!(RTCLinearBounds))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCLinearBounds>())).bounds0 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCLinearBounds),
"::",
stringify!(bounds0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCLinearBounds>())).bounds1 as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCLinearBounds),
"::",
stringify!(bounds1)
)
);
}
impl RTCIntersectContextFlags {
pub const NONE: RTCIntersectContextFlags = RTCIntersectContextFlags(0);
}
impl RTCIntersectContextFlags {
pub const INCOHERENT: RTCIntersectContextFlags = RTCIntersectContextFlags(0);
}
impl RTCIntersectContextFlags {
pub const COHERENT: RTCIntersectContextFlags = RTCIntersectContextFlags(1);
}
impl ::std::ops::BitOr<RTCIntersectContextFlags> for RTCIntersectContextFlags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
RTCIntersectContextFlags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for RTCIntersectContextFlags {
#[inline]
fn bitor_assign(&mut self, rhs: RTCIntersectContextFlags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<RTCIntersectContextFlags> for RTCIntersectContextFlags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
RTCIntersectContextFlags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for RTCIntersectContextFlags {
#[inline]
fn bitand_assign(&mut self, rhs: RTCIntersectContextFlags) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct RTCIntersectContextFlags(pub ::std::os::raw::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCFilterFunctionNArguments {
pub valid: *mut ::std::os::raw::c_int,
pub geometryUserPtr: *mut ::std::os::raw::c_void,
pub context: *mut RTCIntersectContext,
pub ray: *mut RTCRayN,
pub hit: *mut RTCHitN,
pub N: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCFilterFunctionNArguments() {
assert_eq!(
::std::mem::size_of::<RTCFilterFunctionNArguments>(),
48usize,
concat!("Size of: ", stringify!(RTCFilterFunctionNArguments))
);
assert_eq!(
::std::mem::align_of::<RTCFilterFunctionNArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCFilterFunctionNArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).valid as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).geometryUserPtr as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).context as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).ray as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).hit as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(hit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).N as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(N)
)
);
}
pub type RTCFilterFunctionN =
::std::option::Option<unsafe extern "C" fn(args: *const RTCFilterFunctionNArguments)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCIntersectContext {
pub flags: RTCIntersectContextFlags,
pub filter: RTCFilterFunctionN,
pub instID: [::std::os::raw::c_uint; 1usize],
}
#[test]
fn bindgen_test_layout_RTCIntersectContext() {
assert_eq!(
::std::mem::size_of::<RTCIntersectContext>(),
24usize,
concat!("Size of: ", stringify!(RTCIntersectContext))
);
assert_eq!(
::std::mem::align_of::<RTCIntersectContext>(),
8usize,
concat!("Alignment of ", stringify!(RTCIntersectContext))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCIntersectContext>())).flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectContext),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCIntersectContext>())).filter as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectContext),
"::",
stringify!(filter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCIntersectContext>())).instID as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectContext),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCPointQuery {
pub x: f32,
pub y: f32,
pub z: f32,
pub time: f32,
pub radius: f32,
}
#[test]
fn bindgen_test_layout_RTCPointQuery() {
assert_eq!(
::std::mem::size_of::<RTCPointQuery>(),
32usize,
concat!("Size of: ", stringify!(RTCPointQuery))
);
assert_eq!(
::std::mem::align_of::<RTCPointQuery>(),
16usize,
concat!("Alignment of ", stringify!(RTCPointQuery))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery>())).z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery>())).time as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery>())).radius as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery),
"::",
stringify!(radius)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCPointQuery4 {
pub x: [f32; 4usize],
pub y: [f32; 4usize],
pub z: [f32; 4usize],
pub time: [f32; 4usize],
pub radius: [f32; 4usize],
}
#[test]
fn bindgen_test_layout_RTCPointQuery4() {
assert_eq!(
::std::mem::size_of::<RTCPointQuery4>(),
80usize,
concat!("Size of: ", stringify!(RTCPointQuery4))
);
assert_eq!(
::std::mem::align_of::<RTCPointQuery4>(),
16usize,
concat!("Alignment of ", stringify!(RTCPointQuery4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery4>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery4),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery4>())).y as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery4),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery4>())).z as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery4),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery4>())).time as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery4),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery4>())).radius as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery4),
"::",
stringify!(radius)
)
);
}
#[repr(C)]
#[repr(align(32))]
#[derive(Debug, Copy, Clone)]
pub struct RTCPointQuery8 {
pub x: [f32; 8usize],
pub y: [f32; 8usize],
pub z: [f32; 8usize],
pub time: [f32; 8usize],
pub radius: [f32; 8usize],
}
#[test]
fn bindgen_test_layout_RTCPointQuery8() {
assert_eq!(
::std::mem::size_of::<RTCPointQuery8>(),
160usize,
concat!("Size of: ", stringify!(RTCPointQuery8))
);
assert_eq!(
::std::mem::align_of::<RTCPointQuery8>(),
32usize,
concat!("Alignment of ", stringify!(RTCPointQuery8))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery8>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery8),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery8>())).y as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery8),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery8>())).z as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery8),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery8>())).time as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery8),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery8>())).radius as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery8),
"::",
stringify!(radius)
)
);
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct RTCPointQuery16 {
pub x: [f32; 16usize],
pub y: [f32; 16usize],
pub z: [f32; 16usize],
pub time: [f32; 16usize],
pub radius: [f32; 16usize],
}
#[test]
fn bindgen_test_layout_RTCPointQuery16() {
assert_eq!(
::std::mem::size_of::<RTCPointQuery16>(),
320usize,
concat!("Size of: ", stringify!(RTCPointQuery16))
);
assert_eq!(
::std::mem::align_of::<RTCPointQuery16>(),
64usize,
concat!("Alignment of ", stringify!(RTCPointQuery16))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery16>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery16),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery16>())).y as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery16),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery16>())).z as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery16),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery16>())).time as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery16),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQuery16>())).radius as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery16),
"::",
stringify!(radius)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCPointQueryN {
_unused: [u8; 0],
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCPointQueryContext {
pub world2inst: [[f32; 16usize]; 1usize],
pub inst2world: [[f32; 16usize]; 1usize],
pub instID: [::std::os::raw::c_uint; 1usize],
pub instStackSize: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCPointQueryContext() {
assert_eq!(
::std::mem::size_of::<RTCPointQueryContext>(),
144usize,
concat!("Size of: ", stringify!(RTCPointQueryContext))
);
assert_eq!(
::std::mem::align_of::<RTCPointQueryContext>(),
16usize,
concat!("Alignment of ", stringify!(RTCPointQueryContext))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQueryContext>())).world2inst as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryContext),
"::",
stringify!(world2inst)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQueryContext>())).inst2world as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryContext),
"::",
stringify!(inst2world)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCPointQueryContext>())).instID as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryContext),
"::",
stringify!(instID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCPointQueryContext>())).instStackSize as *const _ as usize
},
132usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryContext),
"::",
stringify!(instStackSize)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCPointQueryFunctionArguments {
pub query: *mut RTCPointQuery,
pub userPtr: *mut ::std::os::raw::c_void,
pub primID: ::std::os::raw::c_uint,
pub geomID: ::std::os::raw::c_uint,
pub context: *mut RTCPointQueryContext,
pub similarityScale: f32,
}
#[test]
fn bindgen_test_layout_RTCPointQueryFunctionArguments() {
assert_eq!(
::std::mem::size_of::<RTCPointQueryFunctionArguments>(),
48usize,
concat!("Size of: ", stringify!(RTCPointQueryFunctionArguments))
);
assert_eq!(
::std::mem::align_of::<RTCPointQueryFunctionArguments>(),
16usize,
concat!("Alignment of ", stringify!(RTCPointQueryFunctionArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).query as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryFunctionArguments),
"::",
stringify!(query)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).userPtr as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryFunctionArguments),
"::",
stringify!(userPtr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).primID as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryFunctionArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).geomID as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryFunctionArguments),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).context as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryFunctionArguments),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCPointQueryFunctionArguments>())).similarityScale as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryFunctionArguments),
"::",
stringify!(similarityScale)
)
);
}
pub type RTCPointQueryFunction =
::std::option::Option<unsafe extern "C" fn(args: *mut RTCPointQueryFunctionArguments) -> bool>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCDeviceTy {
_unused: [u8; 0],
}
pub type RTCDevice = *mut RTCDeviceTy;
extern "C" {
pub fn rtcNewDevice(config: *const ::std::os::raw::c_char) -> RTCDevice;
}
extern "C" {
pub fn rtcRetainDevice(device: RTCDevice);
}
extern "C" {
pub fn rtcReleaseDevice(device: RTCDevice);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCDeviceProperty {
VERSION = 0,
VERSION_MAJOR = 1,
VERSION_MINOR = 2,
VERSION_PATCH = 3,
NATIVE_RAY4_SUPPORTED = 32,
NATIVE_RAY8_SUPPORTED = 33,
NATIVE_RAY16_SUPPORTED = 34,
RAY_STREAM_SUPPORTED = 35,
BACKFACE_CULLING_CURVES_ENABLED = 63,
RAY_MASK_SUPPORTED = 64,
BACKFACE_CULLING_ENABLED = 65,
FILTER_FUNCTION_SUPPORTED = 66,
IGNORE_INVALID_RAYS_ENABLED = 67,
COMPACT_POLYS_ENABLED = 68,
TRIANGLE_GEOMETRY_SUPPORTED = 96,
QUAD_GEOMETRY_SUPPORTED = 97,
SUBDIVISION_GEOMETRY_SUPPORTED = 98,
CURVE_GEOMETRY_SUPPORTED = 99,
USER_GEOMETRY_SUPPORTED = 100,
POINT_GEOMETRY_SUPPORTED = 101,
TASKING_SYSTEM = 128,
JOIN_COMMIT_SUPPORTED = 129,
PARALLEL_COMMIT_SUPPORTED = 130,
}
extern "C" {
pub fn rtcGetDeviceProperty(device: RTCDevice, prop: RTCDeviceProperty) -> ssize_t;
}
extern "C" {
pub fn rtcSetDeviceProperty(device: RTCDevice, prop: RTCDeviceProperty, value: ssize_t);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCError {
NONE = 0,
UNKNOWN = 1,
INVALID_ARGUMENT = 2,
INVALID_OPERATION = 3,
OUT_OF_MEMORY = 4,
UNSUPPORTED_CPU = 5,
CANCELLED = 6,
}
extern "C" {
pub fn rtcGetDeviceError(device: RTCDevice) -> RTCError;
}
pub type RTCErrorFunction = ::std::option::Option<
unsafe extern "C" fn(
userPtr: *mut ::std::os::raw::c_void,
code: RTCError,
str_: *const ::std::os::raw::c_char,
),
>;
extern "C" {
pub fn rtcSetDeviceErrorFunction(
device: RTCDevice,
error: RTCErrorFunction,
userPtr: *mut ::std::os::raw::c_void,
);
}
pub type RTCMemoryMonitorFunction = ::std::option::Option<
unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void, bytes: ssize_t, post: bool) -> bool,
>;
extern "C" {
pub fn rtcSetDeviceMemoryMonitorFunction(
device: RTCDevice,
memoryMonitor: RTCMemoryMonitorFunction,
userPtr: *mut ::std::os::raw::c_void,
);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCBufferType {
INDEX = 0,
VERTEX = 1,
VERTEX_ATTRIBUTE = 2,
NORMAL = 3,
TANGENT = 4,
NORMAL_DERIVATIVE = 5,
GRID = 8,
FACE = 16,
LEVEL = 17,
EDGE_CREASE_INDEX = 18,
EDGE_CREASE_WEIGHT = 19,
VERTEX_CREASE_INDEX = 20,
VERTEX_CREASE_WEIGHT = 21,
HOLE = 22,
FLAGS = 32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCBufferTy {
_unused: [u8; 0],
}
pub type RTCBuffer = *mut RTCBufferTy;
extern "C" {
pub fn rtcNewBuffer(device: RTCDevice, byteSize: size_t) -> RTCBuffer;
}
extern "C" {
pub fn rtcNewSharedBuffer(
device: RTCDevice,
ptr: *mut ::std::os::raw::c_void,
byteSize: size_t,
) -> RTCBuffer;
}
extern "C" {
pub fn rtcGetBufferData(buffer: RTCBuffer) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn rtcRetainBuffer(buffer: RTCBuffer);
}
extern "C" {
pub fn rtcReleaseBuffer(buffer: RTCBuffer);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRay {
pub org_x: f32,
pub org_y: f32,
pub org_z: f32,
pub tnear: f32,
pub dir_x: f32,
pub dir_y: f32,
pub dir_z: f32,
pub time: f32,
pub tfar: f32,
pub mask: ::std::os::raw::c_uint,
pub id: ::std::os::raw::c_uint,
pub flags: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCRay() {
assert_eq!(
::std::mem::size_of::<RTCRay>(),
48usize,
concat!("Size of: ", stringify!(RTCRay))
);
assert_eq!(
::std::mem::align_of::<RTCRay>(),
16usize,
concat!("Alignment of ", stringify!(RTCRay))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).org_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).org_y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).org_z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).tnear as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_x as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_y as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_z as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).time as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).tfar as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).mask as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).id as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).flags as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCHit {
pub Ng_x: f32,
pub Ng_y: f32,
pub Ng_z: f32,
pub u: f32,
pub v: f32,
pub primID: ::std::os::raw::c_uint,
pub geomID: ::std::os::raw::c_uint,
pub instID: [::std::os::raw::c_uint; 1usize],
}
#[test]
fn bindgen_test_layout_RTCHit() {
assert_eq!(
::std::mem::size_of::<RTCHit>(),
32usize,
concat!("Size of: ", stringify!(RTCHit))
);
assert_eq!(
::std::mem::align_of::<RTCHit>(),
16usize,
concat!("Alignment of ", stringify!(RTCHit))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).u as *const _ as usize },
12usize,
concat!("Offset of field: ", stringify!(RTCHit), "::", stringify!(u))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).v as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(RTCHit), "::", stringify!(v))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).primID as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).geomID as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).instID as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayHit {
pub ray: RTCRay,
pub hit: RTCHit,
}
#[test]
fn bindgen_test_layout_RTCRayHit() {
assert_eq!(
::std::mem::size_of::<RTCRayHit>(),
80usize,
concat!("Size of: ", stringify!(RTCRayHit))
);
assert_eq!(
::std::mem::align_of::<RTCRayHit>(),
16usize,
concat!("Alignment of ", stringify!(RTCRayHit))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit>())).ray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit>())).hit as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit),
"::",
stringify!(hit)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRay4 {
pub org_x: [f32; 4usize],
pub org_y: [f32; 4usize],
pub org_z: [f32; 4usize],
pub tnear: [f32; 4usize],
pub dir_x: [f32; 4usize],
pub dir_y: [f32; 4usize],
pub dir_z: [f32; 4usize],
pub time: [f32; 4usize],
pub tfar: [f32; 4usize],
pub mask: [::std::os::raw::c_uint; 4usize],
pub id: [::std::os::raw::c_uint; 4usize],
pub flags: [::std::os::raw::c_uint; 4usize],
}
#[test]
fn bindgen_test_layout_RTCRay4() {
assert_eq!(
::std::mem::size_of::<RTCRay4>(),
192usize,
concat!("Size of: ", stringify!(RTCRay4))
);
assert_eq!(
::std::mem::align_of::<RTCRay4>(),
16usize,
concat!("Alignment of ", stringify!(RTCRay4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_y as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_z as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).tnear as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_x as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_y as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_z as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).time as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).tfar as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).mask as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).id as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).flags as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCHit4 {
pub Ng_x: [f32; 4usize],
pub Ng_y: [f32; 4usize],
pub Ng_z: [f32; 4usize],
pub u: [f32; 4usize],
pub v: [f32; 4usize],
pub primID: [::std::os::raw::c_uint; 4usize],
pub geomID: [::std::os::raw::c_uint; 4usize],
pub instID: [[::std::os::raw::c_uint; 4usize]; 1usize],
}
#[test]
fn bindgen_test_layout_RTCHit4() {
assert_eq!(
::std::mem::size_of::<RTCHit4>(),
128usize,
concat!("Size of: ", stringify!(RTCHit4))
);
assert_eq!(
::std::mem::align_of::<RTCHit4>(),
16usize,
concat!("Alignment of ", stringify!(RTCHit4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_y as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_z as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).u as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).v as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).primID as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).geomID as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).instID as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayHit4 {
pub ray: RTCRay4,
pub hit: RTCHit4,
}
#[test]
fn bindgen_test_layout_RTCRayHit4() {
assert_eq!(
::std::mem::size_of::<RTCRayHit4>(),
320usize,
concat!("Size of: ", stringify!(RTCRayHit4))
);
assert_eq!(
::std::mem::align_of::<RTCRayHit4>(),
16usize,
concat!("Alignment of ", stringify!(RTCRayHit4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit4>())).ray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit4),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit4>())).hit as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit4),
"::",
stringify!(hit)
)
);
}
#[repr(C)]
#[repr(align(32))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRay8 {
pub org_x: [f32; 8usize],
pub org_y: [f32; 8usize],
pub org_z: [f32; 8usize],
pub tnear: [f32; 8usize],
pub dir_x: [f32; 8usize],
pub dir_y: [f32; 8usize],
pub dir_z: [f32; 8usize],
pub time: [f32; 8usize],
pub tfar: [f32; 8usize],
pub mask: [::std::os::raw::c_uint; 8usize],
pub id: [::std::os::raw::c_uint; 8usize],
pub flags: [::std::os::raw::c_uint; 8usize],
}
#[test]
fn bindgen_test_layout_RTCRay8() {
assert_eq!(
::std::mem::size_of::<RTCRay8>(),
384usize,
concat!("Size of: ", stringify!(RTCRay8))
);
assert_eq!(
::std::mem::align_of::<RTCRay8>(),
32usize,
concat!("Alignment of ", stringify!(RTCRay8))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_y as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_z as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).tnear as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_x as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_y as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_z as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).time as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).tfar as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).mask as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).id as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).flags as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[repr(align(32))]
#[derive(Debug, Copy, Clone)]
pub struct RTCHit8 {
pub Ng_x: [f32; 8usize],
pub Ng_y: [f32; 8usize],
pub Ng_z: [f32; 8usize],
pub u: [f32; 8usize],
pub v: [f32; 8usize],
pub primID: [::std::os::raw::c_uint; 8usize],
pub geomID: [::std::os::raw::c_uint; 8usize],
pub instID: [[::std::os::raw::c_uint; 8usize]; 1usize],
}
#[test]
fn bindgen_test_layout_RTCHit8() {
assert_eq!(
::std::mem::size_of::<RTCHit8>(),
256usize,
concat!("Size of: ", stringify!(RTCHit8))
);
assert_eq!(
::std::mem::align_of::<RTCHit8>(),
32usize,
concat!("Alignment of ", stringify!(RTCHit8))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_y as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_z as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).u as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).v as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).primID as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).geomID as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).instID as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[repr(align(32))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayHit8 {
pub ray: RTCRay8,
pub hit: RTCHit8,
}
#[test]
fn bindgen_test_layout_RTCRayHit8() {
assert_eq!(
::std::mem::size_of::<RTCRayHit8>(),
640usize,
concat!("Size of: ", stringify!(RTCRayHit8))
);
assert_eq!(
::std::mem::align_of::<RTCRayHit8>(),
32usize,
concat!("Alignment of ", stringify!(RTCRayHit8))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit8>())).ray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit8),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit8>())).hit as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit8),
"::",
stringify!(hit)
)
);
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct RTCRay16 {
pub org_x: [f32; 16usize],
pub org_y: [f32; 16usize],
pub org_z: [f32; 16usize],
pub tnear: [f32; 16usize],
pub dir_x: [f32; 16usize],
pub dir_y: [f32; 16usize],
pub dir_z: [f32; 16usize],
pub time: [f32; 16usize],
pub tfar: [f32; 16usize],
pub mask: [::std::os::raw::c_uint; 16usize],
pub id: [::std::os::raw::c_uint; 16usize],
pub flags: [::std::os::raw::c_uint; 16usize],
}
#[test]
fn bindgen_test_layout_RTCRay16() {
assert_eq!(
::std::mem::size_of::<RTCRay16>(),
768usize,
concat!("Size of: ", stringify!(RTCRay16))
);
assert_eq!(
::std::mem::align_of::<RTCRay16>(),
64usize,
concat!("Alignment of ", stringify!(RTCRay16))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_y as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_z as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).tnear as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_x as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_y as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_z as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).time as *const _ as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).tfar as *const _ as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).mask as *const _ as usize },
576usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).id as *const _ as usize },
640usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).flags as *const _ as usize },
704usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct RTCHit16 {
pub Ng_x: [f32; 16usize],
pub Ng_y: [f32; 16usize],
pub Ng_z: [f32; 16usize],
pub u: [f32; 16usize],
pub v: [f32; 16usize],
pub primID: [::std::os::raw::c_uint; 16usize],
pub geomID: [::std::os::raw::c_uint; 16usize],
pub instID: [[::std::os::raw::c_uint; 16usize]; 1usize],
}
#[test]
fn bindgen_test_layout_RTCHit16() {
assert_eq!(
::std::mem::size_of::<RTCHit16>(),
512usize,
concat!("Size of: ", stringify!(RTCHit16))
);
assert_eq!(
::std::mem::align_of::<RTCHit16>(),
64usize,
concat!("Alignment of ", stringify!(RTCHit16))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_y as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_z as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).u as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).v as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).primID as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).geomID as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).instID as *const _ as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct RTCRayHit16 {
pub ray: RTCRay16,
pub hit: RTCHit16,
}
#[test]
fn bindgen_test_layout_RTCRayHit16() {
assert_eq!(
::std::mem::size_of::<RTCRayHit16>(),
1280usize,
concat!("Size of: ", stringify!(RTCRayHit16))
);
assert_eq!(
::std::mem::align_of::<RTCRayHit16>(),
64usize,
concat!("Alignment of ", stringify!(RTCRayHit16))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit16>())).ray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit16),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit16>())).hit as *const _ as usize },
768usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit16),
"::",
stringify!(hit)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayNp {
pub org_x: *mut f32,
pub org_y: *mut f32,
pub org_z: *mut f32,
pub tnear: *mut f32,
pub dir_x: *mut f32,
pub dir_y: *mut f32,
pub dir_z: *mut f32,
pub time: *mut f32,
pub tfar: *mut f32,
pub mask: *mut ::std::os::raw::c_uint,
pub id: *mut ::std::os::raw::c_uint,
pub flags: *mut ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCRayNp() {
assert_eq!(
::std::mem::size_of::<RTCRayNp>(),
96usize,
concat!("Size of: ", stringify!(RTCRayNp))
);
assert_eq!(
::std::mem::align_of::<RTCRayNp>(),
8usize,
concat!("Alignment of ", stringify!(RTCRayNp))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_y as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_z as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).tnear as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_x as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_y as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_z as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).time as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).tfar as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).mask as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).id as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).flags as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCHitNp {
pub Ng_x: *mut f32,
pub Ng_y: *mut f32,
pub Ng_z: *mut f32,
pub u: *mut f32,
pub v: *mut f32,
pub primID: *mut ::std::os::raw::c_uint,
pub geomID: *mut ::std::os::raw::c_uint,
pub instID: [*mut ::std::os::raw::c_uint; 1usize],
}
#[test]
fn bindgen_test_layout_RTCHitNp() {
assert_eq!(
::std::mem::size_of::<RTCHitNp>(),
64usize,
concat!("Size of: ", stringify!(RTCHitNp))
);
assert_eq!(
::std::mem::align_of::<RTCHitNp>(),
8usize,
concat!("Alignment of ", stringify!(RTCHitNp))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_y as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_z as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).u as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).v as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).primID as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).geomID as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).instID as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayHitNp {
pub ray: RTCRayNp,
pub hit: RTCHitNp,
}
#[test]
fn bindgen_test_layout_RTCRayHitNp() {
assert_eq!(
::std::mem::size_of::<RTCRayHitNp>(),
160usize,
concat!("Size of: ", stringify!(RTCRayHitNp))
);
assert_eq!(
::std::mem::align_of::<RTCRayHitNp>(),
8usize,
concat!("Alignment of ", stringify!(RTCRayHitNp))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHitNp>())).ray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHitNp),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHitNp>())).hit as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHitNp),
"::",
stringify!(hit)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayN {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCHitN {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayHitN {
_unused: [u8; 0],
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCQuaternionDecomposition {
pub scale_x: f32,
pub scale_y: f32,
pub scale_z: f32,
pub skew_xy: f32,
pub skew_xz: f32,
pub skew_yz: f32,
pub shift_x: f32,
pub shift_y: f32,
pub shift_z: f32,
pub quaternion_r: f32,
pub quaternion_i: f32,
pub quaternion_j: f32,
pub quaternion_k: f32,
pub translation_x: f32,
pub translation_y: f32,
pub translation_z: f32,
}
#[test]
fn bindgen_test_layout_RTCQuaternionDecomposition() {
assert_eq!(
::std::mem::size_of::<RTCQuaternionDecomposition>(),
64usize,
concat!("Size of: ", stringify!(RTCQuaternionDecomposition))
);
assert_eq!(
::std::mem::align_of::<RTCQuaternionDecomposition>(),
16usize,
concat!("Alignment of ", stringify!(RTCQuaternionDecomposition))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).scale_x as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(scale_x)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).scale_y as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(scale_y)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).scale_z as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(scale_z)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).skew_xy as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(skew_xy)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).skew_xz as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(skew_xz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).skew_yz as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(skew_yz)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).shift_x as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(shift_x)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).shift_y as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(shift_y)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).shift_z as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(shift_z)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).quaternion_r as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(quaternion_r)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).quaternion_i as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(quaternion_i)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).quaternion_j as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(quaternion_j)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).quaternion_k as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(quaternion_k)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).translation_x as *const _
as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(translation_x)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).translation_y as *const _
as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(translation_y)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCQuaternionDecomposition>())).translation_z as *const _
as usize
},
60usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(translation_z)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCSceneTy {
_unused: [u8; 0],
}
pub type RTCScene = *mut RTCSceneTy;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCGeometryTy {
_unused: [u8; 0],
}
pub type RTCGeometry = *mut RTCGeometryTy;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCGeometryType {
TRIANGLE = 0,
QUAD = 1,
GRID = 2,
SUBDIVISION = 8,
CONE_LINEAR_CURVE = 15,
ROUND_LINEAR_CURVE = 16,
FLAT_LINEAR_CURVE = 17,
ROUND_BEZIER_CURVE = 24,
FLAT_BEZIER_CURVE = 25,
NORMAL_ORIENTED_BEZIER_CURVE = 26,
ROUND_BSPLINE_CURVE = 32,
FLAT_BSPLINE_CURVE = 33,
NORMAL_ORIENTED_BSPLINE_CURVE = 34,
ROUND_HERMITE_CURVE = 40,
FLAT_HERMITE_CURVE = 41,
NORMAL_ORIENTED_HERMITE_CURVE = 42,
SPHERE_POINT = 50,
DISC_POINT = 51,
ORIENTED_DISC_POINT = 52,
ROUND_CATMULL_ROM_CURVE = 58,
FLAT_CATMULL_ROM_CURVE = 59,
NORMAL_ORIENTED_CATMULL_ROM_CURVE = 60,
USER = 120,
INSTANCE = 121,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCSubdivisionMode {
NO_BOUNDARY = 0,
SMOOTH_BOUNDARY = 1,
PIN_CORNERS = 2,
PIN_BOUNDARY = 3,
PIN_ALL = 4,
}
impl RTCCurveFlags {
pub const NEIGHBOR_LEFT: RTCCurveFlags = RTCCurveFlags(1);
}
impl RTCCurveFlags {
pub const NEIGHBOR_RIGHT: RTCCurveFlags = RTCCurveFlags(2);
}
impl ::std::ops::BitOr<RTCCurveFlags> for RTCCurveFlags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
RTCCurveFlags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for RTCCurveFlags {
#[inline]
fn bitor_assign(&mut self, rhs: RTCCurveFlags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<RTCCurveFlags> for RTCCurveFlags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
RTCCurveFlags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for RTCCurveFlags {
#[inline]
fn bitand_assign(&mut self, rhs: RTCCurveFlags) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct RTCCurveFlags(pub ::std::os::raw::c_uint);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCBoundsFunctionArguments {
pub geometryUserPtr: *mut ::std::os::raw::c_void,
pub primID: ::std::os::raw::c_uint,
pub timeStep: ::std::os::raw::c_uint,
pub bounds_o: *mut RTCBounds,
}
#[test]
fn bindgen_test_layout_RTCBoundsFunctionArguments() {
assert_eq!(
::std::mem::size_of::<RTCBoundsFunctionArguments>(),
24usize,
concat!("Size of: ", stringify!(RTCBoundsFunctionArguments))
);
assert_eq!(
::std::mem::align_of::<RTCBoundsFunctionArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCBoundsFunctionArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).geometryUserPtr as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBoundsFunctionArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).primID as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBoundsFunctionArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).timeStep as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBoundsFunctionArguments),
"::",
stringify!(timeStep)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).bounds_o as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCBoundsFunctionArguments),
"::",
stringify!(bounds_o)
)
);
}
pub type RTCBoundsFunction =
::std::option::Option<unsafe extern "C" fn(args: *const RTCBoundsFunctionArguments)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCIntersectFunctionNArguments {
pub valid: *mut ::std::os::raw::c_int,
pub geometryUserPtr: *mut ::std::os::raw::c_void,
pub primID: ::std::os::raw::c_uint,
pub context: *mut RTCIntersectContext,
pub rayhit: *mut RTCRayHitN,
pub N: ::std::os::raw::c_uint,
pub geomID: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCIntersectFunctionNArguments() {
assert_eq!(
::std::mem::size_of::<RTCIntersectFunctionNArguments>(),
48usize,
concat!("Size of: ", stringify!(RTCIntersectFunctionNArguments))
);
assert_eq!(
::std::mem::align_of::<RTCIntersectFunctionNArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCIntersectFunctionNArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).valid as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).geometryUserPtr as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).primID as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).context as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).rayhit as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(rayhit)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).N as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(N)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).geomID as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(geomID)
)
);
}
pub type RTCIntersectFunctionN =
::std::option::Option<unsafe extern "C" fn(args: *const RTCIntersectFunctionNArguments)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCOccludedFunctionNArguments {
pub valid: *mut ::std::os::raw::c_int,
pub geometryUserPtr: *mut ::std::os::raw::c_void,
pub primID: ::std::os::raw::c_uint,
pub context: *mut RTCIntersectContext,
pub ray: *mut RTCRayN,
pub N: ::std::os::raw::c_uint,
pub geomID: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCOccludedFunctionNArguments() {
assert_eq!(
::std::mem::size_of::<RTCOccludedFunctionNArguments>(),
48usize,
concat!("Size of: ", stringify!(RTCOccludedFunctionNArguments))
);
assert_eq!(
::std::mem::align_of::<RTCOccludedFunctionNArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCOccludedFunctionNArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).valid as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).geometryUserPtr as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).primID as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).context as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).ray as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).N as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(N)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).geomID as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(geomID)
)
);
}
pub type RTCOccludedFunctionN =
::std::option::Option<unsafe extern "C" fn(args: *const RTCOccludedFunctionNArguments)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCDisplacementFunctionNArguments {
pub geometryUserPtr: *mut ::std::os::raw::c_void,
pub geometry: RTCGeometry,
pub primID: ::std::os::raw::c_uint,
pub timeStep: ::std::os::raw::c_uint,
pub u: *const f32,
pub v: *const f32,
pub Ng_x: *const f32,
pub Ng_y: *const f32,
pub Ng_z: *const f32,
pub P_x: *mut f32,
pub P_y: *mut f32,
pub P_z: *mut f32,
pub N: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCDisplacementFunctionNArguments() {
assert_eq!(
::std::mem::size_of::<RTCDisplacementFunctionNArguments>(),
96usize,
concat!("Size of: ", stringify!(RTCDisplacementFunctionNArguments))
);
assert_eq!(
::std::mem::align_of::<RTCDisplacementFunctionNArguments>(),
8usize,
concat!(
"Alignment of ",
stringify!(RTCDisplacementFunctionNArguments)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).geometryUserPtr
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).geometry as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(geometry)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).primID as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).timeStep as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(timeStep)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).u as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).v as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_x as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_y as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_z as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_x as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(P_x)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_y as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(P_y)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_z as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(P_z)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).N as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(N)
)
);
}
pub type RTCDisplacementFunctionN =
::std::option::Option<unsafe extern "C" fn(args: *const RTCDisplacementFunctionNArguments)>;
extern "C" {
pub fn rtcNewGeometry(device: RTCDevice, type_: RTCGeometryType) -> RTCGeometry;
}
extern "C" {
pub fn rtcRetainGeometry(geometry: RTCGeometry);
}
extern "C" {
pub fn rtcReleaseGeometry(geometry: RTCGeometry);
}
extern "C" {
pub fn rtcCommitGeometry(geometry: RTCGeometry);
}
extern "C" {
pub fn rtcEnableGeometry(geometry: RTCGeometry);
}
extern "C" {
pub fn rtcDisableGeometry(geometry: RTCGeometry);
}
extern "C" {
pub fn rtcSetGeometryTimeStepCount(
geometry: RTCGeometry,
timeStepCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcSetGeometryTimeRange(geometry: RTCGeometry, startTime: f32, endTime: f32);
}
extern "C" {
pub fn rtcSetGeometryVertexAttributeCount(
geometry: RTCGeometry,
vertexAttributeCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcSetGeometryMask(geometry: RTCGeometry, mask: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rtcSetGeometryBuildQuality(geometry: RTCGeometry, quality: RTCBuildQuality);
}
extern "C" {
pub fn rtcSetGeometryMaxRadiusScale(geometry: RTCGeometry, maxRadiusScale: f32);
}
extern "C" {
pub fn rtcSetGeometryBuffer(
geometry: RTCGeometry,
type_: RTCBufferType,
slot: ::std::os::raw::c_uint,
format: RTCFormat,
buffer: RTCBuffer,
byteOffset: size_t,
byteStride: size_t,
itemCount: size_t,
);
}
extern "C" {
pub fn rtcSetSharedGeometryBuffer(
geometry: RTCGeometry,
type_: RTCBufferType,
slot: ::std::os::raw::c_uint,
format: RTCFormat,
ptr: *const ::std::os::raw::c_void,
byteOffset: size_t,
byteStride: size_t,
itemCount: size_t,
);
}
extern "C" {
pub fn rtcSetNewGeometryBuffer(
geometry: RTCGeometry,
type_: RTCBufferType,
slot: ::std::os::raw::c_uint,
format: RTCFormat,
byteStride: size_t,
itemCount: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn rtcGetGeometryBufferData(
geometry: RTCGeometry,
type_: RTCBufferType,
slot: ::std::os::raw::c_uint,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn rtcUpdateGeometryBuffer(
geometry: RTCGeometry,
type_: RTCBufferType,
slot: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcSetGeometryIntersectFilterFunction(geometry: RTCGeometry, filter: RTCFilterFunctionN);
}
extern "C" {
pub fn rtcSetGeometryOccludedFilterFunction(geometry: RTCGeometry, filter: RTCFilterFunctionN);
}
extern "C" {
pub fn rtcSetGeometryUserData(geometry: RTCGeometry, ptr: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn rtcGetGeometryUserData(geometry: RTCGeometry) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn rtcSetGeometryPointQueryFunction(
geometry: RTCGeometry,
pointQuery: RTCPointQueryFunction,
);
}
extern "C" {
pub fn rtcSetGeometryUserPrimitiveCount(
geometry: RTCGeometry,
userPrimitiveCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcSetGeometryBoundsFunction(
geometry: RTCGeometry,
bounds: RTCBoundsFunction,
userPtr: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn rtcSetGeometryIntersectFunction(geometry: RTCGeometry, intersect: RTCIntersectFunctionN);
}
extern "C" {
pub fn rtcSetGeometryOccludedFunction(geometry: RTCGeometry, occluded: RTCOccludedFunctionN);
}
extern "C" {
pub fn rtcFilterIntersection(
args: *const RTCIntersectFunctionNArguments,
filterArgs: *const RTCFilterFunctionNArguments,
);
}
extern "C" {
pub fn rtcFilterOcclusion(
args: *const RTCOccludedFunctionNArguments,
filterArgs: *const RTCFilterFunctionNArguments,
);
}
extern "C" {
pub fn rtcSetGeometryInstancedScene(geometry: RTCGeometry, scene: RTCScene);
}
extern "C" {
pub fn rtcSetGeometryTransform(
geometry: RTCGeometry,
timeStep: ::std::os::raw::c_uint,
format: RTCFormat,
xfm: *const ::std::os::raw::c_void,
);
}
extern "C" {
pub fn rtcSetGeometryTransformQuaternion(
geometry: RTCGeometry,
timeStep: ::std::os::raw::c_uint,
qd: *const RTCQuaternionDecomposition,
);
}
extern "C" {
pub fn rtcGetGeometryTransform(
geometry: RTCGeometry,
time: f32,
format: RTCFormat,
xfm: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn rtcSetGeometryTessellationRate(geometry: RTCGeometry, tessellationRate: f32);
}
extern "C" {
pub fn rtcSetGeometryTopologyCount(
geometry: RTCGeometry,
topologyCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcSetGeometrySubdivisionMode(
geometry: RTCGeometry,
topologyID: ::std::os::raw::c_uint,
mode: RTCSubdivisionMode,
);
}
extern "C" {
pub fn rtcSetGeometryVertexAttributeTopology(
geometry: RTCGeometry,
vertexAttributeID: ::std::os::raw::c_uint,
topologyID: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcSetGeometryDisplacementFunction(
geometry: RTCGeometry,
displacement: RTCDisplacementFunctionN,
);
}
extern "C" {
pub fn rtcGetGeometryFirstHalfEdge(
geometry: RTCGeometry,
faceID: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rtcGetGeometryFace(
geometry: RTCGeometry,
edgeID: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rtcGetGeometryNextHalfEdge(
geometry: RTCGeometry,
edgeID: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rtcGetGeometryPreviousHalfEdge(
geometry: RTCGeometry,
edgeID: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rtcGetGeometryOppositeHalfEdge(
geometry: RTCGeometry,
topologyID: ::std::os::raw::c_uint,
edgeID: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCInterpolateArguments {
pub geometry: RTCGeometry,
pub primID: ::std::os::raw::c_uint,
pub u: f32,
pub v: f32,
pub bufferType: RTCBufferType,
pub bufferSlot: ::std::os::raw::c_uint,
pub P: *mut f32,
pub dPdu: *mut f32,
pub dPdv: *mut f32,
pub ddPdudu: *mut f32,
pub ddPdvdv: *mut f32,
pub ddPdudv: *mut f32,
pub valueCount: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCInterpolateArguments() {
assert_eq!(
::std::mem::size_of::<RTCInterpolateArguments>(),
88usize,
concat!("Size of: ", stringify!(RTCInterpolateArguments))
);
assert_eq!(
::std::mem::align_of::<RTCInterpolateArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCInterpolateArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateArguments>())).geometry as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(geometry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).primID as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).u as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).v as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateArguments>())).bufferType as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(bufferType)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateArguments>())).bufferSlot as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(bufferSlot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).P as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(P)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).dPdu as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(dPdu)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).dPdv as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(dPdv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdudu as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(ddPdudu)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdvdv as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(ddPdvdv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdudv as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(ddPdudv)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateArguments>())).valueCount as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(valueCount)
)
);
}
extern "C" {
pub fn rtcInterpolate(args: *const RTCInterpolateArguments);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCInterpolateNArguments {
pub geometry: RTCGeometry,
pub valid: *const ::std::os::raw::c_void,
pub primIDs: *const ::std::os::raw::c_uint,
pub u: *const f32,
pub v: *const f32,
pub N: ::std::os::raw::c_uint,
pub bufferType: RTCBufferType,
pub bufferSlot: ::std::os::raw::c_uint,
pub P: *mut f32,
pub dPdu: *mut f32,
pub dPdv: *mut f32,
pub ddPdudu: *mut f32,
pub ddPdvdv: *mut f32,
pub ddPdudv: *mut f32,
pub valueCount: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCInterpolateNArguments() {
assert_eq!(
::std::mem::size_of::<RTCInterpolateNArguments>(),
112usize,
concat!("Size of: ", stringify!(RTCInterpolateNArguments))
);
assert_eq!(
::std::mem::align_of::<RTCInterpolateNArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCInterpolateNArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).geometry as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(geometry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).valid as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).primIDs as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(primIDs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).u as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).v as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).N as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(N)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).bufferType as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(bufferType)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).bufferSlot as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(bufferSlot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).P as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(P)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).dPdu as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(dPdu)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).dPdv as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(dPdv)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdudu as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(ddPdudu)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdvdv as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(ddPdvdv)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdudv as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(ddPdudv)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).valueCount as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(valueCount)
)
);
}
extern "C" {
pub fn rtcInterpolateN(args: *const RTCInterpolateNArguments);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCGrid {
pub startVertexID: ::std::os::raw::c_uint,
pub stride: ::std::os::raw::c_uint,
pub width: ::std::os::raw::c_ushort,
pub height: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout_RTCGrid() {
assert_eq!(
::std::mem::size_of::<RTCGrid>(),
12usize,
concat!("Size of: ", stringify!(RTCGrid))
);
assert_eq!(
::std::mem::align_of::<RTCGrid>(),
4usize,
concat!("Alignment of ", stringify!(RTCGrid))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCGrid>())).startVertexID as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCGrid),
"::",
stringify!(startVertexID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCGrid>())).stride as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCGrid),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCGrid>())).width as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCGrid),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCGrid>())).height as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(RTCGrid),
"::",
stringify!(height)
)
);
}
impl RTCSceneFlags {
pub const NONE: RTCSceneFlags = RTCSceneFlags(0);
}
impl RTCSceneFlags {
pub const DYNAMIC: RTCSceneFlags = RTCSceneFlags(1);
}
impl RTCSceneFlags {
pub const COMPACT: RTCSceneFlags = RTCSceneFlags(2);
}
impl RTCSceneFlags {
pub const ROBUST: RTCSceneFlags = RTCSceneFlags(4);
}
impl RTCSceneFlags {
pub const CONTEXT_FILTER_FUNCTION: RTCSceneFlags = RTCSceneFlags(8);
}
impl ::std::ops::BitOr<RTCSceneFlags> for RTCSceneFlags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
RTCSceneFlags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for RTCSceneFlags {
#[inline]
fn bitor_assign(&mut self, rhs: RTCSceneFlags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<RTCSceneFlags> for RTCSceneFlags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
RTCSceneFlags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for RTCSceneFlags {
#[inline]
fn bitand_assign(&mut self, rhs: RTCSceneFlags) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct RTCSceneFlags(pub ::std::os::raw::c_uint);
extern "C" {
pub fn rtcNewScene(device: RTCDevice) -> RTCScene;
}
extern "C" {
pub fn rtcGetSceneDevice(hscene: RTCScene) -> RTCDevice;
}
extern "C" {
pub fn rtcRetainScene(scene: RTCScene);
}
extern "C" {
pub fn rtcReleaseScene(scene: RTCScene);
}
extern "C" {
pub fn rtcAttachGeometry(scene: RTCScene, geometry: RTCGeometry) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rtcAttachGeometryByID(
scene: RTCScene,
geometry: RTCGeometry,
geomID: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcDetachGeometry(scene: RTCScene, geomID: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rtcGetGeometry(scene: RTCScene, geomID: ::std::os::raw::c_uint) -> RTCGeometry;
}
extern "C" {
pub fn rtcCommitScene(scene: RTCScene);
}
extern "C" {
pub fn rtcJoinCommitScene(scene: RTCScene);
}
pub type RTCProgressMonitorFunction =
::std::option::Option<unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void, n: f64) -> bool>;
extern "C" {
pub fn rtcSetSceneProgressMonitorFunction(
scene: RTCScene,
progress: RTCProgressMonitorFunction,
ptr: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn rtcSetSceneBuildQuality(scene: RTCScene, quality: RTCBuildQuality);
}
extern "C" {
pub fn rtcSetSceneFlags(scene: RTCScene, flags: RTCSceneFlags);
}
extern "C" {
pub fn rtcGetSceneFlags(scene: RTCScene) -> RTCSceneFlags;
}
extern "C" {
pub fn rtcGetSceneBounds(scene: RTCScene, bounds_o: *mut RTCBounds);
}
extern "C" {
pub fn rtcGetSceneLinearBounds(scene: RTCScene, bounds_o: *mut RTCLinearBounds);
}
extern "C" {
pub fn rtcPointQuery(
scene: RTCScene,
query: *mut RTCPointQuery,
context: *mut RTCPointQueryContext,
queryFunc: RTCPointQueryFunction,
userPtr: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn rtcPointQuery4(
valid: *const ::std::os::raw::c_int,
scene: RTCScene,
query: *mut RTCPointQuery4,
context: *mut RTCPointQueryContext,
queryFunc: RTCPointQueryFunction,
userPtr: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn rtcPointQuery8(
valid: *const ::std::os::raw::c_int,
scene: RTCScene,
query: *mut RTCPointQuery8,
context: *mut RTCPointQueryContext,
queryFunc: RTCPointQueryFunction,
userPtr: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn rtcPointQuery16(
valid: *const ::std::os::raw::c_int,
scene: RTCScene,
query: *mut RTCPointQuery16,
context: *mut RTCPointQueryContext,
queryFunc: RTCPointQueryFunction,
userPtr: *mut *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn rtcIntersect1(
scene: RTCScene,
context: *mut RTCIntersectContext,
rayhit: *mut RTCRayHit,
);
}
extern "C" {
pub fn rtcIntersect4(
valid: *const ::std::os::raw::c_int,
scene: RTCScene,
context: *mut RTCIntersectContext,
rayhit: *mut RTCRayHit4,
);
}
extern "C" {
pub fn rtcIntersect8(
valid: *const ::std::os::raw::c_int,
scene: RTCScene,
context: *mut RTCIntersectContext,
rayhit: *mut RTCRayHit8,
);
}
extern "C" {
pub fn rtcIntersect16(
valid: *const ::std::os::raw::c_int,
scene: RTCScene,
context: *mut RTCIntersectContext,
rayhit: *mut RTCRayHit16,
);
}
extern "C" {
pub fn rtcIntersect1M(
scene: RTCScene,
context: *mut RTCIntersectContext,
rayhit: *mut RTCRayHit,
M: ::std::os::raw::c_uint,
byteStride: size_t,
);
}
extern "C" {
pub fn rtcIntersect1Mp(
scene: RTCScene,
context: *mut RTCIntersectContext,
rayhit: *mut *mut RTCRayHit,
M: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcIntersectNM(
scene: RTCScene,
context: *mut RTCIntersectContext,
rayhit: *mut RTCRayHitN,
N: ::std::os::raw::c_uint,
M: ::std::os::raw::c_uint,
byteStride: size_t,
);
}
extern "C" {
pub fn rtcIntersectNp(
scene: RTCScene,
context: *mut RTCIntersectContext,
rayhit: *const RTCRayHitNp,
N: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcOccluded1(scene: RTCScene, context: *mut RTCIntersectContext, ray: *mut RTCRay);
}
extern "C" {
pub fn rtcOccluded4(
valid: *const ::std::os::raw::c_int,
scene: RTCScene,
context: *mut RTCIntersectContext,
ray: *mut RTCRay4,
);
}
extern "C" {
pub fn rtcOccluded8(
valid: *const ::std::os::raw::c_int,
scene: RTCScene,
context: *mut RTCIntersectContext,
ray: *mut RTCRay8,
);
}
extern "C" {
pub fn rtcOccluded16(
valid: *const ::std::os::raw::c_int,
scene: RTCScene,
context: *mut RTCIntersectContext,
ray: *mut RTCRay16,
);
}
extern "C" {
pub fn rtcOccluded1M(
scene: RTCScene,
context: *mut RTCIntersectContext,
ray: *mut RTCRay,
M: ::std::os::raw::c_uint,
byteStride: size_t,
);
}
extern "C" {
pub fn rtcOccluded1Mp(
scene: RTCScene,
context: *mut RTCIntersectContext,
ray: *mut *mut RTCRay,
M: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcOccludedNM(
scene: RTCScene,
context: *mut RTCIntersectContext,
ray: *mut RTCRayN,
N: ::std::os::raw::c_uint,
M: ::std::os::raw::c_uint,
byteStride: size_t,
);
}
extern "C" {
pub fn rtcOccludedNp(
scene: RTCScene,
context: *mut RTCIntersectContext,
ray: *const RTCRayNp,
N: ::std::os::raw::c_uint,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCCollision {
pub geomID0: ::std::os::raw::c_uint,
pub primID0: ::std::os::raw::c_uint,
pub geomID1: ::std::os::raw::c_uint,
pub primID1: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCCollision() {
assert_eq!(
::std::mem::size_of::<RTCCollision>(),
16usize,
concat!("Size of: ", stringify!(RTCCollision))
);
assert_eq!(
::std::mem::align_of::<RTCCollision>(),
4usize,
concat!("Alignment of ", stringify!(RTCCollision))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCCollision>())).geomID0 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCCollision),
"::",
stringify!(geomID0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCCollision>())).primID0 as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCCollision),
"::",
stringify!(primID0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCCollision>())).geomID1 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCCollision),
"::",
stringify!(geomID1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCCollision>())).primID1 as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCCollision),
"::",
stringify!(primID1)
)
);
}
pub type RTCCollideFunc = ::std::option::Option<
unsafe extern "C" fn(
userPtr: *mut ::std::os::raw::c_void,
collisions: *mut RTCCollision,
num_collisions: ::std::os::raw::c_uint,
),
>;
extern "C" {
pub fn rtcCollide(
scene0: RTCScene,
scene1: RTCScene,
callback: RTCCollideFunc,
userPtr: *mut ::std::os::raw::c_void,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCBVHTy {
_unused: [u8; 0],
}
pub type RTCBVH = *mut RTCBVHTy;
#[repr(C)]
#[repr(align(32))]
#[derive(Debug, Copy, Clone)]
pub struct RTCBuildPrimitive {
pub lower_x: f32,
pub lower_y: f32,
pub lower_z: f32,
pub geomID: ::std::os::raw::c_uint,
pub upper_x: f32,
pub upper_y: f32,
pub upper_z: f32,
pub primID: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCBuildPrimitive() {
assert_eq!(
::std::mem::size_of::<RTCBuildPrimitive>(),
32usize,
concat!("Size of: ", stringify!(RTCBuildPrimitive))
);
assert_eq!(
::std::mem::align_of::<RTCBuildPrimitive>(),
32usize,
concat!("Alignment of ", stringify!(RTCBuildPrimitive))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(lower_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(lower_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(lower_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).geomID as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_x as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(upper_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_y as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(upper_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_z as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(upper_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).primID as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(primID)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCThreadLocalAllocatorTy {
_unused: [u8; 0],
}
pub type RTCThreadLocalAllocator = *mut RTCThreadLocalAllocatorTy;
pub type RTCCreateNodeFunction = ::std::option::Option<
unsafe extern "C" fn(
allocator: RTCThreadLocalAllocator,
childCount: ::std::os::raw::c_uint,
userPtr: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>;
pub type RTCSetNodeChildrenFunction = ::std::option::Option<
unsafe extern "C" fn(
nodePtr: *mut ::std::os::raw::c_void,
children: *mut *mut ::std::os::raw::c_void,
childCount: ::std::os::raw::c_uint,
userPtr: *mut ::std::os::raw::c_void,
),
>;
pub type RTCSetNodeBoundsFunction = ::std::option::Option<
unsafe extern "C" fn(
nodePtr: *mut ::std::os::raw::c_void,
bounds: *mut *const RTCBounds,
childCount: ::std::os::raw::c_uint,
userPtr: *mut ::std::os::raw::c_void,
),
>;
pub type RTCCreateLeafFunction = ::std::option::Option<
unsafe extern "C" fn(
allocator: RTCThreadLocalAllocator,
primitives: *const RTCBuildPrimitive,
primitiveCount: size_t,
userPtr: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>;
pub type RTCSplitPrimitiveFunction = ::std::option::Option<
unsafe extern "C" fn(
primitive: *const RTCBuildPrimitive,
dimension: ::std::os::raw::c_uint,
position: f32,
leftBounds: *mut RTCBounds,
rightBounds: *mut RTCBounds,
userPtr: *mut ::std::os::raw::c_void,
),
>;
impl RTCBuildFlags {
pub const NONE: RTCBuildFlags = RTCBuildFlags(0);
}
impl RTCBuildFlags {
pub const DYNAMIC: RTCBuildFlags = RTCBuildFlags(1);
}
impl ::std::ops::BitOr<RTCBuildFlags> for RTCBuildFlags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
RTCBuildFlags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for RTCBuildFlags {
#[inline]
fn bitor_assign(&mut self, rhs: RTCBuildFlags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<RTCBuildFlags> for RTCBuildFlags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
RTCBuildFlags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for RTCBuildFlags {
#[inline]
fn bitand_assign(&mut self, rhs: RTCBuildFlags) {
self.0 &= rhs.0;
}
}
#[repr(transparent)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct RTCBuildFlags(pub ::std::os::raw::c_uint);
pub const RTCBuildConstants_RTC_BUILD_MAX_PRIMITIVES_PER_LEAF: RTCBuildConstants = 32;
pub type RTCBuildConstants = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCBuildArguments {
pub byteSize: size_t,
pub buildQuality: RTCBuildQuality,
pub buildFlags: RTCBuildFlags,
pub maxBranchingFactor: ::std::os::raw::c_uint,
pub maxDepth: ::std::os::raw::c_uint,
pub sahBlockSize: ::std::os::raw::c_uint,
pub minLeafSize: ::std::os::raw::c_uint,
pub maxLeafSize: ::std::os::raw::c_uint,
pub traversalCost: f32,
pub intersectionCost: f32,
pub bvh: RTCBVH,
pub primitives: *mut RTCBuildPrimitive,
pub primitiveCount: size_t,
pub primitiveArrayCapacity: size_t,
pub createNode: RTCCreateNodeFunction,
pub setNodeChildren: RTCSetNodeChildrenFunction,
pub setNodeBounds: RTCSetNodeBoundsFunction,
pub createLeaf: RTCCreateLeafFunction,
pub splitPrimitive: RTCSplitPrimitiveFunction,
pub buildProgress: RTCProgressMonitorFunction,
pub userPtr: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_RTCBuildArguments() {
assert_eq!(
::std::mem::size_of::<RTCBuildArguments>(),
136usize,
concat!("Size of: ", stringify!(RTCBuildArguments))
);
assert_eq!(
::std::mem::align_of::<RTCBuildArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCBuildArguments))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).byteSize as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(byteSize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildQuality as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(buildQuality)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildFlags as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(buildFlags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).maxBranchingFactor as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(maxBranchingFactor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).maxDepth as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(maxDepth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).sahBlockSize as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(sahBlockSize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).minLeafSize as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(minLeafSize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).maxLeafSize as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(maxLeafSize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).traversalCost as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(traversalCost)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).intersectionCost as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(intersectionCost)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).bvh as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(bvh)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).primitives as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(primitives)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).primitiveCount as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(primitiveCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).primitiveArrayCapacity as *const _
as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(primitiveArrayCapacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).createNode as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(createNode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).setNodeChildren as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(setNodeChildren)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).setNodeBounds as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(setNodeBounds)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).createLeaf as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(createLeaf)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).splitPrimitive as *const _ as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(splitPrimitive)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildProgress as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(buildProgress)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).userPtr as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(userPtr)
)
);
}
extern "C" {
pub fn rtcNewBVH(device: RTCDevice) -> RTCBVH;
}
extern "C" {
pub fn rtcBuildBVH(args: *const RTCBuildArguments) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn rtcThreadLocalAlloc(
allocator: RTCThreadLocalAllocator,
bytes: size_t,
align: size_t,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn rtcRetainBVH(bvh: RTCBVH);
}
extern "C" {
pub fn rtcReleaseBVH(bvh: RTCBVH);
}