boxddd_sys/

bindings_pregenerated.rs

// AUTOGENERATED: pregenerated Box3D bindings for docs.rs/offline builds
// To refresh, run tools/update_box3d_and_bindings.py generate --mode default

/* automatically generated by rust-bindgen 0.72.1 */

pub const B3_DEFAULT_CATEGORY_BITS: u64 = u64::MAX;
pub const B3_DEFAULT_MASK_BITS: u64 = u64::MAX;

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
    storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage }
    }
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[inline]
    fn extract_bit(byte: u8, index: usize) -> bool {
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        byte & mask == mask
    }
    #[inline]
    pub fn get_bit(&self, index: usize) -> bool {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = self.storage.as_ref()[byte_index];
        Self::extract_bit(byte, index)
    }
    #[inline]
    pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe {
            *(core::ptr::addr_of!((*this).storage) as *const u8)
                .offset(byte_index as isize)
        };
        Self::extract_bit(byte, index)
    }
    #[inline]
    fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
        let bit_index = if cfg!(target_endian = "big") {
            7 - (index % 8)
        } else {
            index % 8
        };
        let mask = 1 << bit_index;
        if val { byte | mask } else { byte & !mask }
    }
    #[inline]
    pub fn set_bit(&mut self, index: usize, val: bool) {
        debug_assert!(index / 8 < self.storage.as_ref().len());
        let byte_index = index / 8;
        let byte = &mut self.storage.as_mut()[byte_index];
        *byte = Self::change_bit(*byte, index, val);
    }
    #[inline]
    pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
        debug_assert!(index / 8 < core::mem::size_of::<Storage>());
        let byte_index = index / 8;
        let byte = unsafe {
            (core::ptr::addr_of_mut!((*this).storage) as *mut u8)
                .offset(byte_index as isize)
        };
        unsafe { *byte = Self::change_bit(*byte, index, val) };
    }
    #[inline]
    pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!(
            (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(),
        );
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if self.get_bit(i + bit_offset) {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!(
            (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>(),
        );
        let mut val = 0;
        for i in 0..(bit_width as usize) {
            if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
                let index = if cfg!(target_endian = "big") {
                    bit_width as usize - 1 - i
                } else {
                    i
                };
                val |= 1 << index;
            }
        }
        val
    }
    #[inline]
    pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
        debug_assert!(
            (bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len(),
        );
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            self.set_bit(index + bit_offset, val_bit_is_set);
        }
    }
    #[inline]
    pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
        debug_assert!(bit_width <= 64);
        debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
        debug_assert!(
            (bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>(),
        );
        for i in 0..(bit_width as usize) {
            let mask = 1 << i;
            let val_bit_is_set = val & mask == mask;
            let index = if cfg!(target_endian = "big") {
                bit_width as usize - 1 - i
            } else {
                i
            };
            unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
        }
    }
}
pub const B3_ENABLE_VALIDATION: u32 = 0;
pub const B3_NULL_INDEX: i32 = -1;
pub const B3_HASH_INIT: u32 = 5381;
pub const B3_PI: f64 = 3.14159265359;
pub const B3_DEG_TO_RAD: f64 = 0.01745329251;
pub const B3_RAD_TO_DEG: f64 = 57.2957795131;
pub const B3_MIN_SCALE: f64 = 0.01;
pub const B3_MAX_WORKERS: u32 = 32;
pub const B3_MAX_TASKS: u32 = 256;
pub const B3_GRAPH_COLOR_COUNT: u32 = 24;
pub const B3_CONTACT_MANIFOLD_COUNT_BUCKETS: u32 = 8;
pub const B3_MIN_FRICTION_WEIGHT: f64 = 0.0000000001;
pub const B3_MAX_WORLDS: u32 = 128;
pub const B3_MAX_ROTATION: f64 = 0.7853981633975;
pub const B3_CONTACT_RECYCLE_ANGULAR_DISTANCE: f64 = 0.99240388;
pub const B3_AABB_MARGIN_FRACTION: f64 = 0.125;
pub const B3_TIME_TO_SLEEP: f64 = 0.5;
pub const B3_MAX_MANIFOLD_POINTS: u32 = 4;
pub const B3_MAX_SHAPE_CAST_POINTS: u32 = 64;
pub const B3_GYROSCOPIC_ITERATIONS: u32 = 1;
pub const B3_MAX_HULL_VERTICES: u32 = 128;
pub const B3_MAX_HULL_FACES: u32 = 128;
pub const B3_MAX_HULL_EDGES: u32 = 128;
pub const B3_PARALLEL_EDGE_TOL: f64 = 0.005;
pub const B3_SHAPE_POWER: u32 = 22;
pub const B3_CHILD_POWER: u32 = 20;
pub const B3_MAX_SHAPES: u32 = 4194304;
pub const B3_MAX_CHILD_SHAPES: u32 = 1048576;
pub const B3_RESTITUTION_ITERATIONS: u32 = 1;
pub const B3_DYNAMIC_TREE_VERSION: i64 = -7787375179321898166;
pub const B3_HULL_VERSION: i64 = -2715301031560262655;
pub const B3_MESH_VERSION: i64 = -6066037853393090451;
pub const B3_HEIGHT_FIELD_HOLE: u32 = 255;
pub const B3_HEIGHT_FIELD_VERSION: i64 = -8423759003537458044;
pub const B3_COMPOUND_VERSION: u64 = 6012353156626885901;
pub const B3_MAX_COMPOUND_MESH_MATERIALS: u32 = 4;
/** Prototype for user allocation function.
	@param size the allocation size in bytes
	@param alignment the required alignment, guaranteed to be a power of 2*/
pub type b3AllocFcn = ::std::option::Option<
    unsafe extern "C" fn(size: i32, alignment: i32) -> *mut ::std::os::raw::c_void,
>;
/** Prototype for user free function.
	@param mem the memory previously allocated through `b3AllocFcn`*/
pub type b3FreeFcn = ::std::option::Option<
    unsafe extern "C" fn(mem: *mut ::std::os::raw::c_void),
>;
/// Prototype for the user assert callback. Return 0 to skip the debugger break.
pub type b3AssertFcn = ::std::option::Option<
    unsafe extern "C" fn(
        condition: *const ::std::os::raw::c_char,
        fileName: *const ::std::os::raw::c_char,
        lineNumber: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int,
>;
/// Prototype for user log callback. Used to log warnings.
pub type b3LogFcn = ::std::option::Option<
    unsafe extern "C" fn(message: *const ::std::os::raw::c_char),
>;
unsafe extern "C" {
    /** This allows the user to override the allocation functions. These should be
	set during application startup.*/
    pub fn b3SetAllocator(allocFcn: b3AllocFcn, freeFcn: b3FreeFcn);
}
unsafe extern "C" {
    /// Total bytes allocated by Box3D
    pub fn b3GetByteCount() -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** Override the default assert callback.
	@param assertFcn a non-null assert callback*/
    pub fn b3SetAssertFcn(assertFcn: b3AssertFcn);
}
unsafe extern "C" {
    /// Internal assertion handler. Allows for host intervention.
    pub fn b3InternalAssert(
        condition: *const ::std::os::raw::c_char,
        fileName: *const ::std::os::raw::c_char,
        lineNumber: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Override the default logging callback.
    pub fn b3SetLogFcn(logFcn: b3LogFcn);
}
#[doc = " Version numbering scheme.\n See https://semver.org/"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Version {
    /// Significant changes
    pub major: ::std::os::raw::c_int,
    /// Incremental changes
    pub minor: ::std::os::raw::c_int,
    /// Bug fixes
    pub revision: ::std::os::raw::c_int,
}
unsafe extern "C" {
    /// Get the current version of Box3D
    pub fn b3GetVersion() -> b3Version;
}
unsafe extern "C" {
    /// @return true if the library was built with BOX3D_DOUBLE_PRECISION (large world mode)
    pub fn b3IsDoublePrecision() -> bool;
}
unsafe extern "C" {
    /// Get the absolute number of system ticks. The value is platform specific.
    pub fn b3GetTicks() -> u64;
}
unsafe extern "C" {
    /// Get the milliseconds passed from an initial tick value.
    pub fn b3GetMilliseconds(ticks: u64) -> f32;
}
unsafe extern "C" {
    /// Get the milliseconds passed from an initial tick value.
    pub fn b3GetMillisecondsAndReset(ticks: *mut u64) -> f32;
}
unsafe extern "C" {
    /// Yield to be used in a busy loop.
    pub fn b3Yield();
}
unsafe extern "C" {
    /// Sleep the current thread for a number of milliseconds.
    pub fn b3Sleep(milliseconds: ::std::os::raw::c_int);
}
unsafe extern "C" {
    pub fn b3Hash(hash: u32, data: *const u8, count: ::std::os::raw::c_int) -> u32;
}
/// A 2D vector.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Vec2 {
    pub x: f32,
    pub y: f32,
}
/// A 3D vector.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Vec3 {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}
/** Cosine and sine pair.
 This uses a custom implementation designed for cross-platform determinism.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CosSin {
    /// cosine and sine
    pub cosine: f32,
    pub sine: f32,
}
/// A quaternion.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Quat {
    pub v: b3Vec3,
    pub s: f32,
}
/// A rigid transform.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Transform {
    pub p: b3Vec3,
    pub q: b3Quat,
}
/// In single precision mode these types are the same.
pub type b3Pos = b3Vec3;
/// In single precision mode these types are the same.
pub type b3WorldTransform = b3Transform;
/// A 3x3 matrix.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Matrix3 {
    pub cx: b3Vec3,
    pub cy: b3Vec3,
    pub cz: b3Vec3,
}
/// Axis aligned bounding box.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3AABB {
    pub lowerBound: b3Vec3,
    pub upperBound: b3Vec3,
}
/** A plane.
 separation = dot(normal, point) - offset*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Plane {
    pub normal: b3Vec3,
    pub offset: f32,
}
unsafe extern "C" {
    /** Compute an approximate arctangent in the range [-pi, pi]
 This is hand coded for cross-platform determinism. The atan2f
 function in the standard library is not cross-platform deterministic.
	Accurate to around 0.0023 degrees.*/
    pub fn b3Atan2(y: f32, x: f32) -> f32;
}
unsafe extern "C" {
    /** Compute the cosine and sine of an angle in radians. Implemented
 for cross-platform determinism.*/
    pub fn b3ComputeCosSin(radians: f32) -> b3CosSin;
}
unsafe extern "C" {
    /// Extract a quaternion from a rotation matrix.
    pub fn b3MakeQuatFromMatrix(m: *const b3Matrix3) -> b3Quat;
}
unsafe extern "C" {
    /// Find a quaternion that rotates one vector to another.
    pub fn b3ComputeQuatBetweenUnitVectors(v1: b3Vec3, v2: b3Vec3) -> b3Quat;
}
unsafe extern "C" {
    /** Get the inertia tensor of an offset point.
 https://en.wikipedia.org/wiki/Parallel_axis_theorem*/
    pub fn b3Steiner(mass: f32, origin: b3Vec3) -> b3Matrix3;
}
/// The closest points between to segments or infinite lines.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3SegmentDistanceResult {
    pub point1: b3Vec3,
    pub fraction1: f32,
    pub point2: b3Vec3,
    pub fraction2: f32,
}
unsafe extern "C" {
    /// Compute the closest point on the segment a-b to the target q.
    pub fn b3PointToSegmentDistance(a: b3Vec3, b: b3Vec3, q: b3Vec3) -> b3Vec3;
}
unsafe extern "C" {
    /// Compute the closest points on two infinite lines.
    pub fn b3LineDistance(
        p1: b3Vec3,
        d1: b3Vec3,
        p2: b3Vec3,
        d2: b3Vec3,
    ) -> b3SegmentDistanceResult;
}
unsafe extern "C" {
    /// Compute the closest points on two line segments.
    pub fn b3SegmentDistance(
        p1: b3Vec3,
        q1: b3Vec3,
        p2: b3Vec3,
        q2: b3Vec3,
    ) -> b3SegmentDistanceResult;
}
unsafe extern "C" {
    /// Is this a valid number? Not NaN or infinity.
    pub fn b3IsValidFloat(a: f32) -> bool;
}
unsafe extern "C" {
    /// Is this a valid vector? Not NaN or infinity.
    pub fn b3IsValidVec3(a: b3Vec3) -> bool;
}
unsafe extern "C" {
    /// Is this a valid quaternion? Not NaN or infinity. Is normalized.
    pub fn b3IsValidQuat(q: b3Quat) -> bool;
}
unsafe extern "C" {
    /// Is this a valid transform? Not NaN or infinity. Is normalized.
    pub fn b3IsValidTransform(a: b3Transform) -> bool;
}
unsafe extern "C" {
    /// Is this a valid matrix? Not NaN or infinity.
    pub fn b3IsValidMatrix3(a: b3Matrix3) -> bool;
}
unsafe extern "C" {
    /// Is this a valid bounding box? Not Nan or infinity. Upper bound greater than or equal to lower bound.
    pub fn b3IsValidAABB(a: b3AABB) -> bool;
}
unsafe extern "C" {
    /// Is this AABB reasonably close to the origin? See B3_HUGE.
    pub fn b3IsBoundedAABB(a: b3AABB) -> bool;
}
unsafe extern "C" {
    /// Is this AABB valid and reasonable?
    pub fn b3IsSaneAABB(a: b3AABB) -> bool;
}
unsafe extern "C" {
    /// Is this a valid plane? Normal is a unit vector. Not Nan or infinity.
    pub fn b3IsValidPlane(a: b3Plane) -> bool;
}
unsafe extern "C" {
    /// Is this a valid world position? Not NaN or infinity.
    pub fn b3IsValidPosition(p: b3Pos) -> bool;
}
unsafe extern "C" {
    /// Is this a valid world transform? Not NaN or infinity. Rotation is normalized.
    pub fn b3IsValidWorldTransform(t: b3WorldTransform) -> bool;
}
unsafe extern "C" {
    /** Box3D bases all length units on meters, but you may need different units for your game.
 You can set this value to use different units. This should be done at application startup
 and only modified once. Default value is 1.
 @warning This must be modified before any calls to Box3D*/
    pub fn b3SetLengthUnitsPerMeter(lengthUnits: f32);
}
unsafe extern "C" {
    /// Get the current length units per meter.
    pub fn b3GetLengthUnitsPerMeter() -> f32;
}
unsafe extern "C" {
    /// Set the threshold for logging stalls.
    pub fn b3SetStallThreshold(seconds: f32);
}
unsafe extern "C" {
    /// Get the threshold for logging stalls.
    pub fn b3GetStallThreshold() -> f32;
}
/// World id references a world instance. This should be treated as an opaque handle.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3WorldId {
    pub index1: u16,
    pub generation: u16,
}
/// Body id references a body instance. This should be treated as an opaque handle.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3BodyId {
    pub index1: i32,
    pub world0: u16,
    pub generation: u16,
}
/// Shape id references a shape instance. This should be treated as an opaque handle.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ShapeId {
    pub index1: i32,
    pub world0: u16,
    pub generation: u16,
}
/// Joint id references a joint instance. This should be treated as an opaque handle.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3JointId {
    pub index1: i32,
    pub world0: u16,
    pub generation: u16,
}
/// Contact id references a contact instance. This should be treated as an opaque handle.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ContactId {
    pub index1: i32,
    pub world0: u16,
    pub padding: i16,
    pub generation: u32,
}
/** Task interface
 This is the prototype for a Box3D task. Your task system is expected to run this callback on a worker thread,
 exactly once per enqueue, passing back the same taskContext pointer supplied to b3EnqueueTaskCallback.
 @ingroup world*/
pub type b3TaskCallback = ::std::option::Option<
    unsafe extern "C" fn(taskContext: *mut ::std::os::raw::c_void),
>;
/** These functions can be provided to Box3D to invoke a task system.
 Returns a pointer to the user's task object. May be nullptr. A nullptr indicates to Box3D that the work was executed
 serially within the callback and there is no need to call b3FinishTaskCallback. Otherwise the returned
 value must be non-null will be passed to b3FinishTaskCallback as the userTask.
 @param task the Box3D task to be called by the scheduler
 @param taskContext the Box3D context object that the scheduler must pass to the task
 @param userContext the scheduler context object that is opaque to Box3D
 @param taskName the Box3D task name that the scheduler can use for diagnostics
 @ingroup world*/
pub type b3EnqueueTaskCallback = ::std::option::Option<
    unsafe extern "C" fn(
        task: b3TaskCallback,
        taskContext: *mut ::std::os::raw::c_void,
        userContext: *mut ::std::os::raw::c_void,
        taskName: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_void,
>;
/** Finishes a user task object that wraps a Box3D task. This must block until the task has completed.
 The step blocks here on the tasks it spawned, so b3World_Step holds its stack across every
 fork/join. Drive it from a thread you can dedicate to the step, or from a fiber this callback can
 park to free the underlying thread. In a job system that cannot park a job's stack, do not call
 b3World_Step from inside a job: a job that blocks on its own sub-jobs without yielding its thread
 can deadlock. The in-tree scheduler instead runs other pending tasks on the waiting thread.
 @ingroup world*/
pub type b3FinishTaskCallback = ::std::option::Option<
    unsafe extern "C" fn(
        userTask: *mut ::std::os::raw::c_void,
        userContext: *mut ::std::os::raw::c_void,
    ),
>;
/** The user needs to be able to create debug draw shapes for multi-pass rendering to work efficiently.
 These user shapes are created and destroyed via callback so they can be bound to shape lifetime and scaling updates.
 @ingroup debug_draw*/
pub type b3CreateDebugShapeCallback = ::std::option::Option<
    unsafe extern "C" fn(
        debugShape: *const b3DebugShape,
        userContext: *mut ::std::os::raw::c_void,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type b3DestroyDebugShapeCallback = ::std::option::Option<
    unsafe extern "C" fn(
        userShape: *mut ::std::os::raw::c_void,
        userContext: *mut ::std::os::raw::c_void,
    ),
>;
/** Optional friction mixing callback. This intentionally provides no context objects because this is called
 from a worker thread.
 @warning This function should not attempt to modify Box3D state or user application state.
 @ingroup world*/
pub type b3FrictionCallback = ::std::option::Option<
    unsafe extern "C" fn(
        frictionA: f32,
        userMaterialIdA: u64,
        frictionB: f32,
        userMaterialIdB: u64,
    ) -> f32,
>;
/** Optional restitution mixing callback. This intentionally provides no context objects because this is called
 from a worker thread.
 @warning This function should not attempt to modify Box3D state or user application state.
 @ingroup world*/
pub type b3RestitutionCallback = ::std::option::Option<
    unsafe extern "C" fn(
        restitutionA: f32,
        userMaterialIdA: u64,
        restitutionB: f32,
        userMaterialIdB: u64,
    ) -> f32,
>;
/** Prototype for a contact filter callback.
 This is called when a contact pair is considered for collision. This allows you to
 perform custom logic to prevent collision between shapes. This is only called if
 one of the two shapes has custom filtering enabled. @see b3ShapeDef.
 Notes:
 - this function must be thread-safe
 - this is only called if one of the two shapes has enabled custom filtering
 - this is called only for awake dynamic bodies
 Return false if you want to disable the collision
 @warning Do not attempt to modify the world inside this callback
 @ingroup world*/
pub type b3CustomFilterFcn = ::std::option::Option<
    unsafe extern "C" fn(
        shapeIdA: b3ShapeId,
        shapeIdB: b3ShapeId,
        context: *mut ::std::os::raw::c_void,
    ) -> bool,
>;
/** Prototype for a pre-solve callback.
 This is called after a contact is updated. This allows you to inspect a
 collision before it goes to the solver.
 Notes:
 - this function must be thread-safe
 - this is only called if the shape has enabled pre-solve events
 - this may be called for awake dynamic bodies and sensors
 - this is not called for sensors
 Return false if you want to disable the contact this step
 This has limited information because it is used during CCD which does not have the
 full contact manifold.
 @warning Do not attempt to modify the world inside this callback
 @ingroup world*/
pub type b3PreSolveFcn = ::std::option::Option<
    unsafe extern "C" fn(
        shapeIdA: b3ShapeId,
        shapeIdB: b3ShapeId,
        point: b3Pos,
        normal: b3Vec3,
        context: *mut ::std::os::raw::c_void,
    ) -> bool,
>;
/** Prototype callback for overlap queries.
 Called for each shape found in the query.
 @see b3World_OverlapAABB
 @return false to terminate the query.
 @ingroup world*/
pub type b3OverlapResultFcn = ::std::option::Option<
    unsafe extern "C" fn(
        shapeId: b3ShapeId,
        context: *mut ::std::os::raw::c_void,
    ) -> bool,
>;
/** Prototype callback for ray casts.
 Called for each shape found in the query. You control how the ray cast
 proceeds by returning a float:
 return -1: ignore this shape and continue
 return 0: terminate the ray cast
 return fraction: clip the ray to this point
 return 1: don't clip the ray and continue
 @param shapeId the shape hit by the ray
 @param point the point of initial intersection
 @param normal the normal vector at the point of intersection
 @param fraction the fraction along the ray at the point of intersection
 @param userMaterialId the shape or triangle surface type
 @param triangleIndex the triangle index for mesh or height field shapes or -1 for other shape types
 @param childIndex the child shape index for compound shapes
 @param context the user context
 @return -1 to filter, 0 to terminate, fraction to clip the ray for closest hit, 1 to continue
 @see b3World_CastRay
 @ingroup world*/
pub type b3CastResultFcn = ::std::option::Option<
    unsafe extern "C" fn(
        shapeId: b3ShapeId,
        point: b3Pos,
        normal: b3Vec3,
        fraction: f32,
        userMaterialId: u64,
        triangleIndex: ::std::os::raw::c_int,
        childIndex: ::std::os::raw::c_int,
        context: *mut ::std::os::raw::c_void,
    ) -> f32,
>;
/** Optional world capacities that can be use to avoid run-time allocations
 @ingroup world*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Capacity {
    /// Number of expected static shapes.
    pub staticShapeCount: ::std::os::raw::c_int,
    /// Number of expected dynamic and kinematic shapes.
    pub dynamicShapeCount: ::std::os::raw::c_int,
    /// Number of expected static bodies.
    pub staticBodyCount: ::std::os::raw::c_int,
    /// Number of expected dynamic and kinematic bodies.
    pub dynamicBodyCount: ::std::os::raw::c_int,
    /// Number of expected contacts.
    pub contactCount: ::std::os::raw::c_int,
}
/** World definition used to create a simulation world. Must be initialized using b3DefaultWorldDef.
 @ingroup world*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3WorldDef {
    /// Gravity vector. Box3D has no up-vector defined.
    pub gravity: b3Vec3,
    /** Restitution speed threshold, usually in m/s. Collisions above this
 speed have restitution applied (will bounce).*/
    pub restitutionThreshold: f32,
    /** Hit event speed threshold, usually in m/s. Collisions above this
 speed can generate hit events if the shape also enables hit events.*/
    pub hitEventThreshold: f32,
    /// Contact stiffness. Cycles per second. Increasing this increases the speed of overlap recovery, but can introduce jitter.
    pub contactHertz: f32,
    /** Contact bounciness. Non-dimensional. You can speed up overlap recovery by decreasing this with
 the trade-off that overlap resolution becomes more energetic.*/
    pub contactDampingRatio: f32,
    /** This parameter controls how fast overlap is resolved and usually has units of meters per second. This only
 puts a cap on the resolution speed. The resolution speed is increased by increasing the hertz and/or
 decreasing the damping ratio.*/
    pub contactSpeed: f32,
    /// Maximum linear speed. Usually meters per second.
    pub maximumLinearSpeed: f32,
    /// Optional mixing callback for friction. The default uses sqrt(frictionA * frictionB).
    pub frictionCallback: b3FrictionCallback,
    /// Optional mixing callback for restitution. The default uses max(restitutionA, restitutionB).
    pub restitutionCallback: b3RestitutionCallback,
    /// Can bodies go to sleep to improve performance
    pub enableSleep: bool,
    /// Enable continuous collision
    pub enableContinuous: bool,
    /** Number of workers to use with the provided task system. Box3D performs best when using only
 performance cores and accessing a single L2 cache. Efficiency cores and hyper-threading provide
 little benefit and may even harm performance.
 This is clamped to the range [1, B3_MAX_WORKERS]. Using a value above 1 will turn on multithreading.
 If task callbacks are provided then Box3D will use the user provided task system. Otherwise Box3D
 will create threads and use an internal scheduler.*/
    pub workerCount: u32,
    /// function to spawn task
    pub enqueueTask: b3EnqueueTaskCallback,
    /// function to finish a task
    pub finishTask: b3FinishTaskCallback,
    /// User context that is provided to enqueueTask and finishTask
    pub userTaskContext: *mut ::std::os::raw::c_void,
    /// User data associated with a world
    pub userData: *mut ::std::os::raw::c_void,
    /** Used to create debug draw shapes. This is called when a shape is
 first drawn using b3DebugDraw.*/
    pub createDebugShape: b3CreateDebugShapeCallback,
    /// Used to destroy debug draw shapes. This is called when a shape is modified or destroyed.
    pub destroyDebugShape: b3DestroyDebugShapeCallback,
    /// This is passed to the debug shape callbacks to provide a user context.
    pub userDebugShapeContext: *mut ::std::os::raw::c_void,
    /// Optional initial capacities
    pub capacity: b3Capacity,
    /// Used internally to detect a valid definition. DO NOT SET.
    pub internalValue: ::std::os::raw::c_int,
}
unsafe extern "C" {
    /** Use this to initialize your world definition
 @ingroup world*/
    pub fn b3DefaultWorldDef() -> b3WorldDef;
}
/// zero mass, zero velocity, may be manually moved
pub const b3BodyType_b3_staticBody: b3BodyType = 0;
/// zero mass, velocity set by user, moved by solver
pub const b3BodyType_b3_kinematicBody: b3BodyType = 1;
/// positive mass, velocity determined by forces, moved by solver
pub const b3BodyType_b3_dynamicBody: b3BodyType = 2;
/// number of body types
pub const b3BodyType_b3_bodyTypeCount: b3BodyType = 3;
/** The body simulation type.
 Each body is one of these three types. The type determines how the body behaves in the simulation.
 @ingroup body*/
pub type b3BodyType = ::std::os::raw::c_uint;
/** Motion locks to restrict the body movement
 @ingroup body*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3MotionLocks {
    /// Prevent translation along the x-axis
    pub linearX: bool,
    /// Prevent translation along the y-axis
    pub linearY: bool,
    /// Prevent translation along the z-axis
    pub linearZ: bool,
    /// Prevent rotation around the x-axis
    pub angularX: bool,
    /// Prevent rotation around the y-axis
    pub angularY: bool,
    /// Prevent rotation around the z-axis
    pub angularZ: bool,
}
/** A body definition holds all the data needed to construct a rigid body.
 You can safely re-use body definitions. Shapes are added to a body after construction.
 Body definitions are temporary objects used to bundle creation parameters.
 Must be initialized using b3DefaultBodyDef().
 @ingroup body*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3BodyDef {
    /// The body type: static, kinematic, or dynamic.
    pub type_: b3BodyType,
    /** The initial world position of the body. Bodies should be created with the desired position.
 @note Creating bodies at the origin and then moving them nearly doubles the cost of body creation, especially
 if the body is moved after shapes have been added.*/
    pub position: b3Pos,
    /// The initial world rotation of the body.
    pub rotation: b3Quat,
    /// The initial linear velocity of the body's origin. Usually in meters per second.
    pub linearVelocity: b3Vec3,
    /// The initial angular velocity of the body. Radians per second.
    pub angularVelocity: b3Vec3,
    /** Linear damping is used to reduce the linear velocity. The damping parameter
 can be larger than 1 but the damping effect becomes sensitive to the
 time step when the damping parameter is large.
 Generally linear damping is undesirable because it makes objects move slowly
 as if they are floating.*/
    pub linearDamping: f32,
    /** Angular damping is used to reduce the angular velocity. The damping parameter
 can be larger than 1.0f but the damping effect becomes sensitive to the
 time step when the damping parameter is large.
 Angular damping can be used to slow down rotating bodies.*/
    pub angularDamping: f32,
    /// Scale the gravity applied to this body. Non-dimensional.
    pub gravityScale: f32,
    /// Sleep speed threshold, default is 0.05 meters per second
    pub sleepThreshold: f32,
    /// Optional body name for debugging.
    pub name: *const ::std::os::raw::c_char,
    /// Use this to store application specific body data.
    pub userData: *mut ::std::os::raw::c_void,
    /// Motions locks to restrict linear and angular movement
    pub motionLocks: b3MotionLocks,
    /// Set this flag to false if this body should never fall asleep.
    pub enableSleep: bool,
    /// Is this body initially awake or sleeping?
    pub isAwake: bool,
    /** Treat this body as a high speed object that performs continuous collision detection
 against dynamic and kinematic bodies, but not other bullet bodies.
 @warning Bullets should be used sparingly. They are not a solution for general dynamic-versus-dynamic
 continuous collision. They do not guarantee accurate collision if both bodies are fast moving because
 the bullet does a continuous check after all non-bullet bodies have moved. You could get unlucky and have
 the bullet body end a time step very close to a non-bullet body and the non-bullet body then moves over
 the bullet body. In continuous collision, initial overlap is ignored to avoid freezing bodies in place.
 I do not recommend using them for game projectiles if precise collision timing is needed. Instead consider
 using a ray or shape cast. You can use a marching ray or shape cast for projectile that moves over time.
 If you want a fast moving projectile to collide with a fast moving target, you need to consider the relative
 movement in your ray or shape cast. This is out of the scope of Box3D.
 So what are good use cases for bullets? Pinball games or games with dynamic containers that hold other objects.
 It should be a use case where it doesn't break the game if there is a collision missed, but having them
 captured improves the quality of the game.*/
    pub isBullet: bool,
    /// Used to disable a body. A disabled body does not move or collide.
    pub isEnabled: bool,
    /** This allows this body to bypass rotational speed limits. Should only be used
 for circular objects, like wheels.*/
    pub allowFastRotation: bool,
    /** Enable contact recycling. True by default. Leaving this enabled improves performance
 but may lead to ghost collision that should be avoided on characters.*/
    pub enableContactRecycling: bool,
    /// Used internally to detect a valid definition. DO NOT SET.
    pub internalValue: ::std::os::raw::c_int,
}
unsafe extern "C" {
    /** Use this to initialize your body definition
 @ingroup body*/
    pub fn b3DefaultBodyDef() -> b3BodyDef;
}
/** This is used to filter collision on shapes. It affects shape-vs-shape collision
 and shape-versus-query collision (such as b3World_CastRay).
 @ingroup shape*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Filter {
    /** The collision category bits. Normally you would just set one bit. The category bits should
 represent your application object types. For example:
 @code{.cpp}
 enum MyCategories
 {
    Static  = 0x00000001,
    Dynamic = 0x00000002,
    Debris  = 0x00000004,
    Player  = 0x00000008,
    // etc
 };
 @endcode*/
    pub categoryBits: u64,
    /** The collision mask bits. This states the categories that this
 shape would accept for collision.
 For example, you may want your player to only collide with static objects
 and other players.
 @code{.c}
 maskBits = Static | Player;
 @endcode*/
    pub maskBits: u64,
    /** Collision groups allow a certain group of objects to never collide (negative)
 or always collide (positive). A group index of zero has no effect. Non-zero group filtering
 always wins against the mask bits.
 For example, you may want ragdolls to collide with other ragdolls but you don't want
 ragdoll self-collision. In this case you would give each ragdoll a unique negative group index
 and apply that group index to all shapes on the ragdoll.*/
    pub groupIndex: ::std::os::raw::c_int,
}
unsafe extern "C" {
    /** Use this to initialize your filter
 @ingroup shape*/
    pub fn b3DefaultFilter() -> b3Filter;
}
/** Material properties supported per triangle on meshes and height fields
 @ingroup shape*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3SurfaceMaterial {
    /// The Coulomb (dry) friction coefficient, usually in the range [0,1].
    pub friction: f32,
    /** The coefficient of restitution (bounce) usually in the range [0,1].
 https://en.wikipedia.org/wiki/Coefficient_of_restitution*/
    pub restitution: f32,
    /// The rolling resistance usually in the range [0,1]. This is only used for spheres and capsules.
    pub rollingResistance: f32,
    /** The tangent velocity for conveyor belts. This is local to the shape and will be projected
 onto the contact surface.*/
    pub tangentVelocity: b3Vec3,
    /** User material identifier. This is passed with query results and to friction and restitution
 combining functions. It is not used internally.*/
    pub userMaterialId: u64,
    /** Custom debug draw color. Ignored if 0. The low 24 bits are RGB. The high byte may
 carry a b3DebugMaterial preset, see b3MakeDebugColor.
 @see b3HexColor*/
    pub customColor: u32,
    /// Explicit padding. Must be zero.
    pub padding: u32,
}
unsafe extern "C" {
    /** Use this to initialize your surface material
 @ingroup shape*/
    pub fn b3DefaultSurfaceMaterial() -> b3SurfaceMaterial;
}
/// A capsule is an extruded sphere
pub const b3ShapeType_b3_capsuleShape: b3ShapeType = 0;
/// A baked compound shape composed of spheres, capsules, hulls, and meshes
pub const b3ShapeType_b3_compoundShape: b3ShapeType = 1;
/// A height field useful for terrain
pub const b3ShapeType_b3_heightShape: b3ShapeType = 2;
/// A convex hull
pub const b3ShapeType_b3_hullShape: b3ShapeType = 3;
/// A triangle soup
pub const b3ShapeType_b3_meshShape: b3ShapeType = 4;
/// A sphere with an offset
pub const b3ShapeType_b3_sphereShape: b3ShapeType = 5;
/// The number of shape types
pub const b3ShapeType_b3_shapeTypeCount: b3ShapeType = 6;
/** Shape type
 @ingroup shape*/
