pub type __uint32_t = ::std::os::raw::c_uint;
pub type ai_real = f32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiVector3D {
pub x: ai_real,
pub y: ai_real,
pub z: ai_real,
}
#[test]
fn bindgen_test_layout_aiVector3D() {
assert_eq!(
::std::mem::size_of::<aiVector3D>(),
12usize,
concat!("Size of: ", stringify!(aiVector3D))
);
assert_eq!(
::std::mem::align_of::<aiVector3D>(),
4usize,
concat!("Alignment of ", stringify!(aiVector3D))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiVector3D>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiVector3D),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiVector3D>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(aiVector3D),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiVector3D>())).z as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiVector3D),
"::",
stringify!(z)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiVector2D {
pub x: ai_real,
pub y: ai_real,
}
#[test]
fn bindgen_test_layout_aiVector2D() {
assert_eq!(
::std::mem::size_of::<aiVector2D>(),
8usize,
concat!("Size of: ", stringify!(aiVector2D))
);
assert_eq!(
::std::mem::align_of::<aiVector2D>(),
4usize,
concat!("Alignment of ", stringify!(aiVector2D))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiVector2D>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiVector2D),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiVector2D>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(aiVector2D),
"::",
stringify!(y)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiColor4D {
pub r: ai_real,
pub g: ai_real,
pub b: ai_real,
pub a: ai_real,
}
#[test]
fn bindgen_test_layout_aiColor4D() {
assert_eq!(
::std::mem::size_of::<aiColor4D>(),
16usize,
concat!("Size of: ", stringify!(aiColor4D))
);
assert_eq!(
::std::mem::align_of::<aiColor4D>(),
4usize,
concat!("Alignment of ", stringify!(aiColor4D))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiColor4D>())).r as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiColor4D),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiColor4D>())).g as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(aiColor4D),
"::",
stringify!(g)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiColor4D>())).b as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiColor4D),
"::",
stringify!(b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiColor4D>())).a as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(aiColor4D),
"::",
stringify!(a)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiMatrix4x4 {
pub a1: ai_real,
pub a2: ai_real,
pub a3: ai_real,
pub a4: ai_real,
pub b1: ai_real,
pub b2: ai_real,
pub b3: ai_real,
pub b4: ai_real,
pub c1: ai_real,
pub c2: ai_real,
pub c3: ai_real,
pub c4: ai_real,
pub d1: ai_real,
pub d2: ai_real,
pub d3: ai_real,
pub d4: ai_real,
}
#[test]
fn bindgen_test_layout_aiMatrix4x4() {
assert_eq!(
::std::mem::size_of::<aiMatrix4x4>(),
64usize,
concat!("Size of: ", stringify!(aiMatrix4x4))
);
assert_eq!(
::std::mem::align_of::<aiMatrix4x4>(),
4usize,
concat!("Alignment of ", stringify!(aiMatrix4x4))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).a1 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(a1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).a2 as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(a2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).a3 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(a3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).a4 as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(a4)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).b1 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(b1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).b2 as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(b2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).b3 as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(b3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).b4 as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(b4)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).c1 as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(c1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).c2 as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(c2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).c3 as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(c3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).c4 as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(c4)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).d1 as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(d1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).d2 as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(d2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).d3 as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(d3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMatrix4x4>())).d4 as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(aiMatrix4x4),
"::",
stringify!(d4)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiQuaternion {
pub w: ai_real,
pub x: ai_real,
pub y: ai_real,
pub z: ai_real,
}
#[test]
fn bindgen_test_layout_aiQuaternion() {
assert_eq!(
::std::mem::size_of::<aiQuaternion>(),
16usize,
concat!("Size of: ", stringify!(aiQuaternion))
);
assert_eq!(
::std::mem::align_of::<aiQuaternion>(),
4usize,
concat!("Alignment of ", stringify!(aiQuaternion))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiQuaternion>())).w as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiQuaternion),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiQuaternion>())).x as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(aiQuaternion),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiQuaternion>())).y as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiQuaternion),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiQuaternion>())).z as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(aiQuaternion),
"::",
stringify!(z)
)
);
}
pub type ai_uint32 = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiColor3D {
pub r: ai_real,
pub g: ai_real,
pub b: ai_real,
}
#[test]
fn bindgen_test_layout_aiColor3D() {
assert_eq!(
::std::mem::size_of::<aiColor3D>(),
12usize,
concat!("Size of: ", stringify!(aiColor3D))
);
assert_eq!(
::std::mem::align_of::<aiColor3D>(),
4usize,
concat!("Alignment of ", stringify!(aiColor3D))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiColor3D>())).r as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiColor3D),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiColor3D>())).g as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(aiColor3D),
"::",
stringify!(g)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiColor3D>())).b as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiColor3D),
"::",
stringify!(b)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiString {
pub length: ai_uint32,
pub data: [::std::os::raw::c_char; 1024usize],
}
#[test]
fn bindgen_test_layout_aiString() {
assert_eq!(
::std::mem::size_of::<aiString>(),
1028usize,
concat!("Size of: ", stringify!(aiString))
);
assert_eq!(
::std::mem::align_of::<aiString>(),
4usize,
concat!("Alignment of ", stringify!(aiString))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiString>())).length as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiString),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiString>())).data as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(aiString),
"::",
stringify!(data)
)
);
}
extern "C" {
pub fn aiImportFile(
pFile: *const ::std::os::raw::c_char,
pFlags: ::std::os::raw::c_uint,
) -> *const aiScene;
}
extern "C" {
pub fn aiReleaseImport(pScene: *const aiScene);
}
extern "C" {
pub fn aiGetErrorString() -> *const ::std::os::raw::c_char;
}
pub const aiPostProcessSteps_aiProcess_CalcTangentSpace: aiPostProcessSteps = 1;
pub const aiPostProcessSteps_aiProcess_JoinIdenticalVertices: aiPostProcessSteps = 2;
pub const aiPostProcessSteps_aiProcess_MakeLeftHanded: aiPostProcessSteps = 4;
pub const aiPostProcessSteps_aiProcess_Triangulate: aiPostProcessSteps = 8;
pub const aiPostProcessSteps_aiProcess_RemoveComponent: aiPostProcessSteps = 16;
pub const aiPostProcessSteps_aiProcess_GenNormals: aiPostProcessSteps = 32;
pub const aiPostProcessSteps_aiProcess_GenSmoothNormals: aiPostProcessSteps = 64;
pub const aiPostProcessSteps_aiProcess_SplitLargeMeshes: aiPostProcessSteps = 128;
pub const aiPostProcessSteps_aiProcess_PreTransformVertices: aiPostProcessSteps = 256;
pub const aiPostProcessSteps_aiProcess_LimitBoneWeights: aiPostProcessSteps = 512;
pub const aiPostProcessSteps_aiProcess_ValidateDataStructure: aiPostProcessSteps = 1024;
pub const aiPostProcessSteps_aiProcess_ImproveCacheLocality: aiPostProcessSteps = 2048;
pub const aiPostProcessSteps_aiProcess_RemoveRedundantMaterials: aiPostProcessSteps = 4096;
pub const aiPostProcessSteps_aiProcess_FixInfacingNormals: aiPostProcessSteps = 8192;
pub const aiPostProcessSteps_aiProcess_SortByPType: aiPostProcessSteps = 32768;
pub const aiPostProcessSteps_aiProcess_FindDegenerates: aiPostProcessSteps = 65536;
pub const aiPostProcessSteps_aiProcess_FindInvalidData: aiPostProcessSteps = 131072;
pub const aiPostProcessSteps_aiProcess_GenUVCoords: aiPostProcessSteps = 262144;
pub const aiPostProcessSteps_aiProcess_TransformUVCoords: aiPostProcessSteps = 524288;
pub const aiPostProcessSteps_aiProcess_FindInstances: aiPostProcessSteps = 1048576;
pub const aiPostProcessSteps_aiProcess_OptimizeMeshes: aiPostProcessSteps = 2097152;
pub const aiPostProcessSteps_aiProcess_OptimizeGraph: aiPostProcessSteps = 4194304;
pub const aiPostProcessSteps_aiProcess_FlipUVs: aiPostProcessSteps = 8388608;
pub const aiPostProcessSteps_aiProcess_FlipWindingOrder: aiPostProcessSteps = 16777216;
pub const aiPostProcessSteps_aiProcess_SplitByBoneCount: aiPostProcessSteps = 33554432;
pub const aiPostProcessSteps_aiProcess_Debone: aiPostProcessSteps = 67108864;
pub const aiPostProcessSteps_aiProcess_GlobalScale: aiPostProcessSteps = 134217728;
pub const aiPostProcessSteps_aiProcess_EmbedTextures: aiPostProcessSteps = 268435456;
pub const aiPostProcessSteps_aiProcess_ForceGenNormals: aiPostProcessSteps = 536870912;
pub const aiPostProcessSteps_aiProcess_DropNormals: aiPostProcessSteps = 1073741824;
pub const aiPostProcessSteps_aiProcess_GenBoundingBoxes: aiPostProcessSteps = 2147483648;
pub type aiPostProcessSteps = ::std::os::raw::c_uint;
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct aiTexel {
pub b: ::std::os::raw::c_uchar,
pub g: ::std::os::raw::c_uchar,
pub r: ::std::os::raw::c_uchar,
pub a: ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_aiTexel() {
assert_eq!(
::std::mem::size_of::<aiTexel>(),
4usize,
concat!("Size of: ", stringify!(aiTexel))
);
assert_eq!(
::std::mem::align_of::<aiTexel>(),
1usize,
concat!("Alignment of ", stringify!(aiTexel))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiTexel>())).b as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiTexel),
"::",
stringify!(b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiTexel>())).g as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(aiTexel),
"::",
stringify!(g)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiTexel>())).r as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(aiTexel),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiTexel>())).a as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(aiTexel),
"::",
stringify!(a)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiTexture {
pub mWidth: ::std::os::raw::c_uint,
pub mHeight: ::std::os::raw::c_uint,
pub achFormatHint: [::std::os::raw::c_char; 9usize],
pub pcData: *mut aiTexel,
pub mFilename: aiString,
}
#[test]
fn bindgen_test_layout_aiTexture() {
assert_eq!(
::std::mem::size_of::<aiTexture>(),
1064usize,
concat!("Size of: ", stringify!(aiTexture))
);
assert_eq!(
::std::mem::align_of::<aiTexture>(),
8usize,
concat!("Alignment of ", stringify!(aiTexture))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiTexture>())).mWidth as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiTexture),
"::",
stringify!(mWidth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiTexture>())).mHeight as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(aiTexture),
"::",
stringify!(mHeight)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiTexture>())).achFormatHint as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiTexture),
"::",
stringify!(achFormatHint)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiTexture>())).pcData as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(aiTexture),
"::",
stringify!(pcData)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiTexture>())).mFilename as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(aiTexture),
"::",
stringify!(mFilename)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiAABB {
pub mMin: aiVector3D,
pub mMax: aiVector3D,
}
#[test]
fn bindgen_test_layout_aiAABB() {
assert_eq!(
::std::mem::size_of::<aiAABB>(),
24usize,
concat!("Size of: ", stringify!(aiAABB))
);
assert_eq!(
::std::mem::align_of::<aiAABB>(),
4usize,
concat!("Alignment of ", stringify!(aiAABB))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAABB>())).mMin as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiAABB),
"::",
stringify!(mMin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAABB>())).mMax as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(aiAABB),
"::",
stringify!(mMax)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiFace {
pub mNumIndices: ::std::os::raw::c_uint,
pub mIndices: *mut ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_aiFace() {
assert_eq!(
::std::mem::size_of::<aiFace>(),
16usize,
concat!("Size of: ", stringify!(aiFace))
);
assert_eq!(
::std::mem::align_of::<aiFace>(),
8usize,
concat!("Alignment of ", stringify!(aiFace))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiFace>())).mNumIndices as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiFace),
"::",
stringify!(mNumIndices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiFace>())).mIndices as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiFace),
"::",
stringify!(mIndices)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiVertexWeight {
pub mVertexId: ::std::os::raw::c_uint,
pub mWeight: f32,
}
#[test]
fn bindgen_test_layout_aiVertexWeight() {
assert_eq!(
::std::mem::size_of::<aiVertexWeight>(),
8usize,
concat!("Size of: ", stringify!(aiVertexWeight))
);
assert_eq!(
::std::mem::align_of::<aiVertexWeight>(),
4usize,
concat!("Alignment of ", stringify!(aiVertexWeight))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiVertexWeight>())).mVertexId as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiVertexWeight),
"::",
stringify!(mVertexId)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiVertexWeight>())).mWeight as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(aiVertexWeight),
"::",
stringify!(mWeight)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiBone {
pub mName: aiString,
pub mNumWeights: ::std::os::raw::c_uint,
pub mWeights: *mut aiVertexWeight,
pub mOffsetMatrix: aiMatrix4x4,
}
#[test]
fn bindgen_test_layout_aiBone() {
assert_eq!(
::std::mem::size_of::<aiBone>(),
1104usize,
concat!("Size of: ", stringify!(aiBone))
);
assert_eq!(
::std::mem::align_of::<aiBone>(),
8usize,
concat!("Alignment of ", stringify!(aiBone))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiBone>())).mName as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiBone),
"::",
stringify!(mName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiBone>())).mNumWeights as *const _ as usize },
1028usize,
concat!(
"Offset of field: ",
stringify!(aiBone),
"::",
stringify!(mNumWeights)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiBone>())).mWeights as *const _ as usize },
1032usize,
concat!(
"Offset of field: ",
stringify!(aiBone),
"::",
stringify!(mWeights)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiBone>())).mOffsetMatrix as *const _ as usize },
1040usize,
concat!(
"Offset of field: ",
stringify!(aiBone),
"::",
stringify!(mOffsetMatrix)
)
);
}
pub const aiPrimitiveType_aiPrimitiveType_POINT: aiPrimitiveType = 1;
pub const aiPrimitiveType_aiPrimitiveType_LINE: aiPrimitiveType = 2;
pub const aiPrimitiveType_aiPrimitiveType_TRIANGLE: aiPrimitiveType = 4;
pub const aiPrimitiveType_aiPrimitiveType_POLYGON: aiPrimitiveType = 8;
pub const aiPrimitiveType__aiPrimitiveType_Force32Bit: aiPrimitiveType = 2147483647;
pub type aiPrimitiveType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiAnimMesh {
pub mName: aiString,
pub mVertices: *mut aiVector3D,
pub mNormals: *mut aiVector3D,
pub mTangents: *mut aiVector3D,
pub mBitangents: *mut aiVector3D,
pub mColors: [*mut aiColor4D; 8usize],
pub mTextureCoords: [*mut aiVector3D; 8usize],
pub mNumVertices: ::std::os::raw::c_uint,
pub mWeight: f32,
}
#[test]
fn bindgen_test_layout_aiAnimMesh() {
assert_eq!(
::std::mem::size_of::<aiAnimMesh>(),
1200usize,
concat!("Size of: ", stringify!(aiAnimMesh))
);
assert_eq!(
::std::mem::align_of::<aiAnimMesh>(),
8usize,
concat!("Alignment of ", stringify!(aiAnimMesh))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimMesh>())).mName as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiAnimMesh),
"::",
stringify!(mName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimMesh>())).mVertices as *const _ as usize },
1032usize,
concat!(
"Offset of field: ",
stringify!(aiAnimMesh),
"::",
stringify!(mVertices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimMesh>())).mNormals as *const _ as usize },
1040usize,
concat!(
"Offset of field: ",
stringify!(aiAnimMesh),
"::",
stringify!(mNormals)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimMesh>())).mTangents as *const _ as usize },
1048usize,
concat!(
"Offset of field: ",
stringify!(aiAnimMesh),
"::",
stringify!(mTangents)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimMesh>())).mBitangents as *const _ as usize },
1056usize,
concat!(
"Offset of field: ",
stringify!(aiAnimMesh),
"::",
stringify!(mBitangents)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimMesh>())).mColors as *const _ as usize },
1064usize,
concat!(
"Offset of field: ",
stringify!(aiAnimMesh),
"::",
stringify!(mColors)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimMesh>())).mTextureCoords as *const _ as usize },
1128usize,
concat!(
"Offset of field: ",
stringify!(aiAnimMesh),
"::",
stringify!(mTextureCoords)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimMesh>())).mNumVertices as *const _ as usize },
1192usize,
concat!(
"Offset of field: ",
stringify!(aiAnimMesh),
"::",
stringify!(mNumVertices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimMesh>())).mWeight as *const _ as usize },
1196usize,
concat!(
"Offset of field: ",
stringify!(aiAnimMesh),
"::",
stringify!(mWeight)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiMesh {
pub mPrimitiveTypes: ::std::os::raw::c_uint,
pub mNumVertices: ::std::os::raw::c_uint,
pub mNumFaces: ::std::os::raw::c_uint,
pub mVertices: *mut aiVector3D,
pub mNormals: *mut aiVector3D,
pub mTangents: *mut aiVector3D,
pub mBitangents: *mut aiVector3D,
pub mColors: [*mut aiColor4D; 8usize],
pub mTextureCoords: [*mut aiVector3D; 8usize],
pub mNumUVComponents: [::std::os::raw::c_uint; 8usize],
pub mFaces: *mut aiFace,
pub mNumBones: ::std::os::raw::c_uint,
pub mBones: *mut *mut aiBone,
pub mMaterialIndex: ::std::os::raw::c_uint,
pub mName: aiString,
pub mNumAnimMeshes: ::std::os::raw::c_uint,
pub mAnimMeshes: *mut *mut aiAnimMesh,
pub mMethod: ::std::os::raw::c_uint,
pub mAABB: aiAABB,
}
#[test]
fn bindgen_test_layout_aiMesh() {
assert_eq!(
::std::mem::size_of::<aiMesh>(),
1312usize,
concat!("Size of: ", stringify!(aiMesh))
);
assert_eq!(
::std::mem::align_of::<aiMesh>(),
8usize,
concat!("Alignment of ", stringify!(aiMesh))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mPrimitiveTypes as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mPrimitiveTypes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mNumVertices as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mNumVertices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mNumFaces as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mNumFaces)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mVertices as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mVertices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mNormals as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mNormals)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mTangents as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mTangents)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mBitangents as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mBitangents)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mColors as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mColors)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mTextureCoords as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mTextureCoords)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mNumUVComponents as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mNumUVComponents)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mFaces as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mFaces)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mNumBones as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mNumBones)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mBones as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mBones)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mMaterialIndex as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mMaterialIndex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mName as *const _ as usize },
236usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mNumAnimMeshes as *const _ as usize },
1264usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mNumAnimMeshes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mAnimMeshes as *const _ as usize },
1272usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mAnimMeshes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mMethod as *const _ as usize },
1280usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mMethod)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMesh>())).mAABB as *const _ as usize },
1284usize,
concat!(
"Offset of field: ",
stringify!(aiMesh),
"::",
stringify!(mAABB)
)
);
}
pub const aiLightSourceType_aiLightSource_UNDEFINED: aiLightSourceType = 0;
pub const aiLightSourceType_aiLightSource_DIRECTIONAL: aiLightSourceType = 1;
pub const aiLightSourceType_aiLightSource_POINT: aiLightSourceType = 2;
pub const aiLightSourceType_aiLightSource_SPOT: aiLightSourceType = 3;
pub const aiLightSourceType_aiLightSource_AMBIENT: aiLightSourceType = 4;
pub const aiLightSourceType_aiLightSource_AREA: aiLightSourceType = 5;
pub const aiLightSourceType__aiLightSource_Force32Bit: aiLightSourceType = 2147483647;
pub type aiLightSourceType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiLight {
pub mName: aiString,
pub mType: aiLightSourceType,
pub mPosition: aiVector3D,
pub mDirection: aiVector3D,
pub mUp: aiVector3D,
pub mAttenuationConstant: f32,
pub mAttenuationLinear: f32,
pub mAttenuationQuadratic: f32,
pub mColorDiffuse: aiColor3D,
pub mColorSpecular: aiColor3D,
pub mColorAmbient: aiColor3D,
pub mAngleInnerCone: f32,
pub mAngleOuterCone: f32,
pub mSize: aiVector2D,
}
#[test]
fn bindgen_test_layout_aiLight() {
assert_eq!(
::std::mem::size_of::<aiLight>(),
1132usize,
concat!("Size of: ", stringify!(aiLight))
);
assert_eq!(
::std::mem::align_of::<aiLight>(),
4usize,
concat!("Alignment of ", stringify!(aiLight))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mName as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mType as *const _ as usize },
1028usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mType)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mPosition as *const _ as usize },
1032usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mPosition)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mDirection as *const _ as usize },
1044usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mDirection)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mUp as *const _ as usize },
1056usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mUp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mAttenuationConstant as *const _ as usize },
1068usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mAttenuationConstant)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mAttenuationLinear as *const _ as usize },
1072usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mAttenuationLinear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mAttenuationQuadratic as *const _ as usize },
1076usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mAttenuationQuadratic)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mColorDiffuse as *const _ as usize },
1080usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mColorDiffuse)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mColorSpecular as *const _ as usize },
1092usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mColorSpecular)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mColorAmbient as *const _ as usize },
1104usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mColorAmbient)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mAngleInnerCone as *const _ as usize },
1116usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mAngleInnerCone)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mAngleOuterCone as *const _ as usize },
1120usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mAngleOuterCone)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiLight>())).mSize as *const _ as usize },
1124usize,
concat!(
"Offset of field: ",
stringify!(aiLight),
"::",
stringify!(mSize)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiCamera {
pub mName: aiString,
pub mPosition: aiVector3D,
pub mUp: aiVector3D,
pub mLookAt: aiVector3D,
pub mHorizontalFOV: f32,
pub mClipPlaneNear: f32,
pub mClipPlaneFar: f32,
pub mAspect: f32,
}
#[test]
fn bindgen_test_layout_aiCamera() {
assert_eq!(
::std::mem::size_of::<aiCamera>(),
1080usize,
concat!("Size of: ", stringify!(aiCamera))
);
assert_eq!(
::std::mem::align_of::<aiCamera>(),
4usize,
concat!("Alignment of ", stringify!(aiCamera))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiCamera>())).mName as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiCamera),
"::",
stringify!(mName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiCamera>())).mPosition as *const _ as usize },
1028usize,
concat!(
"Offset of field: ",
stringify!(aiCamera),
"::",
stringify!(mPosition)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiCamera>())).mUp as *const _ as usize },
1040usize,
concat!(
"Offset of field: ",
stringify!(aiCamera),
"::",
stringify!(mUp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiCamera>())).mLookAt as *const _ as usize },
1052usize,
concat!(
"Offset of field: ",
stringify!(aiCamera),
"::",
stringify!(mLookAt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiCamera>())).mHorizontalFOV as *const _ as usize },
1064usize,
concat!(
"Offset of field: ",
stringify!(aiCamera),
"::",
stringify!(mHorizontalFOV)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiCamera>())).mClipPlaneNear as *const _ as usize },
1068usize,
concat!(
"Offset of field: ",
stringify!(aiCamera),
"::",
stringify!(mClipPlaneNear)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiCamera>())).mClipPlaneFar as *const _ as usize },
1072usize,
concat!(
"Offset of field: ",
stringify!(aiCamera),
"::",
stringify!(mClipPlaneFar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiCamera>())).mAspect as *const _ as usize },
1076usize,
concat!(
"Offset of field: ",
stringify!(aiCamera),
"::",
stringify!(mAspect)
)
);
}
pub const aiTextureType_aiTextureType_NONE: aiTextureType = 0;
pub const aiTextureType_aiTextureType_DIFFUSE: aiTextureType = 1;
pub const aiTextureType_aiTextureType_SPECULAR: aiTextureType = 2;
pub const aiTextureType_aiTextureType_AMBIENT: aiTextureType = 3;
pub const aiTextureType_aiTextureType_EMISSIVE: aiTextureType = 4;
pub const aiTextureType_aiTextureType_HEIGHT: aiTextureType = 5;
pub const aiTextureType_aiTextureType_NORMALS: aiTextureType = 6;
pub const aiTextureType_aiTextureType_SHININESS: aiTextureType = 7;
pub const aiTextureType_aiTextureType_OPACITY: aiTextureType = 8;
pub const aiTextureType_aiTextureType_DISPLACEMENT: aiTextureType = 9;
pub const aiTextureType_aiTextureType_LIGHTMAP: aiTextureType = 10;
pub const aiTextureType_aiTextureType_REFLECTION: aiTextureType = 11;
pub const aiTextureType_aiTextureType_BASE_COLOR: aiTextureType = 12;
pub const aiTextureType_aiTextureType_NORMAL_CAMERA: aiTextureType = 13;
pub const aiTextureType_aiTextureType_EMISSION_COLOR: aiTextureType = 14;
pub const aiTextureType_aiTextureType_METALNESS: aiTextureType = 15;
pub const aiTextureType_aiTextureType_DIFFUSE_ROUGHNESS: aiTextureType = 16;
pub const aiTextureType_aiTextureType_AMBIENT_OCCLUSION: aiTextureType = 17;
pub const aiTextureType_aiTextureType_UNKNOWN: aiTextureType = 18;
pub const aiTextureType__aiTextureType_Force32Bit: aiTextureType = 2147483647;
pub type aiTextureType = ::std::os::raw::c_uint;
pub const aiPropertyTypeInfo_aiPTI_Float: aiPropertyTypeInfo = 1;
pub const aiPropertyTypeInfo_aiPTI_Double: aiPropertyTypeInfo = 2;
pub const aiPropertyTypeInfo_aiPTI_String: aiPropertyTypeInfo = 3;
pub const aiPropertyTypeInfo_aiPTI_Integer: aiPropertyTypeInfo = 4;
pub const aiPropertyTypeInfo_aiPTI_Buffer: aiPropertyTypeInfo = 5;
pub const aiPropertyTypeInfo__aiPTI_Force32Bit: aiPropertyTypeInfo = 2147483647;
pub type aiPropertyTypeInfo = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiMaterialProperty {
pub mKey: aiString,
pub mSemantic: ::std::os::raw::c_uint,
pub mIndex: ::std::os::raw::c_uint,
pub mDataLength: ::std::os::raw::c_uint,
pub mType: aiPropertyTypeInfo,
pub mData: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_aiMaterialProperty() {
assert_eq!(
::std::mem::size_of::<aiMaterialProperty>(),
1056usize,
concat!("Size of: ", stringify!(aiMaterialProperty))
);
assert_eq!(
::std::mem::align_of::<aiMaterialProperty>(),
8usize,
concat!("Alignment of ", stringify!(aiMaterialProperty))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMaterialProperty>())).mKey as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiMaterialProperty),
"::",
stringify!(mKey)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMaterialProperty>())).mSemantic as *const _ as usize },
1028usize,
concat!(
"Offset of field: ",
stringify!(aiMaterialProperty),
"::",
stringify!(mSemantic)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMaterialProperty>())).mIndex as *const _ as usize },
1032usize,
concat!(
"Offset of field: ",
stringify!(aiMaterialProperty),
"::",
stringify!(mIndex)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMaterialProperty>())).mDataLength as *const _ as usize },
1036usize,
concat!(
"Offset of field: ",
stringify!(aiMaterialProperty),
"::",
stringify!(mDataLength)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMaterialProperty>())).mType as *const _ as usize },
1040usize,
concat!(
"Offset of field: ",
stringify!(aiMaterialProperty),
"::",
stringify!(mType)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMaterialProperty>())).mData as *const _ as usize },
1048usize,
concat!(
"Offset of field: ",
stringify!(aiMaterialProperty),
"::",
stringify!(mData)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiMaterial {
pub mProperties: *mut *mut aiMaterialProperty,
pub mNumProperties: ::std::os::raw::c_uint,
pub mNumAllocated: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_aiMaterial() {
assert_eq!(
::std::mem::size_of::<aiMaterial>(),
16usize,
concat!("Size of: ", stringify!(aiMaterial))
);
assert_eq!(
::std::mem::align_of::<aiMaterial>(),
8usize,
concat!("Alignment of ", stringify!(aiMaterial))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMaterial>())).mProperties as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiMaterial),
"::",
stringify!(mProperties)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMaterial>())).mNumProperties as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiMaterial),
"::",
stringify!(mNumProperties)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMaterial>())).mNumAllocated as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(aiMaterial),
"::",
stringify!(mNumAllocated)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiVectorKey {
pub mTime: f64,
pub mValue: aiVector3D,
}
#[test]
fn bindgen_test_layout_aiVectorKey() {
assert_eq!(
::std::mem::size_of::<aiVectorKey>(),
24usize,
concat!("Size of: ", stringify!(aiVectorKey))
);
assert_eq!(
::std::mem::align_of::<aiVectorKey>(),
8usize,
concat!("Alignment of ", stringify!(aiVectorKey))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiVectorKey>())).mTime as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiVectorKey),
"::",
stringify!(mTime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiVectorKey>())).mValue as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiVectorKey),
"::",
stringify!(mValue)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiQuatKey {
pub mTime: f64,
pub mValue: aiQuaternion,
}
#[test]
fn bindgen_test_layout_aiQuatKey() {
assert_eq!(
::std::mem::size_of::<aiQuatKey>(),
24usize,
concat!("Size of: ", stringify!(aiQuatKey))
);
assert_eq!(
::std::mem::align_of::<aiQuatKey>(),
8usize,
concat!("Alignment of ", stringify!(aiQuatKey))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiQuatKey>())).mTime as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiQuatKey),
"::",
stringify!(mTime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiQuatKey>())).mValue as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiQuatKey),
"::",
stringify!(mValue)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiMeshKey {
pub mTime: f64,
pub mValue: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_aiMeshKey() {
assert_eq!(
::std::mem::size_of::<aiMeshKey>(),
16usize,
concat!("Size of: ", stringify!(aiMeshKey))
);
assert_eq!(
::std::mem::align_of::<aiMeshKey>(),
8usize,
concat!("Alignment of ", stringify!(aiMeshKey))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMeshKey>())).mTime as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiMeshKey),
"::",
stringify!(mTime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMeshKey>())).mValue as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiMeshKey),
"::",
stringify!(mValue)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiMeshMorphKey {
pub mTime: f64,
pub mValues: *mut ::std::os::raw::c_uint,
pub mWeights: *mut f64,
pub mNumValuesAndWeights: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_aiMeshMorphKey() {
assert_eq!(
::std::mem::size_of::<aiMeshMorphKey>(),
32usize,
concat!("Size of: ", stringify!(aiMeshMorphKey))
);
assert_eq!(
::std::mem::align_of::<aiMeshMorphKey>(),
8usize,
concat!("Alignment of ", stringify!(aiMeshMorphKey))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMeshMorphKey>())).mTime as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiMeshMorphKey),
"::",
stringify!(mTime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMeshMorphKey>())).mValues as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiMeshMorphKey),
"::",
stringify!(mValues)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMeshMorphKey>())).mWeights as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(aiMeshMorphKey),
"::",
stringify!(mWeights)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<aiMeshMorphKey>())).mNumValuesAndWeights as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(aiMeshMorphKey),
"::",
stringify!(mNumValuesAndWeights)
)
);
}
pub const aiAnimBehaviour_aiAnimBehaviour_DEFAULT: aiAnimBehaviour = 0;
pub const aiAnimBehaviour_aiAnimBehaviour_CONSTANT: aiAnimBehaviour = 1;
pub const aiAnimBehaviour_aiAnimBehaviour_LINEAR: aiAnimBehaviour = 2;
pub const aiAnimBehaviour_aiAnimBehaviour_REPEAT: aiAnimBehaviour = 3;
pub const aiAnimBehaviour__aiAnimBehaviour_Force32Bit: aiAnimBehaviour = 2147483647;
pub type aiAnimBehaviour = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiNodeAnim {
pub mNodeName: aiString,
pub mNumPositionKeys: ::std::os::raw::c_uint,
pub mPositionKeys: *mut aiVectorKey,
pub mNumRotationKeys: ::std::os::raw::c_uint,
pub mRotationKeys: *mut aiQuatKey,
pub mNumScalingKeys: ::std::os::raw::c_uint,
pub mScalingKeys: *mut aiVectorKey,
pub mPreState: aiAnimBehaviour,
pub mPostState: aiAnimBehaviour,
}
#[test]
fn bindgen_test_layout_aiNodeAnim() {
assert_eq!(
::std::mem::size_of::<aiNodeAnim>(),
1080usize,
concat!("Size of: ", stringify!(aiNodeAnim))
);
assert_eq!(
::std::mem::align_of::<aiNodeAnim>(),
8usize,
concat!("Alignment of ", stringify!(aiNodeAnim))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNodeAnim>())).mNodeName as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiNodeAnim),
"::",
stringify!(mNodeName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNodeAnim>())).mNumPositionKeys as *const _ as usize },
1028usize,
concat!(
"Offset of field: ",
stringify!(aiNodeAnim),
"::",
stringify!(mNumPositionKeys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNodeAnim>())).mPositionKeys as *const _ as usize },
1032usize,
concat!(
"Offset of field: ",
stringify!(aiNodeAnim),
"::",
stringify!(mPositionKeys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNodeAnim>())).mNumRotationKeys as *const _ as usize },
1040usize,
concat!(
"Offset of field: ",
stringify!(aiNodeAnim),
"::",
stringify!(mNumRotationKeys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNodeAnim>())).mRotationKeys as *const _ as usize },
1048usize,
concat!(
"Offset of field: ",
stringify!(aiNodeAnim),
"::",
stringify!(mRotationKeys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNodeAnim>())).mNumScalingKeys as *const _ as usize },
1056usize,
concat!(
"Offset of field: ",
stringify!(aiNodeAnim),
"::",
stringify!(mNumScalingKeys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNodeAnim>())).mScalingKeys as *const _ as usize },
1064usize,
concat!(
"Offset of field: ",
stringify!(aiNodeAnim),
"::",
stringify!(mScalingKeys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNodeAnim>())).mPreState as *const _ as usize },
1072usize,
concat!(
"Offset of field: ",
stringify!(aiNodeAnim),
"::",
stringify!(mPreState)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNodeAnim>())).mPostState as *const _ as usize },
1076usize,
concat!(
"Offset of field: ",
stringify!(aiNodeAnim),
"::",
stringify!(mPostState)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiMeshAnim {
pub mName: aiString,
pub mNumKeys: ::std::os::raw::c_uint,
pub mKeys: *mut aiMeshKey,
}
#[test]
fn bindgen_test_layout_aiMeshAnim() {
assert_eq!(
::std::mem::size_of::<aiMeshAnim>(),
1040usize,
concat!("Size of: ", stringify!(aiMeshAnim))
);
assert_eq!(
::std::mem::align_of::<aiMeshAnim>(),
8usize,
concat!("Alignment of ", stringify!(aiMeshAnim))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMeshAnim>())).mName as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiMeshAnim),
"::",
stringify!(mName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMeshAnim>())).mNumKeys as *const _ as usize },
1028usize,
concat!(
"Offset of field: ",
stringify!(aiMeshAnim),
"::",
stringify!(mNumKeys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMeshAnim>())).mKeys as *const _ as usize },
1032usize,
concat!(
"Offset of field: ",
stringify!(aiMeshAnim),
"::",
stringify!(mKeys)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiMeshMorphAnim {
pub mName: aiString,
pub mNumKeys: ::std::os::raw::c_uint,
pub mKeys: *mut aiMeshMorphKey,
}
#[test]
fn bindgen_test_layout_aiMeshMorphAnim() {
assert_eq!(
::std::mem::size_of::<aiMeshMorphAnim>(),
1040usize,
concat!("Size of: ", stringify!(aiMeshMorphAnim))
);
assert_eq!(
::std::mem::align_of::<aiMeshMorphAnim>(),
8usize,
concat!("Alignment of ", stringify!(aiMeshMorphAnim))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMeshMorphAnim>())).mName as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiMeshMorphAnim),
"::",
stringify!(mName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMeshMorphAnim>())).mNumKeys as *const _ as usize },
1028usize,
concat!(
"Offset of field: ",
stringify!(aiMeshMorphAnim),
"::",
stringify!(mNumKeys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMeshMorphAnim>())).mKeys as *const _ as usize },
1032usize,
concat!(
"Offset of field: ",
stringify!(aiMeshMorphAnim),
"::",
stringify!(mKeys)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiAnimation {
pub mName: aiString,
pub mDuration: f64,
pub mTicksPerSecond: f64,
pub mNumChannels: ::std::os::raw::c_uint,
pub mChannels: *mut *mut aiNodeAnim,
pub mNumMeshChannels: ::std::os::raw::c_uint,
pub mMeshChannels: *mut *mut aiMeshAnim,
pub mNumMorphMeshChannels: ::std::os::raw::c_uint,
pub mMorphMeshChannels: *mut *mut aiMeshMorphAnim,
}
#[test]
fn bindgen_test_layout_aiAnimation() {
assert_eq!(
::std::mem::size_of::<aiAnimation>(),
1096usize,
concat!("Size of: ", stringify!(aiAnimation))
);
assert_eq!(
::std::mem::align_of::<aiAnimation>(),
8usize,
concat!("Alignment of ", stringify!(aiAnimation))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimation>())).mName as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiAnimation),
"::",
stringify!(mName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimation>())).mDuration as *const _ as usize },
1032usize,
concat!(
"Offset of field: ",
stringify!(aiAnimation),
"::",
stringify!(mDuration)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimation>())).mTicksPerSecond as *const _ as usize },
1040usize,
concat!(
"Offset of field: ",
stringify!(aiAnimation),
"::",
stringify!(mTicksPerSecond)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimation>())).mNumChannels as *const _ as usize },
1048usize,
concat!(
"Offset of field: ",
stringify!(aiAnimation),
"::",
stringify!(mNumChannels)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimation>())).mChannels as *const _ as usize },
1056usize,
concat!(
"Offset of field: ",
stringify!(aiAnimation),
"::",
stringify!(mChannels)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimation>())).mNumMeshChannels as *const _ as usize },
1064usize,
concat!(
"Offset of field: ",
stringify!(aiAnimation),
"::",
stringify!(mNumMeshChannels)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimation>())).mMeshChannels as *const _ as usize },
1072usize,
concat!(
"Offset of field: ",
stringify!(aiAnimation),
"::",
stringify!(mMeshChannels)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<aiAnimation>())).mNumMorphMeshChannels as *const _ as usize
},
1080usize,
concat!(
"Offset of field: ",
stringify!(aiAnimation),
"::",
stringify!(mNumMorphMeshChannels)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiAnimation>())).mMorphMeshChannels as *const _ as usize },
1088usize,
concat!(
"Offset of field: ",
stringify!(aiAnimation),
"::",
stringify!(mMorphMeshChannels)
)
);
}
pub const aiMetadataType_AI_BOOL: aiMetadataType = 0;
pub const aiMetadataType_AI_INT32: aiMetadataType = 1;
pub const aiMetadataType_AI_UINT64: aiMetadataType = 2;
pub const aiMetadataType_AI_FLOAT: aiMetadataType = 3;
pub const aiMetadataType_AI_DOUBLE: aiMetadataType = 4;
pub const aiMetadataType_AI_AISTRING: aiMetadataType = 5;
pub const aiMetadataType_AI_AIVECTOR3D: aiMetadataType = 6;
pub const aiMetadataType_AI_META_MAX: aiMetadataType = 7;
pub const aiMetadataType_FORCE_32BIT: aiMetadataType = 2147483647;
pub type aiMetadataType = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiMetadataEntry {
pub mType: aiMetadataType,
pub mData: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_aiMetadataEntry() {
assert_eq!(
::std::mem::size_of::<aiMetadataEntry>(),
16usize,
concat!("Size of: ", stringify!(aiMetadataEntry))
);
assert_eq!(
::std::mem::align_of::<aiMetadataEntry>(),
8usize,
concat!("Alignment of ", stringify!(aiMetadataEntry))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMetadataEntry>())).mType as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiMetadataEntry),
"::",
stringify!(mType)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMetadataEntry>())).mData as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiMetadataEntry),
"::",
stringify!(mData)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiMetadata {
pub mNumProperties: ::std::os::raw::c_uint,
pub mKeys: *mut aiString,
pub mValues: *mut aiMetadataEntry,
}
#[test]
fn bindgen_test_layout_aiMetadata() {
assert_eq!(
::std::mem::size_of::<aiMetadata>(),
24usize,
concat!("Size of: ", stringify!(aiMetadata))
);
assert_eq!(
::std::mem::align_of::<aiMetadata>(),
8usize,
concat!("Alignment of ", stringify!(aiMetadata))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMetadata>())).mNumProperties as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiMetadata),
"::",
stringify!(mNumProperties)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMetadata>())).mKeys as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiMetadata),
"::",
stringify!(mKeys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiMetadata>())).mValues as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(aiMetadata),
"::",
stringify!(mValues)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct aiNode {
pub mName: aiString,
pub mTransformation: aiMatrix4x4,
pub mParent: *mut aiNode,
pub mNumChildren: ::std::os::raw::c_uint,
pub mChildren: *mut *mut aiNode,
pub mNumMeshes: ::std::os::raw::c_uint,
pub mMeshes: *mut ::std::os::raw::c_uint,
pub mMetaData: *mut aiMetadata,
}
#[test]
fn bindgen_test_layout_aiNode() {
assert_eq!(
::std::mem::size_of::<aiNode>(),
1144usize,
concat!("Size of: ", stringify!(aiNode))
);
assert_eq!(
::std::mem::align_of::<aiNode>(),
8usize,
concat!("Alignment of ", stringify!(aiNode))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNode>())).mName as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiNode),
"::",
stringify!(mName)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNode>())).mTransformation as *const _ as usize },
1028usize,
concat!(
"Offset of field: ",
stringify!(aiNode),
"::",
stringify!(mTransformation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNode>())).mParent as *const _ as usize },
1096usize,
concat!(
"Offset of field: ",
stringify!(aiNode),
"::",
stringify!(mParent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNode>())).mNumChildren as *const _ as usize },
1104usize,
concat!(
"Offset of field: ",
stringify!(aiNode),
"::",
stringify!(mNumChildren)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNode>())).mChildren as *const _ as usize },
1112usize,
concat!(
"Offset of field: ",
stringify!(aiNode),
"::",
stringify!(mChildren)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNode>())).mNumMeshes as *const _ as usize },
1120usize,
concat!(
"Offset of field: ",
stringify!(aiNode),
"::",
stringify!(mNumMeshes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNode>())).mMeshes as *const _ as usize },
1128usize,
concat!(
"Offset of field: ",
stringify!(aiNode),
"::",
stringify!(mMeshes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiNode>())).mMetaData as *const _ as usize },
1136usize,
concat!(
"Offset of field: ",
stringify!(aiNode),
"::",
stringify!(mMetaData)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct aiScene {
pub mFlags: ::std::os::raw::c_uint,
pub mRootNode: *mut aiNode,
pub mNumMeshes: ::std::os::raw::c_uint,
pub mMeshes: *mut *mut aiMesh,
pub mNumMaterials: ::std::os::raw::c_uint,
pub mMaterials: *mut *mut aiMaterial,
pub mNumAnimations: ::std::os::raw::c_uint,
pub mAnimations: *mut *mut aiAnimation,
pub mNumTextures: ::std::os::raw::c_uint,
pub mTextures: *mut *mut aiTexture,
pub mNumLights: ::std::os::raw::c_uint,
pub mLights: *mut *mut aiLight,
pub mNumCameras: ::std::os::raw::c_uint,
pub mCameras: *mut *mut aiCamera,
pub mMetaData: *mut aiMetadata,
pub mPrivate: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_aiScene() {
assert_eq!(
::std::mem::size_of::<aiScene>(),
128usize,
concat!("Size of: ", stringify!(aiScene))
);
assert_eq!(
::std::mem::align_of::<aiScene>(),
8usize,
concat!("Alignment of ", stringify!(aiScene))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mFlags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mFlags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mRootNode as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mRootNode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mNumMeshes as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mNumMeshes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mMeshes as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mMeshes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mNumMaterials as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mNumMaterials)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mMaterials as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mMaterials)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mNumAnimations as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mNumAnimations)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mAnimations as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mAnimations)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mNumTextures as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mNumTextures)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mTextures as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mTextures)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mNumLights as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mNumLights)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mLights as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mLights)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mNumCameras as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mNumCameras)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mCameras as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mCameras)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mMetaData as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mMetaData)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<aiScene>())).mPrivate as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(aiScene),
"::",
stringify!(mPrivate)
)
);
}