pub const RTC_VERSION_MAJOR: u32 = 3;
pub const RTC_VERSION_MINOR: u32 = 2;
pub const RTC_VERSION_PATCH: u32 = 4;
pub const RTC_VERSION: u32 = 30204;
pub const RTC_VERSION_STRING: &'static [u8; 6usize] = b"3.2.4\0";
pub const RTC_MAX_TIME_STEP_COUNT: u32 = 129;
pub const RTC_MAX_INSTANCE_LEVEL_COUNT: u32 = 1;
pub type __ssize_t = ::std::os::raw::c_long;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCFormat {
UNDEFINED = 0,
UCHAR = 4097,
UCHAR2 = 4098,
UCHAR3 = 4099,
UCHAR4 = 4100,
CHAR = 8193,
CHAR2 = 8194,
CHAR3 = 8195,
CHAR4 = 8196,
USHORT = 12289,
USHORT2 = 12290,
USHORT3 = 12291,
USHORT4 = 12292,
SHORT = 16385,
SHORT2 = 16386,
SHORT3 = 16387,
SHORT4 = 16388,
UINT = 20481,
UINT2 = 20482,
UINT3 = 20483,
UINT4 = 20484,
INT = 24577,
INT2 = 24578,
INT3 = 24579,
INT4 = 24580,
ULLONG = 28673,
ULLONG2 = 28674,
ULLONG3 = 28675,
ULLONG4 = 28676,
LLONG = 32769,
LLONG2 = 32770,
LLONG3 = 32771,
LLONG4 = 32772,
FLOAT = 36865,
FLOAT2 = 36866,
FLOAT3 = 36867,
FLOAT4 = 36868,
FLOAT5 = 36869,
FLOAT6 = 36870,
FLOAT7 = 36871,
FLOAT8 = 36872,
FLOAT9 = 36873,
FLOAT10 = 36874,
FLOAT11 = 36875,
FLOAT12 = 36876,
FLOAT13 = 36877,
FLOAT14 = 36878,
FLOAT15 = 36879,
FLOAT16 = 36880,
FLOAT2X2_ROW_MAJOR = 37154,
FLOAT2X3_ROW_MAJOR = 37155,
FLOAT2X4_ROW_MAJOR = 37156,
FLOAT3X2_ROW_MAJOR = 37170,
FLOAT3X3_ROW_MAJOR = 37171,
FLOAT3X4_ROW_MAJOR = 37172,
FLOAT4X2_ROW_MAJOR = 37186,
FLOAT4X3_ROW_MAJOR = 37187,
FLOAT4X4_ROW_MAJOR = 37188,
FLOAT2X2_COLUMN_MAJOR = 37410,
FLOAT2X3_COLUMN_MAJOR = 37411,
FLOAT2X4_COLUMN_MAJOR = 37412,
FLOAT3X2_COLUMN_MAJOR = 37426,
FLOAT3X3_COLUMN_MAJOR = 37427,
FLOAT3X4_COLUMN_MAJOR = 37428,
FLOAT4X2_COLUMN_MAJOR = 37442,
FLOAT4X3_COLUMN_MAJOR = 37443,
FLOAT4X4_COLUMN_MAJOR = 37444,
GRID = 40961,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCBuildQuality {
LOW = 0,
MEDIUM = 1,
HIGH = 2,
REFIT = 3,
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCBounds {
pub lower_x: f32,
pub lower_y: f32,
pub lower_z: f32,
pub align0: f32,
pub upper_x: f32,
pub upper_y: f32,
pub upper_z: f32,
pub align1: f32,
}
#[test]
fn bindgen_test_layout_RTCBounds() {
assert_eq!(
::std::mem::size_of::<RTCBounds>(),
32usize,
concat!("Size of: ", stringify!(RTCBounds))
);
assert_eq!(
::std::mem::align_of::<RTCBounds>(),
16usize,
concat!("Alignment of ", stringify!(RTCBounds))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(lower_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(lower_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).lower_z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(lower_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).align0 as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(align0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_x as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(upper_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_y as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(upper_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).upper_z as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(upper_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBounds>())).align1 as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCBounds),
"::",
stringify!(align1)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCLinearBounds {
pub bounds0: RTCBounds,
pub bounds1: RTCBounds,
}
#[test]
fn bindgen_test_layout_RTCLinearBounds() {
assert_eq!(
::std::mem::size_of::<RTCLinearBounds>(),
64usize,
concat!("Size of: ", stringify!(RTCLinearBounds))
);
assert_eq!(
::std::mem::align_of::<RTCLinearBounds>(),
16usize,
concat!("Alignment of ", stringify!(RTCLinearBounds))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCLinearBounds>())).bounds0 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCLinearBounds),
"::",
stringify!(bounds0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCLinearBounds>())).bounds1 as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCLinearBounds),
"::",
stringify!(bounds1)
)
);
}
impl RTCIntersectContextFlags {
pub const NONE: RTCIntersectContextFlags =
RTCIntersectContextFlags(0);
}
impl RTCIntersectContextFlags {
pub const INCOHERENT: RTCIntersectContextFlags =
RTCIntersectContextFlags(0);
}
impl RTCIntersectContextFlags {
pub const COHERENT: RTCIntersectContextFlags =
RTCIntersectContextFlags(1);
}
impl ::std::ops::BitOr<RTCIntersectContextFlags> for RTCIntersectContextFlags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
RTCIntersectContextFlags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for RTCIntersectContextFlags {
#[inline]
fn bitor_assign(&mut self, rhs: RTCIntersectContextFlags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<RTCIntersectContextFlags> for RTCIntersectContextFlags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
RTCIntersectContextFlags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for RTCIntersectContextFlags {
#[inline]
fn bitand_assign(&mut self, rhs: RTCIntersectContextFlags) {
self.0 &= rhs.0;
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct RTCIntersectContextFlags(pub u32);
#[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: *const RTCIntersectContext,
pub ray: *mut RTCRayN,
pub hit: *mut RTCHitN,
pub N: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCFilterFunctionNArguments() {
assert_eq!(
::std::mem::size_of::<RTCFilterFunctionNArguments>(),
48usize,
concat!("Size of: ", stringify!(RTCFilterFunctionNArguments))
);
assert_eq!(
::std::mem::align_of::<RTCFilterFunctionNArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCFilterFunctionNArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).valid as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).geometryUserPtr as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).context as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).ray as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).hit as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(hit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCFilterFunctionNArguments>())).N as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCFilterFunctionNArguments),
"::",
stringify!(N)
)
);
}
pub type RTCFilterFunctionN =
::std::option::Option<unsafe extern "C" fn(args: *const RTCFilterFunctionNArguments)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCIntersectContext {
pub flags: RTCIntersectContextFlags,
pub filter: RTCFilterFunctionN,
pub instID: [::std::os::raw::c_uint; 1usize],
}
#[test]
fn bindgen_test_layout_RTCIntersectContext() {
assert_eq!(
::std::mem::size_of::<RTCIntersectContext>(),
24usize,
concat!("Size of: ", stringify!(RTCIntersectContext))
);
assert_eq!(
::std::mem::align_of::<RTCIntersectContext>(),
8usize,
concat!("Alignment of ", stringify!(RTCIntersectContext))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCIntersectContext>())).flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectContext),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCIntersectContext>())).filter as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectContext),
"::",
stringify!(filter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCIntersectContext>())).instID as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectContext),
"::",
stringify!(instID)
)
);
}
extern "C" {
pub fn rtcInitIntersectContext(context: *mut RTCIntersectContext);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCDeviceTy {
_unused: [u8; 0],
}
pub type RTCDevice = *mut RTCDeviceTy;
extern "C" {
pub fn rtcNewDevice(config: *const ::std::os::raw::c_char) -> RTCDevice;
}
extern "C" {
pub fn rtcRetainDevice(device: RTCDevice);
}
extern "C" {
pub fn rtcReleaseDevice(device: RTCDevice);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCDeviceProperty {
VERSION = 0,
VERSION_MAJOR = 1,
VERSION_MINOR = 2,
VERSION_PATCH = 3,
NATIVE_RAY4_SUPPORTED = 32,
NATIVE_RAY8_SUPPORTED = 33,
NATIVE_RAY16_SUPPORTED = 34,
RAY_STREAM_SUPPORTED = 35,
RAY_MASK_SUPPORTED = 64,
BACKFACE_CULLING_ENABLED = 65,
FILTER_FUNCTION_SUPPORTED = 66,
IGNORE_INVALID_RAYS_ENABLED = 67,
TRIANGLE_GEOMETRY_SUPPORTED = 96,
QUAD_GEOMETRY_SUPPORTED = 97,
SUBDIVISION_GEOMETRY_SUPPORTED = 98,
CURVE_GEOMETRY_SUPPORTED = 99,
USER_GEOMETRY_SUPPORTED = 100,
TASKING_SYSTEM = 128,
JOIN_COMMIT_SUPPORTED = 129,
}
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, PartialEq, Eq, Hash)]
pub enum RTCError {
NONE = 0,
UNKNOWN = 1,
INVALID_ARGUMENT = 2,
INVALID_OPERATION = 3,
OUT_OF_MEMORY = 4,
UNSUPPORTED_CPU = 5,
CANCELLED = 6,
}
extern "C" {
pub fn rtcGetDeviceError(device: RTCDevice) -> RTCError;
}
pub type RTCErrorFunction = ::std::option::Option<
unsafe extern "C" fn(
userPtr: *mut ::std::os::raw::c_void,
code: RTCError,
str: *const ::std::os::raw::c_char,
),
>;
extern "C" {
pub fn rtcSetDeviceErrorFunction(
device: RTCDevice,
error: RTCErrorFunction,
userPtr: *mut ::std::os::raw::c_void,
);
}
pub type RTCMemoryMonitorFunction = ::std::option::Option<
unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void, bytes: 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, PartialEq, Eq, Hash)]
pub enum RTCBufferType {
INDEX = 0,
VERTEX = 1,
VERTEX_ATTRIBUTE = 2,
NORMAL = 3,
TANGENT = 4,
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() {
assert_eq!(
::std::mem::size_of::<RTCRay>(),
48usize,
concat!("Size of: ", stringify!(RTCRay))
);
assert_eq!(
::std::mem::align_of::<RTCRay>(),
16usize,
concat!("Alignment of ", stringify!(RTCRay))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).org_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).org_y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).org_z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).tnear as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_x as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_y as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).dir_z as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).time as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).tfar as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).mask as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).id as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay>())).flags as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(RTCRay),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCHit {
pub Ng_x: f32,
pub Ng_y: f32,
pub Ng_z: f32,
pub u: f32,
pub v: f32,
pub primID: ::std::os::raw::c_uint,
pub geomID: ::std::os::raw::c_uint,
pub instID: [::std::os::raw::c_uint; 1usize],
}
#[test]
fn bindgen_test_layout_RTCHit() {
assert_eq!(
::std::mem::size_of::<RTCHit>(),
32usize,
concat!("Size of: ", stringify!(RTCHit))
);
assert_eq!(
::std::mem::align_of::<RTCHit>(),
4usize,
concat!("Alignment of ", stringify!(RTCHit))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).Ng_z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).u as *const _ as usize },
12usize,
concat!("Offset of field: ", stringify!(RTCHit), "::", stringify!(u))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).v as *const _ as usize },
16usize,
concat!("Offset of field: ", stringify!(RTCHit), "::", stringify!(v))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).primID as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).geomID as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit>())).instID as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCHit),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayHit {
pub ray: RTCRay,
pub hit: RTCHit,
}
#[test]
fn bindgen_test_layout_RTCRayHit() {
assert_eq!(
::std::mem::size_of::<RTCRayHit>(),
80usize,
concat!("Size of: ", stringify!(RTCRayHit))
);
assert_eq!(
::std::mem::align_of::<RTCRayHit>(),
16usize,
concat!("Alignment of ", stringify!(RTCRayHit))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit>())).ray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit>())).hit as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit),
"::",
stringify!(hit)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRay4 {
pub org_x: [f32; 4usize],
pub org_y: [f32; 4usize],
pub org_z: [f32; 4usize],
pub tnear: [f32; 4usize],
pub dir_x: [f32; 4usize],
pub dir_y: [f32; 4usize],
pub dir_z: [f32; 4usize],
pub time: [f32; 4usize],
pub tfar: [f32; 4usize],
pub mask: [::std::os::raw::c_uint; 4usize],
pub id: [::std::os::raw::c_uint; 4usize],
pub flags: [::std::os::raw::c_uint; 4usize],
}
#[test]
fn bindgen_test_layout_RTCRay4() {
assert_eq!(
::std::mem::size_of::<RTCRay4>(),
192usize,
concat!("Size of: ", stringify!(RTCRay4))
);
assert_eq!(
::std::mem::align_of::<RTCRay4>(),
16usize,
concat!("Alignment of ", stringify!(RTCRay4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_y as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).org_z as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).tnear as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_x as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_y as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).dir_z as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).time as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).tfar as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).mask as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).id as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay4>())).flags as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(RTCRay4),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCHit4 {
pub Ng_x: [f32; 4usize],
pub Ng_y: [f32; 4usize],
pub Ng_z: [f32; 4usize],
pub u: [f32; 4usize],
pub v: [f32; 4usize],
pub primID: [::std::os::raw::c_uint; 4usize],
pub geomID: [::std::os::raw::c_uint; 4usize],
pub instID: [[::std::os::raw::c_uint; 4usize]; 1usize],
}
#[test]
fn bindgen_test_layout_RTCHit4() {
assert_eq!(
::std::mem::size_of::<RTCHit4>(),
128usize,
concat!("Size of: ", stringify!(RTCHit4))
);
assert_eq!(
::std::mem::align_of::<RTCHit4>(),
16usize,
concat!("Alignment of ", stringify!(RTCHit4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_y as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).Ng_z as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).u as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).v as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).primID as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).geomID as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit4>())).instID as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(RTCHit4),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayHit4 {
pub ray: RTCRay4,
pub hit: RTCHit4,
}
#[test]
fn bindgen_test_layout_RTCRayHit4() {
assert_eq!(
::std::mem::size_of::<RTCRayHit4>(),
320usize,
concat!("Size of: ", stringify!(RTCRayHit4))
);
assert_eq!(
::std::mem::align_of::<RTCRayHit4>(),
16usize,
concat!("Alignment of ", stringify!(RTCRayHit4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit4>())).ray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit4),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit4>())).hit as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit4),
"::",
stringify!(hit)
)
);
}
#[repr(C)]
#[repr(align(32))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRay8 {
pub org_x: [f32; 8usize],
pub org_y: [f32; 8usize],
pub org_z: [f32; 8usize],
pub tnear: [f32; 8usize],
pub dir_x: [f32; 8usize],
pub dir_y: [f32; 8usize],
pub dir_z: [f32; 8usize],
pub time: [f32; 8usize],
pub tfar: [f32; 8usize],
pub mask: [::std::os::raw::c_uint; 8usize],
pub id: [::std::os::raw::c_uint; 8usize],
pub flags: [::std::os::raw::c_uint; 8usize],
}
#[test]
fn bindgen_test_layout_RTCRay8() {
assert_eq!(
::std::mem::size_of::<RTCRay8>(),
384usize,
concat!("Size of: ", stringify!(RTCRay8))
);
assert_eq!(
::std::mem::align_of::<RTCRay8>(),
32usize,
concat!("Alignment of ", stringify!(RTCRay8))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_y as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).org_z as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).tnear as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_x as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_y as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).dir_z as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).time as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).tfar as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).mask as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).id as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay8>())).flags as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(RTCRay8),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[repr(align(32))]
#[derive(Debug, Copy, Clone)]
pub struct RTCHit8 {
pub Ng_x: [f32; 8usize],
pub Ng_y: [f32; 8usize],
pub Ng_z: [f32; 8usize],
pub u: [f32; 8usize],
pub v: [f32; 8usize],
pub primID: [::std::os::raw::c_uint; 8usize],
pub geomID: [::std::os::raw::c_uint; 8usize],
pub instID: [[::std::os::raw::c_uint; 8usize]; 1usize],
}
#[test]
fn bindgen_test_layout_RTCHit8() {
assert_eq!(
::std::mem::size_of::<RTCHit8>(),
256usize,
concat!("Size of: ", stringify!(RTCHit8))
);
assert_eq!(
::std::mem::align_of::<RTCHit8>(),
32usize,
concat!("Alignment of ", stringify!(RTCHit8))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_y as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).Ng_z as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).u as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).v as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).primID as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).geomID as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit8>())).instID as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(RTCHit8),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[repr(align(32))]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayHit8 {
pub ray: RTCRay8,
pub hit: RTCHit8,
}
#[test]
fn bindgen_test_layout_RTCRayHit8() {
assert_eq!(
::std::mem::size_of::<RTCRayHit8>(),
640usize,
concat!("Size of: ", stringify!(RTCRayHit8))
);
assert_eq!(
::std::mem::align_of::<RTCRayHit8>(),
32usize,
concat!("Alignment of ", stringify!(RTCRayHit8))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit8>())).ray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit8),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit8>())).hit as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit8),
"::",
stringify!(hit)
)
);
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct RTCRay16 {
pub org_x: [f32; 16usize],
pub org_y: [f32; 16usize],
pub org_z: [f32; 16usize],
pub tnear: [f32; 16usize],
pub dir_x: [f32; 16usize],
pub dir_y: [f32; 16usize],
pub dir_z: [f32; 16usize],
pub time: [f32; 16usize],
pub tfar: [f32; 16usize],
pub mask: [::std::os::raw::c_uint; 16usize],
pub id: [::std::os::raw::c_uint; 16usize],
pub flags: [::std::os::raw::c_uint; 16usize],
}
#[test]
fn bindgen_test_layout_RTCRay16() {
assert_eq!(
::std::mem::size_of::<RTCRay16>(),
768usize,
concat!("Size of: ", stringify!(RTCRay16))
);
assert_eq!(
::std::mem::align_of::<RTCRay16>(),
64usize,
concat!("Alignment of ", stringify!(RTCRay16))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_y as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).org_z as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).tnear as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_x as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_y as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).dir_z as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).time as *const _ as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).tfar as *const _ as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).mask as *const _ as usize },
576usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).id as *const _ as usize },
640usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRay16>())).flags as *const _ as usize },
704usize,
concat!(
"Offset of field: ",
stringify!(RTCRay16),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct RTCHit16 {
pub Ng_x: [f32; 16usize],
pub Ng_y: [f32; 16usize],
pub Ng_z: [f32; 16usize],
pub u: [f32; 16usize],
pub v: [f32; 16usize],
pub primID: [::std::os::raw::c_uint; 16usize],
pub geomID: [::std::os::raw::c_uint; 16usize],
pub instID: [[::std::os::raw::c_uint; 16usize]; 1usize],
}
#[test]
fn bindgen_test_layout_RTCHit16() {
assert_eq!(
::std::mem::size_of::<RTCHit16>(),
512usize,
concat!("Size of: ", stringify!(RTCHit16))
);
assert_eq!(
::std::mem::align_of::<RTCHit16>(),
64usize,
concat!("Alignment of ", stringify!(RTCHit16))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_y as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).Ng_z as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).u as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).v as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).primID as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).geomID as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHit16>())).instID as *const _ as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(RTCHit16),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[repr(align(64))]
#[derive(Copy, Clone)]
pub struct RTCRayHit16 {
pub ray: RTCRay16,
pub hit: RTCHit16,
}
#[test]
fn bindgen_test_layout_RTCRayHit16() {
assert_eq!(
::std::mem::size_of::<RTCRayHit16>(),
1280usize,
concat!("Size of: ", stringify!(RTCRayHit16))
);
assert_eq!(
::std::mem::align_of::<RTCRayHit16>(),
64usize,
concat!("Alignment of ", stringify!(RTCRayHit16))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit16>())).ray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit16),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHit16>())).hit as *const _ as usize },
768usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHit16),
"::",
stringify!(hit)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayNp {
pub org_x: *mut f32,
pub org_y: *mut f32,
pub org_z: *mut f32,
pub tnear: *mut f32,
pub dir_x: *mut f32,
pub dir_y: *mut f32,
pub dir_z: *mut f32,
pub time: *mut f32,
pub tfar: *mut f32,
pub mask: *mut ::std::os::raw::c_uint,
pub id: *mut ::std::os::raw::c_uint,
pub flags: *mut ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCRayNp() {
assert_eq!(
::std::mem::size_of::<RTCRayNp>(),
96usize,
concat!("Size of: ", stringify!(RTCRayNp))
);
assert_eq!(
::std::mem::align_of::<RTCRayNp>(),
8usize,
concat!("Alignment of ", stringify!(RTCRayNp))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(org_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_y as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(org_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).org_z as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(org_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).tnear as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(tnear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_x as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(dir_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_y as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(dir_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).dir_z as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(dir_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).time as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).tfar as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(tfar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).mask as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(mask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).id as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayNp>())).flags as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(RTCRayNp),
"::",
stringify!(flags)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCHitNp {
pub Ng_x: *mut f32,
pub Ng_y: *mut f32,
pub Ng_z: *mut f32,
pub u: *mut f32,
pub v: *mut f32,
pub primID: *mut ::std::os::raw::c_uint,
pub geomID: *mut ::std::os::raw::c_uint,
pub instID: [*mut ::std::os::raw::c_uint; 1usize],
}
#[test]
fn bindgen_test_layout_RTCHitNp() {
assert_eq!(
::std::mem::size_of::<RTCHitNp>(),
64usize,
concat!("Size of: ", stringify!(RTCHitNp))
);
assert_eq!(
::std::mem::align_of::<RTCHitNp>(),
8usize,
concat!("Alignment of ", stringify!(RTCHitNp))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_y as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).Ng_z as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).u as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).v as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).primID as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).geomID as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCHitNp>())).instID as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCHitNp),
"::",
stringify!(instID)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayHitNp {
pub ray: RTCRayNp,
pub hit: RTCHitNp,
}
#[test]
fn bindgen_test_layout_RTCRayHitNp() {
assert_eq!(
::std::mem::size_of::<RTCRayHitNp>(),
160usize,
concat!("Size of: ", stringify!(RTCRayHitNp))
);
assert_eq!(
::std::mem::align_of::<RTCRayHitNp>(),
8usize,
concat!("Alignment of ", stringify!(RTCRayHitNp))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHitNp>())).ray as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHitNp),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCRayHitNp>())).hit as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCRayHitNp),
"::",
stringify!(hit)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayN {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCHitN {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCRayHitN {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCSceneTy {
_unused: [u8; 0],
}
pub type RTCScene = *mut RTCSceneTy;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCGeometryTy {
_unused: [u8; 0],
}
pub type RTCGeometry = *mut RTCGeometryTy;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCGeometryType {
TRIANGLE = 0,
QUAD = 1,
GRID = 2,
SUBDIVISION = 8,
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,
USER = 120,
INSTANCE = 121,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum RTCSubdivisionMode {
NO_BOUNDARY = 0,
SMOOTH_BOUNDARY = 1,
PIN_CORNERS = 2,
PIN_BOUNDARY = 3,
PIN_ALL = 4,
}
impl RTCCurveFlags {
pub const NEIGHBOR_LEFT: RTCCurveFlags = RTCCurveFlags(1);
}
impl RTCCurveFlags {
pub const NEIGHBOR_RIGHT: RTCCurveFlags = RTCCurveFlags(2);
}
impl ::std::ops::BitOr<RTCCurveFlags> for RTCCurveFlags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
RTCCurveFlags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for RTCCurveFlags {
#[inline]
fn bitor_assign(&mut self, rhs: RTCCurveFlags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<RTCCurveFlags> for RTCCurveFlags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
RTCCurveFlags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for RTCCurveFlags {
#[inline]
fn bitand_assign(&mut self, rhs: RTCCurveFlags) {
self.0 &= rhs.0;
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct RTCCurveFlags(pub u32);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCBoundsFunctionArguments {
pub geometryUserPtr: *mut ::std::os::raw::c_void,
pub primID: ::std::os::raw::c_uint,
pub timeStep: ::std::os::raw::c_uint,
pub bounds_o: *mut RTCBounds,
}
#[test]
fn bindgen_test_layout_RTCBoundsFunctionArguments() {
assert_eq!(
::std::mem::size_of::<RTCBoundsFunctionArguments>(),
24usize,
concat!("Size of: ", stringify!(RTCBoundsFunctionArguments))
);
assert_eq!(
::std::mem::align_of::<RTCBoundsFunctionArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCBoundsFunctionArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).geometryUserPtr as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBoundsFunctionArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).primID as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBoundsFunctionArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).timeStep as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBoundsFunctionArguments),
"::",
stringify!(timeStep)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBoundsFunctionArguments>())).bounds_o as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCBoundsFunctionArguments),
"::",
stringify!(bounds_o)
)
);
}
pub type RTCBoundsFunction =
::std::option::Option<unsafe extern "C" fn(args: *const RTCBoundsFunctionArguments)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCIntersectFunctionNArguments {
pub valid: *mut ::std::os::raw::c_int,
pub geometryUserPtr: *mut ::std::os::raw::c_void,
pub primID: ::std::os::raw::c_uint,
pub context: *mut RTCIntersectContext,
pub rayhit: *mut RTCRayHitN,
pub N: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCIntersectFunctionNArguments() {
assert_eq!(
::std::mem::size_of::<RTCIntersectFunctionNArguments>(),
48usize,
concat!("Size of: ", stringify!(RTCIntersectFunctionNArguments))
);
assert_eq!(
::std::mem::align_of::<RTCIntersectFunctionNArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCIntersectFunctionNArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).valid as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).geometryUserPtr as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).primID as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).context as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).rayhit as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(rayhit)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCIntersectFunctionNArguments>())).N as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(RTCIntersectFunctionNArguments),
"::",
stringify!(N)
)
);
}
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,
}
#[test]
fn bindgen_test_layout_RTCOccludedFunctionNArguments() {
assert_eq!(
::std::mem::size_of::<RTCOccludedFunctionNArguments>(),
48usize,
concat!("Size of: ", stringify!(RTCOccludedFunctionNArguments))
);
assert_eq!(
::std::mem::align_of::<RTCOccludedFunctionNArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCOccludedFunctionNArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).valid as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).geometryUserPtr as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).primID as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).context as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(context)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).ray as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(ray)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCOccludedFunctionNArguments>())).N as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCOccludedFunctionNArguments),
"::",
stringify!(N)
)
);
}
pub type RTCOccludedFunctionN =
::std::option::Option<unsafe extern "C" fn(args: *const RTCOccludedFunctionNArguments)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCDisplacementFunctionNArguments {
pub geometryUserPtr: *mut ::std::os::raw::c_void,
pub geometry: RTCGeometry,
pub primID: ::std::os::raw::c_uint,
pub timeStep: ::std::os::raw::c_uint,
pub u: *const f32,
pub v: *const f32,
pub Ng_x: *const f32,
pub Ng_y: *const f32,
pub Ng_z: *const f32,
pub P_x: *mut f32,
pub P_y: *mut f32,
pub P_z: *mut f32,
pub N: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCDisplacementFunctionNArguments() {
assert_eq!(
::std::mem::size_of::<RTCDisplacementFunctionNArguments>(),
96usize,
concat!("Size of: ", stringify!(RTCDisplacementFunctionNArguments))
);
assert_eq!(
::std::mem::align_of::<RTCDisplacementFunctionNArguments>(),
8usize,
concat!(
"Alignment of ",
stringify!(RTCDisplacementFunctionNArguments)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).geometryUserPtr
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(geometryUserPtr)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).geometry as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(geometry)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).primID as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).timeStep as *const _
as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(timeStep)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).u as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).v as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_x as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(Ng_x)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_y as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(Ng_y)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).Ng_z as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(Ng_z)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_x as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(P_x)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_y as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(P_y)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).P_z as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(P_z)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCDisplacementFunctionNArguments>())).N as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(RTCDisplacementFunctionNArguments),
"::",
stringify!(N)
)
);
}
pub type RTCDisplacementFunctionN =
::std::option::Option<unsafe extern "C" fn(args: *const RTCDisplacementFunctionNArguments)>;
extern "C" {
pub fn rtcNewGeometry(device: RTCDevice, type_: RTCGeometryType) -> RTCGeometry;
}
extern "C" {
pub fn rtcRetainGeometry(geometry: RTCGeometry);
}
extern "C" {
pub fn rtcReleaseGeometry(geometry: RTCGeometry);
}
extern "C" {
pub fn rtcCommitGeometry(geometry: RTCGeometry);
}
extern "C" {
pub fn rtcEnableGeometry(geometry: RTCGeometry);
}
extern "C" {
pub fn rtcDisableGeometry(geometry: RTCGeometry);
}
extern "C" {
pub fn rtcSetGeometryTimeStepCount(
geometry: RTCGeometry,
timeStepCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn 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 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 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 rtcGetGeometryTransform(
geometry: RTCGeometry,
time: f32,
format: RTCFormat,
xfm: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn rtcSetGeometryTessellationRate(geometry: RTCGeometry, tessellationRate: f32);
}
extern "C" {
pub fn rtcSetGeometryTopologyCount(
geometry: RTCGeometry,
topologyCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcSetGeometrySubdivisionMode(
geometry: RTCGeometry,
topologyID: ::std::os::raw::c_uint,
mode: RTCSubdivisionMode,
);
}
extern "C" {
pub fn rtcSetGeometryVertexAttributeTopology(
geometry: RTCGeometry,
vertexAttributeID: ::std::os::raw::c_uint,
topologyID: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcSetGeometryDisplacementFunction(
geometry: RTCGeometry,
displacement: RTCDisplacementFunctionN,
);
}
extern "C" {
pub fn rtcGetGeometryFirstHalfEdge(
geometry: RTCGeometry,
faceID: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rtcGetGeometryFace(
geometry: RTCGeometry,
edgeID: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rtcGetGeometryNextHalfEdge(
geometry: RTCGeometry,
edgeID: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rtcGetGeometryPreviousHalfEdge(
geometry: RTCGeometry,
edgeID: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rtcGetGeometryOppositeHalfEdge(
geometry: RTCGeometry,
topologyID: ::std::os::raw::c_uint,
edgeID: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCInterpolateArguments {
pub geometry: RTCGeometry,
pub primID: ::std::os::raw::c_uint,
pub u: f32,
pub v: f32,
pub bufferType: RTCBufferType,
pub bufferSlot: ::std::os::raw::c_uint,
pub P: *mut f32,
pub dPdu: *mut f32,
pub dPdv: *mut f32,
pub ddPdudu: *mut f32,
pub ddPdvdv: *mut f32,
pub ddPdudv: *mut f32,
pub valueCount: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCInterpolateArguments() {
assert_eq!(
::std::mem::size_of::<RTCInterpolateArguments>(),
88usize,
concat!("Size of: ", stringify!(RTCInterpolateArguments))
);
assert_eq!(
::std::mem::align_of::<RTCInterpolateArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCInterpolateArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateArguments>())).geometry as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(geometry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).primID as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(primID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).u as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).v as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateArguments>())).bufferType as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(bufferType)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateArguments>())).bufferSlot as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(bufferSlot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).P as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(P)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).dPdu as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(dPdu)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).dPdv as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(dPdv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdudu as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(ddPdudu)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdvdv as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(ddPdvdv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateArguments>())).ddPdudv as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(ddPdudv)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateArguments>())).valueCount as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateArguments),
"::",
stringify!(valueCount)
)
);
}
extern "C" {
pub fn rtcInterpolate(args: *const RTCInterpolateArguments);
}
extern "C" {
pub fn rtcInterpolate0(
geometry: RTCGeometry,
primID: ::std::os::raw::c_uint,
u: f32,
v: f32,
bufferType: RTCBufferType,
bufferSlot: ::std::os::raw::c_uint,
P: *mut f32,
valueCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcInterpolate1(
geometry: RTCGeometry,
primID: ::std::os::raw::c_uint,
u: f32,
v: f32,
bufferType: RTCBufferType,
bufferSlot: ::std::os::raw::c_uint,
P: *mut f32,
dPdu: *mut f32,
dPdv: *mut f32,
valueCount: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcInterpolate2(
geometry: RTCGeometry,
primID: ::std::os::raw::c_uint,
u: f32,
v: f32,
bufferType: RTCBufferType,
bufferSlot: ::std::os::raw::c_uint,
P: *mut f32,
dPdu: *mut f32,
dPdv: *mut f32,
ddPdudu: *mut f32,
ddPdvdv: *mut f32,
ddPdudv: *mut f32,
valueCount: ::std::os::raw::c_uint,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCInterpolateNArguments {
pub geometry: RTCGeometry,
pub valid: *const ::std::os::raw::c_void,
pub primIDs: *const ::std::os::raw::c_uint,
pub u: *const f32,
pub v: *const f32,
pub N: ::std::os::raw::c_uint,
pub bufferType: RTCBufferType,
pub bufferSlot: ::std::os::raw::c_uint,
pub P: *mut f32,
pub dPdu: *mut f32,
pub dPdv: *mut f32,
pub ddPdudu: *mut f32,
pub ddPdvdv: *mut f32,
pub ddPdudv: *mut f32,
pub valueCount: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCInterpolateNArguments() {
assert_eq!(
::std::mem::size_of::<RTCInterpolateNArguments>(),
112usize,
concat!("Size of: ", stringify!(RTCInterpolateNArguments))
);
assert_eq!(
::std::mem::align_of::<RTCInterpolateNArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCInterpolateNArguments))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).geometry as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(geometry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).valid as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(valid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).primIDs as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(primIDs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).u as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).v as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).N as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(N)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).bufferType as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(bufferType)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).bufferSlot as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(bufferSlot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).P as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(P)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).dPdu as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(dPdu)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCInterpolateNArguments>())).dPdv as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(dPdv)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdudu as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(ddPdudu)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdvdv as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(ddPdvdv)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).ddPdudv as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(ddPdudv)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCInterpolateNArguments>())).valueCount as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(RTCInterpolateNArguments),
"::",
stringify!(valueCount)
)
);
}
extern "C" {
pub fn rtcInterpolateN(args: *const RTCInterpolateNArguments);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCGrid {
pub startVertexID: ::std::os::raw::c_uint,
pub stride: ::std::os::raw::c_uint,
pub width: ::std::os::raw::c_ushort,
pub height: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout_RTCGrid() {
assert_eq!(
::std::mem::size_of::<RTCGrid>(),
12usize,
concat!("Size of: ", stringify!(RTCGrid))
);
assert_eq!(
::std::mem::align_of::<RTCGrid>(),
4usize,
concat!("Alignment of ", stringify!(RTCGrid))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCGrid>())).startVertexID as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCGrid),
"::",
stringify!(startVertexID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCGrid>())).stride as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCGrid),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCGrid>())).width as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCGrid),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCGrid>())).height as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(RTCGrid),
"::",
stringify!(height)
)
);
}
impl RTCSceneFlags {
pub const NONE: RTCSceneFlags = RTCSceneFlags(0);
}
impl RTCSceneFlags {
pub const DYNAMIC: RTCSceneFlags = RTCSceneFlags(1);
}
impl RTCSceneFlags {
pub const COMPACT: RTCSceneFlags = RTCSceneFlags(2);
}
impl RTCSceneFlags {
pub const ROBUST: RTCSceneFlags = RTCSceneFlags(4);
}
impl RTCSceneFlags {
pub const CONTEXT_FILTER_FUNCTION: RTCSceneFlags = RTCSceneFlags(8);
}
impl ::std::ops::BitOr<RTCSceneFlags> for RTCSceneFlags {
type Output = Self;
#[inline]
fn bitor(self, other: Self) -> Self {
RTCSceneFlags(self.0 | other.0)
}
}
impl ::std::ops::BitOrAssign for RTCSceneFlags {
#[inline]
fn bitor_assign(&mut self, rhs: RTCSceneFlags) {
self.0 |= rhs.0;
}
}
impl ::std::ops::BitAnd<RTCSceneFlags> for RTCSceneFlags {
type Output = Self;
#[inline]
fn bitand(self, other: Self) -> Self {
RTCSceneFlags(self.0 & other.0)
}
}
impl ::std::ops::BitAndAssign for RTCSceneFlags {
#[inline]
fn bitand_assign(&mut self, rhs: RTCSceneFlags) {
self.0 &= rhs.0;
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct RTCSceneFlags(pub u32);
extern "C" {
pub fn rtcNewScene(device: RTCDevice) -> RTCScene;
}
extern "C" {
pub fn rtcRetainScene(scene: RTCScene);
}
extern "C" {
pub fn rtcReleaseScene(scene: RTCScene);
}
extern "C" {
pub fn rtcAttachGeometry(scene: RTCScene, geometry: RTCGeometry) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn rtcAttachGeometryByID(
scene: RTCScene,
geometry: RTCGeometry,
geomID: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn rtcDetachGeometry(scene: RTCScene, geomID: ::std::os::raw::c_uint);
}
extern "C" {
pub fn rtcGetGeometry(scene: RTCScene, geomID: ::std::os::raw::c_uint) -> RTCGeometry;
}
extern "C" {
pub fn rtcCommitScene(scene: RTCScene);
}
extern "C" {
pub fn rtcJoinCommitScene(scene: RTCScene);
}
pub type RTCProgressMonitorFunction =
::std::option::Option<unsafe extern "C" fn(ptr: *mut ::std::os::raw::c_void, n: f64) -> bool>;
extern "C" {
pub fn rtcSetSceneProgressMonitorFunction(
scene: RTCScene,
progress: RTCProgressMonitorFunction,
ptr: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn rtcSetSceneBuildQuality(scene: RTCScene, quality: RTCBuildQuality);
}
extern "C" {
pub fn rtcSetSceneFlags(scene: RTCScene, flags: RTCSceneFlags);
}
extern "C" {
pub fn rtcGetSceneFlags(scene: RTCScene) -> RTCSceneFlags;
}
extern "C" {
pub fn rtcGetSceneBounds(scene: RTCScene, bounds_o: *mut RTCBounds);
}
extern "C" {
pub fn rtcGetSceneLinearBounds(scene: RTCScene, bounds_o: *mut RTCLinearBounds);
}
extern "C" {
pub fn 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 RTCBVHTy {
_unused: [u8; 0],
}
pub type RTCBVH = *mut RTCBVHTy;
#[repr(C)]
#[repr(align(32))]
#[derive(Debug, Copy, Clone)]
pub struct RTCBuildPrimitive {
pub lower_x: f32,
pub lower_y: f32,
pub lower_z: f32,
pub geomID: ::std::os::raw::c_uint,
pub upper_x: f32,
pub upper_y: f32,
pub upper_z: f32,
pub primID: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_RTCBuildPrimitive() {
assert_eq!(
::std::mem::size_of::<RTCBuildPrimitive>(),
32usize,
concat!("Size of: ", stringify!(RTCBuildPrimitive))
);
assert_eq!(
::std::mem::align_of::<RTCBuildPrimitive>(),
32usize,
concat!("Alignment of ", stringify!(RTCBuildPrimitive))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(lower_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(lower_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).lower_z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(lower_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).geomID as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(geomID)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_x as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(upper_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_y as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(upper_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).upper_z as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(upper_z)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildPrimitive>())).primID as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildPrimitive),
"::",
stringify!(primID)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct RTCThreadLocalAllocatorTy {
_unused: [u8; 0],
}
pub type RTCThreadLocalAllocator = *mut RTCThreadLocalAllocatorTy;
pub type RTCCreateNodeFunction = ::std::option::Option<
unsafe extern "C" fn(
allocator: RTCThreadLocalAllocator,
childCount: ::std::os::raw::c_uint,
userPtr: *mut ::std::os::raw::c_void,
) -> *mut ::std::os::raw::c_void,
>;
pub type RTCSetNodeChildrenFunction = ::std::option::Option<
unsafe extern "C" fn(
nodePtr: *mut ::std::os::raw::c_void,
children: *mut *mut ::std::os::raw::c_void,
childCount: ::std::os::raw::c_uint,
userPtr: *mut ::std::os::raw::c_void,
),
>;
pub type RTCSetNodeBoundsFunction = ::std::option::Option<
unsafe extern "C" fn(
nodePtr: *mut ::std::os::raw::c_void,
bounds: *mut *const RTCBounds,
childCount: ::std::os::raw::c_uint,
userPtr: *mut ::std::os::raw::c_void,
),
>;
pub type RTCCreateLeafFunction = ::std::option::Option<
unsafe extern "C" fn(
allocator: RTCThreadLocalAllocator,
primitives: *const RTCBuildPrimitive,
primitiveCount: 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(C)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub struct RTCBuildFlags(pub u32);
#[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() {
assert_eq!(
::std::mem::size_of::<RTCBuildArguments>(),
136usize,
concat!("Size of: ", stringify!(RTCBuildArguments))
);
assert_eq!(
::std::mem::align_of::<RTCBuildArguments>(),
8usize,
concat!("Alignment of ", stringify!(RTCBuildArguments))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).byteSize as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(byteSize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildQuality as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(buildQuality)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildFlags as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(buildFlags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).maxBranchingFactor as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(maxBranchingFactor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).maxDepth as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(maxDepth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).sahBlockSize as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(sahBlockSize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).minLeafSize as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(minLeafSize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).maxLeafSize as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(maxLeafSize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).traversalCost as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(traversalCost)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).intersectionCost as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(intersectionCost)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).bvh as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(bvh)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).primitives as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(primitives)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).primitiveCount as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(primitiveCount)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).primitiveArrayCapacity as *const _
as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(primitiveArrayCapacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).createNode as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(createNode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).setNodeChildren as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(setNodeChildren)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).setNodeBounds as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(setNodeBounds)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).createLeaf as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(createLeaf)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<RTCBuildArguments>())).splitPrimitive as *const _ as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(splitPrimitive)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).buildProgress as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(buildProgress)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<RTCBuildArguments>())).userPtr as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(RTCBuildArguments),
"::",
stringify!(userPtr)
)
);
}
extern "C" {
pub fn rtcDefaultBuildArguments() -> RTCBuildArguments;
}
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);
}