pub type b3ShapeType = ::std::os::raw::c_uint;
/** Used to create a shape
 @ingroup shape*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ShapeDef {
    /// Optional shape name for debugging
    pub name: *const ::std::os::raw::c_char,
    /// Use this to store application specific shape data.
    pub userData: *mut ::std::os::raw::c_void,
    /// Surface material used on mesh shapes per triangle. Ignored for convex shapes. Ignored for compound shapes.
    pub materials: *mut b3SurfaceMaterial,
    /// Surface material count.
    pub materialCount: ::std::os::raw::c_int,
    /// The base surface material. Ignored for compound shapes.
    pub baseMaterial: b3SurfaceMaterial,
    /// The density, usually in kg/m^3.
    pub density: f32,
    /// Explosion scale for b3World_Explode. non-dimensional
    pub explosionScale: f32,
    /// Contact filtering data.
    pub filter: b3Filter,
    /// Enable custom filtering. Only one of the two shapes needs to enable custom filtering. See b3WorldDef.
    pub enableCustomFiltering: bool,
    /** A sensor shape generates overlap events but never generates a collision response.
 Sensors do not have continuous collision. Instead, use a ray or shape cast for those scenarios.
 Sensors still contribute to the body mass if they have non-zero density.
 @note Sensor events are disabled by default.
 @see enableSensorEvents*/
    pub isSensor: bool,
    /// Enable sensor events for this shape. This applies to sensors and non-sensors. False by default, even for sensors.
    pub enableSensorEvents: bool,
    /// Enable contact events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors. False by default.
    pub enableContactEvents: bool,
    /// Enable hit events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors. False by default.
    pub enableHitEvents: bool,
    /** Enable pre-solve contact events for this shape. Only applies to dynamic bodies. These are expensive
	and must be carefully handled due to multithreading. Ignored for sensors.*/
    pub enablePreSolveEvents: bool,
    /** When shapes are created they will scan the environment for collision the next time step. This can significantly slow down
 static body creation when there are many static shapes.
 This is flag is ignored for dynamic and kinematic shapes which always invoke contact creation.*/
    pub invokeContactCreation: bool,
    /** Should the body update the mass properties when this shape is created. Default is true.
 Warning: if this is false, you MUST call b3Body_ApplyMassFromShapes or b3Body_SetMassData before simulating the world.*/
    pub updateBodyMass: bool,
    /** Enable speculative collision. Leave this true unless you care about reducing ghost collision
 more than continuous collision under rotation.
 Experimental: this can only disable speculative contact between hulls and triangles (meshes and height fields).*/
    pub enableSpeculativeContact: bool,
    /// Used internally to detect a valid definition. DO NOT SET.
    pub internalValue: ::std::os::raw::c_int,
}
unsafe extern "C" {
    /** Use this to initialize your shape definition
 @ingroup shape*/
    pub fn b3DefaultShapeDef() -> b3ShapeDef;
}
/**! @cond
 Profiling data. Times are in milliseconds.
 @ingroup world*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Profile {
    pub step: f32,
    pub pairs: f32,
    pub collide: f32,
    pub solve: f32,
    pub solverSetup: f32,
    pub constraints: f32,
    pub prepareConstraints: f32,
    pub integrateVelocities: f32,
    pub warmStart: f32,
    pub solveImpulses: f32,
    pub integratePositions: f32,
    pub relaxImpulses: f32,
    pub applyRestitution: f32,
    pub storeImpulses: f32,
    pub splitIslands: f32,
    pub transforms: f32,
    pub sensorHits: f32,
    pub jointEvents: f32,
    pub hitEvents: f32,
    pub refit: f32,
    pub bullets: f32,
    pub sleepIslands: f32,
    pub sensors: f32,
}
/** Counters that give details of the simulation size.
 @ingroup world*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Counters {
    pub bodyCount: ::std::os::raw::c_int,
    pub shapeCount: ::std::os::raw::c_int,
    pub contactCount: ::std::os::raw::c_int,
    pub jointCount: ::std::os::raw::c_int,
    pub islandCount: ::std::os::raw::c_int,
    pub stackUsed: ::std::os::raw::c_int,
    pub arenaCapacity: ::std::os::raw::c_int,
    pub staticTreeHeight: ::std::os::raw::c_int,
    pub treeHeight: ::std::os::raw::c_int,
    pub satCallCount: ::std::os::raw::c_int,
    pub satCacheHitCount: ::std::os::raw::c_int,
    pub byteCount: ::std::os::raw::c_int,
    pub taskCount: ::std::os::raw::c_int,
    pub colorCounts: [::std::os::raw::c_int; 24usize],
    pub manifoldCounts: [::std::os::raw::c_int; 8usize],
    /** Number of contacts touched by the collide pass
 graph contacts + awake-set non-touching*/
    pub awakeContactCount: ::std::os::raw::c_int,
    /// Number of contacts recycled in the most recent step.
    pub recycledContactCount: ::std::os::raw::c_int,
    /// Maximum number of time of impact iterations
    pub distanceIterations: ::std::os::raw::c_int,
    pub pushBackIterations: ::std::os::raw::c_int,
    pub rootIterations: ::std::os::raw::c_int,
}
pub const b3JointType_b3_parallelJoint: b3JointType = 0;
pub const b3JointType_b3_distanceJoint: b3JointType = 1;
pub const b3JointType_b3_filterJoint: b3JointType = 2;
pub const b3JointType_b3_motorJoint: b3JointType = 3;
pub const b3JointType_b3_prismaticJoint: b3JointType = 4;
pub const b3JointType_b3_revoluteJoint: b3JointType = 5;
pub const b3JointType_b3_sphericalJoint: b3JointType = 6;
pub const b3JointType_b3_weldJoint: b3JointType = 7;
pub const b3JointType_b3_wheelJoint: b3JointType = 8;
/** Joint type enumeration. This is useful because all joint types use b3JointId and sometimes you
 want to get the type of a joint.
 @ingroup joint*/
pub type b3JointType = ::std::os::raw::c_uint;
/** Base joint definition used by all joint types. The local frames are measured from the
 body's origin rather than the center of mass because:
 1. You might not know where the center of mass will be.
 2. If you add/remove shapes from a body and recompute the mass, the joints will be broken.
 @ingroup joint*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3JointDef {
    /// User data pointer
    pub userData: *mut ::std::os::raw::c_void,
    /// The first attached body
    pub bodyIdA: b3BodyId,
    /// The second attached body
    pub bodyIdB: b3BodyId,
    /// The first local joint frame
    pub localFrameA: b3Transform,
    /// The second local joint frame
    pub localFrameB: b3Transform,
    /// Force threshold for joint events
    pub forceThreshold: f32,
    /// Torque threshold for joint events
    pub torqueThreshold: f32,
    /// Constraint hertz (advanced feature)
    pub constraintHertz: f32,
    /// Constraint damping ratio (advanced feature)
    pub constraintDampingRatio: f32,
    /// Debug draw scale
    pub drawScale: f32,
    /// Set this flag to true if the attached bodies should collide
    pub collideConnected: bool,
    /// Used internally to detect a valid definition. DO NOT SET.
    pub internalValue: ::std::os::raw::c_int,
}
/** Distance joint definition.
 Connects a point on body A with a point on body B by a segment.
 Useful for ropes and springs.
 @ingroup distance_joint*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3DistanceJointDef {
    /// Base joint definition
    pub base: b3JointDef,
    /// The rest length of this joint. Clamped to a stable minimum value.
    pub length: f32,
    /** Enable the distance constraint to behave like a spring. If false
 then the distance joint will be rigid, overriding the limit and motor.*/
    pub enableSpring: bool,
    /// The lower spring force controls how much tension it can sustain
    pub lowerSpringForce: f32,
    /// The upper spring force controls how much compression it can sustain
    pub upperSpringForce: f32,
    /// The spring linear stiffness Hertz, cycles per second
    pub hertz: f32,
    /// The spring linear damping ratio, non-dimensional
    pub dampingRatio: f32,
    /// Enable/disable the joint limit
    pub enableLimit: bool,
    /// Minimum length. Clamped to a stable minimum value.
    pub minLength: f32,
    /// Maximum length. Must be greater than or equal to the minimum length.
    pub maxLength: f32,
    /// Enable/disable the joint motor
    pub enableMotor: bool,
    /// The maximum motor force, usually in newtons
    pub maxMotorForce: f32,
    /// The desired motor speed, usually in meters per second
    pub motorSpeed: f32,
}
unsafe extern "C" {
    /** Use this to initialize your joint definition
 @ingroup distance_joint*/
    pub fn b3DefaultDistanceJointDef() -> b3DistanceJointDef;
}
/** A motor joint is used to control the relative position and velocity between two bodies.
 @ingroup motor_joint*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3MotorJointDef {
    /// Base joint definition
    pub base: b3JointDef,
    /// The desired linear velocity
    pub linearVelocity: b3Vec3,
    /// The maximum motor force in newtons
    pub maxVelocityForce: f32,
    /// The desired angular velocity
    pub angularVelocity: b3Vec3,
    /// The maximum motor torque in newton-meters
    pub maxVelocityTorque: f32,
    /// Linear spring hertz for position control
    pub linearHertz: f32,
    /// Linear spring damping ratio
    pub linearDampingRatio: f32,
    /// Maximum spring force in newtons
    pub maxSpringForce: f32,
    /// Angular spring hertz for position control
    pub angularHertz: f32,
    /// Angular spring damping ratio
    pub angularDampingRatio: f32,
    /// Maximum spring torque in newton-meters
    pub maxSpringTorque: f32,
}
unsafe extern "C" {
    /** Use this to initialize your joint definition
 @ingroup motor_joint*/
    pub fn b3DefaultMotorJointDef() -> b3MotorJointDef;
}
/** A filter joint is used to disable collision between two specific bodies.
 @ingroup filter_joint*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3FilterJointDef {
    /// Base joint definition
    pub base: b3JointDef,
}
unsafe extern "C" {
    /** Use this to initialize your joint definition
 @ingroup filter_joint*/
    pub fn b3DefaultFilterJointDef() -> b3FilterJointDef;
}
/** Parallel joint definition. Constrains the angle between axis z in body A and axis z in body B
 using a spring. Useful to keep a body upright.
 @ingroup parallel_joint*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ParallelJointDef {
    /// Base joint definition
    pub base: b3JointDef,
    /// The spring stiffness Hertz, cycles per second
    pub hertz: f32,
    /// The spring damping ratio, non-dimensional
    pub dampingRatio: f32,
    /// The maximum spring torque, typically in newton-meters.
    pub maxTorque: f32,
}
unsafe extern "C" {
    /** Use this to initialize your joint definition
 @ingroup parallel_joint*/
    pub fn b3DefaultParallelJointDef() -> b3ParallelJointDef;
}
/** Prismatic joint definition. Body B may slide along the x-axis in local frame A.
 Body B cannot rotate relative to body A. The joint translation is zero when the
 local frame origins coincide in world space.
 @ingroup prismatic_joint*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3PrismaticJointDef {
    /// Base joint definition
    pub base: b3JointDef,
    /// Enable a linear spring along the prismatic joint axis
    pub enableSpring: bool,
    /// The spring stiffness Hertz, cycles per second
    pub hertz: f32,
    /// The spring damping ratio, non-dimensional
    pub dampingRatio: f32,
    /** The target translation for the joint in meters. The spring-damper will drive
 to this translation.*/
    pub targetTranslation: f32,
    /// Enable/disable the joint limit
    pub enableLimit: bool,
    /// The lower translation limit
    pub lowerTranslation: f32,
    /// The upper translation limit
    pub upperTranslation: f32,
    /// Enable/disable the joint motor
    pub enableMotor: bool,
    /// The maximum motor force, typically in newtons
    pub maxMotorForce: f32,
    /// The desired motor speed, typically in meters per second
    pub motorSpeed: f32,
}
unsafe extern "C" {
    /** Use this to initialize your joint definition
 @ingroup prismatic_joint*/
    pub fn b3DefaultPrismaticJointDef() -> b3PrismaticJointDef;
}
/** Revolute joint definition. A point on body B is fixed to a point on body A.
 Allows relative rotation about the z-axis.
 @ingroup revolute_joint*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3RevoluteJointDef {
    /// Base joint definition.
    pub base: b3JointDef,
    /** The bodyB angle minus bodyA angle in the reference state (radians).
 This defines the zero angle for the joint limit.*/
    pub targetAngle: f32,
    /// Enable a rotational spring on the revolute hinge axis.
    pub enableSpring: bool,
    /// The spring stiffness Hertz, cycles per second.
    pub hertz: f32,
    /// The spring damping ratio, non-dimensional.
    pub dampingRatio: f32,
    /// A flag to enable joint limits.
    pub enableLimit: bool,
    /// The lower angle for the joint limit in radians. Minimum of -0.99*pi radians.
    pub lowerAngle: f32,
    /// The upper angle for the joint limit in radians. Maximum of 0.99*pi radians.
    pub upperAngle: f32,
    /// A flag to enable the joint motor.
    pub enableMotor: bool,
    /// The maximum motor torque, typically in newton-meters.
    pub maxMotorTorque: f32,
    /// The desired motor speed in radians per second.
    pub motorSpeed: f32,
}
unsafe extern "C" {
    /** Use this to initialize your joint definition.
 @ingroup revolute_joint*/
    pub fn b3DefaultRevoluteJointDef() -> b3RevoluteJointDef;
}
/** Spherical joint definition. A point on body B is fixed to a point on body A.
 Allows rotation about the shared point.
 @ingroup spherical_joint*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3SphericalJointDef {
    /// Base joint definition
    pub base: b3JointDef,
    /// Enable a rotational spring that attempts to align the two joint frames.
    pub enableSpring: bool,
    /** The spring stiffness Hertz, cycles per second. This may be clamped internally
 according to the time step to maintain stability. Non-negative number.*/
    pub hertz: f32,
    /// The spring damping ratio, non-dimensional. Non-negative number.
    pub dampingRatio: f32,
    /// Target spring rotation, joint frame B relative to joint frame A.
    pub targetRotation: b3Quat,
    /// A flag to enable the cone limit. The cone is centered on the frameA z-axis.
    pub enableConeLimit: bool,
    /// The angle for the cone limit in radians. Valid range is [0, pi]
    pub coneAngle: f32,
    /// A flag to enable the twist limit. The twist is centered on the frameB z-axis.
    pub enableTwistLimit: bool,
    /// The angle for the lower twist limit in radians. Minimum of -0.99*pi radians.
    pub lowerTwistAngle: f32,
    /// The angle for the upper twist limit in radians. Maximum of 0.99*pi radians.
    pub upperTwistAngle: f32,
    /// A flag to enable the joint motor
    pub enableMotor: bool,
    /// The maximum motor torque, typically in newton-meters. Non-negative number.
    pub maxMotorTorque: f32,
    /// The desired motor angular velocity in radians per second.
    pub motorVelocity: b3Vec3,
}
unsafe extern "C" {
    /** Use this to initialize your joint definition.
 @ingroup spherical_joint*/
    pub fn b3DefaultSphericalJointDef() -> b3SphericalJointDef;
}
/** Weld joint definition
 Connects two bodies together rigidly. This constraint provides springs to mimic
 soft-body simulation.
 @note The approximate solver in Box3D cannot hold many bodies together rigidly
 @ingroup weld_joint*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3WeldJointDef {
    /// Base joint definition
    pub base: b3JointDef,
    /// Linear stiffness expressed as Hertz (cycles per second). Use zero for maximum stiffness.
    pub linearHertz: f32,
    /// Angular stiffness as Hertz (cycles per second). Use zero for maximum stiffness.
    pub angularHertz: f32,
    /// Linear damping ratio, non-dimensional. Use 1 for critical damping.
    pub linearDampingRatio: f32,
    /// Linear damping ratio, non-dimensional. Use 1 for critical damping.
    pub angularDampingRatio: f32,
}
unsafe extern "C" {
    /** Use this to initialize your joint definition
 @ingroup weld_joint*/
    pub fn b3DefaultWeldJointDef() -> b3WeldJointDef;
}
/** Wheel joint definition
 Body A is the chassis and body B is the wheel.
 The wheel rotates around the local z-axis in frame B.
 The wheel translates along the local x-axis in frame A.
 The wheel can optionally steer along the x-axis in frame A.
 @ingroup wheel_joint*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3WheelJointDef {
    /// Base joint definition
    pub base: b3JointDef,
    /// Enable a linear spring along the local axis
    pub enableSuspensionSpring: bool,
    /// Spring stiffness in Hertz
    pub suspensionHertz: f32,
    /// Spring damping ratio, non-dimensional
    pub suspensionDampingRatio: f32,
    /// Enable/disable the joint linear limit
    pub enableSuspensionLimit: bool,
    /// The lower suspension translation limit
    pub lowerSuspensionLimit: f32,
    /// The upper translation limit
    pub upperSuspensionLimit: f32,
    /// Enable/disable the joint rotational motor
    pub enableSpinMotor: bool,
    /// The maximum motor torque, typically in newton-meters
    pub maxSpinTorque: f32,
    /// The desired motor speed in radians per second
    pub spinSpeed: f32,
    /// Enable steering, otherwise the steering is fixed forward
    pub enableSteering: bool,
    /// Steering stiffness in Hertz
    pub steeringHertz: f32,
    /// Spring damping ratio, non-dimensional
    pub steeringDampingRatio: f32,
    /// The target steering angle in radians
    pub targetSteeringAngle: f32,
    /// The maximum steering torque in N*m
    pub maxSteeringTorque: f32,
    /// Enable/disable the steering angular limit
    pub enableSteeringLimit: bool,
    /// The lower steering angle in radians
    pub lowerSteeringLimit: f32,
    /// The upper steering angle in radians
    pub upperSteeringLimit: f32,
}
unsafe extern "C" {
    /** Use this to initialize your joint definition
 @ingroup wheel_joint*/
    pub fn b3DefaultWheelJointDef() -> b3WheelJointDef;
}
/** The explosion definition is used to configure options for explosions. Explosions
 consider shape geometry when computing the impulse.
 @ingroup world*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ExplosionDef {
    /// Mask bits to filter shapes
    pub maskBits: u64,
    /// The center of the explosion in world space
    pub position: b3Pos,
    /// The radius of the explosion
    pub radius: f32,
    /// The falloff distance beyond the radius. Impulse is reduced to zero at this distance.
    pub falloff: f32,
    /** Impulse per unit area. This applies an impulse according to the shape area that
 is facing the explosion. Explosions only apply to spheres, capsules, and hulls. This
 may be negative for implosions.*/
    pub impulsePerArea: f32,
}
unsafe extern "C" {
    /** Use this to initialize your explosion definition
 @ingroup world*/
    pub fn b3DefaultExplosionDef() -> b3ExplosionDef;
}
/// A begin-touch event is generated when a shape starts to overlap a sensor shape.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3SensorBeginTouchEvent {
    /// The id of the sensor shape
    pub sensorShapeId: b3ShapeId,
    /// The id of the shape that began touching the sensor shape
    pub visitorShapeId: b3ShapeId,
}
/** An end touch event is generated when a shape stops overlapping a sensor shape.
	These include things like setting the transform, destroying a body or shape, or changing
	a filter. You will also get an end event if the sensor or visitor are destroyed.
	Therefore you should always confirm the shape id is valid using b3Shape_IsValid.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3SensorEndTouchEvent {
    /** The id of the sensor shape
	@warning this shape may have been destroyed
	@see b3Shape_IsValid*/
    pub sensorShapeId: b3ShapeId,
    /** The id of the shape that stopped touching the sensor shape
	@warning this shape may have been destroyed
	@see b3Shape_IsValid*/
    pub visitorShapeId: b3ShapeId,
}
/** Sensor events are buffered in the world and are available
	as begin/end overlap event arrays after the time step is complete.
	Note: these may become invalid if bodies and/or shapes are destroyed*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3SensorEvents {
    /// Array of sensor begin touch events
    pub beginEvents: *mut b3SensorBeginTouchEvent,
    /// Array of sensor end touch events
    pub endEvents: *mut b3SensorEndTouchEvent,
    /// The number of begin touch events
    pub beginCount: ::std::os::raw::c_int,
    /// The number of end touch events
    pub endCount: ::std::os::raw::c_int,
}
/// A begin-touch event is generated when two shapes begin touching.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ContactBeginTouchEvent {
    /// Id of the first shape
    pub shapeIdA: b3ShapeId,
    /// Id of the second shape
    pub shapeIdB: b3ShapeId,
    /** The transient contact id. This contact may be destroyed automatically when the world is modified or simulated.
 Use b3Contact_IsValid before using this id.*/
    pub contactId: b3ContactId,
}
/** An end touch event is generated when two shapes stop touching.
	You will get an end event if you do anything that destroys contacts previous to the last
	world step. These include things like setting the transform, destroying a body
	or shape, or changing a filter or body type.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ContactEndTouchEvent {
    /** Id of the first shape
	@warning this shape may have been destroyed
	@see b3Shape_IsValid*/
    pub shapeIdA: b3ShapeId,
    /** Id of the first shape
	@warning this shape may have been destroyed
	@see b3Shape_IsValid*/
    pub shapeIdB: b3ShapeId,
    /** Id of the contact.
	@warning this contact may have been destroyed
	@see b3Contact_IsValid*/
    pub contactId: b3ContactId,
}
/** A hit touch event is generated when two shapes collide with a speed faster than the hit speed threshold.
 This may be reported for speculative contacts that have a confirmed impulse.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ContactHitEvent {
    /// Id of the first shape
    pub shapeIdA: b3ShapeId,
    /// Id of the second shape
    pub shapeIdB: b3ShapeId,
    /** Id of the contact.
	@warning this contact may have been destroyed
	@see b3Contact_IsValid*/
    pub contactId: b3ContactId,
    /** Point where the shapes hit at the beginning of the time step.
 This is a mid-point between the two surfaces. It could be at speculative
 point where the two shapes were not touching at the beginning of the time step.*/
    pub point: b3Pos,
    /// Normal vector pointing from shape A to shape B
    pub normal: b3Vec3,
    /// The speed the shapes are approaching. Always positive. Typically in meters per second.
    pub approachSpeed: f32,
    /// User material on shape A
    pub userMaterialIdA: u64,
    /// User material on shape B
    pub userMaterialIdB: u64,
}
/** Contact events are buffered in the world and are available
	as event arrays after the time step is complete.
	Note: these may become invalid if bodies and/or shapes are destroyed*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ContactEvents {
    /// Array of begin touch events
    pub beginEvents: *mut b3ContactBeginTouchEvent,
    /// Array of end touch events
    pub endEvents: *mut b3ContactEndTouchEvent,
    /// Array of hit events
    pub hitEvents: *mut b3ContactHitEvent,
    /// Number of begin touch events
    pub beginCount: ::std::os::raw::c_int,
    /// Number of end touch events
    pub endCount: ::std::os::raw::c_int,
    /// Number of hit events
    pub hitCount: ::std::os::raw::c_int,
}
/** Body move events triggered when a body moves.
 Triggered when a body moves due to simulation. Not reported for bodies moved by the user.
 This also has a flag to indicate that the body went to sleep so the application can also
 sleep that actor/entity/object associated with the body.
 On the other hand if the flag does not indicate the body went to sleep then the application
 can treat the actor/entity/object associated with the body as awake.
 This is an efficient way for an application to update game object transforms rather than
 calling functions such as b3Body_GetTransform() because this data is delivered as a contiguous array
 and it is only populated with bodies that have moved.
 @note If sleeping is disabled all dynamic and kinematic bodies will trigger move events.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3BodyMoveEvent {
    /// The body user data.
    pub userData: *mut ::std::os::raw::c_void,
    /// The body transform.
    pub transform: b3WorldTransform,
    /// The body id.
    pub bodyId: b3BodyId,
    /// Did the body fall asleep this time step?
    pub fellAsleep: bool,
}
/** Body events are buffered in the world and are available
	as event arrays after the time step is complete.
	Note: this data becomes invalid if bodies are destroyed*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3BodyEvents {
    /// Array of move events
    pub moveEvents: *mut b3BodyMoveEvent,
    /// Number of move events
    pub moveCount: ::std::os::raw::c_int,
}
/** Joint events report joints that are awake and have a force and/or torque exceeding the threshold
 The observed forces and torques are not returned for efficiency reasons.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3JointEvent {
    /// The joint id
    pub jointId: b3JointId,
    /// The user data from the joint for convenience
    pub userData: *mut ::std::os::raw::c_void,
}
/** Joint events are buffered in the world and are available
 as event arrays after the time step is complete.
 Note: this data becomes invalid if joints are destroyed*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3JointEvents {
    /// Array of events
    pub jointEvents: *mut b3JointEvent,
    /// Number of events
    pub count: ::std::os::raw::c_int,
}
/** The contact data for two shapes. By convention the manifold normal points
 from shape A to shape B.
 @see b3Shape_GetContactData() and b3Body_GetContactData()*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ContactData {
    /** The contact id. You may hold onto this to track a contact across time steps.
 This id may become orphaned. Use b3Contact_IsValid before using it for other functions.*/
    pub contactId: b3ContactId,
    /// The first shape id.
    pub shapeIdA: b3ShapeId,
    /// The second shape id.
    pub shapeIdB: b3ShapeId,
    /** The contact manifold. This points to internal data and may become invalid. Do not store
 this pointer.*/
    pub manifolds: *const b3Manifold,
    /// The number of contact manifolds. For mesh and height-field collision there can be multiple manifolds.
    pub manifoldCount: ::std::os::raw::c_int,
}
/** The query filter is used to filter collisions between queries and shapes. For example,
 you may want a ray-cast representing a projectile to hit players and the static environment
 but not debris.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3QueryFilter {
    /// The collision category bits of this query. Normally you would just set one bit.
    pub categoryBits: u64,
    /** The collision mask bits. This states the shape categories that this
 query would accept for collision.*/
    pub maskBits: u64,
    /** Optional id combined with @ref name to identify this query in a recording, e.g. an entity id.
 Need not be unique on its own. 0 with a null name means untagged. Ignored when not recording.*/
    pub id: u64,
    /** Optional label combined with @ref id to identify this query, e.g. "bullet". Need not be unique
 on its own. The recorder hashes (id, name) into one stable key the viewer tracks the query by,
 so the same id and name pair identifies the same query across frames. NULL means none. Ignored
 when not recording.*/
    pub name: *const ::std::os::raw::c_char,
}
unsafe extern "C" {
    /// Use this to initialize your query filter
    pub fn b3DefaultQueryFilter() -> b3QueryFilter;
}
/// Low level ray cast input data.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3RayCastInput {
    /// Start point of the ray cast.
    pub origin: b3Vec3,
    /** Translation of the ray cast.
 end = start + translation.*/
    pub translation: b3Vec3,
    /// The maximum fraction of the translation to consider, typically 1
    pub maxFraction: f32,
}
/// Result from b3World_RayCastClosest.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3RayResult {
    /// The shape hit.
    pub shapeId: b3ShapeId,
    /// The world point of the hit.
    pub point: b3Pos,
    /// The world normal of the shape surface at the hit point.
    pub normal: b3Vec3,
    /** The user material id at the hit point. This can be per triangle
 if the shape is a mesh, height-field, or compound with child mesh.*/
    pub userMaterialId: u64,
    /// The fraction of the input ray.
    pub fraction: f32,
    /** The triangle index if the shape is a mesh, height-field, or compound with
 child mesh.*/
    pub triangleIndex: ::std::os::raw::c_int,
    /// The child index if the shape is a compound.
    pub childIndex: ::std::os::raw::c_int,
    /// The number of BVH nodes visited. Diagnostic.
    pub nodeVisits: ::std::os::raw::c_int,
    /// The number of BVH leaves visited. Diagnostic.
    pub leafVisits: ::std::os::raw::c_int,
    /// Did the ray hit? If false, all other data is invalid.
    pub hit: bool,
}
/// A shape proxy is used by the GJK algorithm. It can represent a convex shape.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ShapeProxy {
    /// The point cloud.
    pub points: *const b3Vec3,
    /// The number of points. Do not exceed B3_MAX_SHAPE_CAST_POINTS.
    pub count: ::std::os::raw::c_int,
    /// The external radius of the point cloud.
    pub radius: f32,
}
/** Low level shape cast input in generic form. This allows casting an arbitrary point
 cloud wrap with a radius. For example, a sphere is a single point with a non-zero radius.
 A capsule is two points with a non-zero radius. A box is four points with a zero radius.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ShapeCastInput {
    /// A generic query shape.
    pub proxy: b3ShapeProxy,
    /// The translation of the shape cast.
    pub translation: b3Vec3,
    /// The maximum fraction of the translation to consider, typically 1.
    pub maxFraction: f32,
    /// Allow shape cast to encroach when initially touching. This only works if the radius is greater than zero.
    pub canEncroach: bool,
}
/** Input for sweeping an AABB through a dynamic tree. The box is in the tree's world float frame.
 The caller folds the cast shape radius and any world origin into the box, so the tree traversal
 stays a conservative box sweep and the precise narrow phase happens per shape in the callback.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3BoxCastInput {
    /// The AABB to cast, in the tree's frame.
    pub box_: b3AABB,
    /// The sweep translation.
    pub translation: b3Vec3,
    /// The maximum fraction of the translation to consider, typically 1.
    pub maxFraction: f32,
}
/// Low level ray cast or shape-cast output data.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CastOutput {
    /// The surface normal at the hit point.
    pub normal: b3Vec3,
    /// The surface hit point.
    pub point: b3Vec3,
    /// The fraction of the input translation at collision.
    pub fraction: f32,
    /// The number of iterations used.
    pub iterations: ::std::os::raw::c_int,
    /// The index of the mesh or height field triangle hit.
    pub triangleIndex: ::std::os::raw::c_int,
    /// The index of the compound child shape.
    pub childIndex: ::std::os::raw::c_int,
    /// The material index. May be -1 for null.
    pub materialIndex: ::std::os::raw::c_int,
    /// Did the cast hit?
    pub hit: bool,
}
/// Same type in single precision.
pub type b3WorldCastOutput = b3CastOutput;
/// Body cast result for ray and shape casts.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3BodyCastResult {
    /// The shape hit.
    pub shapeId: b3ShapeId,
    /// The world point on the shape surface.
    pub point: b3Pos,
    /// The world normal vector on the shape surface.
    pub normal: b3Vec3,
    /** The fraction along the ray hit.
 hit point = origin + fraction * translation*/
    pub fraction: f32,
    /// The triangle index if the shape is a mesh or height-field.
    pub triangleIndex: ::std::os::raw::c_int,
    /** The user material id at the hit point. This can be per triangle
 if the shape is a mesh, height-field, or compound with child mesh.*/
    pub userMaterialId: u64,
    /// The number of iterations used. Diagnostic.
    pub iterations: ::std::os::raw::c_int,
    /// Did the cast hit? If false, all other fields are invalid.
    pub hit: bool,
}
/** Used to warm start the GJK simplex. If you call this function multiple times with nearby
 transforms this might improve performance. Otherwise you can zero initialize this.
 The distance cache must be initialized to zero on the first call.
 Users should generally just zero initialize this structure for each call.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3SimplexCache {
    /// Value use to compare length, area, volume of two simplexes.
    pub metric: f32,
    /// The number of stored simplex points
    pub count: u16,
    /// The cached simplex indices on shape A
    pub indexA: [u8; 4usize],
    /// The cached simplex indices on shape B
    pub indexB: [u8; 4usize],
}
/// Input parameters for b3ShapeCast
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ShapeCastPairInput {
    ///< The proxy for shape A
    pub proxyA: b3ShapeProxy,
    ///< The proxy for shape B
    pub proxyB: b3ShapeProxy,
    ///< Transform of shape B in shape A's frame, the relative pose B in A
    pub transform: b3Transform,
    ///< The translation of shape B, in A's frame
    pub translationB: b3Vec3,
    ///< The fraction of the translation to consider, typically 1
    pub maxFraction: f32,
    ///< Allows shapes with a radius to move slightly closer if already touching
    pub canEncroach: bool,
}
/// Input for b3ShapeDistance
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3DistanceInput {
    /// The proxy for shape A
    pub proxyA: b3ShapeProxy,
    /// The proxy for shape B
    pub proxyB: b3ShapeProxy,
    /** Transform of shape B in shape A's frame, the relative pose B in A
 (b3InvMulWorldTransforms( worldA, worldB )). The query is origin independent and runs in frame A.*/
    pub transform: b3Transform,
    /// Should the proxy radius be considered?
    pub useRadii: bool,
}
/// Output for b3ShapeDistance
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3DistanceOutput {
    ///< Closest point on shapeA, in shape A's frame
    pub pointA: b3Vec3,
    ///< Closest point on shapeB, in shape A's frame
    pub pointB: b3Vec3,
    ///< A to B normal in shape A's frame. Invalid if distance is zero.
    pub normal: b3Vec3,
    ///< The final distance, zero if overlapped
    pub distance: f32,
    ///< Number of GJK iterations used
    pub iterations: ::std::os::raw::c_int,
    ///< The number of simplexes stored in the simplex array
    pub simplexCount: ::std::os::raw::c_int,
}
/// Simplex vertex for debugging the GJK algorithm
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3SimplexVertex {
    ///< support point in proxyA
    pub wA: b3Vec3,
    ///< support point in proxyB
    pub wB: b3Vec3,
    ///< wB - wA
    pub w: b3Vec3,
    ///< barycentric coordinates
    pub a: f32,
    ///< wA index
    pub indexA: ::std::os::raw::c_int,
    ///< wB index
    pub indexB: ::std::os::raw::c_int,
}
/// Simplex from the GJK algorithm
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Simplex {
    ///< vertices
    pub vertices: [b3SimplexVertex; 4usize],
    ///< number of valid vertices
    pub count: ::std::os::raw::c_int,
}
/** This describes the motion of a body/shape for TOI computation. Shapes are defined with respect to the body origin,
 which may not coincide with the center of mass. However, to support dynamics we must interpolate the center of mass
 position.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Sweep {
    ///< Local center of mass position
    pub localCenter: b3Vec3,
    ///< Starting center of mass world position
    pub c1: b3Vec3,
    ///< Ending center of mass world position
    pub c2: b3Vec3,
    ///< Starting world rotation
    pub q1: b3Quat,
    ///< Ending world rotation
    pub q2: b3Quat,
}
/// Time of impact input
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3TOIInput {
    ///< The proxy for shape A
    pub proxyA: b3ShapeProxy,
    ///< The proxy for shape B
    pub proxyB: b3ShapeProxy,
    ///< The movement of shape A
    pub sweepA: b3Sweep,
    ///< The movement of shape B
    pub sweepB: b3Sweep,
    ///< Defines the sweep interval [0, tMax]
    pub maxFraction: f32,
}
pub const b3TOIState_b3_toiStateUnknown: b3TOIState = 0;
pub const b3TOIState_b3_toiStateFailed: b3TOIState = 1;
pub const b3TOIState_b3_toiStateOverlapped: b3TOIState = 2;
pub const b3TOIState_b3_toiStateHit: b3TOIState = 3;
pub const b3TOIState_b3_toiStateSeparated: b3TOIState = 4;
/// Describes the TOI output
pub type b3TOIState = ::std::os::raw::c_uint;
/// Time of impact output
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3TOIOutput {
    /// The type of result
    pub state: b3TOIState,
    /// The hit point
    pub point: b3Vec3,
    /// The hit normal
    pub normal: b3Vec3,
    /// The sweep time of the collision
    pub fraction: f32,
    /// The final distance
    pub distance: f32,
    /// Number of outer iterations
    pub distanceIterations: ::std::os::raw::c_int,
    /// Total number of push back iterations
    pub pushBackIterations: ::std::os::raw::c_int,
    /// Total number of root iterations
    pub rootIterations: ::std::os::raw::c_int,
    /** Indicates that the time of impact detected initial
 overlap and used a fallback sphere as a last ditch effort
 to prevent tunneling.*/
    pub usedFallback: bool,
}
pub const b3TreeNodeFlags_b3_allocatedNode: b3TreeNodeFlags = 1;
pub const b3TreeNodeFlags_b3_enlargedNode: b3TreeNodeFlags = 2;
pub const b3TreeNodeFlags_b3_leafNode: b3TreeNodeFlags = 4;
/// Flags for tree nodes. For internal usage.
pub type b3TreeNodeFlags = ::std::os::raw::c_uint;
/// Tree node child indices. For internal usage.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3TreeNodeChildren {
    ///< child node index 1
    pub child1: ::std::os::raw::c_int,
    ///< child node index 2
    pub child2: ::std::os::raw::c_int,
}
/** A node in the dynamic tree. This is private data placed here for performance reasons.
 todo test padding to 64 bytes to avoid straddling cache lines*/
