#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVec3 {
pub x: f32,
pub y: f32,
pub z: f32,
}
#[test] fn check_size_PxVec3() { assert_eq!(std::mem::size_of::<PxVec3>(), 12); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxQuat {
pub x: f32,
pub y: f32,
pub z: f32,
pub w: f32,
}
#[test] fn check_size_PxQuat() { assert_eq!(std::mem::size_of::<PxQuat>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxMat33 {
pub column0: PxVec3,
pub column1: PxVec3,
pub column2: PxVec3,
}
#[test] fn check_size_PxMat33() { assert_eq!(std::mem::size_of::<PxMat33>(), 36); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxPlane {
pub n: PxVec3,
pub d: f32,
}
#[test] fn check_size_PxPlane() { assert_eq!(std::mem::size_of::<PxPlane>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxTransform {
pub q: PxQuat,
pub p: PxVec3,
}
#[test] fn check_size_PxTransform() { assert_eq!(std::mem::size_of::<PxTransform>(), 28); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVec4 {
pub x: f32,
pub y: f32,
pub z: f32,
pub w: f32,
}
#[test] fn check_size_PxVec4() { assert_eq!(std::mem::size_of::<PxVec4>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxMat44 {
pub column0: PxVec4,
pub column1: PxVec4,
pub column2: PxVec4,
pub column3: PxVec4,
}
#[test] fn check_size_PxMat44() { assert_eq!(std::mem::size_of::<PxMat44>(), 64); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBounds3 {
pub minimum: PxVec3,
pub maximum: PxVec3,
}
#[test] fn check_size_PxBounds3() { assert_eq!(std::mem::size_of::<PxBounds3>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVec2 {
pub x: f32,
pub y: f32,
}
#[test] fn check_size_PxVec2() { assert_eq!(std::mem::size_of::<PxVec2>(), 8); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxStridedData {
pub stride: u32,
pub structgen_pad0: [u8; 4],
pub data: *const std::ffi::c_void,
}
#[test] fn check_size_PxStridedData() { assert_eq!(std::mem::size_of::<PxStridedData>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBoundedData {
pub stride: u32,
pub structgen_pad0: [u8; 4],
pub data: *const std::ffi::c_void,
pub count: u32,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxBoundedData() { assert_eq!(std::mem::size_of::<PxBoundedData>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxDebugPoint {
pub pos: PxVec3,
pub color: u32,
}
#[test] fn check_size_PxDebugPoint() { assert_eq!(std::mem::size_of::<PxDebugPoint>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxDebugLine {
pub pos0: PxVec3,
pub color0: u32,
pub pos1: PxVec3,
pub color1: u32,
}
#[test] fn check_size_PxDebugLine() { assert_eq!(std::mem::size_of::<PxDebugLine>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxDebugTriangle {
pub pos0: PxVec3,
pub color0: u32,
pub pos1: PxVec3,
pub color1: u32,
pub pos2: PxVec3,
pub color2: u32,
}
#[test] fn check_size_PxDebugTriangle() { assert_eq!(std::mem::size_of::<PxDebugTriangle>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxDebugText {
pub position: PxVec3,
pub size: f32,
pub color: u32,
pub structgen_pad0: [u8; 4],
pub string: *const i8,
}
#[test] fn check_size_PxDebugText() { assert_eq!(std::mem::size_of::<PxDebugText>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBase {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxBase() { assert_eq!(std::mem::size_of::<PxBase>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxDeserializationContext {
pub structgen_pad0: [u8; 8],
pub mExtraDataAddress: *mut u8,
}
#[test] fn check_size_PxDeserializationContext() { assert_eq!(std::mem::size_of::<PxDeserializationContext>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxTolerancesScale {
pub length: f32,
pub speed: f32,
}
#[test] fn check_size_PxTolerancesScale() { assert_eq!(std::mem::size_of::<PxTolerancesScale>(), 8); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxTask {
pub structgen_pad0: [u8; 8],
pub mContextID: usize,
pub mTm: *mut PxTaskManager,
pub mTaskID: u32,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxTask() { assert_eq!(std::mem::size_of::<PxTask>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBaseTask {
pub structgen_pad0: [u8; 8],
pub mContextID: usize,
pub mTm: *mut PxTaskManager,
}
#[test] fn check_size_PxBaseTask() { assert_eq!(std::mem::size_of::<PxBaseTask>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxLightCpuTask {
pub structgen_pad0: [u8; 8],
pub mContextID: usize,
pub mTm: *mut PxTaskManager,
pub mCont: *mut PxBaseTask,
pub mRefCount: i32,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxLightCpuTask() { assert_eq!(std::mem::size_of::<PxLightCpuTask>(), 40); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxGeometry {
pub mType: i32,
}
#[test] fn check_size_PxGeometry() { assert_eq!(std::mem::size_of::<PxGeometry>(), 4); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBoxGeometry {
pub mType: i32,
pub halfExtents: PxVec3,
}
#[test] fn check_size_PxBoxGeometry() { assert_eq!(std::mem::size_of::<PxBoxGeometry>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBVHStructure {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxBVHStructure() { assert_eq!(std::mem::size_of::<PxBVHStructure>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxCapsuleGeometry {
pub mType: i32,
pub radius: f32,
pub halfHeight: f32,
}
#[test] fn check_size_PxCapsuleGeometry() { assert_eq!(std::mem::size_of::<PxCapsuleGeometry>(), 12); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxConvexMesh {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxConvexMesh() { assert_eq!(std::mem::size_of::<PxConvexMesh>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxHullPolygon {
pub mPlane: [f32; 4],
pub mNbVerts: u16,
pub mIndexBase: u16,
}
#[test] fn check_size_PxHullPolygon() { assert_eq!(std::mem::size_of::<PxHullPolygon>(), 20); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxMeshScale {
pub scale: PxVec3,
pub rotation: PxQuat,
}
#[test] fn check_size_PxMeshScale() { assert_eq!(std::mem::size_of::<PxMeshScale>(), 28); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxConvexMeshGeometry {
pub mType: i32,
pub scale: PxMeshScale,
pub convexMesh: *mut PxConvexMesh,
pub meshFlags: PxConvexMeshGeometryFlags,
pub paddingFromFlags: PxPadding_3_,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxConvexMeshGeometry() { assert_eq!(std::mem::size_of::<PxConvexMeshGeometry>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSphereGeometry {
pub mType: i32,
pub radius: f32,
}
#[test] fn check_size_PxSphereGeometry() { assert_eq!(std::mem::size_of::<PxSphereGeometry>(), 8); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxPlaneGeometry {
pub mType: i32,
}
#[test] fn check_size_PxPlaneGeometry() { assert_eq!(std::mem::size_of::<PxPlaneGeometry>(), 4); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxTriangleMesh {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxTriangleMesh() { assert_eq!(std::mem::size_of::<PxTriangleMesh>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxTriangleMeshGeometry {
pub mType: i32,
pub scale: PxMeshScale,
pub meshFlags: PxMeshGeometryFlags,
pub paddingFromFlags: PxPadding_3_,
pub structgen_pad0: [u8; 4],
pub triangleMesh: *mut PxTriangleMesh,
}
#[test] fn check_size_PxTriangleMeshGeometry() { assert_eq!(std::mem::size_of::<PxTriangleMeshGeometry>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxHeightField {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxHeightField() { assert_eq!(std::mem::size_of::<PxHeightField>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxHeightFieldGeometry {
pub mType: i32,
pub structgen_pad0: [u8; 4],
pub heightField: *mut PxHeightField,
pub heightScale: f32,
pub rowScale: f32,
pub columnScale: f32,
pub heightFieldFlags: PxMeshGeometryFlags,
pub paddingFromFlags: PxPadding_3_,
}
#[test] fn check_size_PxHeightFieldGeometry() { assert_eq!(std::mem::size_of::<PxHeightFieldGeometry>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxGeometryHolder {
pub structgen_pad0: [u8; 48],
}
#[test] fn check_size_PxGeometryHolder() { assert_eq!(std::mem::size_of::<PxGeometryHolder>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxRigidActor {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxRigidActor() { assert_eq!(std::mem::size_of::<PxRigidActor>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxShape {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxShape() { assert_eq!(std::mem::size_of::<PxShape>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxActorShape {
pub actor: *mut PxRigidActor,
pub shape: *mut PxShape,
}
#[test] fn check_size_PxActorShape() { assert_eq!(std::mem::size_of::<PxActorShape>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxQueryHit {
pub actor: *mut PxRigidActor,
pub shape: *mut PxShape,
pub faceIndex: u32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxQueryHit() { assert_eq!(std::mem::size_of::<PxQueryHit>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxLocationHit {
pub actor: *mut PxRigidActor,
pub shape: *mut PxShape,
pub faceIndex: u32,
pub flags: PxHitFlags,
pub structgen_pad0: [u8; 2],
pub position: PxVec3,
pub normal: PxVec3,
pub distance: f32,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxLocationHit() { assert_eq!(std::mem::size_of::<PxLocationHit>(), 56); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxRaycastHit {
pub actor: *mut PxRigidActor,
pub shape: *mut PxShape,
pub faceIndex: u32,
pub flags: PxHitFlags,
pub structgen_pad0: [u8; 2],
pub position: PxVec3,
pub normal: PxVec3,
pub distance: f32,
pub u: f32,
pub v: f32,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxRaycastHit() { assert_eq!(std::mem::size_of::<PxRaycastHit>(), 64); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSweepHit {
pub actor: *mut PxRigidActor,
pub shape: *mut PxShape,
pub faceIndex: u32,
pub flags: PxHitFlags,
pub structgen_pad0: [u8; 2],
pub position: PxVec3,
pub normal: PxVec3,
pub distance: f32,
pub padTo16Bytes: u32,
}
#[test] fn check_size_PxSweepHit() { assert_eq!(std::mem::size_of::<PxSweepHit>(), 56); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxHeightFieldSample {
pub height: i16,
pub materialIndex0: PxBitAndByte,
pub materialIndex1: PxBitAndByte,
}
#[test] fn check_size_PxHeightFieldSample() { assert_eq!(std::mem::size_of::<PxHeightFieldSample>(), 4); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxHeightFieldDesc {
pub nbRows: u32,
pub nbColumns: u32,
pub format: u32,
pub structgen_pad0: [u8; 4],
pub samples: PxStridedData,
pub convexEdgeThreshold: f32,
pub flags: PxHeightFieldFlags,
pub structgen_pad1: [u8; 2],
}
#[test] fn check_size_PxHeightFieldDesc() { assert_eq!(std::mem::size_of::<PxHeightFieldDesc>(), 40); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxTriangle {
pub verts: [PxVec3; 3],
}
#[test] fn check_size_PxTriangle() { assert_eq!(std::mem::size_of::<PxTriangle>(), 36); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSimpleTriangleMesh {
pub points: PxBoundedData,
pub triangles: PxBoundedData,
pub flags: PxMeshFlags,
pub structgen_pad0: [u8; 6],
}
#[test] fn check_size_PxSimpleTriangleMesh() { assert_eq!(std::mem::size_of::<PxSimpleTriangleMesh>(), 56); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxActor {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxActor() { assert_eq!(std::mem::size_of::<PxActor>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxScene {
pub structgen_pad0: [u8; 8],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxScene() { assert_eq!(std::mem::size_of::<PxScene>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxAggregate {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxAggregate() { assert_eq!(std::mem::size_of::<PxAggregate>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxArticulationBase {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxArticulationBase() { assert_eq!(std::mem::size_of::<PxArticulationBase>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxArticulationLink {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxArticulationLink() { assert_eq!(std::mem::size_of::<PxArticulationLink>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxArticulationJointBase {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxArticulationJointBase() { assert_eq!(std::mem::size_of::<PxArticulationJointBase>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxArticulation {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxArticulation() { assert_eq!(std::mem::size_of::<PxArticulation>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxArticulationDriveCache {
pub structgen_pad0: [u8; 1],
}
#[test] fn check_size_PxArticulationDriveCache() { assert_eq!(std::mem::size_of::<PxArticulationDriveCache>(), 1); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxConstraintInvMassScale {
pub linear0: f32,
pub angular0: f32,
pub linear1: f32,
pub angular1: f32,
}
#[test] fn check_size_PxConstraintInvMassScale() { assert_eq!(std::mem::size_of::<PxConstraintInvMassScale>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxConstraint {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxConstraint() { assert_eq!(std::mem::size_of::<PxConstraint>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSolverBody {
pub linearVelocity: PxVec3,
pub maxSolverNormalProgress: u16,
pub maxSolverFrictionProgress: u16,
pub angularState: PxVec3,
pub solverProgress: u32,
}
#[test] fn check_size_PxSolverBody() { assert_eq!(std::mem::size_of::<PxSolverBody>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSolverBodyData {
pub linearVelocity: PxVec3,
pub invMass: f32,
pub angularVelocity: PxVec3,
pub reportThreshold: f32,
pub sqrtInvInertia: PxMat33,
pub penBiasClamp: f32,
pub nodeIndex: u32,
pub maxContactImpulse: f32,
pub body2World: PxTransform,
pub lockFlags: u16,
pub pad: u16,
}
#[test] fn check_size_PxSolverBodyData() { assert_eq!(std::mem::size_of::<PxSolverBodyData>(), 112); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxTGSSolverBodyVel {
pub linearVelocity: PxVec3,
pub nbStaticInteractions: u16,
pub maxDynamicPartition: u16,
pub angularVelocity: PxVec3,
pub partitionMask: u32,
pub deltaAngDt: PxVec3,
pub maxAngVel: f32,
pub deltaLinDt: PxVec3,
pub lockFlags: u16,
pub isKinematic: bool,
pub pad: u8,
}
#[test] fn check_size_PxTGSSolverBodyVel() { assert_eq!(std::mem::size_of::<PxTGSSolverBodyVel>(), 64); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxTGSSolverBodyData {
pub originalLinearVelocity: PxVec3,
pub maxContactImpulse: f32,
pub originalAngularVelocity: PxVec3,
pub penBiasClamp: f32,
pub invMass: f32,
pub nodeIndex: u32,
pub reportThreshold: f32,
pub pad: u32,
}
#[test] fn check_size_PxTGSSolverBodyData() { assert_eq!(std::mem::size_of::<PxTGSSolverBodyData>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSpatialForce {
pub force: PxVec3,
pub pad0: f32,
pub torque: PxVec3,
pub pad1: f32,
}
#[test] fn check_size_PxSpatialForce() { assert_eq!(std::mem::size_of::<PxSpatialForce>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxArticulationRootLinkData {
pub transform: PxTransform,
pub worldLinVel: PxVec3,
pub worldAngVel: PxVec3,
pub worldLinAccel: PxVec3,
pub worldAngAccel: PxVec3,
}
#[test] fn check_size_PxArticulationRootLinkData() { assert_eq!(std::mem::size_of::<PxArticulationRootLinkData>(), 76); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxArticulationCache {
pub externalForces: *mut PxSpatialForce,
pub denseJacobian: *mut f32,
pub massMatrix: *mut f32,
pub jointVelocity: *mut f32,
pub jointAcceleration: *mut f32,
pub jointPosition: *mut f32,
pub jointForce: *mut f32,
pub structgen_pad0: [u8; 16],
pub rootLinkData: *mut PxArticulationRootLinkData,
pub coefficientMatrix: *mut f32,
pub lambda: *mut f32,
pub scratchMemory: *mut std::ffi::c_void,
pub scratchAllocator: *mut std::ffi::c_void,
pub version: u32,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxArticulationCache() { assert_eq!(std::mem::size_of::<PxArticulationCache>(), 120); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxArticulationReducedCoordinate {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxArticulationReducedCoordinate() { assert_eq!(std::mem::size_of::<PxArticulationReducedCoordinate>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxJoint {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxJoint() { assert_eq!(std::mem::size_of::<PxJoint>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxArticulationJoint {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxArticulationJoint() { assert_eq!(std::mem::size_of::<PxArticulationJoint>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxArticulationJointReducedCoordinate {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxArticulationJointReducedCoordinate() { assert_eq!(std::mem::size_of::<PxArticulationJointReducedCoordinate>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxFilterData {
pub word0: u32,
pub word1: u32,
pub word2: u32,
pub word3: u32,
}
#[test] fn check_size_PxFilterData() { assert_eq!(std::mem::size_of::<PxFilterData>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxMaterial {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxMaterial() { assert_eq!(std::mem::size_of::<PxMaterial>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxRigidBody {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxRigidBody() { assert_eq!(std::mem::size_of::<PxRigidBody>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxQueryFilterData {
pub data: PxFilterData,
pub flags: PxQueryFlags,
pub structgen_pad0: [u8; 2],
}
#[test] fn check_size_PxQueryFilterData() { assert_eq!(std::mem::size_of::<PxQueryFilterData>(), 20); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxOverlapHit {
pub actor: *mut PxRigidActor,
pub shape: *mut PxShape,
pub faceIndex: u32,
pub padTo16Bytes: u32,
}
#[test] fn check_size_PxOverlapHit() { assert_eq!(std::mem::size_of::<PxOverlapHit>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBatchQueryMemory {
pub userRaycastResultBuffer: *mut PxRaycastQueryResult,
pub userRaycastTouchBuffer: *mut PxRaycastHit,
pub userSweepResultBuffer: *mut PxSweepQueryResult,
pub userSweepTouchBuffer: *mut PxSweepHit,
pub userOverlapResultBuffer: *mut PxOverlapQueryResult,
pub userOverlapTouchBuffer: *mut PxOverlapHit,
pub raycastTouchBufferSize: u32,
pub sweepTouchBufferSize: u32,
pub overlapTouchBufferSize: u32,
pub raycastResultBufferSize: u32,
pub sweepResultBufferSize: u32,
pub overlapResultBufferSize: u32,
}
#[test] fn check_size_PxBatchQueryMemory() { assert_eq!(std::mem::size_of::<PxBatchQueryMemory>(), 72); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBatchQueryDesc {
pub filterShaderData: *mut std::ffi::c_void,
pub filterShaderDataSize: u32,
pub structgen_pad0: [u8; 4],
pub preFilterShader: *mut std::ffi::c_void,
pub postFilterShader: *mut std::ffi::c_void,
pub queryMemory: PxBatchQueryMemory,
}
#[test] fn check_size_PxBatchQueryDesc() { assert_eq!(std::mem::size_of::<PxBatchQueryDesc>(), 104); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxQueryCache {
pub shape: *mut PxShape,
pub actor: *mut PxRigidActor,
pub faceIndex: u32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxQueryCache() { assert_eq!(std::mem::size_of::<PxQueryCache>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxConstraintShaderTable {
pub solverPrep: *mut std::ffi::c_void,
pub project: *mut std::ffi::c_void,
pub visualize: *mut std::ffi::c_void,
pub flag: u32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxConstraintShaderTable() { assert_eq!(std::mem::size_of::<PxConstraintShaderTable>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxMassModificationProps {
pub mInvMassScale0: f32,
pub mInvInertiaScale0: f32,
pub mInvMassScale1: f32,
pub mInvInertiaScale1: f32,
}
#[test] fn check_size_PxMassModificationProps() { assert_eq!(std::mem::size_of::<PxMassModificationProps>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactPatch {
pub mMassModification: PxMassModificationProps,
pub normal: PxVec3,
pub restitution: f32,
pub dynamicFriction: f32,
pub staticFriction: f32,
pub startContactIndex: u8,
pub nbContacts: u8,
pub materialFlags: u8,
pub internalFlags: u8,
pub materialIndex0: u16,
pub materialIndex1: u16,
}
#[test] fn check_size_PxContactPatch() { assert_eq!(std::mem::size_of::<PxContactPatch>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContact {
pub contact: PxVec3,
pub separation: f32,
}
#[test] fn check_size_PxContact() { assert_eq!(std::mem::size_of::<PxContact>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactStreamIterator {
pub zero: PxVec3,
pub structgen_pad0: [u8; 4],
pub patch: *const PxContactPatch,
pub contact: *const PxContact,
pub faceIndice: *const u32,
pub totalPatches: u32,
pub totalContacts: u32,
pub nextContactIndex: u32,
pub nextPatchIndex: u32,
pub contactPatchHeaderSize: u32,
pub contactPointSize: u32,
pub mStreamFormat: u32,
pub forceNoResponse: u32,
pub pointStepped: bool,
pub structgen_pad1: [u8; 3],
pub hasFaceIndices: u32,
}
#[test] fn check_size_PxContactStreamIterator() { assert_eq!(std::mem::size_of::<PxContactStreamIterator>(), 80); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxModifiableContact {
pub contact: PxVec3,
pub separation: f32,
pub targetVelocity: PxVec3,
pub maxImpulse: f32,
pub normal: PxVec3,
pub restitution: f32,
pub materialFlags: u32,
pub materialIndex0: u16,
pub materialIndex1: u16,
pub staticFriction: f32,
pub dynamicFriction: f32,
}
#[test] fn check_size_PxModifiableContact() { assert_eq!(std::mem::size_of::<PxModifiableContact>(), 64); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactSet {
pub mCount: u32,
pub structgen_pad0: [u8; 4],
pub mContacts: *mut PxModifiableContact,
}
#[test] fn check_size_PxContactSet() { assert_eq!(std::mem::size_of::<PxContactSet>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactModifyPair {
pub actor: [*const PxRigidActor; 2],
pub shape: [*const PxShape; 2],
pub transform: [PxTransform; 2],
pub contacts: PxContactSet,
}
#[test] fn check_size_PxContactModifyPair() { assert_eq!(std::mem::size_of::<PxContactModifyPair>(), 104); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSceneLimits {
pub maxNbActors: u32,
pub maxNbBodies: u32,
pub maxNbStaticShapes: u32,
pub maxNbDynamicShapes: u32,
pub maxNbAggregates: u32,
pub maxNbConstraints: u32,
pub maxNbRegions: u32,
pub maxNbBroadPhaseOverlaps: u32,
}
#[test] fn check_size_PxSceneLimits() { assert_eq!(std::mem::size_of::<PxSceneLimits>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxgDynamicsMemoryConfig {
pub constraintBufferCapacity: u32,
pub contactBufferCapacity: u32,
pub tempBufferCapacity: u32,
pub contactStreamSize: u32,
pub patchStreamSize: u32,
pub forceStreamCapacity: u32,
pub heapCapacity: u32,
pub foundLostPairsCapacity: u32,
}
#[test] fn check_size_PxgDynamicsMemoryConfig() { assert_eq!(std::mem::size_of::<PxgDynamicsMemoryConfig>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSceneDesc {
pub gravity: PxVec3,
pub structgen_pad0: [u8; 4],
pub simulationEventCallback: *mut PxSimulationEventCallback,
pub contactModifyCallback: *mut PxContactModifyCallback,
pub ccdContactModifyCallback: *mut PxCCDContactModifyCallback,
pub filterShaderData: *const std::ffi::c_void,
pub filterShaderDataSize: u32,
pub structgen_pad1: [u8; 4],
pub filterShader: *mut std::ffi::c_void,
pub filterCallback: *mut PxSimulationFilterCallback,
pub kineKineFilteringMode: u32,
pub staticKineFilteringMode: u32,
pub broadPhaseType: u32,
pub structgen_pad2: [u8; 4],
pub broadPhaseCallback: *mut PxBroadPhaseCallback,
pub limits: PxSceneLimits,
pub frictionType: u32,
pub solverType: u32,
pub bounceThresholdVelocity: f32,
pub frictionOffsetThreshold: f32,
pub ccdMaxSeparation: f32,
pub solverOffsetSlop: f32,
pub flags: PxSceneFlags,
pub structgen_pad3: [u8; 4],
pub cpuDispatcher: *mut PxCpuDispatcher,
pub cudaContextManager: *mut PxCudaContextManager,
pub staticStructure: u32,
pub dynamicStructure: u32,
pub dynamicTreeRebuildRateHint: u32,
pub sceneQueryUpdateMode: u32,
pub userData: *mut std::ffi::c_void,
pub solverBatchSize: u32,
pub solverArticulationBatchSize: u32,
pub nbContactDataBlocks: u32,
pub maxNbContactDataBlocks: u32,
pub maxBiasCoefficient: f32,
pub contactReportStreamBufferSize: u32,
pub ccdMaxPasses: u32,
pub ccdThreshold: f32,
pub wakeCounterResetValue: f32,
pub sanityBounds: PxBounds3,
pub gpuDynamicsConfig: PxgDynamicsMemoryConfig,
pub gpuMaxNumPartitions: u32,
pub gpuComputeVersion: u32,
pub structgen_pad4: [u8; 12],
}
#[test] fn check_size_PxSceneDesc() { assert_eq!(std::mem::size_of::<PxSceneDesc>(), 312); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxRigidStatic {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxRigidStatic() { assert_eq!(std::mem::size_of::<PxRigidStatic>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxRigidDynamic {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxRigidDynamic() { assert_eq!(std::mem::size_of::<PxRigidDynamic>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxPruningStructure {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxPruningStructure() { assert_eq!(std::mem::size_of::<PxPruningStructure>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSimulationStatistics {
pub nbActiveConstraints: u32,
pub nbActiveDynamicBodies: u32,
pub nbActiveKinematicBodies: u32,
pub nbStaticBodies: u32,
pub nbDynamicBodies: u32,
pub nbKinematicBodies: u32,
pub nbShapes: [u32; 7],
pub nbAggregates: u32,
pub nbArticulations: u32,
pub nbAxisSolverConstraints: u32,
pub compressedContactSize: u32,
pub requiredContactConstraintMemory: u32,
pub peakConstraintMemory: u32,
pub nbDiscreteContactPairsTotal: u32,
pub nbDiscreteContactPairsWithCacheHits: u32,
pub nbDiscreteContactPairsWithContacts: u32,
pub nbNewPairs: u32,
pub nbLostPairs: u32,
pub nbNewTouches: u32,
pub nbLostTouches: u32,
pub nbPartitions: u32,
pub nbBroadPhaseAdds: u32,
pub nbBroadPhaseRemoves: u32,
pub nbDiscreteContactPairs: [[u32; 7]; 7],
pub nbCCDPairs: [[u32; 7]; 7],
pub nbModifiedContactPairs: [[u32; 7]; 7],
pub nbTriggerPairs: [[u32; 7]; 7],
}
#[test] fn check_size_PxSimulationStatistics() { assert_eq!(std::mem::size_of::<PxSimulationStatistics>(), 900); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxDominanceGroupPair {
pub dominance0: u8,
pub dominance1: u8,
}
#[test] fn check_size_PxDominanceGroupPair() { assert_eq!(std::mem::size_of::<PxDominanceGroupPair>(), 2); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactPair {
pub shapes: [*mut PxShape; 2],
pub contactPatches: *const u8,
pub contactPoints: *const u8,
pub contactImpulses: *const f32,
pub requiredBufferSize: u32,
pub contactCount: u8,
pub patchCount: u8,
pub contactStreamSize: u16,
pub flags: PxContactPairFlags,
pub events: PxPairFlags,
pub internalData: [u32; 2],
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxContactPair() { assert_eq!(std::mem::size_of::<PxContactPair>(), 64); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactPairHeader {
pub actors: [*mut PxRigidActor; 2],
pub extraDataStream: *const u8,
pub extraDataStreamSize: u16,
pub flags: PxContactPairHeaderFlags,
pub structgen_pad0: [u8; 4],
pub pairs: *const PxContactPair,
pub nbPairs: u32,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxContactPairHeader() { assert_eq!(std::mem::size_of::<PxContactPairHeader>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBroadPhaseCaps {
pub maxNbRegions: u32,
pub maxNbObjects: u32,
pub needsPredefinedBounds: bool,
pub structgen_pad0: [u8; 3],
}
#[test] fn check_size_PxBroadPhaseCaps() { assert_eq!(std::mem::size_of::<PxBroadPhaseCaps>(), 12); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBroadPhaseRegion {
pub bounds: PxBounds3,
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxBroadPhaseRegion() { assert_eq!(std::mem::size_of::<PxBroadPhaseRegion>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBroadPhaseRegionInfo {
pub region: PxBroadPhaseRegion,
pub nbStaticObjects: u32,
pub nbDynamicObjects: u32,
pub active: bool,
pub overlap: bool,
pub structgen_pad0: [u8; 6],
}
#[test] fn check_size_PxBroadPhaseRegionInfo() { assert_eq!(std::mem::size_of::<PxBroadPhaseRegionInfo>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSceneReadLock {
pub structgen_pad0: [u8; 8],
}
#[test] fn check_size_PxSceneReadLock() { assert_eq!(std::mem::size_of::<PxSceneReadLock>(), 8); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSceneWriteLock {
pub structgen_pad0: [u8; 8],
}
#[test] fn check_size_PxSceneWriteLock() { assert_eq!(std::mem::size_of::<PxSceneWriteLock>(), 8); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactPairExtraDataItem {
pub _type: u8,
}
#[test] fn check_size_PxContactPairExtraDataItem() { assert_eq!(std::mem::size_of::<PxContactPairExtraDataItem>(), 1); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactPairVelocity {
pub _type: u8,
pub structgen_pad0: [u8; 3],
pub linearVelocity: [PxVec3; 2],
pub angularVelocity: [PxVec3; 2],
}
#[test] fn check_size_PxContactPairVelocity() { assert_eq!(std::mem::size_of::<PxContactPairVelocity>(), 52); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactPairPose {
pub _type: u8,
pub structgen_pad0: [u8; 3],
pub globalPose: [PxTransform; 2],
}
#[test] fn check_size_PxContactPairPose() { assert_eq!(std::mem::size_of::<PxContactPairPose>(), 60); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactPairIndex {
pub _type: u8,
pub structgen_pad0: [u8; 1],
pub index: u16,
}
#[test] fn check_size_PxContactPairIndex() { assert_eq!(std::mem::size_of::<PxContactPairIndex>(), 4); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactPairExtraDataIterator {
pub currPtr: *const u8,
pub endPtr: *const u8,
pub preSolverVelocity: *const PxContactPairVelocity,
pub postSolverVelocity: *const PxContactPairVelocity,
pub eventPose: *const PxContactPairPose,
pub contactPairIndex: u32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxContactPairExtraDataIterator() { assert_eq!(std::mem::size_of::<PxContactPairExtraDataIterator>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactPairPoint {
pub position: PxVec3,
pub separation: f32,
pub normal: PxVec3,
pub internalFaceIndex0: u32,
pub impulse: PxVec3,
pub internalFaceIndex1: u32,
}
#[test] fn check_size_PxContactPairPoint() { assert_eq!(std::mem::size_of::<PxContactPairPoint>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxTriggerPair {
pub triggerShape: *mut PxShape,
pub triggerActor: *mut PxRigidActor,
pub otherShape: *mut PxShape,
pub otherActor: *mut PxRigidActor,
pub status: u32,
pub flags: PxTriggerPairFlags,
pub structgen_pad0: [u8; 3],
}
#[test] fn check_size_PxTriggerPair() { assert_eq!(std::mem::size_of::<PxTriggerPair>(), 40); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxConstraintInfo {
pub constraint: *mut PxConstraint,
pub externalReference: *mut std::ffi::c_void,
pub _type: u32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxConstraintInfo() { assert_eq!(std::mem::size_of::<PxConstraintInfo>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxExtendedVec3 {
pub x: f64,
pub y: f64,
pub z: f64,
}
#[test] fn check_size_PxExtendedVec3() { assert_eq!(std::mem::size_of::<PxExtendedVec3>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxObstacle {
pub mType: i32,
pub structgen_pad0: [u8; 4],
pub mUserData: *mut std::ffi::c_void,
pub mPos: PxExtendedVec3,
pub mRot: PxQuat,
}
#[test] fn check_size_PxObstacle() { assert_eq!(std::mem::size_of::<PxObstacle>(), 56); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBoxObstacle {
pub mType: i32,
pub structgen_pad0: [u8; 4],
pub mUserData: *mut std::ffi::c_void,
pub mPos: PxExtendedVec3,
pub mRot: PxQuat,
pub mHalfExtents: PxVec3,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxBoxObstacle() { assert_eq!(std::mem::size_of::<PxBoxObstacle>(), 72); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxCapsuleObstacle {
pub mType: i32,
pub structgen_pad0: [u8; 4],
pub mUserData: *mut std::ffi::c_void,
pub mPos: PxExtendedVec3,
pub mRot: PxQuat,
pub mHalfHeight: f32,
pub mRadius: f32,
}
#[test] fn check_size_PxCapsuleObstacle() { assert_eq!(std::mem::size_of::<PxCapsuleObstacle>(), 64); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxControllerShapeHit {
pub controller: *mut PxController,
pub worldPos: PxExtendedVec3,
pub worldNormal: PxVec3,
pub dir: PxVec3,
pub length: f32,
pub structgen_pad0: [u8; 4],
pub shape: *mut PxShape,
pub actor: *mut PxRigidActor,
pub triangleIndex: u32,
pub structgen_pad1: [u8; 4],
}
#[test] fn check_size_PxControllerShapeHit() { assert_eq!(std::mem::size_of::<PxControllerShapeHit>(), 88); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxControllersHit {
pub controller: *mut PxController,
pub worldPos: PxExtendedVec3,
pub worldNormal: PxVec3,
pub dir: PxVec3,
pub length: f32,
pub structgen_pad0: [u8; 4],
pub other: *mut PxController,
}
#[test] fn check_size_PxControllersHit() { assert_eq!(std::mem::size_of::<PxControllersHit>(), 72); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxControllerObstacleHit {
pub controller: *mut PxController,
pub worldPos: PxExtendedVec3,
pub worldNormal: PxVec3,
pub dir: PxVec3,
pub length: f32,
pub structgen_pad0: [u8; 4],
pub userData: *const std::ffi::c_void,
}
#[test] fn check_size_PxControllerObstacleHit() { assert_eq!(std::mem::size_of::<PxControllerObstacleHit>(), 72); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxControllerFilters {
pub mFilterData: *const PxFilterData,
pub mFilterCallback: *mut PxQueryFilterCallback,
pub mFilterFlags: PxQueryFlags,
pub structgen_pad0: [u8; 6],
pub mCCTFilterCallback: *mut PxControllerFilterCallback,
}
#[test] fn check_size_PxControllerFilters() { assert_eq!(std::mem::size_of::<PxControllerFilters>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxControllerDesc {
pub structgen_pad0: [u8; 8],
pub position: PxExtendedVec3,
pub upDirection: PxVec3,
pub slopeLimit: f32,
pub invisibleWallHeight: f32,
pub maxJumpHeight: f32,
pub contactOffset: f32,
pub stepOffset: f32,
pub density: f32,
pub scaleCoeff: f32,
pub volumeGrowth: f32,
pub structgen_pad1: [u8; 4],
pub reportCallback: *mut PxUserControllerHitReport,
pub behaviorCallback: *mut PxControllerBehaviorCallback,
pub nonWalkableMode: u32,
pub structgen_pad2: [u8; 4],
pub material: *mut PxMaterial,
pub registerDeletionListener: bool,
pub structgen_pad3: [u8; 7],
pub userData: *mut std::ffi::c_void,
pub mType: u32,
pub structgen_pad4: [u8; 4],
}
#[test] fn check_size_PxControllerDesc() { assert_eq!(std::mem::size_of::<PxControllerDesc>(), 136); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxControllerState {
pub deltaXP: PxVec3,
pub structgen_pad0: [u8; 4],
pub touchedShape: *mut PxShape,
pub touchedActor: *mut PxRigidActor,
pub touchedObstacleHandle: u32,
pub collisionFlags: u32,
pub standOnAnotherCCT: bool,
pub standOnObstacle: bool,
pub isMovingUp: bool,
pub structgen_pad1: [u8; 5],
}
#[test] fn check_size_PxControllerState() { assert_eq!(std::mem::size_of::<PxControllerState>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxControllerStats {
pub nbIterations: u16,
pub nbFullUpdates: u16,
pub nbPartialUpdates: u16,
pub nbTessellation: u16,
}
#[test] fn check_size_PxControllerStats() { assert_eq!(std::mem::size_of::<PxControllerStats>(), 8); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBoxControllerDesc {
pub structgen_pad0: [u8; 8],
pub position: PxExtendedVec3,
pub upDirection: PxVec3,
pub slopeLimit: f32,
pub invisibleWallHeight: f32,
pub maxJumpHeight: f32,
pub contactOffset: f32,
pub stepOffset: f32,
pub density: f32,
pub scaleCoeff: f32,
pub volumeGrowth: f32,
pub structgen_pad1: [u8; 4],
pub reportCallback: *mut PxUserControllerHitReport,
pub behaviorCallback: *mut PxControllerBehaviorCallback,
pub nonWalkableMode: u32,
pub structgen_pad2: [u8; 4],
pub material: *mut PxMaterial,
pub registerDeletionListener: bool,
pub structgen_pad3: [u8; 7],
pub userData: *mut std::ffi::c_void,
pub mType: u32,
pub halfHeight: f32,
pub halfSideExtent: f32,
pub halfForwardExtent: f32,
}
#[test] fn check_size_PxBoxControllerDesc() { assert_eq!(std::mem::size_of::<PxBoxControllerDesc>(), 144); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxCapsuleControllerDesc {
pub structgen_pad0: [u8; 8],
pub position: PxExtendedVec3,
pub upDirection: PxVec3,
pub slopeLimit: f32,
pub invisibleWallHeight: f32,
pub maxJumpHeight: f32,
pub contactOffset: f32,
pub stepOffset: f32,
pub density: f32,
pub scaleCoeff: f32,
pub volumeGrowth: f32,
pub structgen_pad1: [u8; 4],
pub reportCallback: *mut PxUserControllerHitReport,
pub behaviorCallback: *mut PxControllerBehaviorCallback,
pub nonWalkableMode: u32,
pub structgen_pad2: [u8; 4],
pub material: *mut PxMaterial,
pub registerDeletionListener: bool,
pub structgen_pad3: [u8; 7],
pub userData: *mut std::ffi::c_void,
pub mType: u32,
pub radius: f32,
pub height: f32,
pub climbingMode: u32,
}
#[test] fn check_size_PxCapsuleControllerDesc() { assert_eq!(std::mem::size_of::<PxCapsuleControllerDesc>(), 144); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxConvexMeshDesc {
pub points: PxBoundedData,
pub polygons: PxBoundedData,
pub indices: PxBoundedData,
pub flags: PxConvexFlags,
pub vertexLimit: u16,
pub quantizedCount: u16,
pub structgen_pad0: [u8; 2],
}
#[test] fn check_size_PxConvexMeshDesc() { assert_eq!(std::mem::size_of::<PxConvexMeshDesc>(), 80); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxTriangleMeshDesc {
pub points: PxBoundedData,
pub triangles: PxBoundedData,
pub flags: PxMeshFlags,
pub structgen_pad0: [u8; 6],
pub materialIndices: PxTypedStridedData_physx_PxMaterialTableIndex_,
}
#[test] fn check_size_PxTriangleMeshDesc() { assert_eq!(std::mem::size_of::<PxTriangleMeshDesc>(), 72); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBVH33MidphaseDesc {
pub meshSizePerformanceTradeOff: f32,
pub meshCookingHint: u32,
}
#[test] fn check_size_PxBVH33MidphaseDesc() { assert_eq!(std::mem::size_of::<PxBVH33MidphaseDesc>(), 8); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBVH34MidphaseDesc {
pub numPrimsPerLeaf: u32,
}
#[test] fn check_size_PxBVH34MidphaseDesc() { assert_eq!(std::mem::size_of::<PxBVH34MidphaseDesc>(), 4); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxMidphaseDesc {
pub structgen_pad0: [u8; 8],
pub mType: u32,
}
#[test] fn check_size_PxMidphaseDesc() { assert_eq!(std::mem::size_of::<PxMidphaseDesc>(), 12); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxBVHStructureDesc {
pub bounds: PxBoundedData,
}
#[test] fn check_size_PxBVHStructureDesc() { assert_eq!(std::mem::size_of::<PxBVHStructureDesc>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxCookingParams {
pub areaTestEpsilon: f32,
pub planeTolerance: f32,
pub convexMeshCookingType: u32,
pub suppressTriangleMeshRemapTable: bool,
pub buildTriangleAdjacencies: bool,
pub buildGPUData: bool,
pub structgen_pad0: [u8; 1],
pub scale: PxTolerancesScale,
pub meshPreprocessParams: PxMeshPreprocessingFlags,
pub meshWeldTolerance: f32,
pub midphaseDesc: PxMidphaseDesc,
pub gaussMapLimit: u32,
}
#[test] fn check_size_PxCookingParams() { assert_eq!(std::mem::size_of::<PxCookingParams>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxDefaultMemoryOutputStream {
pub structgen_pad0: [u8; 32],
}
#[test] fn check_size_PxDefaultMemoryOutputStream() { assert_eq!(std::mem::size_of::<PxDefaultMemoryOutputStream>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxDefaultMemoryInputData {
pub structgen_pad0: [u8; 32],
}
#[test] fn check_size_PxDefaultMemoryInputData() { assert_eq!(std::mem::size_of::<PxDefaultMemoryInputData>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxDefaultFileOutputStream {
pub structgen_pad0: [u8; 16],
}
#[test] fn check_size_PxDefaultFileOutputStream() { assert_eq!(std::mem::size_of::<PxDefaultFileOutputStream>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxDefaultFileInputData {
pub structgen_pad0: [u8; 24],
}
#[test] fn check_size_PxDefaultFileInputData() { assert_eq!(std::mem::size_of::<PxDefaultFileInputData>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSpring {
pub stiffness: f32,
pub damping: f32,
}
#[test] fn check_size_PxSpring() { assert_eq!(std::mem::size_of::<PxSpring>(), 8); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxDistanceJoint {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxDistanceJoint() { assert_eq!(std::mem::size_of::<PxDistanceJoint>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxContactJoint {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxContactJoint() { assert_eq!(std::mem::size_of::<PxContactJoint>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxJacobianRow {
pub linear0: PxVec3,
pub linear1: PxVec3,
pub angular0: PxVec3,
pub angular1: PxVec3,
}
#[test] fn check_size_PxJacobianRow() { assert_eq!(std::mem::size_of::<PxJacobianRow>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxFixedJoint {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxFixedJoint() { assert_eq!(std::mem::size_of::<PxFixedJoint>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxJointLimitParameters {
pub restitution: f32,
pub bounceThreshold: f32,
pub stiffness: f32,
pub damping: f32,
pub contactDistance: f32,
}
#[test] fn check_size_PxJointLimitParameters() { assert_eq!(std::mem::size_of::<PxJointLimitParameters>(), 20); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxJointLinearLimit {
pub restitution: f32,
pub bounceThreshold: f32,
pub stiffness: f32,
pub damping: f32,
pub contactDistance: f32,
pub value: f32,
}
#[test] fn check_size_PxJointLinearLimit() { assert_eq!(std::mem::size_of::<PxJointLinearLimit>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxJointLinearLimitPair {
pub restitution: f32,
pub bounceThreshold: f32,
pub stiffness: f32,
pub damping: f32,
pub contactDistance: f32,
pub upper: f32,
pub lower: f32,
}
#[test] fn check_size_PxJointLinearLimitPair() { assert_eq!(std::mem::size_of::<PxJointLinearLimitPair>(), 28); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxJointAngularLimitPair {
pub restitution: f32,
pub bounceThreshold: f32,
pub stiffness: f32,
pub damping: f32,
pub contactDistance: f32,
pub upper: f32,
pub lower: f32,
}
#[test] fn check_size_PxJointAngularLimitPair() { assert_eq!(std::mem::size_of::<PxJointAngularLimitPair>(), 28); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxJointLimitCone {
pub restitution: f32,
pub bounceThreshold: f32,
pub stiffness: f32,
pub damping: f32,
pub contactDistance: f32,
pub yAngle: f32,
pub zAngle: f32,
}
#[test] fn check_size_PxJointLimitCone() { assert_eq!(std::mem::size_of::<PxJointLimitCone>(), 28); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxJointLimitPyramid {
pub restitution: f32,
pub bounceThreshold: f32,
pub stiffness: f32,
pub damping: f32,
pub contactDistance: f32,
pub yAngleMin: f32,
pub yAngleMax: f32,
pub zAngleMin: f32,
pub zAngleMax: f32,
}
#[test] fn check_size_PxJointLimitPyramid() { assert_eq!(std::mem::size_of::<PxJointLimitPyramid>(), 36); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxPrismaticJoint {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxPrismaticJoint() { assert_eq!(std::mem::size_of::<PxPrismaticJoint>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxRevoluteJoint {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxRevoluteJoint() { assert_eq!(std::mem::size_of::<PxRevoluteJoint>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSphericalJoint {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxSphericalJoint() { assert_eq!(std::mem::size_of::<PxSphericalJoint>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxD6Joint {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub userData: *mut std::ffi::c_void,
}
#[test] fn check_size_PxD6Joint() { assert_eq!(std::mem::size_of::<PxD6Joint>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxD6JointDrive {
pub stiffness: f32,
pub damping: f32,
pub forceLimit: f32,
pub flags: PxD6JointDriveFlags,
}
#[test] fn check_size_PxD6JointDrive() { assert_eq!(std::mem::size_of::<PxD6JointDrive>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxGroupsMask {
pub bits0: u16,
pub bits1: u16,
pub bits2: u16,
pub bits3: u16,
}
#[test] fn check_size_PxGroupsMask() { assert_eq!(std::mem::size_of::<PxGroupsMask>(), 8); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxMassProperties {
pub inertiaTensor: PxMat33,
pub centerOfMass: PxVec3,
pub mass: f32,
}
#[test] fn check_size_PxMassProperties() { assert_eq!(std::mem::size_of::<PxMassProperties>(), 52); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxMeshOverlapUtil {
pub structgen_pad0: [u8; 1040],
}
#[test] fn check_size_PxMeshOverlapUtil() { assert_eq!(std::mem::size_of::<PxMeshOverlapUtil>(), 1040); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSerialization_PxXmlMiscParameter {
pub upVector: PxVec3,
pub scale: PxTolerancesScale,
}
#[test] fn check_size_PxSerialization_PxXmlMiscParameter() { assert_eq!(std::mem::size_of::<PxSerialization_PxXmlMiscParameter>(), 20); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSceneQueryHit {
pub actor: *mut PxRigidActor,
pub shape: *mut PxShape,
pub faceIndex: u32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxSceneQueryHit() { assert_eq!(std::mem::size_of::<PxSceneQueryHit>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSceneQueryFilterData {
pub data: PxFilterData,
pub flags: PxQueryFlags,
pub structgen_pad0: [u8; 2],
}
#[test] fn check_size_PxSceneQueryFilterData() { assert_eq!(std::mem::size_of::<PxSceneQueryFilterData>(), 20); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxSceneQueryCache {
pub shape: *mut PxShape,
pub actor: *mut PxRigidActor,
pub faceIndex: u32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxSceneQueryCache() { assert_eq!(std::mem::size_of::<PxSceneQueryCache>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxRepXObject {
pub typeName: *const i8,
pub serializable: *const std::ffi::c_void,
pub id: usize,
}
#[test] fn check_size_PxRepXObject() { assert_eq!(std::mem::size_of::<PxRepXObject>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxRepXInstantiationArgs {
pub structgen_pad0: [u8; 8],
pub cooker: *mut PxCooking,
pub stringTable: *mut PxStringTable,
}
#[test] fn check_size_PxRepXInstantiationArgs() { assert_eq!(std::mem::size_of::<PxRepXInstantiationArgs>(), 24); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleChassisData {
pub mMOI: PxVec3,
pub mMass: f32,
pub mCMOffset: PxVec3,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxVehicleChassisData() { assert_eq!(std::mem::size_of::<PxVehicleChassisData>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleEngineData {
pub mTorqueCurve: PxFixedSizeLookupTable_eMAX_NB_ENGINE_TORQUE_CURVE_ENTRIES_,
pub mMOI: f32,
pub mPeakTorque: f32,
pub mMaxOmega: f32,
pub mDampingRateFullThrottle: f32,
pub mDampingRateZeroThrottleClutchEngaged: f32,
pub mDampingRateZeroThrottleClutchDisengaged: f32,
pub structgen_pad0: [u8; 8],
}
#[test] fn check_size_PxVehicleEngineData() { assert_eq!(std::mem::size_of::<PxVehicleEngineData>(), 112); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleGearsData {
pub mRatios: [f32; 32],
pub mFinalRatio: f32,
pub mNbRatios: u32,
pub mSwitchTime: f32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxVehicleGearsData() { assert_eq!(std::mem::size_of::<PxVehicleGearsData>(), 144); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleAutoBoxData {
pub mUpRatios: [f32; 32],
pub mDownRatios: [f32; 32],
}
#[test] fn check_size_PxVehicleAutoBoxData() { assert_eq!(std::mem::size_of::<PxVehicleAutoBoxData>(), 256); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDifferential4WData {
pub mFrontRearSplit: f32,
pub mFrontLeftRightSplit: f32,
pub mRearLeftRightSplit: f32,
pub mCentreBias: f32,
pub mFrontBias: f32,
pub mRearBias: f32,
pub mType: u32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxVehicleDifferential4WData() { assert_eq!(std::mem::size_of::<PxVehicleDifferential4WData>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDifferentialNWData {
pub structgen_pad0: [u8; 16],
}
#[test] fn check_size_PxVehicleDifferentialNWData() { assert_eq!(std::mem::size_of::<PxVehicleDifferentialNWData>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleAckermannGeometryData {
pub mAccuracy: f32,
pub mFrontWidth: f32,
pub mRearWidth: f32,
pub mAxleSeparation: f32,
}
#[test] fn check_size_PxVehicleAckermannGeometryData() { assert_eq!(std::mem::size_of::<PxVehicleAckermannGeometryData>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleClutchData {
pub mStrength: f32,
pub mAccuracyMode: u32,
pub mEstimateIterations: u32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxVehicleClutchData() { assert_eq!(std::mem::size_of::<PxVehicleClutchData>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleTireLoadFilterData {
pub mMinNormalisedLoad: f32,
pub mMinFilteredNormalisedLoad: f32,
pub mMaxNormalisedLoad: f32,
pub mMaxFilteredNormalisedLoad: f32,
pub structgen_pad0: [u8; 16],
}
#[test] fn check_size_PxVehicleTireLoadFilterData() { assert_eq!(std::mem::size_of::<PxVehicleTireLoadFilterData>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleWheelData {
pub mRadius: f32,
pub mWidth: f32,
pub mMass: f32,
pub mMOI: f32,
pub mDampingRate: f32,
pub mMaxBrakeTorque: f32,
pub mMaxHandBrakeTorque: f32,
pub mMaxSteer: f32,
pub mToeAngle: f32,
pub structgen_pad0: [u8; 12],
}
#[test] fn check_size_PxVehicleWheelData() { assert_eq!(std::mem::size_of::<PxVehicleWheelData>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleSuspensionData {
pub mSpringStrength: f32,
pub mSpringDamperRate: f32,
pub mMaxCompression: f32,
pub mMaxDroop: f32,
pub mSprungMass: f32,
pub mCamberAtRest: f32,
pub mCamberAtMaxCompression: f32,
pub mCamberAtMaxDroop: f32,
pub structgen_pad0: [u8; 16],
}
#[test] fn check_size_PxVehicleSuspensionData() { assert_eq!(std::mem::size_of::<PxVehicleSuspensionData>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleAntiRollBarData {
pub mWheel0: u32,
pub mWheel1: u32,
pub mStiffness: f32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxVehicleAntiRollBarData() { assert_eq!(std::mem::size_of::<PxVehicleAntiRollBarData>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleTireData {
pub mLatStiffX: f32,
pub mLatStiffY: f32,
pub mLongitudinalStiffnessPerUnitGravity: f32,
pub mCamberStiffnessPerUnitGravity: f32,
pub mFrictionVsSlipGraph: [[f32; 2]; 3],
pub mType: u32,
pub structgen_pad0: [u8; 20],
}
#[test] fn check_size_PxVehicleTireData() { assert_eq!(std::mem::size_of::<PxVehicleTireData>(), 64); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleWheelsSimData {
pub structgen_pad0: [u8; 96],
}
#[test] fn check_size_PxVehicleWheelsSimData() { assert_eq!(std::mem::size_of::<PxVehicleWheelsSimData>(), 96); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleWheelsDynData {
pub structgen_pad0: [u8; 48],
}
#[test] fn check_size_PxVehicleWheelsDynData() { assert_eq!(std::mem::size_of::<PxVehicleWheelsDynData>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleWheels {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub mWheelsSimData: PxVehicleWheelsSimData,
pub mWheelsDynData: PxVehicleWheelsDynData,
pub mActor: *mut PxRigidDynamic,
pub structgen_pad2: [u8; 5],
pub mType: u8,
pub mPad0: [u8; 14],
pub structgen_pad3: [u8; 4],
}
#[test] fn check_size_PxVehicleWheels() { assert_eq!(std::mem::size_of::<PxVehicleWheels>(), 192); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDriveSimData {
pub mEngine: PxVehicleEngineData,
pub mGears: PxVehicleGearsData,
pub mClutch: PxVehicleClutchData,
pub mAutoBox: PxVehicleAutoBoxData,
}
#[test] fn check_size_PxVehicleDriveSimData() { assert_eq!(std::mem::size_of::<PxVehicleDriveSimData>(), 528); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDriveDynData {
pub mControlAnalogVals: [f32; 16],
pub mUseAutoGears: bool,
pub mGearUpPressed: bool,
pub mGearDownPressed: bool,
pub structgen_pad0: [u8; 1],
pub mCurrentGear: u32,
pub mTargetGear: u32,
pub mEnginespeed: f32,
pub mGearSwitchTime: f32,
pub mAutoBoxSwitchTime: f32,
pub structgen_pad1: [u8; 8],
}
#[test] fn check_size_PxVehicleDriveDynData() { assert_eq!(std::mem::size_of::<PxVehicleDriveDynData>(), 96); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDrive {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub mWheelsSimData: PxVehicleWheelsSimData,
pub mWheelsDynData: PxVehicleWheelsDynData,
pub mActor: *mut PxRigidDynamic,
pub structgen_pad2: [u8; 5],
pub mType: u8,
pub mPad0: [u8; 14],
pub mDriveDynData: PxVehicleDriveDynData,
pub structgen_pad3: [u8; 4],
}
#[test] fn check_size_PxVehicleDrive() { assert_eq!(std::mem::size_of::<PxVehicleDrive>(), 288); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDriveSimData4W {
pub mEngine: PxVehicleEngineData,
pub mGears: PxVehicleGearsData,
pub mClutch: PxVehicleClutchData,
pub mAutoBox: PxVehicleAutoBoxData,
pub structgen_pad0: [u8; 48],
}
#[test] fn check_size_PxVehicleDriveSimData4W() { assert_eq!(std::mem::size_of::<PxVehicleDriveSimData4W>(), 576); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDrive4W {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub mWheelsSimData: PxVehicleWheelsSimData,
pub mWheelsDynData: PxVehicleWheelsDynData,
pub mActor: *mut PxRigidDynamic,
pub structgen_pad2: [u8; 5],
pub mType: u8,
pub mPad0: [u8; 14],
pub mDriveDynData: PxVehicleDriveDynData,
pub mDriveSimData: PxVehicleDriveSimData4W,
pub structgen_pad3: [u8; 4],
}
#[test] fn check_size_PxVehicleDrive4W() { assert_eq!(std::mem::size_of::<PxVehicleDrive4W>(), 864); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDriveTank {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub mWheelsSimData: PxVehicleWheelsSimData,
pub mWheelsDynData: PxVehicleWheelsDynData,
pub mActor: *mut PxRigidDynamic,
pub structgen_pad2: [u8; 5],
pub mType: u8,
pub mPad0: [u8; 14],
pub mDriveDynData: PxVehicleDriveDynData,
pub mDriveSimData: PxVehicleDriveSimData,
pub structgen_pad3: [u8; 20],
}
#[test] fn check_size_PxVehicleDriveTank() { assert_eq!(std::mem::size_of::<PxVehicleDriveTank>(), 832); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDrivableSurfaceType {
pub mType: u32,
}
#[test] fn check_size_PxVehicleDrivableSurfaceType() { assert_eq!(std::mem::size_of::<PxVehicleDrivableSurfaceType>(), 4); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDrivableSurfaceToTireFrictionPairs {
pub structgen_pad0: [u8; 48],
}
#[test] fn check_size_PxVehicleDrivableSurfaceToTireFrictionPairs() { assert_eq!(std::mem::size_of::<PxVehicleDrivableSurfaceToTireFrictionPairs>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxWheelQueryResult {
pub suspLineStart: PxVec3,
pub suspLineDir: PxVec3,
pub suspLineLength: f32,
pub isInAir: bool,
pub structgen_pad0: [u8; 3],
pub tireContactActor: *mut PxActor,
pub tireContactShape: *mut PxShape,
pub tireSurfaceMaterial: *const PxMaterial,
pub tireSurfaceType: u32,
pub tireContactPoint: PxVec3,
pub tireContactNormal: PxVec3,
pub tireFriction: f32,
pub suspJounce: f32,
pub suspSpringForce: f32,
pub tireLongitudinalDir: PxVec3,
pub tireLateralDir: PxVec3,
pub longitudinalSlip: f32,
pub lateralSlip: f32,
pub steerAngle: f32,
pub localPose: PxTransform,
}
#[test] fn check_size_PxWheelQueryResult() { assert_eq!(std::mem::size_of::<PxWheelQueryResult>(), 160); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleWheelConcurrentUpdateData {
pub structgen_pad0: [u8; 64],
}
#[test] fn check_size_PxVehicleWheelConcurrentUpdateData() { assert_eq!(std::mem::size_of::<PxVehicleWheelConcurrentUpdateData>(), 64); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleConcurrentUpdateData {
pub concurrentWheelUpdates: *mut PxVehicleWheelConcurrentUpdateData,
pub nbConcurrentWheelUpdates: u32,
pub structgen_pad0: [u8; 28],
}
#[test] fn check_size_PxVehicleConcurrentUpdateData() { assert_eq!(std::mem::size_of::<PxVehicleConcurrentUpdateData>(), 40); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleWheelQueryResult {
pub wheelQueryResults: *mut PxWheelQueryResult,
pub nbWheelQueryResults: u32,
pub structgen_pad0: [u8; 4],
}
#[test] fn check_size_PxVehicleWheelQueryResult() { assert_eq!(std::mem::size_of::<PxVehicleWheelQueryResult>(), 16); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleGraph {
pub structgen_pad0: [u8; 15840],
}
#[test] fn check_size_PxVehicleGraph() { assert_eq!(std::mem::size_of::<PxVehicleGraph>(), 15840); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleTelemetryData {
pub structgen_pad0: [u8; 48],
}
#[test] fn check_size_PxVehicleTelemetryData() { assert_eq!(std::mem::size_of::<PxVehicleTelemetryData>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDriveSimDataNW {
pub mEngine: PxVehicleEngineData,
pub mGears: PxVehicleGearsData,
pub mClutch: PxVehicleClutchData,
pub mAutoBox: PxVehicleAutoBoxData,
pub structgen_pad0: [u8; 16],
}
#[test] fn check_size_PxVehicleDriveSimDataNW() { assert_eq!(std::mem::size_of::<PxVehicleDriveSimDataNW>(), 544); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDriveNW {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub mWheelsSimData: PxVehicleWheelsSimData,
pub mWheelsDynData: PxVehicleWheelsDynData,
pub mActor: *mut PxRigidDynamic,
pub structgen_pad2: [u8; 5],
pub mType: u8,
pub mPad0: [u8; 14],
pub mDriveDynData: PxVehicleDriveDynData,
pub mDriveSimData: PxVehicleDriveSimDataNW,
pub structgen_pad3: [u8; 4],
}
#[test] fn check_size_PxVehicleDriveNW() { assert_eq!(std::mem::size_of::<PxVehicleDriveNW>(), 832); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDrive4WRawInputData {
pub structgen_pad0: [u8; 40],
}
#[test] fn check_size_PxVehicleDrive4WRawInputData() { assert_eq!(std::mem::size_of::<PxVehicleDrive4WRawInputData>(), 40); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleKeySmoothingData {
pub mRiseRates: [f32; 16],
pub mFallRates: [f32; 16],
}
#[test] fn check_size_PxVehicleKeySmoothingData() { assert_eq!(std::mem::size_of::<PxVehicleKeySmoothingData>(), 128); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehiclePadSmoothingData {
pub mRiseRates: [f32; 16],
pub mFallRates: [f32; 16],
}
#[test] fn check_size_PxVehiclePadSmoothingData() { assert_eq!(std::mem::size_of::<PxVehiclePadSmoothingData>(), 128); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDriveNWRawInputData {
pub structgen_pad0: [u8; 40],
}
#[test] fn check_size_PxVehicleDriveNWRawInputData() { assert_eq!(std::mem::size_of::<PxVehicleDriveNWRawInputData>(), 40); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleDriveTankRawInputData {
pub structgen_pad0: [u8; 32],
}
#[test] fn check_size_PxVehicleDriveTankRawInputData() { assert_eq!(std::mem::size_of::<PxVehicleDriveTankRawInputData>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleCopyDynamicsMap {
pub sourceWheelIds: [u8; 20],
pub targetWheelIds: [u8; 20],
}
#[test] fn check_size_PxVehicleCopyDynamicsMap() { assert_eq!(std::mem::size_of::<PxVehicleCopyDynamicsMap>(), 40); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleGraphChannelDesc {
pub mMinY: f32,
pub mMaxY: f32,
pub mMidY: f32,
pub mColorLow: PxVec3,
pub mColorHigh: PxVec3,
pub structgen_pad0: [u8; 4],
pub mTitle: *mut i8,
}
#[test] fn check_size_PxVehicleGraphChannelDesc() { assert_eq!(std::mem::size_of::<PxVehicleGraphChannelDesc>(), 48); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleGraphDesc {
pub structgen_pad0: [u8; 32],
}
#[test] fn check_size_PxVehicleGraphDesc() { assert_eq!(std::mem::size_of::<PxVehicleGraphDesc>(), 32); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxVehicleNoDrive {
pub structgen_pad0: [u8; 8],
pub mConcreteType: u16,
pub mBaseFlags: PxBaseFlags,
pub structgen_pad1: [u8; 4],
pub mWheelsSimData: PxVehicleWheelsSimData,
pub mWheelsDynData: PxVehicleWheelsDynData,
pub mActor: *mut PxRigidDynamic,
pub structgen_pad2: [u8; 5],
pub mType: u8,
pub mPad0: [u8; 14],
pub structgen_pad3: [u8; 36],
}
#[test] fn check_size_PxVehicleNoDrive() { assert_eq!(std::mem::size_of::<PxVehicleNoDrive>(), 224); }
#[derive(Clone, Copy)]
#[repr(C)]
pub struct PxProfileScoped {
pub mCallback: *mut PxProfilerCallback,
pub mEventName: *const i8,
pub mProfilerData: *mut std::ffi::c_void,
pub mContextId: usize,
pub mDetached: bool,
pub structgen_pad0: [u8; 7],
}
#[test] fn check_size_PxProfileScoped() { assert_eq!(std::mem::size_of::<PxProfileScoped>(), 40); }