pub const RTC_VERSION_MAJOR: u32 = 3;
pub const RTC_VERSION_MINOR: u32 = 13;
pub const RTC_VERSION_PATCH: u32 = 5;
pub const RTC_VERSION: u32 = 31305;
pub const RTC_VERSION_STRING: &[u8; 7usize] = b"3.13.5\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;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
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, Hash, PartialEq, Eq)]
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() {
const UNINIT: ::std::mem::MaybeUninit<RTCBounds> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).lower_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(lower_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lower_y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(lower_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lower_z) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(lower_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).align0) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(align0)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).upper_x) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(upper_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).upper_y) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(upper_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).upper_z) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(upper_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).align1) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCLinearBounds> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).bounds0) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCLinearBounds),
"::",
stringify!(bounds0)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bounds1) as usize - ptr 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, Hash, PartialEq, Eq)]
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() {
const UNINIT: ::std::mem::MaybeUninit<RTCFilterFunctionNArguments> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).valid) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geometryUserPtr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ray) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hit) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(hit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).N) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCIntersectContext> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectContext),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filter) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectContext),
"::",
stringify!(filter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instID) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCPointQuery> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).radius) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCPointQuery4> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery4),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery4),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery4),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery4),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).radius) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCPointQuery8> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery8),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery8),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery8),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery8),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).radius) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery8),
"::",
stringify!(radius)
)
);
}
#[repr(C)]
#[repr(align(64))]
#[derive(Debug, 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCPointQuery16> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery16),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery16),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery16),
"::",
stringify!(z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQuery16),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).radius) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCPointQueryContext> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).world2inst) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryContext),
"::",
stringify!(world2inst)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).inst2world) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryContext),
"::",
stringify!(inst2world)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instID) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryContext),
"::",
stringify!(instID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instStackSize) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCPointQueryFunctionArguments> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).query) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryFunctionArguments),
"::",
stringify!(query)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).userPtr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryFunctionArguments),
"::",
stringify!(userPtr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryFunctionArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geomID) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryFunctionArguments),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCPointQueryFunctionArguments),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).similarityScale) as usize - ptr 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, Hash, PartialEq, Eq)]
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) -> isize;
}
extern "C" {
pub fn rtcSetDeviceProperty(device: RTCDevice, prop: RTCDeviceProperty, value: isize);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
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: isize, 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, Hash, PartialEq, Eq)]
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: usize) -> RTCBuffer;
}
extern "C" {
pub fn rtcNewSharedBuffer(
device: RTCDevice,
ptr: *mut ::std::os::raw::c_void,
byteSize: usize,
) -> 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCRay> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).org_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).org_y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).org_z) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tnear) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_x) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_y) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_z) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tfar) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCHit> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).Ng_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_z) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
12usize,
concat!("Offset of field: ", stringify!(RTCHit), "::", stringify!(u))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
16usize,
concat!("Offset of field: ", stringify!(RTCHit), "::", stringify!(v))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geomID) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instID) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCRayHit> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).ray) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hit) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCRay4> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).org_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).org_y) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).org_z) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tnear) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_x) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_y) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_z) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tfar) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCHit4> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).Ng_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_y) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_z) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geomID) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instID) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCRayHit4> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).ray) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit4),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hit) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCRay8> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).org_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).org_y) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).org_z) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tnear) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_x) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_y) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_z) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tfar) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCHit8> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).Ng_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_y) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_z) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geomID) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instID) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCRayHit8> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).ray) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit8),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hit) as usize - ptr as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit8),
"::",
stringify!(hit)
)
);
}
#[repr(C)]
#[repr(align(64))]
#[derive(Debug, 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCRay16> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).org_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).org_y) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).org_z) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tnear) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_x) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_y) as usize - ptr as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_z) as usize - ptr as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tfar) as usize - ptr as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
576usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
640usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
704usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[repr(align(64))]
#[derive(Debug, 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCHit16> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).Ng_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_y) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_z) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geomID) as usize - ptr as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instID) as usize - ptr as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[repr(align(64))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayHit16 {
pub ray: RTCRay16,
pub hit: RTCHit16,
}
#[test]
fn bindgen_test_layout_RTCRayHit16() {
const UNINIT: ::std::mem::MaybeUninit<RTCRayHit16> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).ray) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit16),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hit) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCRayNp> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).org_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).org_y) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).org_z) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tnear) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_x) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_y) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dir_z) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tfar) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mask) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCHitNp> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).Ng_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_y) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_z) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geomID) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).instID) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCRayHitNp> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).ray) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHitNp),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hit) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCQuaternionDecomposition> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).scale_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(scale_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scale_y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(scale_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scale_z) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(scale_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).skew_xy) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(skew_xy)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).skew_xz) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(skew_xz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).skew_yz) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(skew_yz)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).shift_x) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(shift_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).shift_y) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(shift_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).shift_z) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(shift_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quaternion_r) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(quaternion_r)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quaternion_i) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(quaternion_i)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quaternion_j) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(quaternion_j)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quaternion_k) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(quaternion_k)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).translation_x) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(translation_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).translation_y) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCQuaternionDecomposition),
"::",
stringify!(translation_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).translation_z) as usize - ptr 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, Hash, PartialEq, Eq)]
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, Hash, PartialEq, Eq)]
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, Hash, PartialEq, Eq)]
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() {
const UNINIT: ::std::mem::MaybeUninit<RTCBoundsFunctionArguments> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).geometryUserPtr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBoundsFunctionArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBoundsFunctionArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).timeStep) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBoundsFunctionArguments),
"::",
stringify!(timeStep)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bounds_o) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCIntersectFunctionNArguments> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).valid) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geometryUserPtr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rayhit) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(rayhit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).N) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(N)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geomID) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCOccludedFunctionNArguments> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).valid) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geometryUserPtr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).context) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ray) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).N) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(N)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geomID) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCDisplacementFunctionNArguments> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).geometryUserPtr) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geometry) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(geometry)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).timeStep) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(timeStep)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_x) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_y) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).Ng_z) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).P_x) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(P_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).P_y) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(P_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).P_z) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(P_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).N) as usize - ptr 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: usize,
byteStride: usize,
itemCount: usize,
);
}
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: usize,
byteStride: usize,
itemCount: usize,
);
}
extern "C" {
pub fn rtcSetNewGeometryBuffer(
geometry: RTCGeometry,
type_: RTCBufferType,
slot: ::std::os::raw::c_uint,
format: RTCFormat,
byteStride: usize,
itemCount: usize,
) -> *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() {
const UNINIT: ::std::mem::MaybeUninit<RTCInterpolateArguments> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).geometry) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(geometry)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bufferType) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(bufferType)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bufferSlot) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(bufferSlot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).P) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(P)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dPdu) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(dPdu)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dPdv) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(dPdv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ddPdudu) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(ddPdudu)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ddPdvdv) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(ddPdvdv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ddPdudv) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(ddPdudv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).valueCount) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCInterpolateNArguments> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).geometry) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(geometry)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).valid) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primIDs) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(primIDs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).N) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(N)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bufferType) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(bufferType)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bufferSlot) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(bufferSlot)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).P) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(P)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dPdu) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(dPdu)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dPdv) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(dPdv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ddPdudu) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(ddPdudu)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ddPdvdv) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(ddPdvdv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ddPdudv) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(ddPdudv)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).valueCount) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCGrid> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).startVertexID) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCGrid),
"::",
stringify!(startVertexID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stride) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCGrid),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCGrid),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr 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, Hash, PartialEq, Eq)]
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 rtcGetGeometryThreadSafe(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: usize,
);
}
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: usize,
);
}
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: usize,
);
}
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: usize,
);
}
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() {
const UNINIT: ::std::mem::MaybeUninit<RTCCollision> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).geomID0) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCCollision),
"::",
stringify!(geomID0)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID0) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCCollision),
"::",
stringify!(primID0)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geomID1) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCCollision),
"::",
stringify!(geomID1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID1) as usize - ptr 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() {
const UNINIT: ::std::mem::MaybeUninit<RTCBuildPrimitive> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).lower_x) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(lower_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lower_y) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(lower_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lower_z) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(lower_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).geomID) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).upper_x) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(upper_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).upper_y) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(upper_y)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).upper_z) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(upper_z)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primID) as usize - ptr 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: usize,
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, Hash, PartialEq, Eq)]
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: usize,
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: usize,
pub primitiveArrayCapacity: usize,
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() {
const UNINIT: ::std::mem::MaybeUninit<RTCBuildArguments> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr).byteSize) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(byteSize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buildQuality) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(buildQuality)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buildFlags) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(buildFlags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxBranchingFactor) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(maxBranchingFactor)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxDepth) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(maxDepth)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sahBlockSize) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(sahBlockSize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minLeafSize) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(minLeafSize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maxLeafSize) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(maxLeafSize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).traversalCost) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(traversalCost)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).intersectionCost) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(intersectionCost)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bvh) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(bvh)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primitives) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(primitives)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primitiveCount) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(primitiveCount)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).primitiveArrayCapacity) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(primitiveArrayCapacity)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).createNode) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(createNode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).setNodeChildren) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(setNodeChildren)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).setNodeBounds) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(setNodeBounds)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).createLeaf) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(createLeaf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).splitPrimitive) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(splitPrimitive)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buildProgress) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(buildProgress)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).userPtr) as usize - ptr 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: usize,
align: usize,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn rtcRetainBVH(bvh: RTCBVH);
}
extern "C" {
pub fn rtcReleaseBVH(bvh: RTCBVH);
}