#[repr(C)]
#[derive(Copy, Clone)]
pub struct b3TreeNode {
    /// The node bounding box
    pub aabb: b3AABB,
    /// Category bits for collision filtering
    pub categoryBits: u64,
    pub __bindgen_anon_1: b3TreeNode__bindgen_ty_1,
    pub __bindgen_anon_2: b3TreeNode__bindgen_ty_2,
    /// Height of the node. Leaves have a height of 0.
    pub height: u16,
    /// @see b3TreeNodeFlags
    pub flags: u16,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union b3TreeNode__bindgen_ty_1 {
    /// Children (internal node)
    pub children: b3TreeNodeChildren,
    /// User data (leaf node)
    pub userData: u64,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union b3TreeNode__bindgen_ty_2 {
    /// The node parent index (allocated node)
    pub parent: ::std::os::raw::c_int,
    /// The node freelist next index (free node)
    pub next: ::std::os::raw::c_int,
}
/** The dynamic tree structure. This should be considered private data.
 It is placed here for performance reasons.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3DynamicTree {
    /** The dynamic tree version. Always the first field. Useful
 if the tree is serialized.*/
    pub version: u64,
    /// The tree nodes
    pub nodes: *mut b3TreeNode,
    /// The root index
    pub root: ::std::os::raw::c_int,
    /// The number of nodes
    pub nodeCount: ::std::os::raw::c_int,
    /// The allocated node space
    pub nodeCapacity: ::std::os::raw::c_int,
    /// Number of proxies created
    pub proxyCount: ::std::os::raw::c_int,
    /// Node free list
    pub freeList: ::std::os::raw::c_int,
    /// Leaf indices for rebuild
    pub leafIndices: *mut ::std::os::raw::c_int,
    /// Leaf bounding boxes for rebuild
    pub leafBoxes: *mut b3AABB,
    /// Leaf bounding box centers for rebuild
    pub leafCenters: *mut b3Vec3,
    /// Bins for sorting during rebuild
    pub binIndices: *mut ::std::os::raw::c_int,
    /// Allocated space for rebuilding
    pub rebuildCapacity: ::std::os::raw::c_int,
}
/// These are performance results returned by dynamic tree queries.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3TreeStats {
    /// Number of internal nodes visited during the query
    pub nodeVisits: ::std::os::raw::c_int,
    /// Number of leaf nodes visited during the query
    pub leafVisits: ::std::os::raw::c_int,
}
/** This function receives proxies found in the AABB query.
 @return true if the query should continue*/
pub type b3TreeQueryCallbackFcn = ::std::option::Option<
    unsafe extern "C" fn(
        proxyId: ::std::os::raw::c_int,
        userData: u64,
        context: *mut ::std::os::raw::c_void,
    ) -> bool,
>;
/** This function receives the minimum distance squared so far and proxy to check in the closest query.
 @return minimum distance squared to user objects in the proxy*/
pub type b3TreeQueryClosestCallbackFcn = ::std::option::Option<
    unsafe extern "C" fn(
        distanceSqrMin: f32,
        proxyId: ::std::os::raw::c_int,
        userData: u64,
        context: *mut ::std::os::raw::c_void,
    ) -> f32,
>;
/** This function receives clipped AABB cast input for a proxy. The function returns the new cast
 fraction.
 - return a value of 0 to terminate the cast
 - return a value less than input->maxFraction to clip the cast
 - return a value of input->maxFraction to continue the cast without clipping*/
pub type b3TreeBoxCastCallbackFcn = ::std::option::Option<
    unsafe extern "C" fn(
        input: *const b3BoxCastInput,
        proxyId: ::std::os::raw::c_int,
        userData: u64,
        context: *mut ::std::os::raw::c_void,
    ) -> f32,
>;
/** This function receives clipped ray cast input for a proxy. The function
 returns the new ray fraction.
 - return a value of 0 to terminate the ray cast
 - return a value less than input->maxFraction to clip the ray
 - return a value of input->maxFraction to continue the ray cast without clipping*/
pub type b3TreeRayCastCallbackFcn = ::std::option::Option<
    unsafe extern "C" fn(
        input: *const b3RayCastInput,
        proxyId: ::std::os::raw::c_int,
        userData: u64,
        context: *mut ::std::os::raw::c_void,
    ) -> f32,
>;
/// The plane between a character mover and a shape
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3PlaneResult {
    /// Outward pointing plane.
    pub plane: b3Plane,
    /// Closest point on the shape. May not be unique.
    pub point: b3Vec3,
}
/** These are collision planes that can be fed to b3SolvePlanes. Normally
 this is assembled by the user from plane results in b3PlaneResult.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CollisionPlane {
    /// The collision plane between the mover and some shape.
    pub plane: b3Plane,
    /** Setting this to FLT_MAX makes the plane as rigid as possible. Lower values can
 make the plane collision soft. Usually in meters.*/
    pub pushLimit: f32,
    /// The push on the mover determined by b3SolvePlanes. Usually in meters.
    pub push: f32,
    /// Indicates if b3ClipVector should clip against this plane. Should be false for soft collision.
    pub clipVelocity: bool,
}
/// Result returned by b3SolvePlanes.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3PlaneSolverResult {
    /// The final relative translation.
    pub delta: b3Vec3,
    /// The number of iterations used by the plane solver. For diagnostics.
    pub iterationCount: ::std::os::raw::c_int,
}
/// Body plane result for movers.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3BodyPlaneResult {
    /// The shape id on the body.
    pub shapeId: b3ShapeId,
    /// The plane result.
    pub result: b3PlaneResult,
}
/** Used to collect collision planes for character movers.
 Return true to continue gathering planes.*/
pub type b3PlaneResultFcn = ::std::option::Option<
    unsafe extern "C" fn(
        shapeId: b3ShapeId,
        plane: *const b3PlaneResult,
        planeCount: ::std::os::raw::c_int,
        context: *mut ::std::os::raw::c_void,
    ) -> bool,
>;
/** Used to filter shapes for shape casting character movers.
 Return true to accept the collision*/
pub type b3MoverFilterFcn = ::std::option::Option<
    unsafe extern "C" fn(
        shapeId: b3ShapeId,
        context: *mut ::std::os::raw::c_void,
    ) -> bool,
>;
/// This holds the mass data computed for a shape.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3MassData {
    /// The shape mass
    pub mass: f32,
    /// The local center of mass position.
    pub center: b3Vec3,
    /// The inertia tensor about the shape center of mass.
    pub inertia: b3Matrix3,
}
/// A solid sphere
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Sphere {
    /// The local center
    pub center: b3Vec3,
    /// The radius
    pub radius: f32,
}
/** A solid capsule can be viewed as two hemispheres connected
 by a rectangle.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Capsule {
    /// Local center of the first hemisphere
    pub center1: b3Vec3,
    /// Local center of the second hemisphere
    pub center2: b3Vec3,
    /// The radius of the hemispheres
    pub radius: f32,
}
/// A hull vertex. Identified by a half-edge with this vertex as its tail.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3HullVertex {
    /** A half-edge that has this vertex as the origin
 Can be used along with edge twins and winding order
 to traverse all the edges connected to this vertex.*/
    pub edge: u8,
}
/// Half-edge for hull data structure
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3HullHalfEdge {
    /// Next edge index CCW
    pub next: u8,
    /// Twin edge index
    pub twin: u8,
    /// index of origin vertex and point
    pub origin: u8,
    /// Face to the left of this edge
    pub face: u8,
}
/** A hull face. Hulls use a half-edge data structure, so a face
 can be determined from a single half-edge index.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3HullFace {
    /// An arbitrary half-edge on this face
    pub edge: u8,
}
/** A convex hull.
 @note This data structure has data hanging off the end and cannot be directly copied.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3HullData {
    /// Version must be first and match B3_HULL_VERSION
    pub version: u64,
    /// The total number of bytes for this hull.
    pub byteCount: ::std::os::raw::c_int,
    /// Hash of this hull (this field is zero when the hash is computed).
    pub hash: u32,
    /// Axis-aligned box in local space.
    pub aabb: b3AABB,
    /// Surface area, typically in squared meters.
    pub surfaceArea: f32,
    /// Volume, typically in m^3.
    pub volume: f32,
    /// The radius of the largest sphere at the center.
    pub innerRadius: f32,
    /// The local centroid
    pub center: b3Vec3,
    /// The inertia tensor about the centroid.
    pub centralInertia: b3Matrix3,
    /// The vertex count.
    pub vertexCount: ::std::os::raw::c_int,
    /// Offset of the vertex array in bytes from the struct address.
    pub vertexOffset: ::std::os::raw::c_int,
    /// Offset of the point array in bytes from the struct address.
    pub pointOffset: ::std::os::raw::c_int,
    /// This is the half-edge count (double the edge count)
    pub edgeCount: ::std::os::raw::c_int,
    /// Offset of the edge array in bytes from the struct address.
    pub edgeOffset: ::std::os::raw::c_int,
    /// The face count. Hulls faces are convex polygons.
    pub faceCount: ::std::os::raw::c_int,
    /// Offset of the face plane array in bytes from the struct address.
    pub planeOffset: ::std::os::raw::c_int,
    /// Offset of the face array in bytes from the struct address.
    pub faceOffset: ::std::os::raw::c_int,
    /// Offset of structure of array (SOA) vertices
    pub soaVertexOffset: ::std::os::raw::c_int,
    /// Offset of structure of array (SOA) unit normal vectors
    pub soaNormalOffset: ::std::os::raw::c_int,
    /** Explicit padding. Hull identity is a content hash and memcmp over raw bytes,
 so there must be no unnamed padding for struct copies to scramble.*/
    pub padding: ::std::os::raw::c_int,
}
/// Efficient box hull
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3BoxHull {
    /// The embedded hull. So the offsets index into the arrays that follow.
    pub base: b3HullData,
    ///< Box vertices.
    pub boxVertices: [b3HullVertex; 8usize],
    ///< Box points.
    pub boxPoints: [b3Vec3; 8usize],
    ///< Box half-edges.
    pub boxEdges: [b3HullHalfEdge; 24usize],
    ///< Box face planes.
    pub boxPlanes: [b3Plane; 6usize],
    ///< Box faces.
    pub boxFaces: [b3HullFace; 6usize],
    ///< Explicit padding, see b3HullData::padding.
    pub padding: [u8; 10usize],
    ///< vertex x
    pub vx: [f32; 8usize],
    ///< vertex y
    pub vy: [f32; 8usize],
    ///< vertex z
    pub vz: [f32; 8usize],
    ///< normal x, padded to multiple of 4
    pub nx: [f32; 8usize],
    ///< normal y, padded to multiple of 4
    pub ny: [f32; 8usize],
    ///< normal z, padded to multiple of 4
    pub nz: [f32; 8usize],
}
/// This is used to create a re-usable collision mesh.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3MeshDef {
    /// Triangle vertices
    pub vertices: *mut b3Vec3,
    /// Triangle vertex indices. 3 for each triangle. CCW winding.
    pub indices: *mut i32,
    /** Triangle material index. 1 per triangle. Indexes into b3ShapeDef::materials.
 This allows different run-time material data to be associated with different
 instances of this mesh.*/
    pub materialIndices: *mut u8,
    /// Tolerance for vertex welding in length units.
    pub weldTolerance: f32,
    /// The vertex count. Must be 3 or more.
    pub vertexCount: ::std::os::raw::c_int,
    /// The triangle count. Must be 1 or more.
    pub triangleCount: ::std::os::raw::c_int,
    /// Optionally weld nearby vertices.
    pub weldVertices: bool,
    /** Use the median split instead of SAH to speed up mesh creation. Good
 for meshes that are structured like a grid.*/
    pub useMedianSplit: bool,
    /// Compute triangle adjacency information using shared edges
    pub identifyEdges: bool,
}
pub const b3MeshEdgeFlags_b3_concaveEdge1: b3MeshEdgeFlags = 1;
pub const b3MeshEdgeFlags_b3_concaveEdge2: b3MeshEdgeFlags = 2;
pub const b3MeshEdgeFlags_b3_concaveEdge3: b3MeshEdgeFlags = 4;
pub const b3MeshEdgeFlags_b3_inverseConcaveEdge1: b3MeshEdgeFlags = 16;
pub const b3MeshEdgeFlags_b3_inverseConcaveEdge2: b3MeshEdgeFlags = 32;
pub const b3MeshEdgeFlags_b3_inverseConcaveEdge3: b3MeshEdgeFlags = 64;
pub const b3MeshEdgeFlags_b3_allConcaveEdges: b3MeshEdgeFlags = 7;
pub const b3MeshEdgeFlags_b3_flatEdge1: b3MeshEdgeFlags = 17;
pub const b3MeshEdgeFlags_b3_flatEdge2: b3MeshEdgeFlags = 34;
pub const b3MeshEdgeFlags_b3_flatEdge3: b3MeshEdgeFlags = 68;
pub const b3MeshEdgeFlags_b3_allFlatEdges: b3MeshEdgeFlags = 119;
/// Triangle mesh edge flags.
pub type b3MeshEdgeFlags = ::std::os::raw::c_uint;
/// A mesh triangle.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3MeshTriangle {
    ///< Index of vertex 1.
    pub index1: i32,
    ///< Index of vertex 2.
    pub index2: i32,
    ///< Index of vertex 3.
    pub index3: i32,
}
/// A mesh BVH node.
#[repr(C)]
#[derive(Copy, Clone)]
pub struct b3MeshNode {
    /// The lower bound of the node AABB. Strategic placement for SIMD.
    pub lowerBound: b3Vec3,
    pub data: b3MeshNode__bindgen_ty_1,
    /// The upper bound of the node AABB.  Strategic placement for SIMD.
    pub upperBound: b3Vec3,
    /// The index of the leaf triangles.
    pub triangleOffset: u32,
}
/// Anonymous union.
#[repr(C)]
#[derive(Copy, Clone)]
pub union b3MeshNode__bindgen_ty_1 {
    pub asNode: b3MeshNode__bindgen_ty_1__bindgen_ty_1,
    pub asLeaf: b3MeshNode__bindgen_ty_1__bindgen_ty_2,
}
/// Internal node
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3MeshNode__bindgen_ty_1__bindgen_ty_1 {
    pub _bitfield_align_1: [u32; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
impl b3MeshNode__bindgen_ty_1__bindgen_ty_1 {
    #[inline]
    pub fn axis(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_axis(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn axis_raw(this: *const Self) -> u32 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 2u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_axis_raw(this: *mut Self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn childOffset(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
    }
    #[inline]
    pub fn set_childOffset(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 30u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn childOffset_raw(this: *const Self) -> u32 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 30u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_childOffset_raw(this: *mut Self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                30u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        axis: u32,
        childOffset: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                2u8,
                {
                    let axis: u32 = unsafe { ::std::mem::transmute(axis) };
                    axis as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                30u8,
                {
                    let childOffset: u32 = unsafe { ::std::mem::transmute(childOffset) };
                    childOffset as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
/// Leaf node
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3MeshNode__bindgen_ty_1__bindgen_ty_2 {
    pub _bitfield_align_1: [u32; 0],
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize]>,
}
impl b3MeshNode__bindgen_ty_1__bindgen_ty_2 {
    #[inline]
    pub fn type_(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
    }
    #[inline]
    pub fn set_type(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 2u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn type__raw(this: *const Self) -> u32 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 0usize, 2u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_type_raw(this: *mut Self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                0usize,
                2u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn triangleCount(&self) -> u32 {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 30u8) as u32) }
    }
    #[inline]
    pub fn set_triangleCount(&mut self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(2usize, 30u8, val as u64)
        }
    }
    #[inline]
    pub unsafe fn triangleCount_raw(this: *const Self) -> u32 {
        unsafe {
            ::std::mem::transmute(
                <__BindgenBitfieldUnit<
                    [u8; 4usize],
                >>::raw_get(::std::ptr::addr_of!((*this)._bitfield_1), 2usize, 30u8)
                    as u32,
            )
        }
    }
    #[inline]
    pub unsafe fn set_triangleCount_raw(this: *mut Self, val: u32) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            <__BindgenBitfieldUnit<
                [u8; 4usize],
            >>::raw_set(
                ::std::ptr::addr_of_mut!((*this)._bitfield_1),
                2usize,
                30u8,
                val as u64,
            )
        }
    }
    #[inline]
    pub fn new_bitfield_1(
        type_: u32,
        triangleCount: u32,
    ) -> __BindgenBitfieldUnit<[u8; 4usize]> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize]> = Default::default();
        __bindgen_bitfield_unit
            .set(
                0usize,
                2u8,
                {
                    let type_: u32 = unsafe { ::std::mem::transmute(type_) };
                    type_ as u64
                },
            );
        __bindgen_bitfield_unit
            .set(
                2usize,
                30u8,
                {
                    let triangleCount: u32 = unsafe {
                        ::std::mem::transmute(triangleCount)
                    };
                    triangleCount as u64
                },
            );
        __bindgen_bitfield_unit
    }
}
/** This is a sorted triangle collision bounding volume hierarchy.
 @note This struct has data hanging off the end and cannot be directly copied.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3MeshData {
    /// Version must be first.
    pub version: u64,
    /// The total number of bytes for this mesh.
    pub byteCount: ::std::os::raw::c_int,
    /// Hash of this mesh (this field is zero when the hash is computed)
    pub hash: u32,
    /// Local axis-aligned box.
    pub bounds: b3AABB,
    /// Combined surface area of all triangles. Single-sided.
    pub surfaceArea: f32,
    /// The height of the bounding volume hierarchy.
    pub treeHeight: ::std::os::raw::c_int,
    /// The number of degenerate triangles. Diagnostic.
    pub degenerateCount: ::std::os::raw::c_int,
    /// Offset of the node array in bytes from the struct address.
    pub nodeOffset: ::std::os::raw::c_int,
    /// The number of BVH nodes.
    pub nodeCount: ::std::os::raw::c_int,
    /// Offset of the vertex array in bytes from the struct address.
    pub vertexOffset: ::std::os::raw::c_int,
    /// The number of vertices.
    pub vertexCount: ::std::os::raw::c_int,
    /// Offset of the triangle array in bytes from the struct address.
    pub triangleOffset: ::std::os::raw::c_int,
    /// The number of triangles.
    pub triangleCount: ::std::os::raw::c_int,
    /// Offset of the material array in bytes from the struct address.
    pub materialOffset: ::std::os::raw::c_int,
    /// The number of materials.
    pub materialCount: ::std::os::raw::c_int,
    /// Offset of the triangle flag array in bytes from the struct address.
    pub flagsOffset: ::std::os::raw::c_int,
}
/// This allows mesh data to be re-used with different scales.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Mesh {
    /// Immutable pointer to the mesh data.
    pub data: *const b3MeshData,
    /** This scale may be non-uniform and have negative components. However,
 no component may be very small in magnitude.*/
    pub scale: b3Vec3,
}
/// Data used to create a height field
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3HeightFieldDef {
    /** Grid point heights
 count = countX * countZ*/
    pub heights: *mut f32,
    /** Grid cell material
 A value of 0xFF is reserved for holes
 count = (countX - 1) * (countZ - 1)*/
    pub materialIndices: *mut u8,
    /// The height field scale. All components must be positive values.
    pub scale: b3Vec3,
    /// The number of grid lines along the x-axis.
    pub countX: ::std::os::raw::c_int,
    /// The number of grid lines along the z-axis.
    pub countZ: ::std::os::raw::c_int,
    /** Global minimum and maximum heights used for quantization. This is important
 if you want height fields to be placed next to each other and line up exactly.
 In that case, both height fields should use the same minimum and maximum heights.
 All height values are clamped to this range.
 These values are in unscaled space.*/
    pub globalMinimumHeight: f32,
    /// The maximum.
    pub globalMaximumHeight: f32,
    /// Use clock-wise winding. This effectively inverts the height-field along the y-axis.
    pub clockwiseWinding: bool,
}
/** A height field with compressed storage.
 @note This data structure has data hanging off the end and cannot be directly copied.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3HeightFieldData {
    /// Version must be first and match B3_HEIGHT_FIELD_VERSION
    pub version: u64,
    /// The total number of bytes for this height field.
    pub byteCount: ::std::os::raw::c_int,
    /// Hash of this height field (this field is zero when the hash is computed).
    pub hash: u32,
    /// The local axis-aligned bounding box.
    pub aabb: b3AABB,
    /// The minimum y value.
    pub minHeight: f32,
    /// The maximum y value
    pub maxHeight: f32,
    /// The quantization scale.
    pub heightScale: f32,
    /// The overall scale.
    pub scale: b3Vec3,
    /// The number of grid columns along the local x-axis.
    pub columnCount: ::std::os::raw::c_int,
    /// The number of grid rows along the local z-axis.
    pub rowCount: ::std::os::raw::c_int,
    /** Offset of the compressed height array in bytes from the struct address.
 uint16_t, one per grid point.*/
    pub heightsOffset: ::std::os::raw::c_int,
    /** Offset of the material index array in bytes from the struct address.
 uint8_t, one per cell.*/
    pub materialOffset: ::std::os::raw::c_int,
    /** Offset of the flag array in bytes from the struct address.
 uint8_t, one per triangle.*/
    pub flagsOffset: ::std::os::raw::c_int,
    /// Triangle winding.
    pub clockwise: bool,
    /** Explicit padding. Identity is a content hash over raw bytes, so there must
 be no unnamed padding for struct copies to scramble.*/
    pub padding: [u8; 3usize],
}
/// Definition for a capsule in a compound shape.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CompoundCapsuleDef {
    /// Local capsule.
    pub capsule: b3Capsule,
    /// Material properties.
    pub material: b3SurfaceMaterial,
}
/// Definition for a convex hull in a compound shape.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CompoundHullDef {
    /// Shared hull.
    pub hull: *const b3HullData,
    /// Transform of the shared hull into compound local space.
    pub transform: b3Transform,
    /// Material properties.
    pub material: b3SurfaceMaterial,
}
/// Definition for a triangle mesh in a compound shape.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CompoundMeshDef {
    /// Shared mesh.
    pub meshData: *const b3MeshData,
    /// Transform of the shared mesh into compound local space.
    pub transform: b3Transform,
    /// Local space non-uniform mesh scale. May have negative components.
    pub scale: b3Vec3,
    /** Material properties.
 This array must line up with the material indices on the triangles.*/
    pub materials: *const b3SurfaceMaterial,
    /// Number of materials.
    pub materialCount: ::std::os::raw::c_int,
}
/// Definition for a sphere in a compound shape.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CompoundSphereDef {
    /// Local sphere.
    pub sphere: b3Sphere,
    /// Material properties.
    pub material: b3SurfaceMaterial,
}
/** Definition for creating a compound shape. All this data is fully cloned
 into the run-time compound shape.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CompoundDef {
    /// Capsule instances.
    pub capsules: *mut b3CompoundCapsuleDef,
    /// Number of capsules.
    pub capsuleCount: ::std::os::raw::c_int,
    /// Hulls instances.
    pub hulls: *mut b3CompoundHullDef,
    /// Number of hull instances.
    pub hullCount: ::std::os::raw::c_int,
    /// Mesh instances.
    pub meshes: *mut b3CompoundMeshDef,
    /// Number of mesh instances.
    pub meshCount: ::std::os::raw::c_int,
    /// Sphere instances.
    pub spheres: *mut b3CompoundSphereDef,
    /// Number of spheres.
    pub sphereCount: ::std::os::raw::c_int,
}
/** The data for a baked compound shape. This is a potentially large yet highly optimized
 data structure. It can contain thousands of child shapes, yet at runtime it populates
 into the world as a single shape in the runtime broad-phase.
 This data structure has data living off the end and must be accessed using offsets.
 Accessors are provided for user relevant data.
 Note: you don't need to use this to create runtime compounds. For runtime compounds you can
 add multiple shapes to a body using the regular shape creation functions.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CompoundData {
    /// The compound version is always first.
    pub version: u64,
    /// The total number of bytes for this compound.
    pub byteCount: ::std::os::raw::c_int,
    /// Offset of the tree node array in bytes from the struct address.
    pub nodeOffset: ::std::os::raw::c_int,
    /// Immutable dynamic tree. The tree node pointer must be fixed up using the node offset
    pub tree: b3DynamicTree,
    /// Offset of the material array in bytes from the struct address.
    pub materialOffset: ::std::os::raw::c_int,
    /// The number of materials.
    pub materialCount: ::std::os::raw::c_int,
    /// Offset of the capsule array in bytes from the struct address.
    pub capsuleOffset: ::std::os::raw::c_int,
    /// The number of capsules.
    pub capsuleCount: ::std::os::raw::c_int,
    /// Offset of the hull instance array in bytes from the struct address.
    pub hullOffset: ::std::os::raw::c_int,
    /// The number of hull instances.
    pub hullCount: ::std::os::raw::c_int,
    /// The number of unique hulls. Diagnostic.
    pub sharedHullCount: ::std::os::raw::c_int,
    /// Offset of the mesh instance array in bytes from the struct address.
    pub meshOffset: ::std::os::raw::c_int,
    /// The number of mesh instances.
    pub meshCount: ::std::os::raw::c_int,
    /// The number of unique meshes. Diagnostic.
    pub sharedMeshCount: ::std::os::raw::c_int,
    /// Offset of the sphere array in bytes from the struct address.
    pub sphereOffset: ::std::os::raw::c_int,
    /// The number of spheres.
    pub sphereCount: ::std::os::raw::c_int,
}
/// A capsule that lives in a compound.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CompoundCapsule {
    /// Local capsule.
    pub capsule: b3Capsule,
    /// Index to a shared material.
    pub materialIndex: ::std::os::raw::c_int,
}
/// A hull that lives in a compound.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CompoundHull {
    /// Pointer to the unique shared hull.
    pub hull: *const b3HullData,
    /// The transform of this hull instance.
    pub transform: b3Transform,
    /// Index to a shared material.
    pub materialIndex: ::std::os::raw::c_int,
}
/// A mesh with non-uniform scale that lives in a compound.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CompoundMesh {
    /// Pointer to the unique shared mesh.
    pub meshData: *const b3MeshData,
    /// The transform of this mesh instance.
    pub transform: b3Transform,
    /// Non-uniform scale of this mesh instance.
    pub scale: b3Vec3,
    /** This is used to access the surface material from b3GetCompoundMaterials.
 Requires an extra level of indirection. The triangle material index
 is clamped to B3_MAX_COMPOUND_MESH_MATERIALS.
 materialIndex = materialIndices[triangle->materialIndex]*/
    pub materialIndices: [::std::os::raw::c_int; 4usize],
}
/// A sphere that lives in a compound.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3CompoundSphere {
    /// Local sphere.
    pub sphere: b3Sphere,
    /// Index to a shared material.
    pub materialIndex: ::std::os::raw::c_int,
}
/// Child shape of a compound
#[repr(C)]
#[derive(Copy, Clone)]
pub struct b3ChildShape {
    pub __bindgen_anon_1: b3ChildShape__bindgen_ty_1,
    /// Transform of the shape into compound local space.
    pub transform: b3Transform,
    /** Material indices. Index 0 is used for convex shapes.
 todo limit to 64K?*/
    pub materialIndices: [::std::os::raw::c_int; 4usize],
    /// The shape type (union tag).
    pub type_: b3ShapeType,
}
/// Tagged union.
#[repr(C)]
#[derive(Copy, Clone)]
pub union b3ChildShape__bindgen_ty_1 {
    ///< Capsule.
    pub capsule: b3Capsule,
    ///< Hull.
    pub hull: *const b3HullData,
    ///< Mesh.
    pub mesh: b3Mesh,
    ///< Sphere.
    pub sphere: b3Sphere,
}
/// Callback for compound overlap queries.
pub type b3CompoundQueryFcn = ::std::option::Option<
    unsafe extern "C" fn(
        compound: *const b3CompoundData,
        childIndex: ::std::os::raw::c_int,
        context: *mut ::std::os::raw::c_void,
    ) -> bool,
>;
/** A manifold point is a contact point belonging to a contact manifold.
 It holds details related to the geometry and dynamics of the contact points.
 Box3D uses speculative collision so some contact points may be separated.
 You may use the maxNormalImpulse to determine if there was an interaction during
 the time step.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3ManifoldPoint {
    /// Location of the contact point relative to the bodyA center of mass in world space.
    pub anchorA: b3Vec3,
    /// Location of the contact point relative to the bodyB center of mass in world space.
    pub anchorB: b3Vec3,
    /// The separation of the contact point, negative if penetrating
    pub separation: f32,
    /// Cached separation used for contact recycling
    pub baseSeparation: f32,
    /** The impulse along the manifold normal vector. Since Box3D uses sub-stepping, this is
 result from the final sub-step.*/
    pub normalImpulse: f32,
    /** The total normal impulse applied during sub-stepping. This is important
 to identify speculative contact points that had an interaction in the time step.*/
    pub totalNormalImpulse: f32,
    /** Relative normal velocity pre-solve. Used for hit events. If the normal impulse is
 zero then there was no hit. Negative means shapes are approaching.*/
    pub normalVelocity: f32,
    /** Local point for matching
 Uniquely identifies a contact point between two shapes*/
    pub featureId: u32,
    /// Triangle index if one of the shapes is a mesh or height field
    pub triangleIndex: ::std::os::raw::c_int,
    /// Did this contact point exist in the previous step?
    pub persisted: bool,
}
/** A contact manifold describes the contact points between colliding shapes.
 @note Box3D uses speculative collision so some contact points may be separated.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Manifold {
    /// The manifold points. There may be 1 to 4 valid points.
    pub points: [b3ManifoldPoint; 4usize],
    /// The unit normal vector in world space, points from shape A to shape B
    pub normal: b3Vec3,
    /// Central friction angular impulse (applied about the normal)
    pub twistImpulse: f32,
    /// Central friction linear impulse
    pub frictionImpulse: b3Vec3,
    /// Rolling resistance angular impulse
    pub rollingImpulse: b3Vec3,
    /// The number of contact points, will be 0 to 4
    pub pointCount: ::std::os::raw::c_int,
}
pub const b3SeparatingFeature_b3_invalidAxis: b3SeparatingFeature = 0;
pub const b3SeparatingFeature_b3_backsideAxis: b3SeparatingFeature = 1;
pub const b3SeparatingFeature_b3_faceAxisA: b3SeparatingFeature = 2;
pub const b3SeparatingFeature_b3_faceAxisB: b3SeparatingFeature = 3;
pub const b3SeparatingFeature_b3_edgePairAxis: b3SeparatingFeature = 4;
pub const b3SeparatingFeature_b3_closestPointsAxis: b3SeparatingFeature = 5;
/// These are for testing
pub const b3SeparatingFeature_b3_manualFaceAxisA: b3SeparatingFeature = 6;
/// These are for testing
pub const b3SeparatingFeature_b3_manualFaceAxisB: b3SeparatingFeature = 7;
/// These are for testing
pub const b3SeparatingFeature_b3_manualEdgePairAxis: b3SeparatingFeature = 8;
/// Cached separating axis feature.
pub type b3SeparatingFeature = ::std::os::raw::c_uint;
pub const b3TriangleFeature_b3_featureNone: b3TriangleFeature = 0;
pub const b3TriangleFeature_b3_featureTriangleFace: b3TriangleFeature = 1;
pub const b3TriangleFeature_b3_featureHullFace: b3TriangleFeature = 2;
/// v1-v2
pub const b3TriangleFeature_b3_featureEdge1: b3TriangleFeature = 3;
/// v2-v3
pub const b3TriangleFeature_b3_featureEdge2: b3TriangleFeature = 4;
/// v3-v1
pub const b3TriangleFeature_b3_featureEdge3: b3TriangleFeature = 5;
/// v3-v1
pub const b3TriangleFeature_b3_featureVertex1: b3TriangleFeature = 6;
/// v3-v1
pub const b3TriangleFeature_b3_featureVertex2: b3TriangleFeature = 7;
/// v3-v1
pub const b3TriangleFeature_b3_featureVertex3: b3TriangleFeature = 8;
/// Cached triangle feature.
pub type b3TriangleFeature = ::std::os::raw::c_uint;
/// Separating axis test cache. Provides temporal acceleration of collision routines.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3SATCache {
    /// The separation when the cache is populated. Negative for overlap.
    pub separation: f32,
    /// b3SeparatingFeature.
    pub type_: u8,
    /// Index of the feature on shape A.
    pub indexA: u8,
    /// Index of the feature on shape B.
    pub indexB: u8,
    /// Was the cache re-used?
    pub hit: u8,
}
/** Contact points are always the result of two edges intersecting.
 It can be two edges of the same shape, which is just a shape vertex.
 Or a contact point can be the result of two edges crossing from different shapes.
 This is designed to support hull versus hull, but it is adapted to work
 with all shape types. The feature pair is used to identify contact points
 for temporal coherence and warm starting.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3FeaturePair {
    /// Incoming type (either edge on shape A or shape B)
    pub owner1: u8,
    /// Incoming edge index (into associated shape array)
    pub index1: u8,
    /// Outgoing type (either edge on shape A or shape B)
    pub owner2: u8,
    /// Outgoing edge index (into associated shape array)
    pub index2: u8,
}
/// A local manifold point and normal in frame A.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3LocalManifoldPoint {
    /// Local point in frame A.
    pub point: b3Vec3,
    /// The contact point separation. Negative for overlap.
    pub separation: f32,
    /// The feature pair for this point.
    pub pair: b3FeaturePair,
    /// The triangle index when collide with a mesh or height-field.
    pub triangleIndex: ::std::os::raw::c_int,
}
/// A local manifold with no dynamic information. Used by b3Collide functions.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3LocalManifold {
    /// Local normal in frame A.
    pub normal: b3Vec3,
    /// The triangle normal.
    pub triangleNormal: b3Vec3,
    /// The manifold points. From a point buffer.
    pub points: *mut b3LocalManifoldPoint,
    /// The number of manifold points. Only bounded by the buffer capacity.
    pub pointCount: ::std::os::raw::c_int,
    /// The index of the triangle.
    pub triangleIndex: ::std::os::raw::c_int,
    ///< Vertex 1 index.
    pub i1: ::std::os::raw::c_int,
    ///< Vertex 2 index.
    pub i2: ::std::os::raw::c_int,
    ///< Vertex 3 index.
    pub i3: ::std::os::raw::c_int,
    /// The squared distance of a sphere from a triangle. For ghost collision reduction.
    pub squaredDistance: f32,
    /// The triangle feature involved.
    pub feature: b3TriangleFeature,
    /// b3MeshEdgeFlags.
    pub triangleFlags: ::std::os::raw::c_int,
}
pub const b3HexColor_b3_colorAliceBlue: b3HexColor = 15792383;
pub const b3HexColor_b3_colorAntiqueWhite: b3HexColor = 16444375;
pub const b3HexColor_b3_colorAqua: b3HexColor = 65535;
pub const b3HexColor_b3_colorAquamarine: b3HexColor = 8388564;
pub const b3HexColor_b3_colorAzure: b3HexColor = 15794175;
pub const b3HexColor_b3_colorBeige: b3HexColor = 16119260;
pub const b3HexColor_b3_colorBisque: b3HexColor = 16770244;
pub const b3HexColor_b3_colorBlack: b3HexColor = 0;
pub const b3HexColor_b3_colorBlanchedAlmond: b3HexColor = 16772045;
pub const b3HexColor_b3_colorBlue: b3HexColor = 255;
pub const b3HexColor_b3_colorBlueViolet: b3HexColor = 9055202;
pub const b3HexColor_b3_colorBrown: b3HexColor = 10824234;
pub const b3HexColor_b3_colorBurlywood: b3HexColor = 14596231;
pub const b3HexColor_b3_colorCadetBlue: b3HexColor = 6266528;
pub const b3HexColor_b3_colorChartreuse: b3HexColor = 8388352;
pub const b3HexColor_b3_colorChocolate: b3HexColor = 13789470;
pub const b3HexColor_b3_colorCoral: b3HexColor = 16744272;
pub const b3HexColor_b3_colorCornflowerBlue: b3HexColor = 6591981;
pub const b3HexColor_b3_colorCornsilk: b3HexColor = 16775388;
pub const b3HexColor_b3_colorCrimson: b3HexColor = 14423100;
pub const b3HexColor_b3_colorCyan: b3HexColor = 65535;
pub const b3HexColor_b3_colorDarkBlue: b3HexColor = 139;
pub const b3HexColor_b3_colorDarkCyan: b3HexColor = 35723;
pub const b3HexColor_b3_colorDarkGoldenRod: b3HexColor = 12092939;
pub const b3HexColor_b3_colorDarkGray: b3HexColor = 11119017;
pub const b3HexColor_b3_colorDarkGreen: b3HexColor = 25600;
pub const b3HexColor_b3_colorDarkKhaki: b3HexColor = 12433259;
pub const b3HexColor_b3_colorDarkMagenta: b3HexColor = 9109643;
pub const b3HexColor_b3_colorDarkOliveGreen: b3HexColor = 5597999;
pub const b3HexColor_b3_colorDarkOrange: b3HexColor = 16747520;
pub const b3HexColor_b3_colorDarkOrchid: b3HexColor = 10040012;
pub const b3HexColor_b3_colorDarkRed: b3HexColor = 9109504;
pub const b3HexColor_b3_colorDarkSalmon: b3HexColor = 15308410;
pub const b3HexColor_b3_colorDarkSeaGreen: b3HexColor = 9419919;
pub const b3HexColor_b3_colorDarkSlateBlue: b3HexColor = 4734347;
pub const b3HexColor_b3_colorDarkSlateGray: b3HexColor = 3100495;
pub const b3HexColor_b3_colorDarkTurquoise: b3HexColor = 52945;
pub const b3HexColor_b3_colorDarkViolet: b3HexColor = 9699539;
pub const b3HexColor_b3_colorDeepPink: b3HexColor = 16716947;
pub const b3HexColor_b3_colorDeepSkyBlue: b3HexColor = 49151;
pub const b3HexColor_b3_colorDimGray: b3HexColor = 6908265;
pub const b3HexColor_b3_colorDodgerBlue: b3HexColor = 2003199;
pub const b3HexColor_b3_colorFireBrick: b3HexColor = 11674146;
pub const b3HexColor_b3_colorFloralWhite: b3HexColor = 16775920;
pub const b3HexColor_b3_colorForestGreen: b3HexColor = 2263842;
pub const b3HexColor_b3_colorFuchsia: b3HexColor = 16711935;
pub const b3HexColor_b3_colorGainsboro: b3HexColor = 14474460;
pub const b3HexColor_b3_colorGhostWhite: b3HexColor = 16316671;
pub const b3HexColor_b3_colorGold: b3HexColor = 16766720;
pub const b3HexColor_b3_colorGoldenRod: b3HexColor = 14329120;
pub const b3HexColor_b3_colorGray: b3HexColor = 8421504;
pub const b3HexColor_b3_colorGreen: b3HexColor = 32768;
pub const b3HexColor_b3_colorGreenYellow: b3HexColor = 11403055;
pub const b3HexColor_b3_colorHoneyDew: b3HexColor = 15794160;
pub const b3HexColor_b3_colorHotPink: b3HexColor = 16738740;
pub const b3HexColor_b3_colorIndianRed: b3HexColor = 13458524;
pub const b3HexColor_b3_colorIndigo: b3HexColor = 4915330;
pub const b3HexColor_b3_colorIvory: b3HexColor = 16777200;
pub const b3HexColor_b3_colorKhaki: b3HexColor = 15787660;
pub const b3HexColor_b3_colorLavender: b3HexColor = 15132410;
pub const b3HexColor_b3_colorLavenderBlush: b3HexColor = 16773365;
pub const b3HexColor_b3_colorLawnGreen: b3HexColor = 8190976;
pub const b3HexColor_b3_colorLemonChiffon: b3HexColor = 16775885;
pub const b3HexColor_b3_colorLightBlue: b3HexColor = 11393254;
pub const b3HexColor_b3_colorLightCoral: b3HexColor = 15761536;
pub const b3HexColor_b3_colorLightCyan: b3HexColor = 14745599;
pub const b3HexColor_b3_colorLightGoldenRodYellow: b3HexColor = 16448210;
pub const b3HexColor_b3_colorLightGray: b3HexColor = 13882323;
pub const b3HexColor_b3_colorLightGreen: b3HexColor = 9498256;
pub const b3HexColor_b3_colorLightPink: b3HexColor = 16758465;
pub const b3HexColor_b3_colorLightSalmon: b3HexColor = 16752762;
pub const b3HexColor_b3_colorLightSeaGreen: b3HexColor = 2142890;
pub const b3HexColor_b3_colorLightSkyBlue: b3HexColor = 8900346;
pub const b3HexColor_b3_colorLightSlateGray: b3HexColor = 7833753;
pub const b3HexColor_b3_colorLightSteelBlue: b3HexColor = 11584734;
pub const b3HexColor_b3_colorLightYellow: b3HexColor = 16777184;
pub const b3HexColor_b3_colorLime: b3HexColor = 65280;
pub const b3HexColor_b3_colorLimeGreen: b3HexColor = 3329330;
pub const b3HexColor_b3_colorLinen: b3HexColor = 16445670;
pub const b3HexColor_b3_colorMagenta: b3HexColor = 16711935;
pub const b3HexColor_b3_colorMaroon: b3HexColor = 8388608;
pub const b3HexColor_b3_colorMediumAquaMarine: b3HexColor = 6737322;
pub const b3HexColor_b3_colorMediumBlue: b3HexColor = 205;
pub const b3HexColor_b3_colorMediumOrchid: b3HexColor = 12211667;
pub const b3HexColor_b3_colorMediumPurple: b3HexColor = 9662683;
pub const b3HexColor_b3_colorMediumSeaGreen: b3HexColor = 3978097;
pub const b3HexColor_b3_colorMediumSlateBlue: b3HexColor = 8087790;
pub const b3HexColor_b3_colorMediumSpringGreen: b3HexColor = 64154;
pub const b3HexColor_b3_colorMediumTurquoise: b3HexColor = 4772300;
pub const b3HexColor_b3_colorMediumVioletRed: b3HexColor = 13047173;
pub const b3HexColor_b3_colorMidnightBlue: b3HexColor = 1644912;
pub const b3HexColor_b3_colorMintCream: b3HexColor = 16121850;
pub const b3HexColor_b3_colorMistyRose: b3HexColor = 16770273;
pub const b3HexColor_b3_colorMoccasin: b3HexColor = 16770229;
pub const b3HexColor_b3_colorNavajoWhite: b3HexColor = 16768685;
pub const b3HexColor_b3_colorNavy: b3HexColor = 128;
pub const b3HexColor_b3_colorOldLace: b3HexColor = 16643558;
pub const b3HexColor_b3_colorOlive: b3HexColor = 8421376;
pub const b3HexColor_b3_colorOliveDrab: b3HexColor = 7048739;
pub const b3HexColor_b3_colorOrange: b3HexColor = 16753920;
pub const b3HexColor_b3_colorOrangeRed: b3HexColor = 16729344;
pub const b3HexColor_b3_colorOrchid: b3HexColor = 14315734;
pub const b3HexColor_b3_colorPaleGoldenRod: b3HexColor = 15657130;
pub const b3HexColor_b3_colorPaleGreen: b3HexColor = 10025880;
pub const b3HexColor_b3_colorPaleTurquoise: b3HexColor = 11529966;
pub const b3HexColor_b3_colorPaleVioletRed: b3HexColor = 14381203;
pub const b3HexColor_b3_colorPapayaWhip: b3HexColor = 16773077;
pub const b3HexColor_b3_colorPeachPuff: b3HexColor = 16767673;
pub const b3HexColor_b3_colorPeru: b3HexColor = 13468991;
pub const b3HexColor_b3_colorPink: b3HexColor = 16761035;
pub const b3HexColor_b3_colorPlum: b3HexColor = 14524637;
pub const b3HexColor_b3_colorPowderBlue: b3HexColor = 11591910;
pub const b3HexColor_b3_colorPurple: b3HexColor = 8388736;
pub const b3HexColor_b3_colorRebeccaPurple: b3HexColor = 6697881;
pub const b3HexColor_b3_colorRed: b3HexColor = 16711680;
pub const b3HexColor_b3_colorRosyBrown: b3HexColor = 12357519;
pub const b3HexColor_b3_colorRoyalBlue: b3HexColor = 4286945;
pub const b3HexColor_b3_colorSaddleBrown: b3HexColor = 9127187;
pub const b3HexColor_b3_colorSalmon: b3HexColor = 16416882;
pub const b3HexColor_b3_colorSandyBrown: b3HexColor = 16032864;
pub const b3HexColor_b3_colorSeaGreen: b3HexColor = 3050327;
pub const b3HexColor_b3_colorSeaShell: b3HexColor = 16774638;
pub const b3HexColor_b3_colorSienna: b3HexColor = 10506797;
pub const b3HexColor_b3_colorSilver: b3HexColor = 12632256;
pub const b3HexColor_b3_colorSkyBlue: b3HexColor = 8900331;
pub const b3HexColor_b3_colorSlateBlue: b3HexColor = 6970061;
pub const b3HexColor_b3_colorSlateGray: b3HexColor = 7372944;
pub const b3HexColor_b3_colorSnow: b3HexColor = 16775930;
pub const b3HexColor_b3_colorSpringGreen: b3HexColor = 65407;
pub const b3HexColor_b3_colorSteelBlue: b3HexColor = 4620980;
pub const b3HexColor_b3_colorTan: b3HexColor = 13808780;
pub const b3HexColor_b3_colorTeal: b3HexColor = 32896;
pub const b3HexColor_b3_colorThistle: b3HexColor = 14204888;
pub const b3HexColor_b3_colorTomato: b3HexColor = 16737095;
pub const b3HexColor_b3_colorTurquoise: b3HexColor = 4251856;
pub const b3HexColor_b3_colorViolet: b3HexColor = 15631086;
pub const b3HexColor_b3_colorWheat: b3HexColor = 16113331;
pub const b3HexColor_b3_colorWhite: b3HexColor = 16777215;
pub const b3HexColor_b3_colorWhiteSmoke: b3HexColor = 16119285;
pub const b3HexColor_b3_colorYellow: b3HexColor = 16776960;
pub const b3HexColor_b3_colorYellowGreen: b3HexColor = 10145074;
pub const b3HexColor_b3_colorBox2DRed: b3HexColor = 14430514;
pub const b3HexColor_b3_colorBox2DBlue: b3HexColor = 3190463;
pub const b3HexColor_b3_colorBox2DGreen: b3HexColor = 9226532;
pub const b3HexColor_b3_colorBox2DYellow: b3HexColor = 16772748;
/** These colors are used for debug draw and mostly match the named SVG colors.
 See https://www.rapidtables.com/web/color/index.html
 https://johndecember.com/html/spec/colorsvg.html
 https://upload.wikimedia.org/wikipedia/commons/2/2b/SVG_Recognized_color_keyword_names.svg*/
pub type b3HexColor = ::std::os::raw::c_uint;
pub const b3DebugMaterial_b3_debugMaterialDefault: b3DebugMaterial = 0;
pub const b3DebugMaterial_b3_debugMaterialMatte: b3DebugMaterial = 1;
pub const b3DebugMaterial_b3_debugMaterialSoft: b3DebugMaterial = 2;
pub const b3DebugMaterial_b3_debugMaterialDead: b3DebugMaterial = 3;
pub const b3DebugMaterial_b3_debugMaterialGlossy: b3DebugMaterial = 4;
pub const b3DebugMaterial_b3_debugMaterialMetallic: b3DebugMaterial = 5;
/** Debug draw material preset. Optionally packed into the unused high byte of a
 b3HexColor (or b3SurfaceMaterial::customColor) to drive the renderer's PBR
 roughness and metalness. The low 24 bits stay RGB, so a plain 0xRRGGBB color
 reads as b3_debugMaterialDefault and keeps the renderer's per-body-type look.*/
pub type b3DebugMaterial = ::std::os::raw::c_uint;
unsafe extern "C" {
    /** Get the visualization color assigned to a constraint graph color slot. The last index
 (B3_GRAPH_COLOR_COUNT - 1) is the overflow color.*/
    pub fn b3GetGraphColor(index: ::std::os::raw::c_int) -> b3HexColor;
}
/** This is sent to the user for debug shape creation. The user should know the type in case they have
 custom sphere or capsule rendering.*/
#[repr(C)]
#[derive(Copy, Clone)]
pub struct b3DebugShape {
    /// Shape id.
    pub shapeId: b3ShapeId,
    /// Shape type.
    pub type_: b3ShapeType,
    pub __bindgen_anon_1: b3DebugShape__bindgen_ty_1,
}
/// Tagged union.
#[repr(C)]
#[derive(Copy, Clone)]
pub union b3DebugShape__bindgen_ty_1 {
    ///< Capsule shape.
    pub capsule: *const b3Capsule,
    ///< Compound shape.
    pub compound: *const b3CompoundData,
    ///< Height-field shape.
    pub heightField: *const b3HeightFieldData,
    ///< Convex hull shape.
    pub hull: *const b3HullData,
    ///< Mesh shape with scale.
    pub mesh: *const b3Mesh,
    ///< Sphere shape.
    pub sphere: *const b3Sphere,
}
/** This struct is passed to b3World_Draw to draw a debug view of the simulation world.
 Callbacks receive world coordinates. In large world mode the translation is double precision so
 it stays accurate far from the origin. Shift into your own camera frame inside the callbacks.*/
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3DebugDraw {
    /** Draws a user shape. The userShape pointer is owned by the application and is known to Box3D as
 an opaque pointer returned from b3CreateDebugShapeCallback. When this is called the drawn shape has
 passed a culling test against drawingBounds below.*/
    pub DrawShapeFcn: ::std::option::Option<
        unsafe extern "C" fn(
            userShape: *mut ::std::os::raw::c_void,
            transform: b3WorldTransform,
            color: b3HexColor,
            context: *mut ::std::os::raw::c_void,
        ),
    >,
    /// Draw a line segment.
    pub DrawSegmentFcn: ::std::option::Option<
        unsafe extern "C" fn(
            p1: b3Pos,
            p2: b3Pos,
            color: b3HexColor,
            context: *mut ::std::os::raw::c_void,
        ),
    >,
    /// Draw a transform. Choose your own length scale.
    pub DrawTransformFcn: ::std::option::Option<
        unsafe extern "C" fn(
            transform: b3WorldTransform,
            context: *mut ::std::os::raw::c_void,
        ),
    >,
    /// Draw a point.
    pub DrawPointFcn: ::std::option::Option<
        unsafe extern "C" fn(
            p: b3Pos,
            size: f32,
            color: b3HexColor,
            context: *mut ::std::os::raw::c_void,
        ),
    >,
    /// Draw a sphere.
    pub DrawSphereFcn: ::std::option::Option<
        unsafe extern "C" fn(
            p: b3Pos,
            radius: f32,
            color: b3HexColor,
            alpha: f32,
            context: *mut ::std::os::raw::c_void,
        ),
    >,
    /// Draw a capsule.
    pub DrawCapsuleFcn: ::std::option::Option<
        unsafe extern "C" fn(
            p1: b3Pos,
            p2: b3Pos,
            radius: f32,
            color: b3HexColor,
            alpha: f32,
            context: *mut ::std::os::raw::c_void,
        ),
    >,
    /// Draw a bounding box.
    pub DrawBoundsFcn: ::std::option::Option<
        unsafe extern "C" fn(
            aabb: b3AABB,
            color: b3HexColor,
            context: *mut ::std::os::raw::c_void,
        ),
    >,
    /// Draw an oriented box.
    pub DrawBoxFcn: ::std::option::Option<
        unsafe extern "C" fn(
            extents: b3Vec3,
            transform: b3WorldTransform,
            color: b3HexColor,
            context: *mut ::std::os::raw::c_void,
        ),
    >,
    /// Draw a string in world space
    pub DrawStringFcn: ::std::option::Option<
        unsafe extern "C" fn(
            p: b3Pos,
            s: *const ::std::os::raw::c_char,
            color: b3HexColor,
            context: *mut ::std::os::raw::c_void,
        ),
    >,
    /// World bounds to use for debug draw
    pub drawingBounds: b3AABB,
    /// Scale to use when drawing forces
    pub forceScale: f32,
    /// Global scaling for joint drawing
    pub jointScale: f32,
    /// Option to draw shapes
    pub drawShapes: bool,
    /// Option to draw joints
    pub drawJoints: bool,
    /// Option to draw additional information for joints
    pub drawJointExtras: bool,
    /// Option to draw the bounding boxes for shapes
    pub drawBounds: bool,
    /// Option to draw the mass and center of mass of dynamic bodies
    pub drawMass: bool,
    /// Option to draw the sleep information for dynamic and kinematic bodies
    pub drawSleep: bool,
    /// Option to draw body names
    pub drawBodyNames: bool,
    /// Option to draw contact points
    pub drawContacts: bool,
    /// Draw contact anchor A or B
    pub drawAnchorA: bool,
    /// Option to visualize the graph coloring used for contacts and joints
    pub drawGraphColors: bool,
    /// Option to draw contact features
    pub drawContactFeatures: bool,
    /// Option to draw contact normals
    pub drawContactNormals: bool,
    /// Option to draw contact normal forces
    pub drawContactForces: bool,
    /// Option to draw islands as bounding boxes
    pub drawIslands: bool,
    /// User context that is passed as an argument to drawing callback functions
    pub context: *mut ::std::os::raw::c_void,
}
unsafe extern "C" {
    /// Create a debug draw struct with default values.
    pub fn b3DefaultDebugDraw() -> b3DebugDraw;
}
unsafe extern "C" {
    /// Constructing the tree initializes the node pool.
    pub fn b3DynamicTree_Create(proxyCapacity: ::std::os::raw::c_int) -> b3DynamicTree;
}
unsafe extern "C" {
    /// Destroy the tree, freeing the node pool.
    pub fn b3DynamicTree_Destroy(tree: *mut b3DynamicTree);
}
unsafe extern "C" {
    /// Create a proxy. Provide an AABB and a userData value.
    pub fn b3DynamicTree_CreateProxy(
        tree: *mut b3DynamicTree,
        aabb: b3AABB,
        categoryBits: u64,
        userData: u64,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Destroy a proxy. This asserts if the id is invalid.
    pub fn b3DynamicTree_DestroyProxy(
        tree: *mut b3DynamicTree,
        proxyId: ::std::os::raw::c_int,
    );
}
unsafe extern "C" {
    /// Move a proxy to a new AABB by removing and reinserting into the tree.
    pub fn b3DynamicTree_MoveProxy(
        tree: *mut b3DynamicTree,
        proxyId: ::std::os::raw::c_int,
        aabb: b3AABB,
    );
}
unsafe extern "C" {
    /// Enlarge a proxy and enlarge ancestors as necessary.
    pub fn b3DynamicTree_EnlargeProxy(
        tree: *mut b3DynamicTree,
        proxyId: ::std::os::raw::c_int,
        aabb: b3AABB,
    );
}
unsafe extern "C" {
    /// Modify the category bits on a proxy. This is an expensive operation.
    pub fn b3DynamicTree_SetCategoryBits(
        tree: *mut b3DynamicTree,
        proxyId: ::std::os::raw::c_int,
        categoryBits: u64,
    );
}
unsafe extern "C" {
    /// Get the category bits on a proxy.
    pub fn b3DynamicTree_GetCategoryBits(
        tree: *mut b3DynamicTree,
        proxyId: ::std::os::raw::c_int,
    ) -> u64;
}
unsafe extern "C" {
    /** Query an AABB for overlapping proxies. The callback function is called for each proxy that overlaps the supplied AABB.
	@return performance data*/
    pub fn b3DynamicTree_Query(
        tree: *const b3DynamicTree,
        aabb: b3AABB,
        maskBits: u64,
        requireAllBits: bool,
        callback: b3TreeQueryCallbackFcn,
        context: *mut ::std::os::raw::c_void,
    ) -> b3TreeStats;
}
unsafe extern "C" {
    /** Query an AABB for the closest object. The callback function is called for each proxy that might be closest to the supplied
 point.
 @param tree the dynamic tree to query
 @param point the query point
 @param maskBits nodes are skipped if the bit-wise AND with the node category bits is zero
 @param requireAllBits nodes are skipped if the bit-wise AND with the node category bits does not equal the maskBits
 @param callback a user provided instance of b3TreeQueryClosestCallbackFcn
 @param context a user context object that is provided to the callback
 @param minDistanceSqr the initial and final minimum squared distance. Provide a small initial to restrict the search and
 improve performance. If the value is large this query has performance that scales linearly with the number of proxies and
 would be slower than a brute force search.
	@return performance data*/
    pub fn b3DynamicTree_QueryClosest(
        tree: *const b3DynamicTree,
        point: b3Vec3,
        maskBits: u64,
        requireAllBits: bool,
        callback: b3TreeQueryClosestCallbackFcn,
        context: *mut ::std::os::raw::c_void,
        minDistanceSqr: *mut f32,
    ) -> b3TreeStats;
}
unsafe extern "C" {
    /** Ray cast against the proxies in the tree. This relies on the callback
 to perform an exact ray cast in the case where the proxy contains a shape.
 The callback also performs any collision filtering. This has performance
 roughly equal to k * log(n), where k is the number of collisions and n is the
 number of proxies in the tree.
 Bit-wise filtering using mask bits can greatly improve performance in some scenarios.
	However, this filtering may be approximate, so the user should still apply filtering to results.
 @param tree the dynamic tree to ray cast
 @param input the ray cast input data. The ray extends from p1 to p1 + maxFraction * (p2 - p1)
 @param maskBits bit mask test: `bool accept = (maskBits & node->categoryBits) != 0;`
 @param requireAllBits modifies bit mask test: `bool accept = (maskBits & node->categoryBits) == maskBits;`
 @param callback a callback function that is called for each proxy that is hit by the ray
 @param context user context that is passed to the callback
	@return performance data*/
    pub fn b3DynamicTree_RayCast(
        tree: *const b3DynamicTree,
        input: *const b3RayCastInput,
        maskBits: u64,
        requireAllBits: bool,
        callback: b3TreeRayCastCallbackFcn,
        context: *mut ::std::os::raw::c_void,
    ) -> b3TreeStats;
}
unsafe extern "C" {
    /** Sweep an AABB through the tree. The box is in the tree's world float frame and the callback
 re-differences each shape at full precision against the query origin. Used by the large world
 spatial queries so the tree traversal stays float while the narrow phase stays precise.*/
    pub fn b3DynamicTree_BoxCast(
        tree: *const b3DynamicTree,
        input: *const b3BoxCastInput,
        maskBits: u64,
        requireAllBits: bool,
        callback: b3TreeBoxCastCallbackFcn,
        context: *mut ::std::os::raw::c_void,
    ) -> b3TreeStats;
}
unsafe extern "C" {
    /// Get the height of the binary tree.
    pub fn b3DynamicTree_GetHeight(tree: *const b3DynamicTree) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Get the ratio of the sum of the node areas to the root area.
    pub fn b3DynamicTree_GetAreaRatio(tree: *const b3DynamicTree) -> f32;
}
unsafe extern "C" {
    /// Get the bounding box that contains the entire tree
    pub fn b3DynamicTree_GetRootBounds(tree: *const b3DynamicTree) -> b3AABB;
}
unsafe extern "C" {
    /// Get the number of proxies created
    pub fn b3DynamicTree_GetProxyCount(
        tree: *const b3DynamicTree,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Rebuild the tree while retaining subtrees that haven't changed. Returns the number of boxes sorted.
    pub fn b3DynamicTree_Rebuild(
        tree: *mut b3DynamicTree,
        fullBuild: bool,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Get the number of bytes used by this tree
    pub fn b3DynamicTree_GetByteCount(
        tree: *const b3DynamicTree,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Validate this tree. For testing.
    pub fn b3DynamicTree_Validate(tree: *const b3DynamicTree);
}
unsafe extern "C" {
    /// Validate this tree has no enlarged AABBs. For testing.
    pub fn b3DynamicTree_ValidateNoEnlarged(tree: *const b3DynamicTree);
}
unsafe extern "C" {
    /// Save this tree to a file for debugging
    pub fn b3DynamicTree_Save(
        tree: *const b3DynamicTree,
        fileName: *const ::std::os::raw::c_char,
    );
}
unsafe extern "C" {
    /// Load a file for debugging
    pub fn b3DynamicTree_Load(
        fileName: *const ::std::os::raw::c_char,
        scale: f32,
    ) -> b3DynamicTree;
}
unsafe extern "C" {
    /// Create a tessellated cylinder as a hull.
    pub fn b3CreateCylinder(
        height: f32,
        radius: f32,
        yOffset: f32,
        sides: ::std::os::raw::c_int,
    ) -> *mut b3HullData;
}
unsafe extern "C" {
    /// Create a tessellated cone as a hull.
    pub fn b3CreateCone(
        height: f32,
        radius1: f32,
        radius2: f32,
        slices: ::std::os::raw::c_int,
    ) -> *mut b3HullData;
}
unsafe extern "C" {
    /// Create a rock shaped hull.
    pub fn b3CreateRock(radius: f32) -> *mut b3HullData;
}
unsafe extern "C" {
    /// Create a generic convex hull.
    pub fn b3CreateHull(
        points: *const b3Vec3,
        pointCount: ::std::os::raw::c_int,
        maxVertexCount: ::std::os::raw::c_int,
    ) -> *mut b3HullData;
}
unsafe extern "C" {
    /// Deep clone a hull.
    pub fn b3CloneHull(hull: *const b3HullData) -> *mut b3HullData;
}
unsafe extern "C" {
    /// Clone and transform a hull. Supports non-uniform and mirroring scale.
    pub fn b3CloneAndTransformHull(
        original: *const b3HullData,
        transform: b3Transform,
        scale: b3Vec3,
    ) -> *mut b3HullData;
}
unsafe extern "C" {
    /// Destroy a hull.
    pub fn b3DestroyHull(hull: *mut b3HullData);
}
unsafe extern "C" {
    /// Make a cube as a hull. Do not call b3DestroyHull on this.
    pub fn b3MakeCubeHull(halfWidth: f32) -> b3BoxHull;
}
unsafe extern "C" {
    /// Make a box as a hull. Do not call b3DestroyHull on this.
    pub fn b3MakeBoxHull(hx: f32, hy: f32, hz: f32) -> b3BoxHull;
}
unsafe extern "C" {
    /// Make an offset box as a hull. Do not call b3DestroyHull on this.
    pub fn b3MakeOffsetBoxHull(hx: f32, hy: f32, hz: f32, offset: b3Vec3) -> b3BoxHull;
}
unsafe extern "C" {
    /** Make a transformed box as a hull. Do not call b3DestroyHull on this.
 @param hx, hy, hz positive half widths
 @param transform local transform of box*/
    pub fn b3MakeTransformedBoxHull(
        hx: f32,
        hy: f32,
        hz: f32,
        transform: b3Transform,
    ) -> b3BoxHull;
}
unsafe extern "C" {
    /** This makes a transformed box hull with post scaling. This is useful for boxes that are scaled in
 a level editor. Such scaling can have reflection and shear. In the case of shear the result
 may be approximate. If you need to support shear consider using b3CreateHull.
 Do not call b3DestroyHull on this.
 @param halfWidths positive half widths
 @param transform local transform of box
 @param postScale scale applied after the transform, may be negative*/
    pub fn b3MakeScaledBoxHull(
        halfWidths: b3Vec3,
        transform: b3Transform,
        postScale: b3Vec3,
    ) -> b3BoxHull;
}
unsafe extern "C" {
    /** This takes a box with a transform and post scale and converts it into a box with the post scale
 resolved with new half-widths and transform. This accepts non-uniform and negative scale.
 This is approximate if there is shear.
 @param halfWidths [in/out] the box half widths
 @param transform [in/out] the box transform with rotation and translation
 @param postScale the post scale being applied to the box after the transform
 @param minHalfWidth the minimum half width after scale is applied*/
    pub fn b3ScaleBox(
        halfWidths: *mut b3Vec3,
        transform: *mut b3Transform,
        postScale: b3Vec3,
        minHalfWidth: f32,
    );
}
unsafe extern "C" {
    /** Create a grid mesh along the x and z axes.
 @param xCount the number of rows in the x direction
 @param zCount the number of rows in the z direction
 @param cellWidth the width of each cell
 @param materialCount the number of materials to generate
 @param identifyEdges compute adjacency information*/
    pub fn b3CreateGridMesh(
        xCount: ::std::os::raw::c_int,
        zCount: ::std::os::raw::c_int,
        cellWidth: f32,
        materialCount: ::std::os::raw::c_int,
        identifyEdges: bool,
    ) -> *mut b3MeshData;
}
unsafe extern "C" {
    /// Create a wave mesh along the x and z axes.
    pub fn b3CreateWaveMesh(
        xCount: ::std::os::raw::c_int,
        zCount: ::std::os::raw::c_int,
        cellWidth: f32,
        amplitude: f32,
        rowFrequency: f32,
        columnFrequency: f32,
    ) -> *mut b3MeshData;
}
unsafe extern "C" {
    /// Create a torus mesh.
    pub fn b3CreateTorusMesh(
        radialResolution: ::std::os::raw::c_int,
        tubularResolution: ::std::os::raw::c_int,
        radius: f32,
        thickness: f32,
    ) -> *mut b3MeshData;
}
unsafe extern "C" {
    /// Create a box mesh.
    pub fn b3CreateBoxMesh(
        center: b3Vec3,
        extent: b3Vec3,
        identifyEdges: bool,
    ) -> *mut b3MeshData;
}
unsafe extern "C" {
    /// Create a hollow box mesh.
    pub fn b3CreateHollowBoxMesh(center: b3Vec3, extent: b3Vec3) -> *mut b3MeshData;
}
unsafe extern "C" {
    /// Create a platform mesh. A truncated pyramid.
    pub fn b3CreatePlatformMesh(
        center: b3Vec3,
        height: f32,
        topWidth: f32,
        bottomWidth: f32,
    ) -> *mut b3MeshData;
}
unsafe extern "C" {
    /// Create a generic mesh.
    pub fn b3CreateMesh(
        def: *const b3MeshDef,
        degenerateTriangleIndices: *mut ::std::os::raw::c_int,
        degenerateCapacity: ::std::os::raw::c_int,
    ) -> *mut b3MeshData;
}
unsafe extern "C" {
    /// Destroy a mesh.
    pub fn b3DestroyMesh(mesh: *mut b3MeshData);
}
unsafe extern "C" {
    /// Get the height of the mesh BVH.
    pub fn b3GetHeight(mesh: *const b3MeshData) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Create a generic height field.
    pub fn b3CreateHeightField(data: *const b3HeightFieldDef) -> *mut b3HeightFieldData;
}
unsafe extern "C" {
    /// Create a grid as a height field.
    pub fn b3CreateGrid(
        rowCount: ::std::os::raw::c_int,
        columnCount: ::std::os::raw::c_int,
        scale: b3Vec3,
        makeHoles: bool,
    ) -> *mut b3HeightFieldData;
}
unsafe extern "C" {
    /// Create a wave grid as a height field.
    pub fn b3CreateWave(
        rowCount: ::std::os::raw::c_int,
        columnCount: ::std::os::raw::c_int,
        scale: b3Vec3,
        rowFrequency: f32,
        columnFrequency: f32,
        makeHoles: bool,
    ) -> *mut b3HeightFieldData;
}
unsafe extern "C" {
    /// Destroy a height field.
    pub fn b3DestroyHeightField(heightField: *mut b3HeightFieldData);
}
unsafe extern "C" {
    /// Save input height data to a file
    pub fn b3DumpHeightData(
        data: *const b3HeightFieldDef,
        fileName: *const ::std::os::raw::c_char,
    );
}
unsafe extern "C" {
    /// Create a height field by loading a previously saved height data
    pub fn b3LoadHeightField(
        fileName: *const ::std::os::raw::c_char,
    ) -> *mut b3HeightFieldData;
}
unsafe extern "C" {
    /// Get a child shape of a compound.
    pub fn b3GetCompoundChild(
        compound: *const b3CompoundData,
        childIndex: ::std::os::raw::c_int,
    ) -> b3ChildShape;
}
unsafe extern "C" {
    /// Query a compound shape for children that overlap an AABB.
    pub fn b3QueryCompound(
        compound: *const b3CompoundData,
        aabb: b3AABB,
        fcn: b3CompoundQueryFcn,
        context: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    /// Access a child capsule by index.
    pub fn b3GetCompoundCapsule(
        compound: *const b3CompoundData,
        index: ::std::os::raw::c_int,
    ) -> b3CompoundCapsule;
}
unsafe extern "C" {
    /// Access a child hull by index.
    pub fn b3GetCompoundHull(
        compound: *const b3CompoundData,
        index: ::std::os::raw::c_int,
    ) -> b3CompoundHull;
}
unsafe extern "C" {
    /// Access a child mesh by index.
    pub fn b3GetCompoundMesh(
        compound: *const b3CompoundData,
        index: ::std::os::raw::c_int,
    ) -> b3CompoundMesh;
}
unsafe extern "C" {
    /// Access a child sphere by index.
    pub fn b3GetCompoundSphere(
        compound: *const b3CompoundData,
        index: ::std::os::raw::c_int,
    ) -> b3CompoundSphere;
}
unsafe extern "C" {
    /// Access the compound material array.
    pub fn b3GetCompoundMaterials(
        compound: *const b3CompoundData,
    ) -> *const b3SurfaceMaterial;
}
unsafe extern "C" {
    /// Create a compound shape. All input data in the definition is cloned into the resulting compound.
    pub fn b3CreateCompound(def: *const b3CompoundDef) -> *mut b3CompoundData;
}
unsafe extern "C" {
    /// Destroy a compound shape.
    pub fn b3DestroyCompound(compound: *mut b3CompoundData);
}
unsafe extern "C" {
    /** Cast the provided compound data to bytes, setting the internal pointers to null.
 Use this before serializing the compound bytes.*/
    pub fn b3ConvertCompoundToBytes(compound: *mut b3CompoundData) -> *mut u8;
}
unsafe extern "C" {
    /** Cast the provided bytes to compound data, setting up internal pointers.
 Use this after de-serializing the compound bytes.*/
    pub fn b3ConvertBytesToCompound(
        bytes: *mut u8,
        byteCount: ::std::os::raw::c_int,
    ) -> *mut b3CompoundData;
}
unsafe extern "C" {
    /// Compute mass properties of a sphere
    pub fn b3ComputeSphereMass(shape: *const b3Sphere, density: f32) -> b3MassData;
}
unsafe extern "C" {
    /// Compute mass properties of a capsule
    pub fn b3ComputeCapsuleMass(shape: *const b3Capsule, density: f32) -> b3MassData;
}
unsafe extern "C" {
    /// Compute mass properties of a hull
    pub fn b3ComputeHullMass(shape: *const b3HullData, density: f32) -> b3MassData;
}
unsafe extern "C" {
    /// Compute the bounding box of a transformed sphere
    pub fn b3ComputeSphereAABB(shape: *const b3Sphere, transform: b3Transform) -> b3AABB;
}
unsafe extern "C" {
    /// Compute the bounding box of a transformed capsule
    pub fn b3ComputeCapsuleAABB(
        shape: *const b3Capsule,
        transform: b3Transform,
    ) -> b3AABB;
}
unsafe extern "C" {
    /// Compute the bounding box of a transformed hull
    pub fn b3ComputeHullAABB(shape: *const b3HullData, transform: b3Transform) -> b3AABB;
}
unsafe extern "C" {
    /// Compute the bounding box of a transformed mesh. Scale may be non-uniform and have negative components.
    pub fn b3ComputeMeshAABB(
        shape: *const b3MeshData,
        transform: b3Transform,
        scale: b3Vec3,
    ) -> b3AABB;
}
unsafe extern "C" {
    /// Compute the bounding box of a transformed height-field
    pub fn b3ComputeHeightFieldAABB(
        shape: *const b3HeightFieldData,
        transform: b3Transform,
    ) -> b3AABB;
}
unsafe extern "C" {
    /// Compute the bounding box of a compound
    pub fn b3ComputeCompoundAABB(
        shape: *const b3CompoundData,
        transform: b3Transform,
    ) -> b3AABB;
}
unsafe extern "C" {
    /// Use this to ensure your ray cast input is valid and avoid internal assertions.
    pub fn b3IsValidRay(input: *const b3RayCastInput) -> bool;
}
unsafe extern "C" {
    /// Overlap shape versus capsule
    pub fn b3OverlapCapsule(
        shape: *const b3Capsule,
        shapeTransform: b3Transform,
        proxy: *const b3ShapeProxy,
    ) -> bool;
}
unsafe extern "C" {
    /// Overlap shape versus compound
    pub fn b3OverlapCompound(
        shape: *const b3CompoundData,
        shapeTransform: b3Transform,
        proxy: *const b3ShapeProxy,
    ) -> bool;
}
unsafe extern "C" {
    /// Overlap shape versus height field
    pub fn b3OverlapHeightField(
        shape: *const b3HeightFieldData,
        shapeTransform: b3Transform,
        proxy: *const b3ShapeProxy,
    ) -> bool;
}
unsafe extern "C" {
    /// Overlap shape versus hull
    pub fn b3OverlapHull(
        shape: *const b3HullData,
        shapeTransform: b3Transform,
        proxy: *const b3ShapeProxy,
    ) -> bool;
}
unsafe extern "C" {
    /// Overlap shape versus mesh
    pub fn b3OverlapMesh(
        shape: *const b3Mesh,
        shapeTransform: b3Transform,
        proxy: *const b3ShapeProxy,
    ) -> bool;
}
unsafe extern "C" {
    /// Overlap shape versus sphere
    pub fn b3OverlapSphere(
        shape: *const b3Sphere,
        shapeTransform: b3Transform,
        proxy: *const b3ShapeProxy,
    ) -> bool;
}
unsafe extern "C" {
    /** Ray cast versus sphere in local space. A zero length ray is a point query. Initial overlap
 reports a hit at the ray origin with zero fraction and zero normal.*/
    pub fn b3RayCastSphere(
        shape: *const b3Sphere,
        input: *const b3RayCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /** Ray cast versus a hollow sphere shell in local space. Unlike the solid sphere a ray starting
 inside is not an overlap: it passes through and hits the far wall.*/
    pub fn b3RayCastHollowSphere(
        shape: *const b3Sphere,
        input: *const b3RayCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /** Ray cast versus capsule in local space. A zero length ray is a point query. Initial overlap
 reports a hit at the ray origin with zero fraction and zero normal.*/
    pub fn b3RayCastCapsule(
        shape: *const b3Capsule,
        input: *const b3RayCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /** Ray cast versus compound in local space. A zero length ray is a point query. Initial overlap
 with a child reports a hit at the ray origin with zero fraction and zero normal.*/
    pub fn b3RayCastCompound(
        shape: *const b3CompoundData,
        input: *const b3RayCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /** Ray cast versus hull shape in local space. A zero length ray is a point query. Initial overlap
 reports a hit at the ray origin with zero fraction and zero normal.*/
    pub fn b3RayCastHull(
        shape: *const b3HullData,
        input: *const b3RayCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /// Ray cast versus mesh in local space. A thin surface with no interior, so there is no overlap case.
    pub fn b3RayCastMesh(
        shape: *const b3Mesh,
        input: *const b3RayCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /// Ray cast versus height field in local space. A thin surface with no interior, so there is no overlap case.
    pub fn b3RayCastHeightField(
        shape: *const b3HeightFieldData,
        input: *const b3RayCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /// Shape cast versus a sphere. Initial overlap is treated as a miss.
    pub fn b3ShapeCastSphere(
        shape: *const b3Sphere,
        input: *const b3ShapeCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /// Shape cast versus a capsule. Initial overlap is treated as a miss.
    pub fn b3ShapeCastCapsule(
        shape: *const b3Capsule,
        input: *const b3ShapeCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /// Shape cast versus compound. Initial overlap is treated as a miss.
    pub fn b3ShapeCastCompound(
        shape: *const b3CompoundData,
        input: *const b3ShapeCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /// Shape cast versus a hull. Initial overlap is treated as a miss.
    pub fn b3ShapeCastHull(
        shape: *const b3HullData,
        input: *const b3ShapeCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /// Shape cast versus a mesh. Initial overlap is treated as a miss.
    pub fn b3ShapeCastMesh(
        shape: *const b3Mesh,
        input: *const b3ShapeCastInput,
    ) -> b3CastOutput;
}
unsafe extern "C" {
    /// Shape cast versus a height field. Initial overlap is treated as a miss.
    pub fn b3ShapeCastHeightField(
        shape: *const b3HeightFieldData,
        input: *const b3ShapeCastInput,
    ) -> b3CastOutput;
}
/// Query callback.
pub type b3MeshQueryFcn = ::std::option::Option<
    unsafe extern "C" fn(
        a: b3Vec3,
        b: b3Vec3,
        c: b3Vec3,
        triangleIndex: ::std::os::raw::c_int,
        context: *mut ::std::os::raw::c_void,
    ) -> bool,
>;
unsafe extern "C" {
    /** Query a mesh for triangles overlapping a bounding box in local space. May have false positives. Useful for debug draw.
 @param mesh the mesh to query, includes scale
 @param bounds the bounding box in local space
 @param fcn a user function to collect triangles
 @param context the context sent to the user function.*/
    pub fn b3QueryMesh(
        mesh: *const b3Mesh,
        bounds: b3AABB,
        fcn: b3MeshQueryFcn,
        context: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    /** Query a height field for triangles overlapping a bounding box in local space. May have false positives. Useful for debug draw.
 @param heightField the height field to query
 @param bounds the bounding box in local space
 @param fcn a user function to collect triangles
 @param context the context sent to the user function.*/
    pub fn b3QueryHeightField(
        heightField: *const b3HeightFieldData,
        bounds: b3AABB,
        fcn: b3MeshQueryFcn,
        context: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    /** Compute the closest points between two shapes represented as point clouds.
 b3SimplexCache cache is input/output. On the first call set b3SimplexCache.count to zero.
 The query runs in frame A, so the witness points and normal are returned in frame A.
 The underlying GJK algorithm may be debugged by passing in debug simplexes and capacity. You may pass in NULL and 0 for these.*/
    pub fn b3ShapeDistance(
        input: *const b3DistanceInput,
        cache: *mut b3SimplexCache,
        simplexes: *mut b3Simplex,
        simplexCapacity: ::std::os::raw::c_int,
    ) -> b3DistanceOutput;
}
unsafe extern "C" {
    /** Perform a linear shape cast of shape B moving and shape A fixed. Determines the hit point, normal, and translation fraction.
 The query runs in frame A, so the hit point and normal are returned in frame A. Initially touching shapes are a miss.*/
    pub fn b3ShapeCast(input: *const b3ShapeCastPairInput) -> b3CastOutput;
}
unsafe extern "C" {
    /// Evaluate the transform sweep at a specific time.
    pub fn b3GetSweepTransform(sweep: *const b3Sweep, time: f32) -> b3Transform;
}
unsafe extern "C" {
    /** Compute the upper bound on time before two shapes penetrate. Time is represented as
 a fraction between [0,tMax]. This uses a swept separating axis and may miss some intermediate,
 non-tunneling collisions. If you change the time interval, you should call this function
 again.*/
    pub fn b3TimeOfImpact(input: *const b3TOIInput) -> b3TOIOutput;
}
unsafe extern "C" {
    /// Collide two spheres.
    pub fn b3CollideSpheres(
        manifold: *mut b3LocalManifold,
        capacity: ::std::os::raw::c_int,
        sphereA: *const b3Sphere,
        sphereB: *const b3Sphere,
        transformBtoA: b3Transform,
    );
}
unsafe extern "C" {
    /// Collide a capsule and a sphere.
    pub fn b3CollideCapsuleAndSphere(
        manifold: *mut b3LocalManifold,
        capacity: ::std::os::raw::c_int,
        capsuleA: *const b3Capsule,
        sphereB: *const b3Sphere,
        transformBtoA: b3Transform,
    );
}
unsafe extern "C" {
    /// Collide a hull and a sphere.
    pub fn b3CollideHullAndSphere(
        manifold: *mut b3LocalManifold,
        capacity: ::std::os::raw::c_int,
        hullA: *const b3HullData,
        sphereB: *const b3Sphere,
        transformBtoA: b3Transform,
        cache: *mut b3SimplexCache,
    );
}
unsafe extern "C" {
    /// Collide two capsules.
    pub fn b3CollideCapsules(
        manifold: *mut b3LocalManifold,
        capacity: ::std::os::raw::c_int,
        capsuleA: *const b3Capsule,
        capsuleB: *const b3Capsule,
        transformBtoA: b3Transform,
    );
}
unsafe extern "C" {
    /// Collide a hull and a capsule.
    pub fn b3CollideHullAndCapsule(
        manifold: *mut b3LocalManifold,
        capacity: ::std::os::raw::c_int,
        hullA: *const b3HullData,
        capsuleB: *const b3Capsule,
        transformBtoA: b3Transform,
        cache: *mut b3SimplexCache,
    );
}
unsafe extern "C" {
    /// Collide two hulls.
    pub fn b3CollideHulls(
        manifold: *mut b3LocalManifold,
        capacity: ::std::os::raw::c_int,
        hullA: *const b3HullData,
        hullB: *const b3HullData,
        transformBtoA: b3Transform,
        cache: *mut b3SATCache,
    );
}
unsafe extern "C" {
    /// Collide a triangle and capsule. Normal points from triangle to capsule.
    pub fn b3CollideTriangleAndCapsule(
        manifold: *mut b3LocalManifold,
        capacity: ::std::os::raw::c_int,
        triangleA: *const b3Vec3,
        capsuleB: *const b3Capsule,
        cache: *mut b3SimplexCache,
    );
}
unsafe extern "C" {
    /// Collide a triangle and hull. Normal points from triangle to hull.
    pub fn b3CollideTriangleAndHull(
        manifold: *mut b3LocalManifold,
        capacity: ::std::os::raw::c_int,
        v1: b3Vec3,
        v2: b3Vec3,
        v3: b3Vec3,
        triangleFlags: ::std::os::raw::c_int,
        hullB: *const b3HullData,
        cache: *mut b3SATCache,
        enableSpeculative: bool,
    );
}
unsafe extern "C" {
    /// Collide a triangle and sphere. Normal points from triangle to sphere.
    pub fn b3CollideTriangleAndSphere(
        manifold: *mut b3LocalManifold,
        capacity: ::std::os::raw::c_int,
        triangleA: *const b3Vec3,
        sphereB: *const b3Sphere,
    );
}
unsafe extern "C" {
    /** Solves the position of a mover that satisfies the given collision planes.
 @param targetDelta the desired translation from the position used to generate the collision planes
 @param planes the collision planes
 @param count the number of collision planes*/
    pub fn b3SolvePlanes(
        targetDelta: b3Vec3,
        planes: *mut b3CollisionPlane,
        count: ::std::os::raw::c_int,
    ) -> b3PlaneSolverResult;
}
unsafe extern "C" {
    /** Clips the velocity against the given collision planes. Planes with zero push or clipVelocity
 set to false are skipped.*/
    pub fn b3ClipVector(
        vector: b3Vec3,
        planes: *const b3CollisionPlane,
        count: ::std::os::raw::c_int,
    ) -> b3Vec3;
}
unsafe extern "C" {
    /** Create a world for rigid body simulation. A world contains bodies, shapes, and constraints. You may create
 up to 128 worlds. Each world is completely independent and may be simulated in parallel.
 @return the world id.*/
    pub fn b3CreateWorld(def: *const b3WorldDef) -> b3WorldId;
}
unsafe extern "C" {
    /// Destroy a world
    pub fn b3DestroyWorld(worldId: b3WorldId);
}
unsafe extern "C" {
    /// Get the current number of worlds
    pub fn b3GetWorldCount() -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Get the maximum number of simultaneous worlds that have been created
    pub fn b3GetMaxWorldCount() -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// World id validation. Provides validation for up to 64K allocations.
    pub fn b3World_IsValid(id: b3WorldId) -> bool;
}
unsafe extern "C" {
    /** Simulate a world for one time step. This performs collision detection, integration, and constraint solution.
 @param worldId The world to simulate
 @param timeStep The amount of time to simulate, this should be a fixed number. Usually 1/60.
 @param subStepCount The number of sub-steps, increasing the sub-step count can increase accuracy. Usually 4.*/
    pub fn b3World_Step(
        worldId: b3WorldId,
        timeStep: f32,
        subStepCount: ::std::os::raw::c_int,
    );
}
unsafe extern "C" {
    /// Call this to draw shapes and other debug draw data
    pub fn b3World_Draw(worldId: b3WorldId, draw: *mut b3DebugDraw, maskBits: u64);
}
unsafe extern "C" {
    /** Get the world's bounds. This is the bounding box that covers the current simulation. May have a small
 amount of padding.*/
    pub fn b3World_GetBounds(worldId: b3WorldId) -> b3AABB;
}
unsafe extern "C" {
    /// Get the body events for the current time step. The event data is transient. Do not store a reference to this data.
    pub fn b3World_GetBodyEvents(worldId: b3WorldId) -> b3BodyEvents;
}
unsafe extern "C" {
    /// Get sensor events for the current time step. The event data is transient. Do not store a reference to this data.
    pub fn b3World_GetSensorEvents(worldId: b3WorldId) -> b3SensorEvents;
}
unsafe extern "C" {
    /// Get contact events for this current time step. The event data is transient. Do not store a reference to this data.
    pub fn b3World_GetContactEvents(worldId: b3WorldId) -> b3ContactEvents;
}
unsafe extern "C" {
    /// Get the joint events for the current time step. The event data is transient. Do not store a reference to this data.
    pub fn b3World_GetJointEvents(worldId: b3WorldId) -> b3JointEvents;
}
unsafe extern "C" {
    /// Overlap test for all shapes that *potentially* overlap the provided AABB
    pub fn b3World_OverlapAABB(
        worldId: b3WorldId,
        aabb: b3AABB,
        filter: b3QueryFilter,
        fcn: b3OverlapResultFcn,
        context: *mut ::std::os::raw::c_void,
    ) -> b3TreeStats;
}
unsafe extern "C" {
    /** Overlap test for all shapes that overlap the provided shape proxy. The proxy points are relative
 to the world origin, which lets the query stay precise far from the world origin.*/
    pub fn b3World_OverlapShape(
        worldId: b3WorldId,
        origin: b3Pos,
        proxy: *const b3ShapeProxy,
        filter: b3QueryFilter,
        fcn: b3OverlapResultFcn,
        context: *mut ::std::os::raw::c_void,
    ) -> b3TreeStats;
}
unsafe extern "C" {
    /** Cast a ray into the world to collect shapes in the path of the ray.
 Your callback function controls whether you get the closest point, any point, or n-points.
 @note The callback function may receive shapes in any order
 @param worldId The world to cast the ray against
 @param origin The start point of the ray
 @param translation The translation of the ray from the start point to the end point
 @param filter Contains bit flags to filter unwanted shapes from the results
 @param fcn A user implemented callback function
 @param context A user context that is passed along to the callback function
	@return traversal performance counters*/
    pub fn b3World_CastRay(
        worldId: b3WorldId,
        origin: b3Pos,
        translation: b3Vec3,
        filter: b3QueryFilter,
        fcn: b3CastResultFcn,
        context: *mut ::std::os::raw::c_void,
    ) -> b3TreeStats;
}
unsafe extern "C" {
    /** Cast a ray into the world to collect the closest hit. This is a convenience function. Ignores initial overlap.
 This is less general than b3World_CastRay() and does not allow for custom filtering.*/
    pub fn b3World_CastRayClosest(
        worldId: b3WorldId,
        origin: b3Pos,
        translation: b3Vec3,
        filter: b3QueryFilter,
    ) -> b3RayResult;
}
unsafe extern "C" {
    /** Cast a shape through the world. Similar to a cast ray except that a shape is cast instead of a point.
 The proxy points are relative to the origin and the hit points come back as world positions, so the
 cast stays precise far from the world origin.
	@see b3World_CastRay*/
    pub fn b3World_CastShape(
        worldId: b3WorldId,
        origin: b3Pos,
        proxy: *const b3ShapeProxy,
        translation: b3Vec3,
        filter: b3QueryFilter,
        fcn: b3CastResultFcn,
        context: *mut ::std::os::raw::c_void,
    ) -> b3TreeStats;
}
unsafe extern "C" {
    /** Cast a capsule mover through the world. This is a special shape cast that handles sliding along other shapes while reducing
 clipping. This is not a good source of information about what the mover is touching. Instead use the planes returned by
 b3World_CollideMover.
 @param worldId World to cast the mover against
 @param origin World position the mover capsule is relative to
 @param mover Capsule mover, relative to the origin
 @param translation Desired mover translation
 @param filter Contains bit flags to filter unwanted shapes from the results
 @param fcn Optional callback for custom shape filtering
 @param context A user context that is passed along to the callback function
 @return the translation fraction*/
    pub fn b3World_CastMover(
        worldId: b3WorldId,
        origin: b3Pos,
        mover: *const b3Capsule,
        translation: b3Vec3,
        filter: b3QueryFilter,
        fcn: b3MoverFilterFcn,
        context: *mut ::std::os::raw::c_void,
    ) -> f32;
}
unsafe extern "C" {
    /** Collide a capsule mover with the world, gathering collision planes that can be fed to b3SolvePlanes. Useful for
 kinematic character movement. The mover and the returned planes are relative to the origin.*/
    pub fn b3World_CollideMover(
        worldId: b3WorldId,
        origin: b3Pos,
        mover: *const b3Capsule,
        filter: b3QueryFilter,
        fcn: b3PlaneResultFcn,
        context: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    /** Enable/disable sleep. If your application does not need sleeping, you can gain some performance
 by disabling sleep completely at the world level.
 @see b3WorldDef*/
    pub fn b3World_EnableSleeping(worldId: b3WorldId, flag: bool);
}
unsafe extern "C" {
    /// Is body sleeping enabled?
    pub fn b3World_IsSleepingEnabled(worldId: b3WorldId) -> bool;
}
unsafe extern "C" {
    /** Enable/disable continuous collision between dynamic and static bodies. Generally you should keep continuous
 collision enabled to prevent fast moving objects from going through static objects. The performance gain from
 disabling continuous collision is minor.
 @see b3WorldDef*/
    pub fn b3World_EnableContinuous(worldId: b3WorldId, flag: bool);
}
unsafe extern "C" {
    /// Is continuous collision enabled?
    pub fn b3World_IsContinuousEnabled(worldId: b3WorldId) -> bool;
}
unsafe extern "C" {
    /** Adjust the restitution threshold. It is recommended not to make this value very small
 because it will prevent bodies from sleeping. Usually in meters per second.
 @see b3WorldDef*/
    pub fn b3World_SetRestitutionThreshold(worldId: b3WorldId, value: f32);
}
unsafe extern "C" {
    /// Get the restitution speed threshold. Usually in meters per second.
    pub fn b3World_GetRestitutionThreshold(worldId: b3WorldId) -> f32;
}
unsafe extern "C" {
    /** Adjust the hit event threshold. This controls the collision speed needed to generate a b3ContactHitEvent.
 Usually in meters per second.
 @see b3WorldDef::hitEventThreshold*/
    pub fn b3World_SetHitEventThreshold(worldId: b3WorldId, value: f32);
}
unsafe extern "C" {
    /// Get the hit event speed threshold. Usually in meters per second.
    pub fn b3World_GetHitEventThreshold(worldId: b3WorldId) -> f32;
}
unsafe extern "C" {
    /// Register the custom filter callback. This is optional.
    pub fn b3World_SetCustomFilterCallback(
        worldId: b3WorldId,
        fcn: b3CustomFilterFcn,
        context: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    /// Register the pre-solve callback. This is optional.
    pub fn b3World_SetPreSolveCallback(
        worldId: b3WorldId,
        fcn: b3PreSolveFcn,
        context: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    /** Set the gravity vector for the entire world. Box3D has no concept of an up direction and this
 is left as a decision for the application. Usually in m/s^2.
 @see b3WorldDef*/
    pub fn b3World_SetGravity(worldId: b3WorldId, gravity: b3Vec3);
}
unsafe extern "C" {
    /// Get the gravity vector
    pub fn b3World_GetGravity(worldId: b3WorldId) -> b3Vec3;
}
unsafe extern "C" {
    /** Apply a radial explosion
 @param worldId The world id
 @param explosionDef The explosion definition*/
    pub fn b3World_Explode(worldId: b3WorldId, explosionDef: *const b3ExplosionDef);
}
unsafe extern "C" {
    /** Adjust contact tuning parameters
 @param worldId The world id
 @param hertz The contact stiffness (cycles per second)
 @param dampingRatio The contact bounciness with 1 being critical damping (non-dimensional)
 @param contactSpeed The maximum contact constraint push out speed (meters per second)
 @note Advanced feature*/
    pub fn b3World_SetContactTuning(
        worldId: b3WorldId,
        hertz: f32,
        dampingRatio: f32,
        contactSpeed: f32,
    );
}
unsafe extern "C" {
    /** Set the contact point recycling distance. Setting this to zero disables contact point recycling.
 Usually in meters.*/
    pub fn b3World_SetContactRecycleDistance(worldId: b3WorldId, recycleDistance: f32);
}
unsafe extern "C" {
    /// Get the contact point recycling distance. Usually in meters.
    pub fn b3World_GetContactRecycleDistance(worldId: b3WorldId) -> f32;
}
unsafe extern "C" {
    /// Set the maximum linear speed. Usually in m/s.
    pub fn b3World_SetMaximumLinearSpeed(worldId: b3WorldId, maximumLinearSpeed: f32);
}
unsafe extern "C" {
    /// Get the maximum linear speed. Usually in m/s.
    pub fn b3World_GetMaximumLinearSpeed(worldId: b3WorldId) -> f32;
}
unsafe extern "C" {
    /** Enable/disable constraint warm starting. Advanced feature for testing. Disabling
 warm starting greatly reduces stability and provides no performance gain.*/
    pub fn b3World_EnableWarmStarting(worldId: b3WorldId, flag: bool);
}
unsafe extern "C" {
    /// Is constraint warm starting enabled?
    pub fn b3World_IsWarmStartingEnabled(worldId: b3WorldId) -> bool;
}
unsafe extern "C" {
    /// Get the number of awake bodies
    pub fn b3World_GetAwakeBodyCount(worldId: b3WorldId) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Get the current world performance profile
    pub fn b3World_GetProfile(worldId: b3WorldId) -> b3Profile;
}
unsafe extern "C" {
    /// Get world counters and sizes
    pub fn b3World_GetCounters(worldId: b3WorldId) -> b3Counters;
}
unsafe extern "C" {
    /// Get max capacity. This can be used with b3WorldDef to avoid run-time allocations and copies
    pub fn b3World_GetMaxCapacity(worldId: b3WorldId) -> b3Capacity;
}
unsafe extern "C" {
    /// Set the user data pointer.
    pub fn b3World_SetUserData(
        worldId: b3WorldId,
        userData: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    /// Get the user data pointer.
    pub fn b3World_GetUserData(worldId: b3WorldId) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    /// Set the friction callback. Passing NULL resets to default.
    pub fn b3World_SetFrictionCallback(worldId: b3WorldId, callback: b3FrictionCallback);
}
unsafe extern "C" {
    /// Set the restitution callback. Passing NULL resets to default.
    pub fn b3World_SetRestitutionCallback(
        worldId: b3WorldId,
        callback: b3RestitutionCallback,
    );
}
unsafe extern "C" {
    /// Set the worker count. Must be in the range [1, B3_MAX_WORKERS]
    pub fn b3World_SetWorkerCount(worldId: b3WorldId, count: ::std::os::raw::c_int);
}
unsafe extern "C" {
    /// Get the worker count.
    pub fn b3World_GetWorkerCount(worldId: b3WorldId) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Dump memory stats to log.
    pub fn b3World_DumpMemoryStats(worldId: b3WorldId);
}
unsafe extern "C" {
    /// Dump shape bounds to box3d_bounds.txt
    pub fn b3World_DumpShapeBounds(worldId: b3WorldId, type_: b3BodyType);
}
unsafe extern "C" {
    /// This is for internal testing
    pub fn b3World_RebuildStaticTree(worldId: b3WorldId);
}
unsafe extern "C" {
    /// This is for internal testing
    pub fn b3World_EnableSpeculative(worldId: b3WorldId, flag: bool);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3Recording {
    _unused: [u8; 0],
}
unsafe extern "C" {
    /** Create a recording buffer with an optional initial byte capacity.
 Pass 0 to use the default (64 KiB). The buffer grows on demand.
 @return a new recording, owned by the caller*/
    pub fn b3CreateRecording(byteCapacity: ::std::os::raw::c_int) -> *mut b3Recording;
}
unsafe extern "C" {
    /** Destroy a recording and free its buffer.
 @param recording may be NULL*/
    pub fn b3DestroyRecording(recording: *mut b3Recording);
}
unsafe extern "C" {
    /** Get a pointer to the raw recording bytes.
 Valid until the recording buffer is modified or destroyed.
 @param recording the recording handle
 @return pointer to the byte buffer, or NULL if no bytes have been written*/
    pub fn b3Recording_GetData(recording: *const b3Recording) -> *const u8;
}
unsafe extern "C" {
    /** Get the number of bytes currently in the recording buffer.
 @param recording the recording handle*/
    pub fn b3Recording_GetSize(recording: *const b3Recording) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** Begin recording world mutations into the provided buffer.
 The buffer is reset on each call so a single b3Recording can be reused for multiple sessions.
 @param worldId the world to record
 @param recording the recording handle to write into*/
    pub fn b3World_StartRecording(worldId: b3WorldId, recording: *mut b3Recording);
}
unsafe extern "C" {
    /** End the current recording session. Writes the trailing geometry registry and
 backpatches the header. The buffer remains valid until the recording is destroyed.
 @param worldId the world currently being recorded*/
    pub fn b3World_StopRecording(worldId: b3WorldId);
}
unsafe extern "C" {
    /** Save the recording buffer to a file. Returns true on success.
 @param recording the recording to save
 @param path file path to write*/
    pub fn b3SaveRecordingToFile(
        recording: *const b3Recording,
        path: *const ::std::os::raw::c_char,
    ) -> bool;
}
unsafe extern "C" {
    /** Load a recording from a file. Returns NULL on failure (file not found, wrong magic).
 The caller owns the returned recording and must destroy it with b3DestroyRecording.
 @param path file path to read*/
    pub fn b3LoadRecordingFromFile(
        path: *const ::std::os::raw::c_char,
    ) -> *mut b3Recording;
}
unsafe extern "C" {
    /** Replay a recording from memory and verify it reproduces the same world-state hashes.
 Stands up a fresh world, restores the seed snapshot, replays every op, and checks each embedded
 StateHash record. Returns true if replay completed without id mismatches or hash divergences.
 @param data pointer to recording bytes
 @param size byte count of the recording
 @param workerCount reserved for future multithreaded replay; pass 1 for now*/
    pub fn b3ValidateReplay(
        data: *const ::std::os::raw::c_void,
        size: ::std::os::raw::c_int,
        workerCount: ::std::os::raw::c_int,
    ) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3RecPlayer {
    _unused: [u8; 0],
}
/// Summary of a recording, read once at open so a viewer can frame and label it.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3RecPlayerInfo {
    pub frameCount: ::std::os::raw::c_int,
    pub workerCount: ::std::os::raw::c_int,
    pub timeStep: f32,
    pub subStepCount: ::std::os::raw::c_int,
    pub lengthScale: f32,
    pub bounds: b3AABB,
}
unsafe extern "C" {
    /** Create a player over a recording. Owns a private copy of the bytes.
 @param data pointer to recording bytes
 @param size byte count of the recording
 @param workerCount worker count for the replay world; pass 1 to match a serial recording.
 Replaying at a different count re-partitions the constraint graph, so the StateHash check
 becomes a cross-thread determinism test. Adjustable later with b3RecPlayer_SetWorkerCount.
 @return a new player, or NULL on bad header or deserialization failure*/
    pub fn b3RecPlayer_Create(
        data: *const ::std::os::raw::c_void,
        size: ::std::os::raw::c_int,
        workerCount: ::std::os::raw::c_int,
    ) -> *mut b3RecPlayer;
}
unsafe extern "C" {
    /// Destroy the player and free all memory. Restores the previous global length scale.
    pub fn b3RecPlayer_Destroy(player: *mut b3RecPlayer);
}
unsafe extern "C" {
    /** Advance one frame. dispatch ops until the next Step completes.
 @return true when a frame was stepped, false at end-of-recording*/
    pub fn b3RecPlayer_StepFrame(player: *mut b3RecPlayer) -> bool;
}
unsafe extern "C" {
    /** Sub-step one frame. This will sub-step and return immediately after body creation.
 The next call will execute the time step. This allows bodies to be rendered
 at the creation pose.*/
    pub fn b3RecPlayer_SubStepFrame(player: *mut b3RecPlayer);
}
unsafe extern "C" {
    /// Rewind to frame 0 (in-place restore so the world id stays stable).
    pub fn b3RecPlayer_Restart(player: *mut b3RecPlayer);
}
unsafe extern "C" {
    /** Seek to a specific frame. Forward seek steps op-by-op; backward seek restores
 the nearest keyframe then re-steps the remaining gap.*/
    pub fn b3RecPlayer_SeekFrame(
        player: *mut b3RecPlayer,
        targetFrame: ::std::os::raw::c_int,
    );
}
unsafe extern "C" {
    /// @return the world currently driven by this player
    pub fn b3RecPlayer_GetWorldId(player: *const b3RecPlayer) -> b3WorldId;
}
unsafe extern "C" {
    /// @return the last fully-stepped frame index (0 before any step)
    pub fn b3RecPlayer_GetFrame(player: *const b3RecPlayer) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// @return total number of recorded frames
    pub fn b3RecPlayer_GetFrameCount(
        player: *const b3RecPlayer,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// @return true when the op stream is exhausted
    pub fn b3RecPlayer_IsAtEnd(player: *const b3RecPlayer) -> bool;
}
unsafe extern "C" {
    /// @return true when the op stream is paused between body creation and world step.
    pub fn b3RecPlayer_IsAtPreStep(player: *const b3RecPlayer) -> bool;
}
unsafe extern "C" {
    /// @return true when any StateHash mismatch has been detected
    pub fn b3RecPlayer_HasDiverged(player: *const b3RecPlayer) -> bool;
}
unsafe extern "C" {
    /// @return a summary of the recording read at open: frame count, recorded tuning, and bounds
    pub fn b3RecPlayer_GetInfo(player: *const b3RecPlayer) -> b3RecPlayerInfo;
}
unsafe extern "C" {
    /// @return the first frame at which replay diverged, or -1 if it has not diverged
    pub fn b3RecPlayer_GetDivergeFrame(
        player: *const b3RecPlayer,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** Set the worker count of the replay world. Clamped to [1, B3_MAX_WORKERS]. Applied to the live
 world at once and reused whenever the player rebuilds its world on Restart or a backward seek.
 Replaying at a different count than recorded re-partitions the constraint graph, so the StateHash
 check becomes a cross-thread determinism test.*/
    pub fn b3RecPlayer_SetWorkerCount(
        player: *mut b3RecPlayer,
        count: ::std::os::raw::c_int,
    );
}
unsafe extern "C" {
    /** Tune the keyframe ring used to speed up backward seeking. A keyframe is a periodic snapshot the
 player restores from instead of replaying from the start, trading memory for seek speed.
 @param player the recording player
 @param budgetBytes memory cap for the kept snapshots; the spacing widens to stay under it
 @param minIntervalFrames finest spacing between keyframes, in frames
 A zero budget or a non-positive interval keeps that value. Clears the existing ring, so call
 b3RecPlayer_Restart afterward to repopulate it under the new policy.*/
    pub fn b3RecPlayer_SetKeyframePolicy(
        player: *mut b3RecPlayer,
        budgetBytes: usize,
        minIntervalFrames: ::std::os::raw::c_int,
    );
}
unsafe extern "C" {
    /// @return the keyframe memory budget in bytes
    pub fn b3RecPlayer_GetKeyframeBudget(player: *const b3RecPlayer) -> usize;
}
unsafe extern "C" {
    /// @return the finest keyframe spacing in frames
    pub fn b3RecPlayer_GetKeyframeMinInterval(
        player: *const b3RecPlayer,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** @return the current keyframe spacing in frames; starts at the min interval and doubles as the
 ring evicts to stay under budget, so it reflects the effective backward-seek granularity now*/
    pub fn b3RecPlayer_GetKeyframeInterval(
        player: *const b3RecPlayer,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// @return the memory currently held by keyframe snapshots, in bytes
    pub fn b3RecPlayer_GetKeyframeBytes(player: *const b3RecPlayer) -> usize;
}
unsafe extern "C" {
    /// @return the number of bodies tracked in creation order (including holes for destroyed bodies)
    pub fn b3RecPlayer_GetBodyCount(player: *const b3RecPlayer) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** Resolve a creation ordinal to the live body id at the current frame.
 @return the body id, or a null id if that ordinal is out of range or its body is destroyed*/
    pub fn b3RecPlayer_GetBodyId(
        player: *const b3RecPlayer,
        index: ::std::os::raw::c_int,
    ) -> b3BodyId;
}
unsafe extern "C" {
    /** Wire host debug-shape callbacks into the player's replay world so a renderer can build
 per-shape draw resources (the 3D sample needs this or the replay world draws nothing).
 Rebuilds the current world under the new callbacks and rewinds to frame 0, so call it
 once right after b3RecPlayer_Create and re-read the world id afterward. The callbacks
 persist across Restart and backward seeks, which recreate the world internally.
 @param player the player to configure
 @param createDebugShape called when a replayed shape is added; returns a user draw handle
 @param destroyDebugShape called when a replayed shape is removed; may be NULL
 @param context user context passed to both callbacks*/
    pub fn b3RecPlayer_SetDebugShapeCallbacks(
        player: *mut b3RecPlayer,
        createDebugShape: b3CreateDebugShapeCallback,
        destroyDebugShape: b3DestroyDebugShapeCallback,
        context: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    /** Draw the spatial queries recorded during the most recently replayed frame, layered on top of the
 world. Call after b3World_Draw. NULL draw function pointers are skipped.
 @param player a valid player handle
 @param draw debug draw callbacks
 @param queryIndex index of the frame query to draw, or -1 to draw all of them
 @param selectedIndex index of the query to emphasize (reserved color plus a label), or -1 for none*/
    pub fn b3RecPlayer_DrawFrameQueries(
        player: *mut b3RecPlayer,
        draw: *mut b3DebugDraw,
        queryIndex: ::std::os::raw::c_int,
        selectedIndex: ::std::os::raw::c_int,
    );
}
pub const b3RecQueryType_b3_recQueryOverlapAABB: b3RecQueryType = 0;
pub const b3RecQueryType_b3_recQueryOverlapShape: b3RecQueryType = 1;
pub const b3RecQueryType_b3_recQueryCastRay: b3RecQueryType = 2;
pub const b3RecQueryType_b3_recQueryCastShape: b3RecQueryType = 3;
pub const b3RecQueryType_b3_recQueryCastRayClosest: b3RecQueryType = 4;
pub const b3RecQueryType_b3_recQueryCastMover: b3RecQueryType = 5;
pub const b3RecQueryType_b3_recQueryCollideMover: b3RecQueryType = 6;
/// The kind of a recorded spatial query, matching the public query and cast functions.
pub type b3RecQueryType = ::std::os::raw::c_uint;
/// A spatial query recorded during a replayed frame, exposed for inspection.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3RecQueryInfo {
    pub type_: b3RecQueryType,
    pub filter: b3QueryFilter,
    pub aabb: b3AABB,
    pub origin: b3Pos,
    pub translation: b3Vec3,
    pub hitCount: ::std::os::raw::c_int,
    pub key: u64,
    pub id: u64,
    pub name: *const ::std::os::raw::c_char,
}
/// One result of a recorded spatial query.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct b3RecQueryHit {
    pub shape: b3ShapeId,
    pub point: b3Pos,
    pub normal: b3Vec3,
    pub fraction: f32,
}
unsafe extern "C" {
    /// @return the number of spatial queries recorded for the most recently replayed frame
    pub fn b3RecPlayer_GetFrameQueryCount(
        player: *const b3RecPlayer,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Get a recorded query from the most recently replayed frame by index.
    pub fn b3RecPlayer_GetFrameQuery(
        player: *const b3RecPlayer,
        index: ::std::os::raw::c_int,
    ) -> b3RecQueryInfo;
}
unsafe extern "C" {
    /// Get one result of a recorded query from the most recently replayed frame.
    pub fn b3RecPlayer_GetFrameQueryHit(
        player: *const b3RecPlayer,
        queryIndex: ::std::os::raw::c_int,
        hitIndex: ::std::os::raw::c_int,
    ) -> b3RecQueryHit;
}
unsafe extern "C" {
    /** Create a rigid body given a definition. No reference to the definition is retained. So you can create the definition
 on the stack and pass it as a pointer.
 @code{.c}
 b3BodyDef bodyDef = b3DefaultBodyDef();
 b3BodyId myBodyId = b3CreateBody(myWorldId, &bodyDef);
 @endcode
 @warning This function is locked during callbacks.*/
    pub fn b3CreateBody(worldId: b3WorldId, def: *const b3BodyDef) -> b3BodyId;
}
unsafe extern "C" {
    /** Destroy a rigid body given an id. This destroys all shapes and joints attached to the body.
 Do not keep references to the associated shapes and joints.*/
    pub fn b3DestroyBody(bodyId: b3BodyId);
}
unsafe extern "C" {
    /** Body identifier validation. A valid body exists in a world and is non-null.
 This can be used to detect orphaned ids. Provides validation for up to 64K allocations.*/
    pub fn b3Body_IsValid(id: b3BodyId) -> bool;
}
unsafe extern "C" {
    /// Get the body type: static, kinematic, or dynamic
    pub fn b3Body_GetType(bodyId: b3BodyId) -> b3BodyType;
}
unsafe extern "C" {
    /** Change the body type. This is an expensive operation. This automatically updates the mass
 properties regardless of the automatic mass setting.*/
    pub fn b3Body_SetType(bodyId: b3BodyId, type_: b3BodyType);
}
unsafe extern "C" {
    /// Set the body name.
    pub fn b3Body_SetName(bodyId: b3BodyId, name: *const ::std::os::raw::c_char);
}
unsafe extern "C" {
    /// Get the body name. Returns an empty string if the name isn't set.
    pub fn b3Body_GetName(bodyId: b3BodyId) -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    /// Set the user data for a body
    pub fn b3Body_SetUserData(bodyId: b3BodyId, userData: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
    /// Get the user data stored in a body
    pub fn b3Body_GetUserData(bodyId: b3BodyId) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    /// Get the world position of a body. This is the location of the body origin.
    pub fn b3Body_GetPosition(bodyId: b3BodyId) -> b3Pos;
}
unsafe extern "C" {
    /// Get the world rotation of a body as a quaternion
    pub fn b3Body_GetRotation(bodyId: b3BodyId) -> b3Quat;
}
unsafe extern "C" {
    /// Get the world transform of a body.
    pub fn b3Body_GetTransform(bodyId: b3BodyId) -> b3WorldTransform;
}
unsafe extern "C" {
    /** Set the world transform of a body. This acts as a teleport and is fairly expensive.
 @note Generally you should create a body with the intended transform.
 @see b3BodyDef::position and b3BodyDef::rotation.*/
    pub fn b3Body_SetTransform(bodyId: b3BodyId, position: b3Pos, rotation: b3Quat);
}
unsafe extern "C" {
    /// Get a local point on a body given a world point.
    pub fn b3Body_GetLocalPoint(bodyId: b3BodyId, worldPoint: b3Pos) -> b3Vec3;
}
unsafe extern "C" {
    /// Get a world point on a body given a local point.
    pub fn b3Body_GetWorldPoint(bodyId: b3BodyId, localPoint: b3Vec3) -> b3Pos;
}
unsafe extern "C" {
    /// Get a local vector on a body given a world vector.
    pub fn b3Body_GetLocalVector(bodyId: b3BodyId, worldVector: b3Vec3) -> b3Vec3;
}
unsafe extern "C" {
    /// Get a world vector on a body given a local vector.
    pub fn b3Body_GetWorldVector(bodyId: b3BodyId, localVector: b3Vec3) -> b3Vec3;
}
unsafe extern "C" {
    /// Get the linear velocity of a body's center of mass. Usually in meters per second.
    pub fn b3Body_GetLinearVelocity(bodyId: b3BodyId) -> b3Vec3;
}
unsafe extern "C" {
    /// Get the angular velocity of a body in radians per second.
    pub fn b3Body_GetAngularVelocity(bodyId: b3BodyId) -> b3Vec3;
}
unsafe extern "C" {
    /// Set the linear velocity of a body at the center of mass. Usually in meters per second.
    pub fn b3Body_SetLinearVelocity(bodyId: b3BodyId, linearVelocity: b3Vec3);
}
unsafe extern "C" {
    /// Set the angular velocity of a body in radians per second.
    pub fn b3Body_SetAngularVelocity(bodyId: b3BodyId, angularVelocity: b3Vec3);
}
unsafe extern "C" {
    /** Set the velocity to reach the given transform after a given time step.
 The result will be close but maybe not exact. This is meant for kinematic bodies.
 The target is not applied if the velocity would be below the sleep threshold.
 This will optionally wake the body if asleep, but only if the movement is significant.*/
    pub fn b3Body_SetTargetTransform(
        bodyId: b3BodyId,
        target: b3WorldTransform,
        timeStep: f32,
        wake: bool,
    );
}
unsafe extern "C" {
    /// Get the linear velocity of a local point attached to a body. Usually in meters per second.
    pub fn b3Body_GetLocalPointVelocity(bodyId: b3BodyId, localPoint: b3Vec3) -> b3Vec3;
}
unsafe extern "C" {
    /// Get the linear velocity of a world point attached to a body. Usually in meters per second.
    pub fn b3Body_GetWorldPointVelocity(bodyId: b3BodyId, worldPoint: b3Pos) -> b3Vec3;
}
unsafe extern "C" {
    /** Apply a force at a world point. If the force is not applied at the center of mass,
 it will generate a torque and affect the angular velocity. This optionally wakes up the body.
 The force is ignored if the body is not awake.
 @param bodyId The body id
 @param force The world force vector, usually in newtons (N)
 @param point The world position of the point of application
 @param wake Option to wake up the body*/
    pub fn b3Body_ApplyForce(bodyId: b3BodyId, force: b3Vec3, point: b3Pos, wake: bool);
}
unsafe extern "C" {
    /** Apply a force to the center of mass. This optionally wakes up the body.
 The force is ignored if the body is not awake.
 @param bodyId The body id
 @param force the world force vector, usually in newtons (N).
 @param wake also wake up the body*/
    pub fn b3Body_ApplyForceToCenter(bodyId: b3BodyId, force: b3Vec3, wake: bool);
}
unsafe extern "C" {
    /** Apply a torque. This affects the angular velocity without affecting the linear velocity.
 This optionally wakes the body. The torque is ignored if the body is not awake.
 @param bodyId The body id
 @param torque the world torque vector, usually in N*m.
 @param wake also wake up the body*/
    pub fn b3Body_ApplyTorque(bodyId: b3BodyId, torque: b3Vec3, wake: bool);
}
unsafe extern "C" {
    /** Apply an impulse at a point. This immediately modifies the velocity.
 It also modifies the angular velocity if the point of application
 is not at the center of mass. This optionally wakes the body.
 The impulse is ignored if the body is not awake.
 @param bodyId The body id
 @param impulse the world impulse vector, usually in N*s or kg*m/s.
 @param point the world position of the point of application.
 @param wake also wake up the body
 @warning This should be used for one-shot impulses. If you need a steady force,
 use a force instead, which will work better with the sub-stepping solver.*/
    pub fn b3Body_ApplyLinearImpulse(
        bodyId: b3BodyId,
        impulse: b3Vec3,
        point: b3Pos,
        wake: bool,
    );
}
unsafe extern "C" {
    /** Apply an impulse to the center of mass. This immediately modifies the velocity.
 The impulse is ignored if the body is not awake. This optionally wakes the body.
 @param bodyId The body id
 @param impulse the world impulse vector, usually in N*s or kg*m/s.
 @param wake also wake up the body
 @warning This should be used for one-shot impulses. If you need a steady force,
 use a force instead, which will work better with the sub-stepping solver.*/
    pub fn b3Body_ApplyLinearImpulseToCenter(
        bodyId: b3BodyId,
        impulse: b3Vec3,
        wake: bool,
    );
}
unsafe extern "C" {
    /** Apply an angular impulse in world space. The impulse is ignored if the body is not awake.
 This optionally wakes the body.
 @param bodyId The body id
 @param impulse the world angular impulse vector, usually in units of kg*m*m/s
 @param wake also wake up the body
 @warning This should be used for one-shot impulses. If you need a steady torque,
 use a torque instead, which will work better with the sub-stepping solver.*/
    pub fn b3Body_ApplyAngularImpulse(bodyId: b3BodyId, impulse: b3Vec3, wake: bool);
}
unsafe extern "C" {
    /// Get the mass of the body, usually in kilograms
    pub fn b3Body_GetMass(bodyId: b3BodyId) -> f32;
}
unsafe extern "C" {
    /// Get the rotational inertia of the body in local space, usually in kg*m^2
    pub fn b3Body_GetLocalRotationalInertia(bodyId: b3BodyId) -> b3Matrix3;
}
unsafe extern "C" {
    /// Get the inverse mass of the body, usually in 1/kilograms
    pub fn b3Body_GetInverseMass(bodyId: b3BodyId) -> f32;
}
unsafe extern "C" {
    /// Get the inverse rotational inertia of the body in world space, usually in 1/kg*m^2
    pub fn b3Body_GetWorldInverseRotationalInertia(bodyId: b3BodyId) -> b3Matrix3;
}
unsafe extern "C" {
    /// Get the center of mass position of the body in local space
    pub fn b3Body_GetLocalCenter(bodyId: b3BodyId) -> b3Vec3;
}
unsafe extern "C" {
    /// Get the center of mass position of the body in world space
    pub fn b3Body_GetWorldCenter(bodyId: b3BodyId) -> b3Pos;
}
unsafe extern "C" {
    /** Override the body's mass properties. Normally this is computed automatically using the
 shape geometry and density. This information is lost if a shape is added or removed or if the
 body type changes.*/
    pub fn b3Body_SetMassData(bodyId: b3BodyId, massData: b3MassData);
}
unsafe extern "C" {
    /// Get the mass data for a body
    pub fn b3Body_GetMassData(bodyId: b3BodyId) -> b3MassData;
}
unsafe extern "C" {
    /** This updates the mass properties to the sum of the mass properties of the shapes.
 This normally does not need to be called unless you called SetMassData to override
 the mass and you later want to reset the mass.
 You may also use this when automatic mass computation has been disabled.
 You should call this regardless of body type.*/
    pub fn b3Body_ApplyMassFromShapes(bodyId: b3BodyId);
}
unsafe extern "C" {
    /// Adjust the linear damping. Normally this is set in b3BodyDef before creation.
    pub fn b3Body_SetLinearDamping(bodyId: b3BodyId, linearDamping: f32);
}
unsafe extern "C" {
    /// Get the current linear damping.
    pub fn b3Body_GetLinearDamping(bodyId: b3BodyId) -> f32;
}
unsafe extern "C" {
    /// Adjust the angular damping. Normally this is set in b3BodyDef before creation.
    pub fn b3Body_SetAngularDamping(bodyId: b3BodyId, angularDamping: f32);
}
unsafe extern "C" {
    /// Get the current angular damping.
    pub fn b3Body_GetAngularDamping(bodyId: b3BodyId) -> f32;
}
unsafe extern "C" {
    /** Adjust the gravity scale. Normally this is set in b3BodyDef before creation.
 @see b3BodyDef::gravityScale*/
    pub fn b3Body_SetGravityScale(bodyId: b3BodyId, gravityScale: f32);
}
unsafe extern "C" {
    /// Get the current gravity scale
    pub fn b3Body_GetGravityScale(bodyId: b3BodyId) -> f32;
}
unsafe extern "C" {
    /// @return true if this body is awake
    pub fn b3Body_IsAwake(bodyId: b3BodyId) -> bool;
}
unsafe extern "C" {
    /** Wake a body from sleep. This wakes the entire island the body is touching.
 @warning Putting a body to sleep will put the entire island of bodies touching this body to sleep,
 which can be expensive and possibly unintuitive.*/
    pub fn b3Body_SetAwake(bodyId: b3BodyId, awake: bool);
}
unsafe extern "C" {
    /// Enable or disable sleeping for this body. If sleeping is disabled the body will wake.
    pub fn b3Body_EnableSleep(bodyId: b3BodyId, enableSleep: bool);
}
unsafe extern "C" {
    /// Returns true if sleeping is enabled for this body
    pub fn b3Body_IsSleepEnabled(bodyId: b3BodyId) -> bool;
}
unsafe extern "C" {
    /// Set the sleep threshold, usually in meters per second
    pub fn b3Body_SetSleepThreshold(bodyId: b3BodyId, sleepThreshold: f32);
}
unsafe extern "C" {
    /// Get the sleep threshold, usually in meters per second.
    pub fn b3Body_GetSleepThreshold(bodyId: b3BodyId) -> f32;
}
unsafe extern "C" {
    /// Returns true if this body is enabled
    pub fn b3Body_IsEnabled(bodyId: b3BodyId) -> bool;
}
unsafe extern "C" {
    /// Disable a body by removing it completely from the simulation. This is expensive.
    pub fn b3Body_Disable(bodyId: b3BodyId);
}
unsafe extern "C" {
    /// Enable a body by adding it to the simulation. This is expensive.
    pub fn b3Body_Enable(bodyId: b3BodyId);
}
unsafe extern "C" {
    /// Set the motion locks on this body.
    pub fn b3Body_SetMotionLocks(bodyId: b3BodyId, locks: b3MotionLocks);
}
unsafe extern "C" {
    /// Get the motion locks for this body.
    pub fn b3Body_GetMotionLocks(bodyId: b3BodyId) -> b3MotionLocks;
}
unsafe extern "C" {
    /** Set this body to be a bullet. A bullet does continuous collision detection
 against dynamic bodies (but not other bullets).*/
    pub fn b3Body_SetBullet(bodyId: b3BodyId, flag: bool);
}
unsafe extern "C" {
    /// Is this body a bullet?
    pub fn b3Body_IsBullet(bodyId: b3BodyId) -> bool;
}
unsafe extern "C" {
    /** Allow this body to rotate fast. Useful for axially symmetric bodies, such as vehicle wheels.
 Normally rotation speed is clamped to improve CCD. However, this clamping is unnecessary for
 bodies that only rotate fast around an axis of symmetry.*/
    pub fn b3Body_AllowFastRotation(bodyId: b3BodyId, flag: bool);
}
unsafe extern "C" {
    /// Is this body allowed to rotate fast?
    pub fn b3Body_IsFastRotationAllowed(bodyId: b3BodyId) -> bool;
}
unsafe extern "C" {
    /** Enable or disable contact recycling for this body. Contact recycling is a performance optimization
 that reuses contact manifolds when bodies move slightly. Disabling it can avoid ghost collisions
 on characters at the cost of higher per-step work. Existing contacts retain their prior setting;
 only contacts created after this call see the new value.
 @see b3BodyDef::enableContactRecycling*/
    pub fn b3Body_EnableContactRecycling(bodyId: b3BodyId, flag: bool);
}
unsafe extern "C" {
    /// Is contact recycling enabled on this body?
    pub fn b3Body_IsContactRecyclingEnabled(bodyId: b3BodyId) -> bool;
}
unsafe extern "C" {
    /** Enable/disable hit events on all shapes
 @see b3ShapeDef::enableHitEvents*/
    pub fn b3Body_EnableHitEvents(bodyId: b3BodyId, flag: bool);
}
unsafe extern "C" {
    /// Get the world that owns this body
    pub fn b3Body_GetWorld(bodyId: b3BodyId) -> b3WorldId;
}
unsafe extern "C" {
    /// Get the number of shapes on this body
    pub fn b3Body_GetShapeCount(bodyId: b3BodyId) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** Get the shape ids for all shapes on this body, up to the provided capacity.
 @returns the number of shape ids stored in the user array*/
    pub fn b3Body_GetShapes(
        bodyId: b3BodyId,
        shapeArray: *mut b3ShapeId,
        capacity: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Get the number of joints on this body
    pub fn b3Body_GetJointCount(bodyId: b3BodyId) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** Get the joint ids for all joints on this body, up to the provided capacity
 @returns the number of joint ids stored in the user array*/
    pub fn b3Body_GetJoints(
        bodyId: b3BodyId,
        jointArray: *mut b3JointId,
        capacity: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Get the maximum capacity required for retrieving all the touching contacts on a body
    pub fn b3Body_GetContactCapacity(bodyId: b3BodyId) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Get the touching contact data for a body
    pub fn b3Body_GetContactData(
        bodyId: b3BodyId,
        contactData: *mut b3ContactData,
        capacity: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** Get the current world AABB that contains all the attached shapes. Note that this may not encompass the body origin.
 If there are no shapes attached then the returned AABB is empty and centered on the body origin.*/
    pub fn b3Body_ComputeAABB(bodyId: b3BodyId) -> b3AABB;
}
unsafe extern "C" {
    /// Get the closest point on a body to a world target.
    pub fn b3Body_GetClosestPoint(
        bodyId: b3BodyId,
        result: *mut b3Vec3,
        target: b3Vec3,
    ) -> f32;
}
unsafe extern "C" {
    /// Cast a ray at a specific body using a specified body transform.
    pub fn b3Body_CastRay(
        bodyId: b3BodyId,
        origin: b3Pos,
        translation: b3Vec3,
        filter: b3QueryFilter,
        maxFraction: f32,
        bodyTransform: b3WorldTransform,
    ) -> b3BodyCastResult;
}
unsafe extern "C" {
    /// Cast a shape at a specific body using a specified body transform.
    pub fn b3Body_CastShape(
        bodyId: b3BodyId,
        origin: b3Pos,
        proxy: *const b3ShapeProxy,
        translation: b3Vec3,
        filter: b3QueryFilter,
        maxFraction: f32,
        canEncroach: bool,
        bodyTransform: b3WorldTransform,
    ) -> b3BodyCastResult;
}
unsafe extern "C" {
    /// Overlap a shape with a specific body using a specified body transform.
    pub fn b3Body_OverlapShape(
        bodyId: b3BodyId,
        origin: b3Pos,
        proxy: *const b3ShapeProxy,
        filter: b3QueryFilter,
        bodyTransform: b3WorldTransform,
    ) -> bool;
}
unsafe extern "C" {
    /// Collide a character mover with a specific body using a specified body transform.
    pub fn b3Body_CollideMover(
        bodyId: b3BodyId,
        bodyPlanes: *mut b3BodyPlaneResult,
        planeCapacity: ::std::os::raw::c_int,
        origin: b3Pos,
        mover: *const b3Capsule,
        filter: b3QueryFilter,
        bodyTransform: b3WorldTransform,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** Create a circle shape and attach it to a body. The shape definition and geometry are fully cloned.
 Contacts are not created until the next time step.
 @return the shape id for accessing the shape*/
    pub fn b3CreateSphereShape(
        bodyId: b3BodyId,
        def: *const b3ShapeDef,
        sphere: *const b3Sphere,
    ) -> b3ShapeId;
}
unsafe extern "C" {
    /** Create a capsule shape and attach it to a body. The shape definition and geometry are fully cloned.
 Contacts are not created until the next time step.
 @return the shape id for accessing the shape*/
    pub fn b3CreateCapsuleShape(
        bodyId: b3BodyId,
        def: *const b3ShapeDef,
        capsule: *const b3Capsule,
    ) -> b3ShapeId;
}
unsafe extern "C" {
    /** Create a convex hull shape and attach it to a body. The shape definition is fully cloned. Contacts are not created
 until the next time step.
 @return the shape id for accessing the shape*/
    pub fn b3CreateHullShape(
        bodyId: b3BodyId,
        def: *const b3ShapeDef,
        hull: *const b3HullData,
    ) -> b3ShapeId;
}
unsafe extern "C" {
    /** Create a convex hull shape and attach it to a body. The hull is cloned then transformed with scale applied first.
 Use this for non-uniform or mirrored scale or a baked local transform. The baked result is shared through the
 world hull database. The shape definition and geometry are fully cloned. Contacts are not created until the next time step.
 @return the shape id for accessing the shape*/
    pub fn b3CreateTransformedHullShape(
        bodyId: b3BodyId,
        def: *const b3ShapeDef,
        hull: *const b3HullData,
        transform: b3Transform,
        scale: b3Vec3,
    ) -> b3ShapeId;
}
unsafe extern "C" {
    /** Create a mesh hull shape and attach it to a body. The shape definition is fully cloned but the mesh is not.
 Contacts are not created until the next time step.
 Mesh collision only creates contacts on static bodies.
 @warning this holds reference to the input mesh data which must remain valid for the lifetime of this shape
 @return the shape id for accessing the shape*/
    pub fn b3CreateMeshShape(
        bodyId: b3BodyId,
        def: *const b3ShapeDef,
        mesh: *const b3MeshData,
        scale: b3Vec3,
    ) -> b3ShapeId;
}
unsafe extern "C" {
    /** Create a height-field shape and attach it to a body. The shape definition is fully cloned but the height field is not.
 Contacts are not created until the next time step.
 Height field is only allowed on static bodies.
 @warning this holds reference to the input height field which must remain valid for the lifetime of this shape
 @return the shape id for accessing the shape*/
    pub fn b3CreateHeightFieldShape(
        bodyId: b3BodyId,
        def: *const b3ShapeDef,
        heightField: *const b3HeightFieldData,
    ) -> b3ShapeId;
}
unsafe extern "C" {
    /** Baked compound shapes are only allowed on static bodies.
 Note: runtime compounds are achieved by adding multiple shapes to a body.
 Runtime compounds can be dynamic and/or kinematic.*/
    pub fn b3CreateBakedCompoundShape(
        bodyId: b3BodyId,
        def: *mut b3ShapeDef,
        compound: *const b3CompoundData,
    ) -> b3ShapeId;
}
unsafe extern "C" {
    /** Destroy a shape. You may defer the body mass update which can improve performance if several shapes on a
	body are destroyed at once.
	@see b3Body_ApplyMassFromShapes*/
    pub fn b3DestroyShape(shapeId: b3ShapeId, updateBodyMass: bool);
}
unsafe extern "C" {
    /// Shape identifier validation. Provides validation for up to 64K allocations.
    pub fn b3Shape_IsValid(id: b3ShapeId) -> bool;
}
unsafe extern "C" {
    /// Get the type of a shape
    pub fn b3Shape_GetType(shapeId: b3ShapeId) -> b3ShapeType;
}
unsafe extern "C" {
    /// Get the id of the body that a shape is attached to
    pub fn b3Shape_GetBody(shapeId: b3ShapeId) -> b3BodyId;
}
unsafe extern "C" {
    /// Get the world that owns this shape
    pub fn b3Shape_GetWorld(shapeId: b3ShapeId) -> b3WorldId;
}
unsafe extern "C" {
    /// Returns true if the shape is a sensor
    pub fn b3Shape_IsSensor(shapeId: b3ShapeId) -> bool;
}
unsafe extern "C" {
    /// Set the shape name.
    pub fn b3Shape_SetName(shapeId: b3ShapeId, name: *const ::std::os::raw::c_char);
}
unsafe extern "C" {
    /// Get the shape name. Returns an empty string if the name isn't set.
    pub fn b3Shape_GetName(shapeId: b3ShapeId) -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    /// Set the user data for a shape
    pub fn b3Shape_SetUserData(
        shapeId: b3ShapeId,
        userData: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    /** Get the user data for a shape. This is useful when you get a shape id
 from an event or query.*/
    pub fn b3Shape_GetUserData(shapeId: b3ShapeId) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    /** Set the mass density of a shape, usually in kg/m^3.
 This will optionally update the mass properties on the parent body.
 @see b3ShapeDef::density, b3Body_ApplyMassFromShapes*/
    pub fn b3Shape_SetDensity(shapeId: b3ShapeId, density: f32, updateBodyMass: bool);
}
unsafe extern "C" {
    /// Get the density of a shape, usually in kg/m^3
    pub fn b3Shape_GetDensity(shapeId: b3ShapeId) -> f32;
}
unsafe extern "C" {
    /// Set the friction on a shape
    pub fn b3Shape_SetFriction(shapeId: b3ShapeId, friction: f32);
}
unsafe extern "C" {
    /// Get the friction of a shape
    pub fn b3Shape_GetFriction(shapeId: b3ShapeId) -> f32;
}
unsafe extern "C" {
    /// Set the shape restitution (bounciness)
    pub fn b3Shape_SetRestitution(shapeId: b3ShapeId, restitution: f32);
}
unsafe extern "C" {
    /// Get the shape restitution
    pub fn b3Shape_GetRestitution(shapeId: b3ShapeId) -> f32;
}
unsafe extern "C" {
    /// Set the shape base surface material. Does not change per triangle materials.
    pub fn b3Shape_SetSurfaceMaterial(
        shapeId: b3ShapeId,
        surfaceMaterial: b3SurfaceMaterial,
    );
}
unsafe extern "C" {
    /// Get the base shape surface material.
    pub fn b3Shape_GetSurfaceMaterial(shapeId: b3ShapeId) -> b3SurfaceMaterial;
}
unsafe extern "C" {
    /// Get the number of mesh surface materials.
    pub fn b3Shape_GetMeshMaterialCount(shapeId: b3ShapeId) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Set a surface material for a mesh shape.
    pub fn b3Shape_SetMeshMaterial(
        shapeId: b3ShapeId,
        surfaceMaterial: b3SurfaceMaterial,
        index: ::std::os::raw::c_int,
    );
}
unsafe extern "C" {
    /// Get a surface material for a mesh shape
    pub fn b3Shape_GetMeshSurfaceMaterial(
        shapeId: b3ShapeId,
        index: ::std::os::raw::c_int,
    ) -> b3SurfaceMaterial;
}
unsafe extern "C" {
    /// Get the shape filter
    pub fn b3Shape_GetFilter(shapeId: b3ShapeId) -> b3Filter;
}
unsafe extern "C" {
    /** Set the current filter. This is almost as expensive as recreating the shape.
 @see b3ShapeDef::filter
 @param shapeId the shape
 @param filter the new filter
 @param invokeContacts if true then the shape will have all contacts recomputed the next time step (expensive)*/
    pub fn b3Shape_SetFilter(shapeId: b3ShapeId, filter: b3Filter, invokeContacts: bool);
}
unsafe extern "C" {
    /** Enable sensor events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors.
 @see b3ShapeDef::isSensor*/
    pub fn b3Shape_EnableSensorEvents(shapeId: b3ShapeId, flag: bool);
}
unsafe extern "C" {
    /// Returns true if sensor events are enabled
    pub fn b3Shape_AreSensorEventsEnabled(shapeId: b3ShapeId) -> bool;
}
unsafe extern "C" {
    /** Enable contact events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors.
 @see b3ShapeDef::enableContactEvents*/
    pub fn b3Shape_EnableContactEvents(shapeId: b3ShapeId, flag: bool);
}
unsafe extern "C" {
    /// Returns true if contact events are enabled
    pub fn b3Shape_AreContactEventsEnabled(shapeId: b3ShapeId) -> bool;
}
unsafe extern "C" {
    /** Enable pre-solve contact events for this shape. Only applies to dynamic bodies. These are expensive
 and must be carefully handled due to multithreading. Ignored for sensors.
 @see b3PreSolveFcn*/
    pub fn b3Shape_EnablePreSolveEvents(shapeId: b3ShapeId, flag: bool);
}
unsafe extern "C" {
    /// Returns true if pre-solve events are enabled
    pub fn b3Shape_ArePreSolveEventsEnabled(shapeId: b3ShapeId) -> bool;
}
unsafe extern "C" {
    /** Enable contact hit events for this shape. Ignored for sensors.
 @see b3WorldDef.hitEventThreshold*/
    pub fn b3Shape_EnableHitEvents(shapeId: b3ShapeId, flag: bool);
}
unsafe extern "C" {
    /// Returns true if hit events are enabled
    pub fn b3Shape_AreHitEventsEnabled(shapeId: b3ShapeId) -> bool;
}
unsafe extern "C" {
    /** Ray cast a shape directly. The ray runs from origin to origin + translation and the hit point
 comes back as a world position, so the cast stays precise far from the world origin.*/
    pub fn b3Shape_RayCast(
        shapeId: b3ShapeId,
        origin: b3Pos,
        translation: b3Vec3,
    ) -> b3WorldCastOutput;
}
unsafe extern "C" {
    /// Get a copy of the shape's sphere. Asserts the type is correct.
    pub fn b3Shape_GetSphere(shapeId: b3ShapeId) -> b3Sphere;
}
unsafe extern "C" {
    /// Get a copy of the shape's capsule. Asserts the type is correct.
    pub fn b3Shape_GetCapsule(shapeId: b3ShapeId) -> b3Capsule;
}
unsafe extern "C" {
    /// Get the shape's convex hull. Asserts the type is correct.
    pub fn b3Shape_GetHull(shapeId: b3ShapeId) -> *const b3HullData;
}
unsafe extern "C" {
    /// Get the shape's mesh. Asserts the type is correct.
    pub fn b3Shape_GetMesh(shapeId: b3ShapeId) -> b3Mesh;
}
unsafe extern "C" {
    /// Get the shape's height field. Asserts the type is correct.
    pub fn b3Shape_GetHeightField(shapeId: b3ShapeId) -> *const b3HeightFieldData;
}
unsafe extern "C" {
    /** Allows you to change a shape to be a sphere or update the current sphere.
 This does not modify the mass properties.
 @see b3Body_ApplyMassFromShapes*/
    pub fn b3Shape_SetSphere(shapeId: b3ShapeId, sphere: *const b3Sphere);
}
unsafe extern "C" {
    /** Allows you to change a shape to be a capsule or update the current capsule.
 This does not modify the mass properties.
 @see b3Body_ApplyMassFromShapes*/
    pub fn b3Shape_SetCapsule(shapeId: b3ShapeId, capsule: *const b3Capsule);
}
unsafe extern "C" {
    /** Allows you to change a shape to be a hull or update the current hull.
 This does not modify the mass properties.
 @see b3Body_ApplyMassFromShapes*/
    pub fn b3Shape_SetHull(shapeId: b3ShapeId, hull: *const b3HullData);
}
unsafe extern "C" {
    /** Allows you to change a shape to be a mesh or update the current mesh.
 This does not modify the mass properties.
 @see b3Body_ApplyMassFromShapes*/
    pub fn b3Shape_SetMesh(
        shapeId: b3ShapeId,
        meshData: *const b3MeshData,
        scale: b3Vec3,
    );
}
unsafe extern "C" {
    /// Get the maximum capacity required for retrieving all the touching contacts on a shape
    pub fn b3Shape_GetContactCapacity(shapeId: b3ShapeId) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** Get the touching contact data for a shape. The provided shapeId will be either shapeIdA or shapeIdB on the contact data.
 @note Box3D uses speculative collision so some contact points may be separated.
 @returns the number of elements filled in the provided array
 @warning do not ignore the return value, it specifies the valid number of elements*/
    pub fn b3Shape_GetContactData(
        shapeId: b3ShapeId,
        contactData: *mut b3ContactData,
        capacity: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** Get the maximum capacity required for retrieving all the overlapped shapes on a sensor shape.
 This returns 0 if the provided shape is not a sensor.
 @param shapeId the id of a sensor shape
 @returns the required capacity to get all the overlaps in b3Shape_GetSensorOverlaps*/
    pub fn b3Shape_GetSensorCapacity(shapeId: b3ShapeId) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /** Get the overlap data for a sensor shape.
 @param shapeId the id of a sensor shape
 @param visitorIds a user allocated array that is filled with the overlapping shapes (visitors)
 @param capacity the capacity of overlappedShapes
 @returns the number of elements filled in the provided array
 @warning do not ignore the return value, it specifies the valid number of elements
 @warning overlaps may contain destroyed shapes so use b3Shape_IsValid to confirm each overlap*/
    pub fn b3Shape_GetSensorData(
        shapeId: b3ShapeId,
        visitorIds: *mut b3ShapeId,
        capacity: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
    /// Get the current world AABB
    pub fn b3Shape_GetAABB(shapeId: b3ShapeId) -> b3AABB;
}
unsafe extern "C" {
    /// Compute the mass data for a shape
    pub fn b3Shape_ComputeMassData(shapeId: b3ShapeId) -> b3MassData;
}
unsafe extern "C" {
    /// Get the closest point on a shape to a target point. Target and result are in world space.
    pub fn b3Shape_GetClosestPoint(shapeId: b3ShapeId, target: b3Vec3) -> b3Vec3;
}
unsafe extern "C" {
    /** Apply a wind force to the body for this shape using the density of air. This considers
 the projected area of the shape in the wind direction. This also considers
 the relative velocity of the shape.
 @param shapeId the shape id
 @param wind the wind velocity in world space
 @param drag the drag coefficient, the force that opposes the relative velocity
 @param lift the lift coefficient, the force that is perpendicular to the relative velocity
 @param maxSpeed the maximum relative speed. Speed cap is necessary for stability. Typically 10m/s or less.
 @param wake should this wake the body*/
    pub fn b3Shape_ApplyWind(
        shapeId: b3ShapeId,
        wind: b3Vec3,
        drag: f32,
        lift: f32,
        maxSpeed: f32,
        wake: bool,
    );
}
unsafe extern "C" {
    /// Destroy a joint
    pub fn b3DestroyJoint(jointId: b3JointId, wakeAttached: bool);
}
unsafe extern "C" {
    /// Joint identifier validation. Provides validation for up to 64K allocations.
    pub fn b3Joint_IsValid(id: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Get the joint type
    pub fn b3Joint_GetType(jointId: b3JointId) -> b3JointType;
}
unsafe extern "C" {
    /// Get body A id on a joint
    pub fn b3Joint_GetBodyA(jointId: b3JointId) -> b3BodyId;
}
unsafe extern "C" {
    /// Get body B id on a joint
    pub fn b3Joint_GetBodyB(jointId: b3JointId) -> b3BodyId;
}
unsafe extern "C" {
    /// Get the world that owns this joint
    pub fn b3Joint_GetWorld(jointId: b3JointId) -> b3WorldId;
}
unsafe extern "C" {
    /// Set the local frame on bodyA
    pub fn b3Joint_SetLocalFrameA(jointId: b3JointId, localFrame: b3Transform);
}
unsafe extern "C" {
    /// Get the local frame on bodyA
    pub fn b3Joint_GetLocalFrameA(jointId: b3JointId) -> b3Transform;
}
unsafe extern "C" {
    /// Set the local frame on bodyB
    pub fn b3Joint_SetLocalFrameB(jointId: b3JointId, localFrame: b3Transform);
}
unsafe extern "C" {
    /// Get the local frame on bodyB
    pub fn b3Joint_GetLocalFrameB(jointId: b3JointId) -> b3Transform;
}
unsafe extern "C" {
    /// Toggle collision between connected bodies
    pub fn b3Joint_SetCollideConnected(jointId: b3JointId, shouldCollide: bool);
}
unsafe extern "C" {
    /// Is collision allowed between connected bodies?
    pub fn b3Joint_GetCollideConnected(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the user data on a joint
    pub fn b3Joint_SetUserData(
        jointId: b3JointId,
        userData: *mut ::std::os::raw::c_void,
    );
}
unsafe extern "C" {
    /// Get the user data on a joint
    pub fn b3Joint_GetUserData(jointId: b3JointId) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    /// Wake the bodies connect to this joint
    pub fn b3Joint_WakeBodies(jointId: b3JointId);
}
unsafe extern "C" {
    /// Get the current constraint force for this joint
    pub fn b3Joint_GetConstraintForce(jointId: b3JointId) -> b3Vec3;
}
unsafe extern "C" {
    /// Get the current constraint torque for this joint
    pub fn b3Joint_GetConstraintTorque(jointId: b3JointId) -> b3Vec3;
}
unsafe extern "C" {
    /// Get the current linear separation error for this joint. Does not consider admissible movement. Usually in meters.
    pub fn b3Joint_GetLinearSeparation(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the current angular separation error for this joint. Does not consider admissible movement. Usually in radians.
    pub fn b3Joint_GetAngularSeparation(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /** Set the joint constraint tuning. Advanced feature.
 @param jointId the joint
 @param hertz the stiffness in Hertz (cycles per second)
 @param dampingRatio the non-dimensional damping ratio (one for critical damping)*/
    pub fn b3Joint_SetConstraintTuning(
        jointId: b3JointId,
        hertz: f32,
        dampingRatio: f32,
    );
}
unsafe extern "C" {
    /// Get the joint constraint tuning. Advanced feature.
    pub fn b3Joint_GetConstraintTuning(
        jointId: b3JointId,
        hertz: *mut f32,
        dampingRatio: *mut f32,
    );
}
unsafe extern "C" {
    /// Set the force threshold for joint events (Newtons)
    pub fn b3Joint_SetForceThreshold(jointId: b3JointId, threshold: f32);
}
unsafe extern "C" {
    /// Get the force threshold for joint events (Newtons)
    pub fn b3Joint_GetForceThreshold(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the torque threshold for joint events (N-m)
    pub fn b3Joint_SetTorqueThreshold(jointId: b3JointId, threshold: f32);
}
unsafe extern "C" {
    /// Get the torque threshold for joint events (N-m)
    pub fn b3Joint_GetTorqueThreshold(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /** Create a parallel joint
 @see b3ParallelJointDef for details*/
    pub fn b3CreateParallelJoint(
        worldId: b3WorldId,
        def: *const b3ParallelJointDef,
    ) -> b3JointId;
}
unsafe extern "C" {
    /// Set the spring stiffness in Hertz
    pub fn b3ParallelJoint_SetSpringHertz(jointId: b3JointId, hertz: f32);
}
unsafe extern "C" {
    /// Set the spring damping ratio, non-dimensional
    pub fn b3ParallelJoint_SetSpringDampingRatio(jointId: b3JointId, dampingRatio: f32);
}
unsafe extern "C" {
    /// Get the spring Hertz
    pub fn b3ParallelJoint_GetSpringHertz(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the spring damping ratio
    pub fn b3ParallelJoint_GetSpringDampingRatio(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the maximum spring torque, usually in newton-meters
    pub fn b3ParallelJoint_SetMaxTorque(jointId: b3JointId, force: f32);
}
unsafe extern "C" {
    /// Get the maximum spring torque, usually in newton-meters
    pub fn b3ParallelJoint_GetMaxTorque(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /** Create a distance joint
 @see b3DistanceJointDef for details*/
    pub fn b3CreateDistanceJoint(
        worldId: b3WorldId,
        def: *const b3DistanceJointDef,
    ) -> b3JointId;
}
unsafe extern "C" {
    /** Set the rest length of a distance joint
 @param jointId The id for a distance joint
 @param length The new distance joint length*/
    pub fn b3DistanceJoint_SetLength(jointId: b3JointId, length: f32);
}
unsafe extern "C" {
    /// Get the rest length of a distance joint
    pub fn b3DistanceJoint_GetLength(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Enable/disable the distance joint spring. When disabled the distance joint is rigid.
    pub fn b3DistanceJoint_EnableSpring(jointId: b3JointId, enableSpring: bool);
}
unsafe extern "C" {
    /// Is the distance joint spring enabled?
    pub fn b3DistanceJoint_IsSpringEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the force range for the spring.
    pub fn b3DistanceJoint_SetSpringForceRange(
        jointId: b3JointId,
        lowerForce: f32,
        upperForce: f32,
    );
}
unsafe extern "C" {
    /// Get the force range for the spring.
    pub fn b3DistanceJoint_GetSpringForceRange(
        jointId: b3JointId,
        lowerForce: *mut f32,
        upperForce: *mut f32,
    );
}
unsafe extern "C" {
    /// Set the spring stiffness in Hertz
    pub fn b3DistanceJoint_SetSpringHertz(jointId: b3JointId, hertz: f32);
}
unsafe extern "C" {
    /// Set the spring damping ratio, non-dimensional
    pub fn b3DistanceJoint_SetSpringDampingRatio(jointId: b3JointId, dampingRatio: f32);
}
unsafe extern "C" {
    /// Get the spring Hertz
    pub fn b3DistanceJoint_GetSpringHertz(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the spring damping ratio
    pub fn b3DistanceJoint_GetSpringDampingRatio(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /** Enable joint limit. The limit only works if the joint spring is enabled. Otherwise the joint is rigid
 and the limit has no effect.*/
    pub fn b3DistanceJoint_EnableLimit(jointId: b3JointId, enableLimit: bool);
}
unsafe extern "C" {
    /// Is the distance joint limit enabled?
    pub fn b3DistanceJoint_IsLimitEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the minimum and maximum length parameters of a distance joint
    pub fn b3DistanceJoint_SetLengthRange(
        jointId: b3JointId,
        minLength: f32,
        maxLength: f32,
    );
}
unsafe extern "C" {
    /// Get the distance joint minimum length
    pub fn b3DistanceJoint_GetMinLength(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the distance joint maximum length
    pub fn b3DistanceJoint_GetMaxLength(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the current length of a distance joint
    pub fn b3DistanceJoint_GetCurrentLength(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Enable/disable the distance joint motor
    pub fn b3DistanceJoint_EnableMotor(jointId: b3JointId, enableMotor: bool);
}
unsafe extern "C" {
    /// Is the distance joint motor enabled?
    pub fn b3DistanceJoint_IsMotorEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the distance joint motor speed, usually in meters per second
    pub fn b3DistanceJoint_SetMotorSpeed(jointId: b3JointId, motorSpeed: f32);
}
unsafe extern "C" {
    /// Get the distance joint motor speed, usually in meters per second
    pub fn b3DistanceJoint_GetMotorSpeed(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the distance joint maximum motor force, usually in newtons
    pub fn b3DistanceJoint_SetMaxMotorForce(jointId: b3JointId, force: f32);
}
unsafe extern "C" {
    /// Get the distance joint maximum motor force, usually in newtons
    pub fn b3DistanceJoint_GetMaxMotorForce(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the distance joint current motor force, usually in newtons
    pub fn b3DistanceJoint_GetMotorForce(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /** Create a motor joint
 @see b3MotorJointDef for details*/
    pub fn b3CreateMotorJoint(
        worldId: b3WorldId,
        def: *const b3MotorJointDef,
    ) -> b3JointId;
}
unsafe extern "C" {
    /// Set the desired relative linear velocity in meters per second
    pub fn b3MotorJoint_SetLinearVelocity(jointId: b3JointId, velocity: b3Vec3);
}
unsafe extern "C" {
    /// Get the desired relative linear velocity in meters per second
    pub fn b3MotorJoint_GetLinearVelocity(jointId: b3JointId) -> b3Vec3;
}
unsafe extern "C" {
    /// Set the desired relative angular velocity in radians per second
    pub fn b3MotorJoint_SetAngularVelocity(jointId: b3JointId, velocity: b3Vec3);
}
unsafe extern "C" {
    /// Get the desired relative angular velocity in radians per second
    pub fn b3MotorJoint_GetAngularVelocity(jointId: b3JointId) -> b3Vec3;
}
unsafe extern "C" {
    /// Set the motor joint maximum force, usually in newtons
    pub fn b3MotorJoint_SetMaxVelocityForce(jointId: b3JointId, maxForce: f32);
}
unsafe extern "C" {
    /// Get the motor joint maximum force, usually in newtons
    pub fn b3MotorJoint_GetMaxVelocityForce(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the motor joint maximum torque, usually in newton-meters
    pub fn b3MotorJoint_SetMaxVelocityTorque(jointId: b3JointId, maxTorque: f32);
}
unsafe extern "C" {
    /// Get the motor joint maximum torque, usually in newton-meters
    pub fn b3MotorJoint_GetMaxVelocityTorque(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the spring linear hertz stiffness
    pub fn b3MotorJoint_SetLinearHertz(jointId: b3JointId, hertz: f32);
}
unsafe extern "C" {
    /// Get the spring linear hertz stiffness
    pub fn b3MotorJoint_GetLinearHertz(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the spring linear damping ratio. Use 1.0 for critical damping.
    pub fn b3MotorJoint_SetLinearDampingRatio(jointId: b3JointId, damping: f32);
}
unsafe extern "C" {
    /// Get the spring linear damping ratio.
    pub fn b3MotorJoint_GetLinearDampingRatio(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the spring angular hertz stiffness
    pub fn b3MotorJoint_SetAngularHertz(jointId: b3JointId, hertz: f32);
}
unsafe extern "C" {
    /// Get the spring angular hertz stiffness
    pub fn b3MotorJoint_GetAngularHertz(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the spring angular damping ratio. Use 1.0 for critical damping.
    pub fn b3MotorJoint_SetAngularDampingRatio(jointId: b3JointId, damping: f32);
}
unsafe extern "C" {
    /// Get the spring angular damping ratio.
    pub fn b3MotorJoint_GetAngularDampingRatio(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the maximum spring force in newtons.
    pub fn b3MotorJoint_SetMaxSpringForce(jointId: b3JointId, maxForce: f32);
}
unsafe extern "C" {
    /// Get the maximum spring force in newtons.
    pub fn b3MotorJoint_GetMaxSpringForce(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the maximum spring torque in newtons * meters
    pub fn b3MotorJoint_SetMaxSpringTorque(jointId: b3JointId, maxTorque: f32);
}
unsafe extern "C" {
    /// Get the maximum spring torque in newtons * meters
    pub fn b3MotorJoint_GetMaxSpringTorque(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /** Create a filter joint.
 @see b3FilterJointDef for details*/
    pub fn b3CreateFilterJoint(
        worldId: b3WorldId,
        def: *const b3FilterJointDef,
    ) -> b3JointId;
}
unsafe extern "C" {
    /** Create a prismatic (slider) joint.
 @see b3PrismaticJointDef for details*/
    pub fn b3CreatePrismaticJoint(
        worldId: b3WorldId,
        def: *const b3PrismaticJointDef,
    ) -> b3JointId;
}
unsafe extern "C" {
    /// Enable/disable the joint spring.
    pub fn b3PrismaticJoint_EnableSpring(jointId: b3JointId, enableSpring: bool);
}
unsafe extern "C" {
    /// Is the prismatic joint spring enabled or not?
    pub fn b3PrismaticJoint_IsSpringEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /** Set the prismatic joint stiffness in Hertz.
 This should usually be less than a quarter of the simulation rate. For example, if the simulation
 runs at 60Hz then the joint stiffness should be 15Hz or less.*/
    pub fn b3PrismaticJoint_SetSpringHertz(jointId: b3JointId, hertz: f32);
}
unsafe extern "C" {
    /// Get the prismatic joint stiffness in Hertz
    pub fn b3PrismaticJoint_GetSpringHertz(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the prismatic joint damping ratio (non-dimensional)
    pub fn b3PrismaticJoint_SetSpringDampingRatio(jointId: b3JointId, dampingRatio: f32);
}
unsafe extern "C" {
    /// Get the prismatic spring damping ratio (non-dimensional)
    pub fn b3PrismaticJoint_GetSpringDampingRatio(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the prismatic joint target translation. Usually in meters.
    pub fn b3PrismaticJoint_SetTargetTranslation(
        jointId: b3JointId,
        targetTranslation: f32,
    );
}
unsafe extern "C" {
    /// Get the prismatic joint target translation. Usually in meters.
    pub fn b3PrismaticJoint_GetTargetTranslation(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Enable/disable a prismatic joint limit
    pub fn b3PrismaticJoint_EnableLimit(jointId: b3JointId, enableLimit: bool);
}
unsafe extern "C" {
    /// Is the prismatic joint limit enabled?
    pub fn b3PrismaticJoint_IsLimitEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Get the prismatic joint lower limit
    pub fn b3PrismaticJoint_GetLowerLimit(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the prismatic joint upper limit
    pub fn b3PrismaticJoint_GetUpperLimit(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the prismatic joint limits
    pub fn b3PrismaticJoint_SetLimits(jointId: b3JointId, lower: f32, upper: f32);
}
unsafe extern "C" {
    /// Enable/disable a prismatic joint motor
    pub fn b3PrismaticJoint_EnableMotor(jointId: b3JointId, enableMotor: bool);
}
unsafe extern "C" {
    /// Is the prismatic joint motor enabled?
    pub fn b3PrismaticJoint_IsMotorEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the prismatic joint motor speed, usually in meters per second
    pub fn b3PrismaticJoint_SetMotorSpeed(jointId: b3JointId, motorSpeed: f32);
}
unsafe extern "C" {
    /// Get the prismatic joint motor speed, usually in meters per second
    pub fn b3PrismaticJoint_GetMotorSpeed(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the prismatic joint maximum motor force, usually in newtons
    pub fn b3PrismaticJoint_SetMaxMotorForce(jointId: b3JointId, force: f32);
}
unsafe extern "C" {
    /// Get the prismatic joint maximum motor force, usually in newtons
    pub fn b3PrismaticJoint_GetMaxMotorForce(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the prismatic joint current motor force, usually in newtons
    pub fn b3PrismaticJoint_GetMotorForce(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the current joint translation, usually in meters.
    pub fn b3PrismaticJoint_GetTranslation(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the current joint translation speed, usually in meters per second.
    pub fn b3PrismaticJoint_GetSpeed(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /** Create a revolute joint
 @see b3RevoluteJointDef for details*/
    pub fn b3CreateRevoluteJoint(
        worldId: b3WorldId,
        def: *const b3RevoluteJointDef,
    ) -> b3JointId;
}
unsafe extern "C" {
    /// Enable/disable the revolute joint spring
    pub fn b3RevoluteJoint_EnableSpring(jointId: b3JointId, enableSpring: bool);
}
unsafe extern "C" {
    /// Is the revolute angular spring enabled?
    pub fn b3RevoluteJoint_IsSpringEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the revolute joint spring stiffness in Hertz
    pub fn b3RevoluteJoint_SetSpringHertz(jointId: b3JointId, hertz: f32);
}
unsafe extern "C" {
    /// Get the revolute joint spring stiffness in Hertz
    pub fn b3RevoluteJoint_GetSpringHertz(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the revolute joint spring damping ratio, non-dimensional
    pub fn b3RevoluteJoint_SetSpringDampingRatio(jointId: b3JointId, dampingRatio: f32);
}
unsafe extern "C" {
    /// Get the revolute joint spring damping ratio, non-dimensional
    pub fn b3RevoluteJoint_GetSpringDampingRatio(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the revolute joint target angle in radians
    pub fn b3RevoluteJoint_SetTargetAngle(jointId: b3JointId, targetRadians: f32);
}
unsafe extern "C" {
    /// Get the revolute joint target angle in radians
    pub fn b3RevoluteJoint_GetTargetAngle(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /** Get the revolute joint current angle in radians relative to the reference angle
 @see b3RevoluteJointDef::referenceAngle*/
    pub fn b3RevoluteJoint_GetAngle(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Enable/disable the revolute joint limit
    pub fn b3RevoluteJoint_EnableLimit(jointId: b3JointId, enableLimit: bool);
}
unsafe extern "C" {
    /// Is the revolute joint limit enabled?
    pub fn b3RevoluteJoint_IsLimitEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Get the revolute joint lower limit in radians
    pub fn b3RevoluteJoint_GetLowerLimit(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the revolute joint upper limit in radians
    pub fn b3RevoluteJoint_GetUpperLimit(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the revolute joint limits in radians
    pub fn b3RevoluteJoint_SetLimits(
        jointId: b3JointId,
        lowerLimitRadians: f32,
        upperLimitRadians: f32,
    );
}
unsafe extern "C" {
    /// Enable/disable a revolute joint motor
    pub fn b3RevoluteJoint_EnableMotor(jointId: b3JointId, enableMotor: bool);
}
unsafe extern "C" {
    /// Is the revolute joint motor enabled?
    pub fn b3RevoluteJoint_IsMotorEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the revolute joint motor speed in radians per second
    pub fn b3RevoluteJoint_SetMotorSpeed(jointId: b3JointId, motorSpeed: f32);
}
unsafe extern "C" {
    /// Get the revolute joint motor speed in radians per second
    pub fn b3RevoluteJoint_GetMotorSpeed(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the revolute joint current motor torque, usually in newton-meters
    pub fn b3RevoluteJoint_GetMotorTorque(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the revolute joint maximum motor torque, usually in newton-meters
    pub fn b3RevoluteJoint_SetMaxMotorTorque(jointId: b3JointId, torque: f32);
}
unsafe extern "C" {
    /// Get the revolute joint maximum motor torque, usually in newton-meters
    pub fn b3RevoluteJoint_GetMaxMotorTorque(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /** Create a spherical joint
 @see b3SphericalJointDef for details*/
    pub fn b3CreateSphericalJoint(
        worldId: b3WorldId,
        def: *const b3SphericalJointDef,
    ) -> b3JointId;
}
unsafe extern "C" {
    /// Enable/disable the spherical joint cone limit
    pub fn b3SphericalJoint_EnableConeLimit(jointId: b3JointId, enableLimit: bool);
}
unsafe extern "C" {
    /// Is the spherical joint cone limit enabled?
    pub fn b3SphericalJoint_IsConeLimitEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Get the spherical joint cone limit in radians
    pub fn b3SphericalJoint_GetConeLimit(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the spherical joint limits in radians
    pub fn b3SphericalJoint_SetConeLimit(jointId: b3JointId, angleRadians: f32);
}
unsafe extern "C" {
    /// Get the spherical joint current cone angle in radians.
    pub fn b3SphericalJoint_GetConeAngle(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Enable/disable the spherical joint limit
    pub fn b3SphericalJoint_EnableTwistLimit(jointId: b3JointId, enableLimit: bool);
}
unsafe extern "C" {
    /// Is the spherical joint limit enabled?
    pub fn b3SphericalJoint_IsTwistLimitEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Get the spherical joint lower limit in radians
    pub fn b3SphericalJoint_GetLowerTwistLimit(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the spherical joint upper limit in radians
    pub fn b3SphericalJoint_GetUpperTwistLimit(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the spherical joint limits in radians
    pub fn b3SphericalJoint_SetTwistLimits(
        jointId: b3JointId,
        lowerLimitRadians: f32,
        upperLimitRadians: f32,
    );
}
unsafe extern "C" {
    /// Get the spherical joint current twist angle in radians.
    pub fn b3SphericalJoint_GetTwistAngle(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Enable/disable the spherical joint spring
    pub fn b3SphericalJoint_EnableSpring(jointId: b3JointId, enableSpring: bool);
}
unsafe extern "C" {
    /// Is the spherical angular spring enabled?
    pub fn b3SphericalJoint_IsSpringEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the spherical joint spring stiffness in Hertz
    pub fn b3SphericalJoint_SetSpringHertz(jointId: b3JointId, hertz: f32);
}
unsafe extern "C" {
    /// Get the spherical joint spring stiffness in Hertz
    pub fn b3SphericalJoint_GetSpringHertz(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the spherical joint spring damping ratio, non-dimensional
    pub fn b3SphericalJoint_SetSpringDampingRatio(jointId: b3JointId, dampingRatio: f32);
}
unsafe extern "C" {
    /// Get the spherical joint spring damping ratio, non-dimensional
    pub fn b3SphericalJoint_GetSpringDampingRatio(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the spherical joint spring target rotation
    pub fn b3SphericalJoint_SetTargetRotation(
        jointId: b3JointId,
        targetRotation: b3Quat,
    );
}
unsafe extern "C" {
    /// Get the spherical joint spring target rotation
    pub fn b3SphericalJoint_GetTargetRotation(jointId: b3JointId) -> b3Quat;
}
unsafe extern "C" {
    /// Enable/disable a spherical joint motor
    pub fn b3SphericalJoint_EnableMotor(jointId: b3JointId, enableMotor: bool);
}
unsafe extern "C" {
    /// Is the spherical joint motor enabled?
    pub fn b3SphericalJoint_IsMotorEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the spherical joint motor velocity in radians per second
    pub fn b3SphericalJoint_SetMotorVelocity(jointId: b3JointId, motorVelocity: b3Vec3);
}
unsafe extern "C" {
    /// Get the spherical joint motor velocity in radians per second
    pub fn b3SphericalJoint_GetMotorVelocity(jointId: b3JointId) -> b3Vec3;
}
unsafe extern "C" {
    /// Get the spherical joint current motor torque, usually in newton-meters
    pub fn b3SphericalJoint_GetMotorTorque(jointId: b3JointId) -> b3Vec3;
}
unsafe extern "C" {
    /// Set the spherical joint maximum motor torque, usually in newton-meters
    pub fn b3SphericalJoint_SetMaxMotorTorque(jointId: b3JointId, torque: f32);
}
unsafe extern "C" {
    /// Get the spherical joint maximum motor torque, usually in newton-meters
    pub fn b3SphericalJoint_GetMaxMotorTorque(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /** Create a weld joint
 @see b3WeldJointDef for details*/
    pub fn b3CreateWeldJoint(
        worldId: b3WorldId,
        def: *const b3WeldJointDef,
    ) -> b3JointId;
}
unsafe extern "C" {
    /// Set the weld joint linear stiffness in Hertz. 0 is rigid.
    pub fn b3WeldJoint_SetLinearHertz(jointId: b3JointId, hertz: f32);
}
unsafe extern "C" {
    /// Get the weld joint linear stiffness in Hertz
    pub fn b3WeldJoint_GetLinearHertz(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the weld joint linear damping ratio (non-dimensional)
    pub fn b3WeldJoint_SetLinearDampingRatio(jointId: b3JointId, dampingRatio: f32);
}
unsafe extern "C" {
    /// Get the weld joint linear damping ratio (non-dimensional)
    pub fn b3WeldJoint_GetLinearDampingRatio(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the weld joint angular stiffness in Hertz. 0 is rigid.
    pub fn b3WeldJoint_SetAngularHertz(jointId: b3JointId, hertz: f32);
}
unsafe extern "C" {
    /// Get the weld joint angular stiffness in Hertz
    pub fn b3WeldJoint_GetAngularHertz(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set weld joint angular damping ratio, non-dimensional
    pub fn b3WeldJoint_SetAngularDampingRatio(jointId: b3JointId, dampingRatio: f32);
}
unsafe extern "C" {
    /// Get the weld joint angular damping ratio, non-dimensional
    pub fn b3WeldJoint_GetAngularDampingRatio(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /** Create a wheel joint.
 @see b3WheelJointDef for details.*/
    pub fn b3CreateWheelJoint(
        worldId: b3WorldId,
        def: *const b3WheelJointDef,
    ) -> b3JointId;
}
unsafe extern "C" {
    /// Enable/disable the wheel joint spring.
    pub fn b3WheelJoint_EnableSuspension(jointId: b3JointId, flag: bool);
}
unsafe extern "C" {
    /// Is the wheel joint spring enabled?
    pub fn b3WheelJoint_IsSuspensionEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the wheel joint stiffness in Hertz.
    pub fn b3WheelJoint_SetSuspensionHertz(jointId: b3JointId, hertz: f32);
}
unsafe extern "C" {
    /// Get the wheel joint stiffness in Hertz.
    pub fn b3WheelJoint_GetSuspensionHertz(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the wheel joint damping ratio, non-dimensional.
    pub fn b3WheelJoint_SetSuspensionDampingRatio(jointId: b3JointId, dampingRatio: f32);
}
unsafe extern "C" {
    /// Get the wheel joint damping ratio, non-dimensional.
    pub fn b3WheelJoint_GetSuspensionDampingRatio(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Enable/disable the wheel joint limit.
    pub fn b3WheelJoint_EnableSuspensionLimit(jointId: b3JointId, flag: bool);
}
unsafe extern "C" {
    /// Is the wheel joint limit enabled?
    pub fn b3WheelJoint_IsSuspensionLimitEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Get the wheel joint lower limit.
    pub fn b3WheelJoint_GetLowerSuspensionLimit(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the wheel joint upper limit.
    pub fn b3WheelJoint_GetUpperSuspensionLimit(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the wheel joint limits.
    pub fn b3WheelJoint_SetSuspensionLimits(jointId: b3JointId, lower: f32, upper: f32);
}
unsafe extern "C" {
    /// Enable/disable the wheel joint motor.
    pub fn b3WheelJoint_EnableSpinMotor(jointId: b3JointId, flag: bool);
}
unsafe extern "C" {
    /// Is the wheel joint motor enabled?
    pub fn b3WheelJoint_IsSpinMotorEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the wheel joint motor speed in radians per second.
    pub fn b3WheelJoint_SetSpinMotorSpeed(jointId: b3JointId, speed: f32);
}
unsafe extern "C" {
    /// Get the wheel joint motor speed in radians per second.
    pub fn b3WheelJoint_GetSpinMotorSpeed(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the wheel joint maximum motor torque, usually in newton-meters.
    pub fn b3WheelJoint_SetMaxSpinTorque(jointId: b3JointId, torque: f32);
}
unsafe extern "C" {
    /// Get the wheel joint maximum motor torque, usually in newton-meters.
    pub fn b3WheelJoint_GetMaxSpinTorque(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the current spin speed in radians per second.
    pub fn b3WheelJoint_GetSpinSpeed(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the wheel joint current motor torque, usually in newton-meters.
    pub fn b3WheelJoint_GetSpinTorque(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Enable/disable wheel steering. Steering allows the wheel to rotate about the suspension axis.
    pub fn b3WheelJoint_EnableSteering(jointId: b3JointId, flag: bool);
}
unsafe extern "C" {
    /// Can the wheel steer?
    pub fn b3WheelJoint_IsSteeringEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Set the wheel joint steering stiffness in Hertz.
    pub fn b3WheelJoint_SetSteeringHertz(jointId: b3JointId, hertz: f32);
}
unsafe extern "C" {
    /// Get the wheel joint steering stiffness in Hertz.
    pub fn b3WheelJoint_GetSteeringHertz(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the wheel joint steering damping ratio, non-dimensional.
    pub fn b3WheelJoint_SetSteeringDampingRatio(jointId: b3JointId, dampingRatio: f32);
}
unsafe extern "C" {
    /// Get the wheel joint steering damping ratio, non-dimensional.
    pub fn b3WheelJoint_GetSteeringDampingRatio(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the wheel joint maximum steering torque in N*m.
    pub fn b3WheelJoint_SetMaxSteeringTorque(jointId: b3JointId, torque: f32);
}
unsafe extern "C" {
    /// Get the wheel joint maximum steering torque in N*m.
    pub fn b3WheelJoint_GetMaxSteeringTorque(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Enable/disable the wheel joint steering limit.
    pub fn b3WheelJoint_EnableSteeringLimit(jointId: b3JointId, flag: bool);
}
unsafe extern "C" {
    /// Is the wheel joint steering limit enabled?
    pub fn b3WheelJoint_IsSteeringLimitEnabled(jointId: b3JointId) -> bool;
}
unsafe extern "C" {
    /// Get the wheel joint lower steering limit in radians.
    pub fn b3WheelJoint_GetLowerSteeringLimit(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the wheel joint upper steering limit in radians.
    pub fn b3WheelJoint_GetUpperSteeringLimit(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Set the wheel joint steering limits in radians.
    pub fn b3WheelJoint_SetSteeringLimits(
        jointId: b3JointId,
        lowerRadians: f32,
        upperRadians: f32,
    );
}
unsafe extern "C" {
    /// Set the wheel joint target steering angle in radians.
    pub fn b3WheelJoint_SetTargetSteeringAngle(jointId: b3JointId, radians: f32);
}
unsafe extern "C" {
    /// Get the wheel joint target steering angle in radians.
    pub fn b3WheelJoint_GetTargetSteeringAngle(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the current steering angle in radians.
    pub fn b3WheelJoint_GetSteeringAngle(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Get the current steering torque in N*m.
    pub fn b3WheelJoint_GetSteeringTorque(jointId: b3JointId) -> f32;
}
unsafe extern "C" {
    /// Contact identifier validation. Provides validation for up to 2^32 allocations.
    pub fn b3Contact_IsValid(id: b3ContactId) -> bool;
}
unsafe extern "C" {
    /// Get the manifolds for a contact. The manifold may have no points if the contact is not touching.
    pub fn b3Contact_GetData(contactId: b3ContactId) -> b3ContactData;
}