coven/modules/PhysX/module_linux.jai

//
// This file was auto-generated using the following command:
//
// jai generate.jai
//

PxEMPTY :: enum s32 {
    PxEmpty :: 0;
}

PxZERO :: enum s32 {
    PxZero :: 0;
}

PxIDENTITY :: enum s32 {
    PxIdentity :: 0;
}

PxErrorCode :: enum_flags s32 {
    NoError :: 0;
    DebugInfo :: 1;
    DebugWarning :: 2;
    InvalidParameter :: 4;
    InvalidOperation :: 8;
    OutOfMemory :: 16;
    InternalError :: 32;
    Abort :: 64;
    PerfWarning :: 128;
    MaskAll :: -1;
}

PxThreadPriority :: enum u32 {
    High :: 0;
    AboveNormal :: 1;
    Normal :: 2;
    BelowNormal :: 3;
    Low :: 4;
    ForceDword :: 4294967295;
}

PxDebugColor :: enum u32 {
    ArgbBlack :: 4278190080;
    ArgbRed :: 4294901760;
    ArgbGreen :: 4278255360;
    ArgbBlue :: 4278190335;
    ArgbYellow :: 4294967040;
    ArgbMagenta :: 4294902015;
    ArgbCyan :: 4278255615;
    ArgbWhite :: 4294967295;
    ArgbGrey :: 4286611584;
    ArgbDarkred :: 4287102976;
    ArgbDarkgreen :: 4278224896;
    ArgbDarkblue :: 4278190216;
}

PxConcreteType :: enum s32 {
    Undefined :: 0;
    Heightfield :: 1;
    ConvexMesh :: 2;
    TriangleMeshBvh33 :: 3;
    TriangleMeshBvh34 :: 4;
    TetrahedronMesh :: 5;
    SoftbodyMesh :: 6;
    RigidDynamic :: 7;
    RigidStatic :: 8;
    Shape :: 9;
    Material :: 10;
    SoftbodyMaterial :: 11;
    ClothMaterial :: 12;
    PbdMaterial :: 13;
    FlipMaterial :: 14;
    MpmMaterial :: 15;
    CustomMaterial :: 16;
    Constraint :: 17;
    Aggregate :: 18;
    ArticulationReducedCoordinate :: 19;
    ArticulationLink :: 20;
    ArticulationJointReducedCoordinate :: 21;
    ArticulationSensor :: 22;
    ArticulationSpatialTendon :: 23;
    ArticulationFixedTendon :: 24;
    ArticulationAttachment :: 25;
    ArticulationTendonJoint :: 26;
    PruningStructure :: 27;
    Bvh :: 28;
    SoftBody :: 29;
    SoftBodyState :: 30;
    PbdParticlesystem :: 31;
    FlipParticlesystem :: 32;
    MpmParticlesystem :: 33;
    CustomParticlesystem :: 34;
    FemCloth :: 35;
    HairSystem :: 36;
    ParticleBuffer :: 37;
    ParticleDiffuseBuffer :: 38;
    ParticleClothBuffer :: 39;
    ParticleRigidBuffer :: 40;
    PhysxCoreCount :: 41;
    FirstPhysxExtension :: 256;
    FirstVehicleExtension :: 512;
    FirstUserExtension :: 1024;
}

PxBaseFlags :: enum_flags u16 {
    OwnsMemory :: 1 << 0;
    IsReleasable :: 1 << 1;
}

PxMetaDataFlag :: enum_flags s32 {
    Class :: 1;
    Virtual :: 2;
    Typedef :: 4;
    Ptr :: 8;
    Handle :: 16;
    ExtraData :: 32;
    ExtraItem :: 64;
    ExtraItems :: 128;
    ExtraName :: 256;
    Union :: 512;
    Padding :: 1024;
    Alignment :: 2048;
    CountMaskMsb :: 4096;
    CountSkipIfOne :: 8192;
    ControlFlip :: 16384;
    ControlMask :: 32768;
    ControlMaskRange :: 255;
    ForceDword :: 2147483647;
}

PxTaskType :: enum s32 {
    Cpu :: 0;
    NotPresent :: 1;
    Completed :: 2;
}

PxGeometryType :: enum s32 {
    Sphere :: 0;
    Plane :: 1;
    Capsule :: 2;
    Box :: 3;
    Convexmesh :: 4;
    Particlesystem :: 5;
    Tetrahedronmesh :: 6;
    Trianglemesh :: 7;
    Heightfield :: 8;
    Hairsystem :: 9;
    Custom :: 10;
    GeometryCount :: 11;
    Invalid :: -1;
}

PxGeometryQueryFlags :: enum_flags u32 {
    SimdGuard :: 1 << 0;
}

PxBVHBuildStrategy :: enum s32 {
    Fast :: 0;
    Default :: 1;
    Sah :: 2;
    Last :: 3;
}

PxConvexMeshGeometryFlags :: enum_flags u8 {
    TightBounds :: 1 << 0;
}

PxMeshGeometryFlags :: enum_flags u8 {
    TightBounds :: 1 << 0;
    DoubleSided :: 1 << 1;
}

PxParticleSolverType :: enum_flags s32 {
    Pbd :: 1;
    Flip :: 2;
    Mpm :: 4;
    Custom :: 8;
}

PxHitFlags :: enum_flags u16 {
    Position :: 1 << 0;
    Normal :: 1 << 1;
    Uv :: 1 << 3;
    AssumeNoInitialOverlap :: 1 << 4;
    AnyHit :: 1 << 5;
    MeshMultiple :: 1 << 6;
    MeshBothSides :: 1 << 7;
    PreciseSweep :: 1 << 8;
    Mtd :: 1 << 9;
    FaceIndex :: 1 << 10;
    Default :: PxHitFlags.Position | PxHitFlags.Normal | PxHitFlags.FaceIndex;
    ModifiableFlags :: PxHitFlags.AssumeNoInitialOverlap | PxHitFlags.MeshMultiple | PxHitFlags.MeshBothSides | PxHitFlags.PreciseSweep;
}

PxHeightFieldFormat :: enum s32 {
    S16Tm :: 1;
}

PxHeightFieldTessFlag :: enum_flags s32 {
    E0ThVertexShared :: 1;
}

PxHeightFieldFlags :: enum_flags u16 {
    NoBoundaryEdges :: 1 << 0;
}

PxHeightFieldMaterial :: enum s32 {
    Hole :: 127;
}

PxMeshMeshQueryFlags :: enum_flags u32 {
    Default :: 0;
    DiscardCoplanar :: 1 << 0;
}

PxMeshFlags :: enum_flags u16 {
    Flipnormals :: 1 << 0;
    E16BitIndices :: 1 << 1;
}

PxMeshMidPhase :: enum s32 {
    Bvh33 :: 0;
    Bvh34 :: 1;
    Last :: 2;
}

PxTriangleMeshFlags :: enum_flags u8 {
    E16BitIndices :: 1 << 1;
    AdjacencyInfo :: 1 << 2;
    PreferNoSdfProj :: 1 << 3;
}

PxTetrahedronMeshFlags :: enum_flags u8 {
    E16BitIndices :: 1 << 1;
}

PxActorFlags :: enum_flags u8 {
    Visualization :: 1 << 0;
    DisableGravity :: 1 << 1;
    SendSleepNotifies :: 1 << 2;
    DisableSimulation :: 1 << 3;
}

PxActorType :: enum s32 {
    RigidStatic :: 0;
    RigidDynamic :: 1;
    ArticulationLink :: 2;
}

PxAggregateType :: enum s32 {
    Generic :: 0;
    Static :: 1;
    Kinematic :: 2;
}

Px1DConstraintFlags :: enum_flags u16 {
    Spring :: 1 << 0;
    AccelerationSpring :: 1 << 1;
    Restitution :: 1 << 2;
    Keepbias :: 1 << 3;
    OutputForce :: 1 << 4;
    HasDriveLimit :: 1 << 5;
    AngularConstraint :: 1 << 6;
    DriveRow :: 1 << 7;
}

PxConstraintSolveHint :: enum s32 {
    None :: 0;
    Acceleration1 :: 256;
    SlerpSpring :: 258;
    Acceleration2 :: 512;
    Acceleration3 :: 768;
    RotationalEquality :: 1024;
    RotationalInequality :: 1025;
    Equality :: 2048;
    Inequality :: 2049;
}

PxConstraintVisualizationFlag :: enum_flags s32 {
    LocalFrames :: 1;
    Limits :: 2;
}

PxPvdUpdateType :: enum s32 {
    CreateInstance :: 0;
    ReleaseInstance :: 1;
    UpdateAllProperties :: 2;
    UpdateSimProperties :: 3;
}

ConstraintType :: enum s32 {
    ContactConstraint :: 0;
    JointConstraint :: 1;
}

BodyState :: enum_flags s32 {
    DynamicBody :: 1;
    StaticBody :: 2;
    KinematicBody :: 4;
    Articulation :: 8;
}

PxArticulationAxis :: enum s32 {
    Twist :: 0;
    Swing1 :: 1;
    Swing2 :: 2;
    X :: 3;
    Y :: 4;
    Z :: 5;
    Count :: 6;
}

PxArticulationMotions :: enum_flags u8 {
    Locked :: 0;
    Limited :: 1 << 0;
    Free :: 1 << 1;
}

PxArticulationJointType :: enum s32 {
    Fix :: 0;
    Prismatic :: 1;
    Revolute :: 2;
    RevoluteUnwrapped :: 3;
    Spherical :: 4;
    Undefined :: 5;
}

PxArticulationFlags :: enum_flags u8 {
    FixBase :: 1 << 0;
    DriveLimitsAreForces :: 1 << 1;
    DisableSelfCollision :: 1 << 2;
    ComputeJointForces :: 1 << 3;
}

PxArticulationDriveType :: enum s32 {
    Force :: 0;
    Acceleration :: 1;
    Target :: 2;
    Velocity :: 3;
    None :: 4;
}

PxArticulationGpuDataType :: enum s32 {
    JointPosition :: 0;
    JointVelocity :: 1;
    JointAcceleration :: 2;
    JointForce :: 3;
    JointSolverForce :: 4;
    JointTargetVelocity :: 5;
    JointTargetPosition :: 6;
    SensorForce :: 7;
    RootTransform :: 8;
    RootVelocity :: 9;
    LinkTransform :: 10;
    LinkVelocity :: 11;
    LinkForce :: 12;
    LinkTorque :: 13;
    FixedTendon :: 14;
    FixedTendonJoint :: 15;
    SpatialTendon :: 16;
    SpatialTendonAttachment :: 17;
}

PxArticulationCacheFlags :: enum_flags u32 {
    Velocity :: 1 << 0;
    Acceleration :: 1 << 1;
    Position :: 1 << 2;
    Force :: 1 << 3;
    LinkVelocity :: 1 << 4;
    LinkAcceleration :: 1 << 5;
    RootTransform :: 1 << 6;
    RootVelocities :: 1 << 7;
    SensorForces :: 1 << 8;
    JointSolverForces :: 1 << 9;
    All :: PxArticulationCacheFlags.Velocity | PxArticulationCacheFlags.Acceleration | PxArticulationCacheFlags.Position | PxArticulationCacheFlags.LinkVelocity | PxArticulationCacheFlags.LinkAcceleration | PxArticulationCacheFlags.RootTransform | PxArticulationCacheFlags.RootVelocities;
}

PxArticulationSensorFlags :: enum_flags u8 {
    ForwardDynamicsForces :: 1 << 0;
    ConstraintSolverForces :: 1 << 1;
    WorldFrame :: 1 << 2;
}

PxArticulationKinematicFlags :: enum_flags u8 {
    Position :: 1 << 0;
    Velocity :: 1 << 1;
}

PxShapeFlags :: enum_flags u8 {
    SimulationShape :: 1 << 0;
    SceneQueryShape :: 1 << 1;
    TriggerShape :: 1 << 2;
    Visualization :: 1 << 3;
}

PxForceMode :: enum s32 {
    Force :: 0;
    Impulse :: 1;
    VelocityChange :: 2;
    Acceleration :: 3;
}

PxRigidBodyFlags :: enum_flags u16 {
    Kinematic :: 1 << 0;
    UseKinematicTargetForSceneQueries :: 1 << 1;
    EnableCcd :: 1 << 2;
    EnableCcdFriction :: 1 << 3;
    EnableSpeculativeCcd :: 1 << 4;
    EnablePoseIntegrationPreview :: 1 << 5;
    EnableCcdMaxContactImpulse :: 1 << 6;
    RetainAccelerations :: 1 << 7;
    ForceKineKineNotifications :: 1 << 8;
    ForceStaticKineNotifications :: 1 << 9;
    EnableGyroscopicForces :: 1 << 10;
}

PxConstraintFlags :: enum_flags u16 {
    Broken :: 1 << 0;
    ProjectToActor0 :: 1 << 1;
    ProjectToActor1 :: 1 << 2;
    Projection :: PxConstraintFlags.ProjectToActor0 | PxConstraintFlags.ProjectToActor1;
    CollisionEnabled :: 1 << 3;
    Visualization :: 1 << 4;
    DriveLimitsAreForces :: 1 << 5;
    ImprovedSlerp :: 1 << 7;
    DisablePreprocessing :: 1 << 8;
    EnableExtendedLimits :: 1 << 9;
    GpuCompatible :: 1 << 10;
    AlwaysUpdate :: 1 << 11;
    DisableConstraint :: 1 << 12;
}

PxContactPatchFlags :: enum_flags s32 {
    HasFaceIndices :: 1;
    Modifiable :: 2;
    ForceNoResponse :: 4;
    HasModifiedMassRatios :: 8;
    HasTargetVelocity :: 16;
    HasMaxImpulse :: 32;
    RegeneratePatches :: 64;
    CompressedModifiedContact :: 128;
}

StreamFormat :: enum s32 {
    SimpleStream :: 0;
    ModifiableStream :: 1;
    CompressedModifiableStream :: 2;
}

PxDeletionEventFlags :: enum_flags u8 {
    UserRelease :: 1 << 0;
    MemoryRelease :: 1 << 1;
}

PxPairFlags :: enum_flags u16 {
    SolveContact :: 1 << 0;
    ModifyContacts :: 1 << 1;
    NotifyTouchFound :: 1 << 2;
    NotifyTouchPersists :: 1 << 3;
    NotifyTouchLost :: 1 << 4;
    NotifyTouchCcd :: 1 << 5;
    NotifyThresholdForceFound :: 1 << 6;
    NotifyThresholdForcePersists :: 1 << 7;
    NotifyThresholdForceLost :: 1 << 8;
    NotifyContactPoints :: 1 << 9;
    DetectDiscreteContact :: 1 << 10;
    DetectCcdContact :: 1 << 11;
    PreSolverVelocity :: 1 << 12;
    PostSolverVelocity :: 1 << 13;
    ContactEventPose :: 1 << 14;
    NextFree :: 1 << 15;
    ContactDefault :: PxPairFlags.SolveContact | PxPairFlags.DetectDiscreteContact;
    TriggerDefault :: PxPairFlags.NotifyTouchFound | PxPairFlags.NotifyTouchLost | PxPairFlags.DetectDiscreteContact;
}

PxFilterFlags :: enum_flags u16 {
    Default :: 0;
    Kill :: 1 << 0;
    Suppress :: 1 << 1;
    Callback :: 1 << 2;
    Notify :: PxFilterFlags.Callback;
}

PxFilterObjectType :: enum s32 {
    RigidStatic :: 0;
    RigidDynamic :: 1;
    Articulation :: 2;
    Particlesystem :: 3;
    Softbody :: 4;
    Femcloth :: 5;
    Hairsystem :: 6;
    MaxTypeCount :: 16;
    Undefined :: 15;
}

PxFilterObjectFlag :: enum_flags s32 {
    Kinematic :: 16;
    Trigger :: 32;
}

PxPairFilteringMode :: enum s32 {
    Keep :: 0;
    Suppress :: 1;
    Kill :: 2;
}

PxDataAccessFlags :: enum_flags u8 {
    Readable :: 1 << 0;
    Writable :: 1 << 1;
    Device :: 1 << 2;
}

PxMaterialFlags :: enum_flags u16 {
    DisableFriction :: 1 << 0;
    DisableStrongFriction :: 1 << 1;
    ImprovedPatchFriction :: 1 << 2;
    CompliantContact :: 1 << 3;
}

PxRigidDynamicLockFlags :: enum_flags u8 {
    LockLinearX :: 1 << 0;
    LockLinearY :: 1 << 1;
    LockLinearZ :: 1 << 2;
    LockAngularX :: 1 << 3;
    LockAngularY :: 1 << 4;
    LockAngularZ :: 1 << 5;
}

PxSceneFlags :: enum_flags u32 {
    EnableActiveActors :: 1 << 0;
    EnableCcd :: 1 << 1;
    DisableCcdResweep :: 1 << 2;
    EnablePcm :: 1 << 6;
    DisableContactReportBufferResize :: 1 << 7;
    DisableContactCache :: 1 << 8;
    RequireRwLock :: 1 << 9;
    EnableStabilization :: 1 << 10;
    EnableAveragePoint :: 1 << 11;
    ExcludeKinematicsFromActiveActors :: 1 << 12;
    EnableGpuDynamics :: 1 << 13;
    EnableEnhancedDeterminism :: 1 << 14;
    EnableFrictionEveryIteration :: 1 << 15;
    SuppressReadback :: 1 << 16;
    ForceReadback :: 1 << 17;
    MutableFlags :: EnableActiveActors | ExcludeKinematicsFromActiveActors | SuppressReadback;
}

PxConvexFlags :: enum_flags u16 {
    E16BitIndices :: 1 << 0;
    ComputeConvex :: 1 << 1;
    CheckZeroAreaTriangles :: 1 << 2;
    QuantizeInput :: 1 << 3;
    DisableMeshValidation :: 1 << 4;
    PlaneShifting :: 1 << 5;
    FastInertiaComputation :: 1 << 6;
    GpuCompatible :: 1 << 7;
    ShiftVertices :: 1 << 8;
}

PxConvexMeshCookingResult :: enum s32 {
    /// Convex mesh cooking succeeded.
    Success :: 0;
    /// Convex mesh cooking failed, algorithm couldn't find 4 initial vertices without a small triangle.
    ZeroAreaTestFailed :: 1;
    /// Convex mesh cooking succeeded, but the algorithm has reached the 255 polygons limit.
    /// The produced hull does not contain all input vertices. Try to simplify the input vertices
    /// or try to use the eINFLATE_CONVEX or the eQUANTIZE_INPUT flags.
    PolygonsLimitReached :: 2;
    /// Something unrecoverable happened. Check the error stream to find out what.
    Failure :: 3;
}

PxDefaultCpuDispatcherWaitForWorkMode :: enum s32 {
    WaitForWork :: 0;
    YieldThread :: 1;
    YieldProcessor :: 2;
}

PxControllerShapeType :: enum s32 {
    /// A box controller.
    Box :: 0;
    /// A capsule controller
    Capsule :: 1;
    /// A capsule controller
    ForceDword :: 2147483647;
}

PxControllerNonWalkableMode :: enum s32 {
    /// Stops character from climbing up non-walkable slopes, but doesn't move it otherwise
    PreventClimbing :: 0;
    /// Stops character from climbing up non-walkable slopes, and forces it to slide down those slopes
    PreventClimbingAndForceSliding :: 1;
}

PxControllerCollisionFlags :: enum_flags u8 {
    CollisionSides :: 1 << 0;
    CollisionUp :: 1 << 1;
    CollisionDown :: 1 << 2;
}

PxCapsuleClimbingMode :: enum s32 {
    /// Standard mode, let the capsule climb over surfaces according to impact normal
    Easy :: 0;
    /// Constrained mode, try to limit climbing according to the step offset
    Constrained :: 1;
    Last :: 2;
}

PxControllerBehaviorFlags :: enum_flags u8 {
    /// Controller can ride on touched object (i.e. when this touched object is moving horizontally).
    ///
    /// The CCT vs. CCT case is not supported.
    CctCanRideOnObject :: 1;
    /// Controller should slide on touched object
    CctSlide :: 2;
    /// Disable all code dealing with controllers riding on objects, let users define it outside of the SDK.
    CctUserDefinedRide :: 4;
}

PxQueryHitType :: enum s32 {
    /// the query should ignore this shape
    None :: 0;
    /// a hit on the shape touches the intersection geometry of the query but does not block it
    Touch :: 1;
    /// a hit on the shape blocks the query (does not block overlap queries)
    Block :: 2;
}

PxQueryFlags :: enum_flags u16 {
    Static :: 1 << 0;
    Dynamic :: 1 << 1;
    Prefilter :: 1 << 2;
    Postfilter :: 1 << 3;
    AnyHit :: 1 << 4;
    NoBlock :: 1 << 5;
    DisableHardcodedFilter :: 1 << 6;
    Reserved :: 1 << 15;
}

PxBroadPhaseType :: enum s32 {
    /// 3-axes sweep-and-prune
    Sap :: 0;
    /// Multi box pruning
    Mbp :: 1;
    /// Automatic box pruning
    Abp :: 2;
    /// Parallel automatic box pruning
    Pabp :: 3;
    /// GPU broad phase
    Gpu :: 4;
    Last :: 5;
}

PxCombineMode :: enum s32 {
    /// Average: (a + b)/2
    Average :: 0;
    /// Minimum: minimum(a,b)
    Min :: 1;
    /// Multiply: a*b
    Multiply :: 2;
    /// Maximum: maximum(a,b)
    Max :: 3;
}

PxD6Axis :: enum s32 {
    /// motion along the X axis
    X :: 0;
    /// motion along the Y axis
    Y :: 1;
    /// motion along the Z axis
    Z :: 2;
    /// motion around the X axis
    Twist :: 3;
    /// motion around the Y axis
    Swing1 :: 4;
    /// motion around the Z axis
    Swing2 :: 5;
    Count :: 6;
}

PxD6Motion :: enum s32 {
    /// The DOF is locked, it does not allow relative motion.
    Locked :: 0;
    /// The DOF is limited, it only allows motion within a specific range.
    Limited :: 1;
    /// The DOF is free and has its full range of motion.
    Free :: 2;
}

PxRevoluteJointFlags :: enum_flags u16 {
    LimitEnabled :: 1 << 0;
    DriveEnabled :: 1 << 1;
    DriveFreespin :: 1 << 2;
}

PxDistanceJointFlags :: enum_flags u16 {
    MaxDistanceEnabled :: 1 << 1;
    MinDistanceEnabled :: 1 << 2;
    SpringEnabled :: 1 << 3;
}



__clang__ :: 1;
NDEBUG :: 1;
PxMat34 :: struct {}

PxAllocatorCallback :: struct {
    vtable_: *void;
}

PxAssertHandler :: struct {
    vtable_: *void;
}

PxFoundation :: struct {
    vtable_: *void;
}

PxAllocator :: struct {
    structgen_pad0: [1] u8;
}

PxRawAllocator :: struct {
    structgen_pad0: [1] u8;
}

PxVirtualAllocatorCallback :: struct {
    vtable_: *void;
}

PxVirtualAllocator :: struct {
    structgen_pad0: [16] u8;
}

PxUserAllocated :: struct {
    structgen_pad0: [1] u8;
}

PxTempAllocatorChunk :: union {
    mNext:  *PxTempAllocatorChunk;
    mIndex: u32;
    mPad:   [16] u8;
}

PxTempAllocator :: struct {
    structgen_pad0: [1] u8;
}

PxLogTwo :: struct {}
PxUnConst :: struct {}
PxBitAndByte :: struct {
    structgen_pad0: [1] u8;
}

PxBitMap :: struct {
    structgen_pad0: [16] u8;
}

PxVec3Padded :: struct {
    x:       float;
    y:       float;
    z:       float;
    padding: u32;
}

PxTransform :: struct {
    q: Quaternion;
    p: Vector3;
}

PxTransformPadded :: struct {
    transform: PxTransform;
    padding:   u32;
}

PxMat33 :: struct {
    column0: Vector3;
    column1: Vector3;
    column2: Vector3;
}

PxBounds3 :: struct {
    minimum: Vector3;
    maximum: Vector3;
}

PxErrorCallback :: struct {
    vtable_: *void;
}

PxAllocationListener :: struct {
    vtable_: *void;
}

PxBroadcastingAllocator :: struct {
    structgen_pad0: [176] u8;
}

PxBroadcastingErrorCallback :: struct {
    structgen_pad0: [160] u8;
}

PxHash :: struct {}
PxInputStream :: struct {
    vtable_: *void;
}

PxInputData :: struct {
    vtable_: *void;
}

PxOutputStream :: struct {
    vtable_: *void;
}

PxMat44 :: struct {
    column0: Vector4;
    column1: Vector4;
    column2: Vector4;
    column3: Vector4;
}

Interpolation :: struct {
    structgen_pad0: [1] u8;
}

PxMutexImpl :: struct {
    structgen_pad0: [1] u8;
}

PxReadWriteLock :: struct {
    structgen_pad0: [8] u8;
}

PxProfilerCallback :: struct {
    vtable_: *void;
}

PxProfileScoped :: struct {
    mCallback:      *PxProfilerCallback;
    mEventName:     *u8;
    mProfilerData:  *void;
    mContextId:     u64;
    mDetached:      bool;
    structgen_pad0: [7] u8;
}

PxSListEntry :: struct {
    structgen_pad0: [16] u8;
}

PxSListImpl :: struct {
    structgen_pad0: [1] u8;
}

PxSyncImpl :: struct {
    structgen_pad0: [1] u8;
}

PxRunnable :: struct {
    vtable_: *void;
}

PxCounterFrequencyToTensOfNanos :: struct {
    mNumerator:   u64;
    mDenominator: u64;
}

PxTime :: struct {
    structgen_pad0: [8] u8;
}

PxStridedData :: struct {
    stride:         u32;
    structgen_pad0: [4] u8;
    data:           *void;
}

PxBoundedData :: struct {
    stride:         u32;
    structgen_pad0: [4] u8;
    data:           *void;
    count:          u32;
    structgen_pad1: [4] u8;
}

PxDebugPoint :: struct {
    pos:   Vector3;
    color: u32;
}

PxDebugLine :: struct {
    pos0:   Vector3;
    color0: u32;
    pos1:   Vector3;
    color1: u32;
}

PxDebugTriangle :: struct {
    pos0:   Vector3;
    color0: u32;
    pos1:   Vector3;
    color1: u32;
    pos2:   Vector3;
    color2: u32;
}

PxDebugText :: struct {
    position:       Vector3;
    size:           float;
    color:          u32;
    structgen_pad0: [4] u8;
    _string:        *u8;
}

PxRenderBuffer :: struct {
    vtable_: *void;
}

PxProcessPxBaseCallback :: struct {
    vtable_: *void;
}

PxSerializationContext :: struct {
    vtable_: *void;
}

PxDeserializationContext :: struct {
    structgen_pad0: [16] u8;
}

PxSerializationRegistry :: struct {
    vtable_: *void;
}

PxCollection :: struct {
    vtable_: *void;
}

PxTypeInfo :: struct {}

PxFEMSoftBodyMaterial :: struct {}
PxFEMClothMaterial :: struct {}
PxPBDMaterial :: struct {}
PxFLIPMaterial :: struct {}
PxMPMMaterial :: struct {}
PxCustomMaterial :: struct {}

PxBVH33TriangleMesh :: struct {}

PxParticleSystem :: struct {}
PxPBDParticleSystem :: struct {}
PxFLIPParticleSystem :: struct {}
PxMPMParticleSystem :: struct {}
PxCustomParticleSystem :: struct {}
PxSoftBody :: struct {}
PxFEMCloth :: struct {}
PxHairSystem :: struct {}
PxParticleBuffer :: struct {}
PxParticleAndDiffuseBuffer :: struct {}
PxParticleClothBuffer :: struct {}
PxParticleRigidBuffer :: struct {}
PxBase :: struct {
    structgen_pad0: [16] u8;
}

PxRefCounted :: struct {
    structgen_pad0: [16] u8;
#place structgen_pad0; #as base: PxBase = ---;
}

PxTolerancesScale :: struct {
    length: float;
    speed:  float;
}

PxStringTable :: struct {
    vtable_: *void;
}

PxSerializer :: struct {
    vtable_: *void;
}

PxMetaDataEntry :: struct {
    type:       *u8;
    name:       *u8;
    offset:     u32;
    size:       u32;
    count:      u32;
    offsetSize: u32;
    flags:      u32;
    alignment:  u32;
}

PxInsertionCallback :: struct {
    vtable_: *void;
}

PxTaskManager :: struct {
    vtable_: *void;
}

PxCpuDispatcher :: struct {
    vtable_: *void;
}

PxBaseTask :: struct {
    structgen_pad0: [24] u8;
}

PxTask :: struct {
    structgen_pad0: [32] u8;
}

PxLightCpuTask :: struct {
    structgen_pad0: [40] u8;
}

PxGeometry :: struct {
    structgen_pad0: [4] u8;
    mTypePadding:   float;
}

PxBoxGeometry :: struct {
    structgen_pad0: [4] u8;
    mTypePadding:   float;
    halfExtents:    Vector3;
#place structgen_pad0; #as geometry: PxGeometry = ---;
}

PxBVHRaycastCallback :: struct {
    vtable_: *void;
}

PxBVHOverlapCallback :: struct {
    vtable_: *void;
}

PxBVHTraversalCallback :: struct {
    vtable_: *void;
}

PxBVH :: struct {
    structgen_pad0: [16] u8;
}

PxCapsuleGeometry :: struct {
    structgen_pad0: [4] u8;
    mTypePadding:   float;
    radius:         float;
    halfHeight:     float;
#place structgen_pad0; #as geometry: PxGeometry = ---;
}

PxHullPolygon :: struct {
    mPlane:     [4] float;
    mNbVerts:   u16;
    mIndexBase: u16;
}

PxConvexMesh :: struct {
    structgen_pad0: [16] u8;
#place structgen_pad0; #as ref_counted: PxRefCounted = ---;
}

PxMeshScale :: struct {
    scale:    Vector3;
    rotation: Quaternion;
}

PxConvexMeshGeometry :: struct {
    structgen_pad0: [4] u8;
    mTypePadding:   float;
    scale:          PxMeshScale;
    structgen_pad1: [4] u8;
    convexMesh:     *PxConvexMesh;
    meshFlags:      u8;
    structgen_pad2: [7] u8;
#place structgen_pad0; #as geometry: PxGeometry = ---;
}

PxSphereGeometry :: struct {
    structgen_pad0: [4] u8;
    mTypePadding:   float;
    radius:         float;
#place structgen_pad0; #as geometry: PxGeometry = ---;
}

PxPlaneGeometry :: struct {
    structgen_pad0: [4] u8;
    mTypePadding:   float;
#place structgen_pad0; #as geometry: PxGeometry = ---;
}

PxTriangleMeshGeometry :: struct {
    structgen_pad0: [4] u8;
    mTypePadding:   float;
    scale:          PxMeshScale;
    meshFlags:      u8;
    structgen_pad1: [3] u8;
    triangleMesh:   *PxTriangleMesh;
#place structgen_pad0; #as geometry: PxGeometry = ---;
}

PxHeightFieldGeometry :: struct {
    structgen_pad0:   [4] u8;
    mTypePadding:     float;
    heightField:      *PxHeightField;
    heightScale:      float;
    rowScale:         float;
    columnScale:      float;
    heightFieldFlags: u8;
    structgen_pad1:   [3] u8;
#place structgen_pad0; #as geometry: PxGeometry = ---;
}

PxParticleSystemGeometry :: struct {
    structgen_pad0: [4] u8;
    mTypePadding:   float;
    mSolverType:    s32;
#place structgen_pad0; #as geometry: PxGeometry = ---;
}

PxHairSystemGeometry :: struct {
    structgen_pad0: [4] u8;
    mTypePadding:   float;
#place structgen_pad0; #as geometry: PxGeometry = ---;
}

PxTetrahedronMeshGeometry :: struct {
    structgen_pad0:  [4] u8;
    mTypePadding:    float;
    tetrahedronMesh: *PxTetrahedronMesh;
#place structgen_pad0; #as geometry: PxGeometry = ---;
}

PxQueryHit :: struct {
    faceIndex: u32;
}

PxLocationHit :: struct {
    faceIndex:      u32;
    flags:          u16;
    structgen_pad0: [2] u8;
    position:       Vector3;
    normal:         Vector3;
    distance:       float;
}

PxGeomRaycastHit :: struct {
    faceIndex:      u32;
    flags:          u16;
    structgen_pad0: [2] u8;
    position:       Vector3;
    normal:         Vector3;
    distance:       float;
    u:              float;
    v:              float;
}

PxGeomOverlapHit :: struct {
    faceIndex: u32;
}

PxGeomSweepHit :: struct {
    faceIndex:      u32;
    flags:          u16;
    structgen_pad0: [2] u8;
    position:       Vector3;
    normal:         Vector3;
    distance:       float;
}

PxGeomIndexPair :: struct {
    id0: u32;
    id1: u32;
}

PxQueryThreadContext :: struct {
    structgen_pad0: [1] u8;
}

PxContactBuffer :: struct {}
PxRenderOutput :: struct {}

PxCustomGeometryType :: struct {
    structgen_pad0: [4] u8;
}

PxCustomGeometryCallbacks :: struct {
    vtable_: *void;
}

PxCustomGeometry :: struct {
    structgen_pad0: [4] u8;
    mTypePadding:   float;
    callbacks:      *PxCustomGeometryCallbacks;
#place structgen_pad0; #as geometry: PxGeometry = ---;
}

PxGeometryHolder :: struct {
    structgen_pad0: [56] u8;
}

PxGeometryQuery :: struct {
    structgen_pad0: [1] u8;
}

PxHeightFieldSample :: struct {
    height:         s16;
    materialIndex0: PxBitAndByte;
    materialIndex1: PxBitAndByte;
}

PxHeightField :: struct {
    structgen_pad0: [16] u8;
#place structgen_pad0; #as ref_counted: PxRefCounted = ---;
}

PxHeightFieldDesc :: struct {
    nbRows:              u32;
    nbColumns:           u32;
    format:              s32;
    structgen_pad0:      [4] u8;
    samples:             PxStridedData;
    convexEdgeThreshold: float;
    flags:               u16;
    structgen_pad1:      [2] u8;
}

PxMeshQuery :: struct {
    structgen_pad0: [1] u8;
}

PxSimpleTriangleMesh :: struct {
    points:         PxBoundedData;
    triangles:      PxBoundedData;
    flags:          u16;
    structgen_pad0: [6] u8;
}

PxTriangle :: struct {
    verts: [3] Vector3;
}

PxTrianglePadded :: struct {
    verts:   [3] Vector3;
    padding: u32;
}

PxTriangleMesh :: struct {
    structgen_pad0: [16] u8;
#place structgen_pad0; #as ref_counted: PxRefCounted = ---;
}

PxBVH34TriangleMesh :: struct {
    structgen_pad0: [16] u8;
}

PxTetrahedron :: struct {
    verts: [4] Vector3;
}

PxSoftBodyAuxData :: struct {
    structgen_pad0: [16] u8;
#place structgen_pad0; #as ref_counted: PxRefCounted = ---;
}

PxTetrahedronMesh :: struct {
    structgen_pad0: [16] u8;
#place structgen_pad0; #as ref_counted: PxRefCounted = ---;
}

PxSoftBodyMesh :: struct {
    structgen_pad0: [16] u8;
#place structgen_pad0; #as ref_counted: PxRefCounted = ---;
}

PxCollisionMeshMappingData :: struct {
    structgen_pad0: [8] u8;
}

PxSoftBodyCollisionData :: struct {
    structgen_pad0: [1] u8;
}

PxTetrahedronMeshData :: struct {
    structgen_pad0: [1] u8;
}

PxSoftBodySimulationData :: struct {
    structgen_pad0: [1] u8;
}

PxCollisionTetrahedronMeshData :: struct {
    structgen_pad0: [8] u8;
}

PxSimulationTetrahedronMeshData :: struct {
    structgen_pad0: [8] u8;
}

PxActor :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxAggregate :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxSpringModifiers :: struct {
    stiffness:      float;
    damping:        float;
    structgen_pad0: [8] u8;
}

PxRestitutionModifiers :: struct {
    restitution:       float;
    velocityThreshold: float;
    structgen_pad0:    [8] u8;
}

Px1DConstraintMods :: union {
    spring: PxSpringModifiers;
    bounce: PxRestitutionModifiers;
}

Px1DConstraint :: struct {
    linear0:        Vector3;
    geometricError: float;
    angular0:       Vector3;
    velocityTarget: float;
    linear1:        Vector3;
    minImpulse:     float;
    angular1:       Vector3;
    maxImpulse:     float;
    mods:           Px1DConstraintMods;
    forInternalUse: float;
    flags:          u16;
    solveHint:      u16;
    structgen_pad0: [8] u8;
}

PxConstraintInvMassScale :: struct {
    linear0:  float;
    angular0: float;
    linear1:  float;
    angular1: float;
}

PxConstraintVisualizer :: struct {
    vtable_: *void;
}

PxConstraintConnector :: struct {
    vtable_: *void;
}

PxContactPoint :: struct {
    normal:             Vector3;
    separation:         float;
    point:              Vector3;
    maxImpulse:         float;
    targetVel:          Vector3;
    staticFriction:     float;
    materialFlags:      u8;
    structgen_pad0:     [3] u8;
    internalFaceIndex1: u32;
    dynamicFriction:    float;
    restitution:        float;
    damping:            float;
    structgen_pad1:     [12] u8;
}

PxSolverBody :: struct {
    linearVelocity:            Vector3;
    maxSolverNormalProgress:   u16;
    maxSolverFrictionProgress: u16;
    angularState:              Vector3;
    solverProgress:            u32;
}

PxSolverBodyData :: struct {
    linearVelocity:    Vector3;
    invMass:           float;
    angularVelocity:   Vector3;
    reportThreshold:   float;
    sqrtInvInertia:    PxMat33;
    penBiasClamp:      float;
    nodeIndex:         u32;
    maxContactImpulse: float;
    body2World:        PxTransform;
    pad:               u16;
    structgen_pad0:    [2] u8;
}

PxConstraintBatchHeader :: struct {
    startIndex:     u32;
    stride:         u16;
    constraintType: u16;
}

PxSolverConstraintDesc :: struct {
    structgen_pad0:         [16] u8;
    bodyADataIndex:         u32;
    bodyBDataIndex:         u32;
    linkIndexA:             u32;
    linkIndexB:             u32;
    constraint:             *u8;
    writeBack:              *void;
    progressA:              u16;
    progressB:              u16;
    constraintLengthOver16: u16;
    padding:                [10] u8;
}

PxSolverConstraintPrepDescBase :: struct {
    invMassScales:  PxConstraintInvMassScale;
    desc:           *PxSolverConstraintDesc;
    body0:          *PxSolverBody;
    body1:          *PxSolverBody;
    data0:          *PxSolverBodyData;
    data1:          *PxSolverBodyData;
    bodyFrame0:     PxTransform;
    bodyFrame1:     PxTransform;
    bodyState0:     s32;
    bodyState1:     s32;
    structgen_pad0: [8] u8;
}

PxSolverConstraintPrepDesc :: struct {
    invMassScales:        PxConstraintInvMassScale;
    desc:                 *PxSolverConstraintDesc;
    body0:                *PxSolverBody;
    body1:                *PxSolverBody;
    data0:                *PxSolverBodyData;
    data1:                *PxSolverBodyData;
    bodyFrame0:           PxTransform;
    bodyFrame1:           PxTransform;
    bodyState0:           s32;
    bodyState1:           s32;
    structgen_pad0:       [8] u8;
    rows:                 *Px1DConstraint;
    numRows:              u32;
    linBreakForce:        float;
    angBreakForce:        float;
    minResponseThreshold: float;
    writeback:            *void;
    disablePreprocessing: bool;
    improvedSlerp:        bool;
    driveLimitsAreForces: bool;
    extendedLimits:       bool;
    disableConstraint:    bool;
    structgen_pad1:       [3] u8;
    body0WorldOffset:     PxVec3Padded;
    structgen_pad2:       [8] u8;
}

PxSolverContactDesc :: struct {
    invMassScales:           PxConstraintInvMassScale;
    desc:                    *PxSolverConstraintDesc;
    body0:                   *PxSolverBody;
    body1:                   *PxSolverBody;
    data0:                   *PxSolverBodyData;
    data1:                   *PxSolverBodyData;
    bodyFrame0:              PxTransform;
    bodyFrame1:              PxTransform;
    bodyState0:              s32;
    bodyState1:              s32;
    shapeInteraction:        *void;
    contacts:                *PxContactPoint;
    numContacts:             u32;
    hasMaxImpulse:           bool;
    disableStrongFriction:   bool;
    hasForceThresholds:      bool;
    structgen_pad0:          [1] u8;
    restDistance:            float;
    maxCCDSeparation:        float;
    frictionPtr:             *u8;
    frictionCount:           u8;
    structgen_pad1:          [7] u8;
    contactForces:           *float;
    startFrictionPatchIndex: u32;
    numFrictionPatches:      u32;
    startContactPatchIndex:  u32;
    numContactPatches:       u16;
    axisConstraintCount:     u16;
    offsetSlop:              float;
    structgen_pad2:          [12] u8;
}

PxConstraintAllocator :: struct {
    vtable_: *void;
}

PxArticulationLimit :: struct {
    low:  float;
    high: float;
}

PxArticulationDrive :: struct {
    stiffness: float;
    damping:   float;
    maxForce:  float;
    driveType: s32;
}

PxTGSSolverBodyVel :: struct {
    linearVelocity:       Vector3;
    nbStaticInteractions: u16;
    maxDynamicPartition:  u16;
    angularVelocity:      Vector3;
    partitionMask:        u32;
    deltaAngDt:           Vector3;
    maxAngVel:            float;
    deltaLinDt:           Vector3;
    lockFlags:            u16;
    isKinematic:          bool;
    pad:                  u8;
}

PxTGSSolverBodyTxInertia :: struct {
    deltaBody2World: PxTransform;
    sqrtInvInertia:  PxMat33;
}

PxTGSSolverBodyData :: struct {
    originalLinearVelocity:  Vector3;
    maxContactImpulse:       float;
    originalAngularVelocity: Vector3;
    penBiasClamp:            float;
    invMass:                 float;
    nodeIndex:               u32;
    reportThreshold:         float;
    pad:                     u32;
}

PxTGSSolverConstraintPrepDescBase :: struct {
    invMassScales:  PxConstraintInvMassScale;
    desc:           *PxSolverConstraintDesc;
    body0:          *PxTGSSolverBodyVel;
    body1:          *PxTGSSolverBodyVel;
    body0TxI:       *PxTGSSolverBodyTxInertia;
    body1TxI:       *PxTGSSolverBodyTxInertia;
    bodyData0:      *PxTGSSolverBodyData;
    bodyData1:      *PxTGSSolverBodyData;
    bodyFrame0:     PxTransform;
    bodyFrame1:     PxTransform;
    bodyState0:     s32;
    bodyState1:     s32;
    structgen_pad0: [8] u8;
}

PxTGSSolverConstraintPrepDesc :: struct {
    invMassScales:        PxConstraintInvMassScale;
    desc:                 *PxSolverConstraintDesc;
    body0:                *PxTGSSolverBodyVel;
    body1:                *PxTGSSolverBodyVel;
    body0TxI:             *PxTGSSolverBodyTxInertia;
    body1TxI:             *PxTGSSolverBodyTxInertia;
    bodyData0:            *PxTGSSolverBodyData;
    bodyData1:            *PxTGSSolverBodyData;
    bodyFrame0:           PxTransform;
    bodyFrame1:           PxTransform;
    bodyState0:           s32;
    bodyState1:           s32;
    rows:                 *Px1DConstraint;
    numRows:              u32;
    linBreakForce:        float;
    angBreakForce:        float;
    minResponseThreshold: float;
    writeback:            *void;
    disablePreprocessing: bool;
    improvedSlerp:        bool;
    driveLimitsAreForces: bool;
    extendedLimits:       bool;
    disableConstraint:    bool;
    structgen_pad0:       [3] u8;
    body0WorldOffset:     PxVec3Padded;
    cA2w:                 PxVec3Padded;
    cB2w:                 PxVec3Padded;
}

PxTGSSolverContactDesc :: struct {
    invMassScales:           PxConstraintInvMassScale;
    desc:                    *PxSolverConstraintDesc;
    body0:                   *PxTGSSolverBodyVel;
    body1:                   *PxTGSSolverBodyVel;
    body0TxI:                *PxTGSSolverBodyTxInertia;
    body1TxI:                *PxTGSSolverBodyTxInertia;
    bodyData0:               *PxTGSSolverBodyData;
    bodyData1:               *PxTGSSolverBodyData;
    bodyFrame0:              PxTransform;
    bodyFrame1:              PxTransform;
    bodyState0:              s32;
    bodyState1:              s32;
    shapeInteraction:        *void;
    contacts:                *PxContactPoint;
    numContacts:             u32;
    hasMaxImpulse:           bool;
    disableStrongFriction:   bool;
    hasForceThresholds:      bool;
    structgen_pad0:          [1] u8;
    restDistance:            float;
    maxCCDSeparation:        float;
    frictionPtr:             *u8;
    frictionCount:           u8;
    structgen_pad1:          [7] u8;
    contactForces:           *float;
    startFrictionPatchIndex: u32;
    numFrictionPatches:      u32;
    startContactPatchIndex:  u32;
    numContactPatches:       u16;
    axisConstraintCount:     u16;
    maxImpulse:              float;
    torsionalPatchRadius:    float;
    minTorsionalPatchRadius: float;
    offsetSlop:              float;
}

PxArticulationTendonLimit :: struct {
    lowLimit:  float;
    highLimit: float;
}

PxArticulationAttachment :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxArticulationTendonJoint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxArticulationTendon :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxArticulationSpatialTendon :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxArticulationFixedTendon :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxSpatialForce :: struct {
    force:  Vector3;
    pad0:   float;
    torque: Vector3;
    pad1:   float;
}

PxSpatialVelocity :: struct {
    linear:  Vector3;
    pad0:    float;
    angular: Vector3;
    pad1:    float;
}

PxArticulationRootLinkData :: struct {
    transform:     PxTransform;
    worldLinVel:   Vector3;
    worldAngVel:   Vector3;
    worldLinAccel: Vector3;
    worldAngAccel: Vector3;
}

PxArticulationCache :: struct {
    externalForces:    *PxSpatialForce;
    denseJacobian:     *float;
    massMatrix:        *float;
    jointVelocity:     *float;
    jointAcceleration: *float;
    jointPosition:     *float;
    jointForce:        *float;
    jointSolverForces: *float;
    linkVelocity:      *PxSpatialVelocity;
    linkAcceleration:  *PxSpatialVelocity;
    rootLinkData:      *PxArticulationRootLinkData;
    sensorForces:      *PxSpatialForce;
    coefficientMatrix: *float;
    lambda:            *float;
    scratchMemory:     *void;
    scratchAllocator:  *void;
    version:           u32;
    structgen_pad0:    [4] u8;
}

PxArticulationSensor :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxArticulationReducedCoordinate :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxArticulationJointReducedCoordinate :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxShape :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as ref_counted: PxRefCounted = ---;
}

PxRigidActor :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as actor: PxActor = ---;
}

PxNodeIndex :: struct {
    structgen_pad0: [8] u8;
}

PxRigidBody :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as rigid_actor: PxRigidActor = ---;
}

PxArticulationLink :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as rigid_body: PxRigidBody = ---;
}

PxConeLimitedConstraint :: struct {
    mAxis:      Vector3;
    mAngle:     float;
    mLowLimit:  float;
    mHighLimit: float;
}

PxConeLimitParams :: struct {
    lowHighLimits: Vector4;
    axisAngle:     Vector4;
}

PxConstraintShaderTable :: struct {
    solverPrep:     *void;
    structgen_pad0: [8] u8;
    visualize:      *void;
    flag:           s32;
    structgen_pad1: [4] u8;
}

PxConstraint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxMassModificationProps :: struct {
    mInvMassScale0:    float;
    mInvInertiaScale0: float;
    mInvMassScale1:    float;
    mInvInertiaScale1: float;
}

PxContactPatch :: struct {
    mMassModification: PxMassModificationProps;
    normal:            Vector3;
    restitution:       float;
    dynamicFriction:   float;
    staticFriction:    float;
    damping:           float;
    startContactIndex: u16;
    nbContacts:        u8;
    materialFlags:     u8;
    internalFlags:     u16;
    materialIndex0:    u16;
    materialIndex1:    u16;
    pad:               [5] u16;
}

PxContact :: struct {
    contact:    Vector3;
    separation: float;
}

PxExtendedContact :: struct {
    contact:        Vector3;
    separation:     float;
    targetVelocity: Vector3;
    maxImpulse:     float;
}

PxModifiableContact :: struct {
    contact:         Vector3;
    separation:      float;
    targetVelocity:  Vector3;
    maxImpulse:      float;
    normal:          Vector3;
    restitution:     float;
    materialFlags:   u32;
    materialIndex0:  u16;
    materialIndex1:  u16;
    staticFriction:  float;
    dynamicFriction: float;
}

PxContactStreamIterator :: struct {
    zero:                   Vector3;
    structgen_pad0:         [4] u8;
    patch:                  *PxContactPatch;
    contact:                *PxContact;
    faceIndice:             *u32;
    totalPatches:           u32;
    totalContacts:          u32;
    nextContactIndex:       u32;
    nextPatchIndex:         u32;
    contactPatchHeaderSize: u32;
    contactPointSize:       u32;
    mStreamFormat:          s32;
    forceNoResponse:        u32;
    pointStepped:           bool;
    structgen_pad1:         [3] u8;
    hasFaceIndices:         u32;
}

PxGpuContactPair :: struct {
    contactPatches:     *u8;
    contactPoints:      *u8;
    contactForces:      *float;
    transformCacheRef0: u32;
    transformCacheRef1: u32;
    nodeIndex0:         PxNodeIndex;
    nodeIndex1:         PxNodeIndex;
    actor0:             *PxActor;
    actor1:             *PxActor;
    nbContacts:         u16;
    nbPatches:          u16;
    structgen_pad0:     [4] u8;
}

PxContactSet :: struct {
    structgen_pad0: [16] u8;
}

PxContactModifyPair :: struct {
    actor:     [2] *PxRigidActor;
    shape:     [2] *PxShape;
    transform: [2] PxTransform;
    contacts:  PxContactSet;
}

PxContactModifyCallback :: struct {
    vtable_: *void;
}

PxCCDContactModifyCallback :: struct {
    vtable_: *void;
}

PxDeletionListener :: struct {
    vtable_: *void;
}

PxBaseMaterial :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as ref_counted: PxRefCounted = ---;
}

PxFEMMaterial :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxFilterData :: struct {
    word0: u32;
    word1: u32;
    word2: u32;
    word3: u32;
}

PxSimulationFilterCallback :: struct {
    vtable_: *void;
}

PxParticleRigidFilterPair :: struct {
    mID0: u64;
    mID1: u64;
}

PxLockedData :: struct {
    vtable_: *void;
}

PxMaterial :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as base_material: PxBaseMaterial = ---;
}

PxGpuParticleBufferIndexPair :: struct {
    systemIndex: u32;
    bufferIndex: u32;
}

PxCudaContextManager :: struct {}
PxParticleRigidAttachment :: struct {}
PxParticleVolume :: struct {
    bound:                 PxBounds3;
    particleIndicesOffset: u32;
    numParticles:          u32;
}

PxDiffuseParticleParams :: struct {
    threshold:           float;
    lifetime:            float;
    airDrag:             float;
    bubbleDrag:          float;
    buoyancy:            float;
    kineticEnergyWeight: float;
    pressureWeight:      float;
    divergenceWeight:    float;
    collisionDecay:      float;
    useAccurateVelocity: bool;
    structgen_pad0:      [3] u8;
}

PxParticleSpring :: struct {
    ind0:      u32;
    ind1:      u32;
    length:    float;
    stiffness: float;
    damping:   float;
    pad:       float;
}

PxParticleMaterial :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxOmniPvd :: struct {}
PxPhysics :: struct {
    vtable_: *void;
}

PxActorShape :: struct {
    actor: *PxRigidActor;
    shape: *PxShape;
}

PxRaycastHit :: struct {
    faceIndex:      u32;
    flags:          u16;
    structgen_pad0: [2] u8;
    position:       Vector3;
    normal:         Vector3;
    distance:       float;
    u:              float;
    v:              float;
    structgen_pad1: [4] u8;
    actor:          *PxRigidActor;
    shape:          *PxShape;
}

PxOverlapHit :: struct {
    faceIndex:      u32;
    structgen_pad0: [4] u8;
    actor:          *PxRigidActor;
    shape:          *PxShape;
}

PxSweepHit :: struct {
    faceIndex:      u32;
    flags:          u16;
    structgen_pad0: [2] u8;
    position:       Vector3;
    normal:         Vector3;
    distance:       float;
    structgen_pad1: [4] u8;
    actor:          *PxRigidActor;
    shape:          *PxShape;
}

PxRaycastCallback :: struct {
    structgen_pad0: [8] u8;
    block:          PxRaycastHit;
    hasBlock:       bool;
    structgen_pad1: [7] u8;
    touches:        *PxRaycastHit;
    maxNbTouches:   u32;
    nbTouches:      u32;
}

PxOverlapCallback :: struct {
    structgen_pad0: [8] u8;
    block:          PxOverlapHit;
    hasBlock:       bool;
    structgen_pad1: [7] u8;
    touches:        *PxOverlapHit;
    maxNbTouches:   u32;
    nbTouches:      u32;
}

PxSweepCallback :: struct {
    structgen_pad0: [8] u8;
    block:          PxSweepHit;
    hasBlock:       bool;
    structgen_pad1: [7] u8;
    touches:        *PxSweepHit;
    maxNbTouches:   u32;
    nbTouches:      u32;
}

PxRaycastBuffer :: struct {
    structgen_pad0: [8] u8;
    block:          PxRaycastHit;
    hasBlock:       bool;
    structgen_pad1: [7] u8;
    touches:        *PxRaycastHit;
    maxNbTouches:   u32;
    nbTouches:      u32;
}

PxOverlapBuffer :: struct {
    structgen_pad0: [8] u8;
    block:          PxOverlapHit;
    hasBlock:       bool;
    structgen_pad1: [7] u8;
    touches:        *PxOverlapHit;
    maxNbTouches:   u32;
    nbTouches:      u32;
}

PxSweepBuffer :: struct {
    structgen_pad0: [8] u8;
    block:          PxSweepHit;
    hasBlock:       bool;
    structgen_pad1: [7] u8;
    touches:        *PxSweepHit;
    maxNbTouches:   u32;
    nbTouches:      u32;
}

PxQueryCache :: struct {
    shape:          *PxShape;
    actor:          *PxRigidActor;
    faceIndex:      u32;
    structgen_pad0: [4] u8;
}

PxQueryFilterData :: struct {
    data:           PxFilterData;
    flags:          u16;
    structgen_pad0: [2] u8;
}

PxQueryFilterCallback :: struct {
    vtable_: *void;
}

PxRigidDynamic :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as rigid_body: PxRigidBody = ---;
}

PxRigidStatic :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as rigid_actor: PxRigidActor = ---;
}

PxSceneQueryDesc :: struct {
    staticStructure:            s32;
    dynamicStructure:           s32;
    dynamicTreeRebuildRateHint: u32;
    dynamicTreeSecondaryPruner: s32;
    staticBVHBuildStrategy:     s32;
    dynamicBVHBuildStrategy:    s32;
    staticNbObjectsPerNode:     u32;
    dynamicNbObjectsPerNode:    u32;
    sceneQueryUpdateMode:       s32;
}

PxSceneQuerySystemBase :: struct {
    vtable_: *void;
}

PxSceneSQSystem :: struct {
    vtable_: *void;
}

PxSceneQuerySystem :: struct {
    vtable_: *void;
}

PxBroadPhaseRegion :: struct {
    mBounds:   PxBounds3;
    mUserData: *void;
}

PxBroadPhaseRegionInfo :: struct {
    mRegion:           PxBroadPhaseRegion;
    mNbStaticObjects:  u32;
    mNbDynamicObjects: u32;
    mActive:           bool;
    mOverlap:          bool;
    structgen_pad0:    [6] u8;
}

PxBroadPhaseCaps :: struct {
    mMaxNbRegions: u32;
}

PxBroadPhaseDesc :: struct {
    mType:                        s32;
    structgen_pad0:               [4] u8;
    mContextID:                   u64;
    structgen_pad1:               [8] u8;
    mFoundLostPairsCapacity:      u32;
    mDiscardStaticVsKinematic:    bool;
    mDiscardKinematicVsKinematic: bool;
    structgen_pad2:               [2] u8;
}

PxBroadPhaseUpdateData :: struct {
    mCreated:       *u32;
    mNbCreated:     u32;
    structgen_pad0: [4] u8;
    mUpdated:       *u32;
    mNbUpdated:     u32;
    structgen_pad1: [4] u8;
    mRemoved:       *u32;
    mNbRemoved:     u32;
    structgen_pad2: [4] u8;
    mBounds:        *PxBounds3;
    mGroups:        *u32;
    mDistances:     *float;
    mCapacity:      u32;
    structgen_pad3: [4] u8;
}

PxBroadPhasePair :: struct {
    mID0: u32;
    mID1: u32;
}

PxBroadPhaseResults :: struct {
    mNbCreatedPairs: u32;
    structgen_pad0:  [4] u8;
    mCreatedPairs:   *PxBroadPhasePair;
    mNbDeletedPairs: u32;
    structgen_pad1:  [4] u8;
    mDeletedPairs:   *PxBroadPhasePair;
}

PxBroadPhaseRegions :: struct {
    vtable_: *void;
}

PxBroadPhase :: struct {
    vtable_: *void;
}

PxAABBManager :: struct {
    vtable_: *void;
}

PxSceneLimits :: struct {
    maxNbActors:             u32;
    maxNbBodies:             u32;
    maxNbStaticShapes:       u32;
    maxNbDynamicShapes:      u32;
    maxNbAggregates:         u32;
    maxNbConstraints:        u32;
    maxNbRegions:            u32;
    maxNbBroadPhaseOverlaps: u32;
}

PxgDynamicsMemoryConfig :: struct {
    tempBufferCapacity:              u32;
    maxRigidContactCount:            u32;
    maxRigidPatchCount:              u32;
    heapCapacity:                    u32;
    foundLostPairsCapacity:          u32;
    foundLostAggregatePairsCapacity: u32;
    totalAggregatePairsCapacity:     u32;
    maxSoftBodyContacts:             u32;
    maxFemClothContacts:             u32;
    maxParticleContacts:             u32;
    collisionStackSize:              u32;
    maxHairContacts:                 u32;
}

PxSceneDesc :: struct {
    staticStructure:               s32;
    dynamicStructure:              s32;
    dynamicTreeRebuildRateHint:    u32;
    dynamicTreeSecondaryPruner:    s32;
    staticBVHBuildStrategy:        s32;
    dynamicBVHBuildStrategy:       s32;
    staticNbObjectsPerNode:        u32;
    dynamicNbObjectsPerNode:       u32;
    sceneQueryUpdateMode:          s32;
    gravity:                       Vector3;
    simulationEventCallback:       *PxSimulationEventCallback;
    contactModifyCallback:         *PxContactModifyCallback;
    ccdContactModifyCallback:      *PxCCDContactModifyCallback;
    filterShaderData:              *void;
    filterShaderDataSize:          u32;
    structgen_pad0:                [4] u8;
    filterShader:                  *void;
    filterCallback:                *PxSimulationFilterCallback;
    kineKineFilteringMode:         s32;
    staticKineFilteringMode:       s32;
    broadPhaseType:                s32;
    structgen_pad1:                [4] u8;
    broadPhaseCallback:            *PxBroadPhaseCallback;
    limits:                        PxSceneLimits;
    frictionType:                  s32;
    solverType:                    s32;
    bounceThresholdVelocity:       float;
    frictionOffsetThreshold:       float;
    frictionCorrelationDistance:   float;
    flags:                         u32;
    cpuDispatcher:                 *PxCpuDispatcher;
    structgen_pad2:                [8] u8;
    userData:                      *void;
    solverBatchSize:               u32;
    solverArticulationBatchSize:   u32;
    nbContactDataBlocks:           u32;
    maxNbContactDataBlocks:        u32;
    maxBiasCoefficient:            float;
    contactReportStreamBufferSize: u32;
    ccdMaxPasses:                  u32;
    ccdThreshold:                  float;
    ccdMaxSeparation:              float;
    wakeCounterResetValue:         float;
    sanityBounds:                  PxBounds3;
    gpuDynamicsConfig:             PxgDynamicsMemoryConfig;
    gpuMaxNumPartitions:           u32;
    gpuMaxNumStaticPartitions:     u32;
    gpuComputeVersion:             u32;
    contactPairSlabSize:           u32;
    sceneQuerySystem:              *PxSceneQuerySystem;
    structgen_pad3:                [8] u8;
}

PxSimulationStatistics :: struct {
    nbActiveConstraints:                 u32;
    nbActiveDynamicBodies:               u32;
    nbActiveKinematicBodies:             u32;
    nbStaticBodies:                      u32;
    nbDynamicBodies:                     u32;
    nbKinematicBodies:                   u32;
    nbShapes:                            [11] u32;
    nbAggregates:                        u32;
    nbArticulations:                     u32;
    nbAxisSolverConstraints:             u32;
    compressedContactSize:               u32;
    requiredContactConstraintMemory:     u32;
    peakConstraintMemory:                u32;
    nbDiscreteContactPairsTotal:         u32;
    nbDiscreteContactPairsWithCacheHits: u32;
    nbDiscreteContactPairsWithContacts:  u32;
    nbNewPairs:                          u32;
    nbLostPairs:                         u32;
    nbNewTouches:                        u32;
    nbLostTouches:                       u32;
    nbPartitions:                        u32;
    structgen_pad0:                      [4] u8;
    gpuMemParticles:                     u64;
    gpuMemSoftBodies:                    u64;
    gpuMemFEMCloths:                     u64;
    gpuMemHairSystems:                   u64;
    gpuMemHeap:                          u64;
    gpuMemHeapBroadPhase:                u64;
    gpuMemHeapNarrowPhase:               u64;
    gpuMemHeapSolver:                    u64;
    gpuMemHeapArticulation:              u64;
    gpuMemHeapSimulation:                u64;
    gpuMemHeapSimulationArticulation:    u64;
    gpuMemHeapSimulationParticles:       u64;
    gpuMemHeapSimulationSoftBody:        u64;
    gpuMemHeapSimulationFEMCloth:        u64;
    gpuMemHeapSimulationHairSystem:      u64;
    gpuMemHeapParticles:                 u64;
    gpuMemHeapSoftBodies:                u64;
    gpuMemHeapFEMCloths:                 u64;
    gpuMemHeapHairSystems:               u64;
    gpuMemHeapOther:                     u64;
    nbBroadPhaseAdds:                    u32;
    nbBroadPhaseRemoves:                 u32;
    nbDiscreteContactPairs:              [11] [11] u32;
    nbCCDPairs:                          [11] [11] u32;
    nbModifiedContactPairs:              [11] [11] u32;
    nbTriggerPairs:                      [11] [11] u32;
}

PxGpuBodyData :: struct {
    quat:   Quaternion;
    pos:    Vector4;
    linVel: Vector4;
    angVel: Vector4;
}

PxGpuActorPair :: struct {
    srcIndex:       u32;
    structgen_pad0: [4] u8;
    nodeIndex:      PxNodeIndex;
}

PxIndexDataPair :: struct {
    index:          u32;
    structgen_pad0: [4] u8;
    data:           *void;
}

PxPvdSceneClient :: struct {
    vtable_: *void;
}

PxDominanceGroupPair :: struct {
    dominance0: u8;
    dominance1: u8;
}

PxBroadPhaseCallback :: struct {
    vtable_: *void;
}

PxScene :: struct {
    structgen_pad0: [8] u8;
    userData:       *void;
}

PxSceneReadLock :: struct {
    structgen_pad0: [8] u8;
}

PxSceneWriteLock :: struct {
    structgen_pad0: [8] u8;
}

PxContactPairExtraDataItem :: struct {
    type: u8;
}

PxContactPairVelocity :: struct {
    type:            u8;
    structgen_pad0:  [3] u8;
    linearVelocity:  [2] Vector3;
    angularVelocity: [2] Vector3;
}

PxContactPairPose :: struct {
    type:           u8;
    structgen_pad0: [3] u8;
    globalPose:     [2] PxTransform;
}

PxContactPairIndex :: struct {
    type:           u8;
    structgen_pad0: [1] u8;
    index:          u16;
}

PxContactPairExtraDataIterator :: struct {
    currPtr:            *u8;
    endPtr:             *u8;
    preSolverVelocity:  *PxContactPairVelocity;
    postSolverVelocity: *PxContactPairVelocity;
    eventPose:          *PxContactPairPose;
    contactPairIndex:   u32;
    structgen_pad0:     [4] u8;
}

PxContactPairHeader :: struct {
    actors:              [2] *PxActor;
    extraDataStream:     *u8;
    extraDataStreamSize: u16;
    flags:               u16;
    structgen_pad0:      [4] u8;
    pairs:               *PxContactPair;
    nbPairs:             u32;
    structgen_pad1:      [4] u8;
}

PxContactPairPoint :: struct {
    position:           Vector3;
    separation:         float;
    normal:             Vector3;
    internalFaceIndex0: u32;
    impulse:            Vector3;
    internalFaceIndex1: u32;
}

PxContactPair :: struct {
    shapes:             [2] *PxShape;
    contactPatches:     *u8;
    contactPoints:      *u8;
    contactImpulses:    *float;
    requiredBufferSize: u32;
    contactCount:       u8;
    patchCount:         u8;
    contactStreamSize:  u16;
    flags:              u16;
    events:             u16;
    internalData:       [2] u32;
    structgen_pad0:     [4] u8;
}

PxTriggerPair :: struct {
    triggerShape:   *PxShape;
    triggerActor:   *PxActor;
    otherShape:     *PxShape;
    otherActor:     *PxActor;
    status:         s32;
    flags:          u8;
    structgen_pad0: [3] u8;
}

PxConstraintInfo :: struct {
    constraint:        *PxConstraint;
    externalReference: *void;
    type:              u32;
    structgen_pad0:    [4] u8;
}

PxSimulationEventCallback :: struct {
    vtable_: *void;
}

PxFEMParameters :: struct {
    velocityDamping:              float;
    settlingThreshold:            float;
    sleepThreshold:               float;
    sleepDamping:                 float;
    selfCollisionFilterDistance:  float;
    selfCollisionStressTolerance: float;
}

PxPruningStructure :: struct {
    structgen_pad0: [16] u8;
}

PxExtendedVec3 :: struct {
    x: float64;
    y: float64;
    z: float64;
}

PxObstacle :: struct {
    structgen_pad0: [8] u8;
    mUserData:      *void;
    mPos:           PxExtendedVec3;
    mRot:           Quaternion;
}

PxBoxObstacle :: struct {
    structgen_pad0: [8] u8;
    mUserData:      *void;
    mPos:           PxExtendedVec3;
    mRot:           Quaternion;
    mHalfExtents:   Vector3;
    structgen_pad1: [4] u8;
}

PxCapsuleObstacle :: struct {
    structgen_pad0: [8] u8;
    mUserData:      *void;
    mPos:           PxExtendedVec3;
    mRot:           Quaternion;
    mHalfHeight:    float;
    mRadius:        float;
}

PxObstacleContext :: struct {
    vtable_: *void;
}

PxControllerState :: struct {
    deltaXP:               Vector3;
    structgen_pad0:        [4] u8;
    touchedShape:          *PxShape;
    touchedActor:          *PxRigidActor;
    touchedObstacleHandle: u32;
    collisionFlags:        u32;
    standOnAnotherCCT:     bool;
    standOnObstacle:       bool;
    isMovingUp:            bool;
    structgen_pad1:        [5] u8;
}

PxControllerStats :: struct {
    nbIterations:     u16;
    nbFullUpdates:    u16;
    nbPartialUpdates: u16;
    nbTessellation:   u16;
}

PxControllerHit :: struct {
    controller:     *PxController;
    worldPos:       PxExtendedVec3;
    worldNormal:    Vector3;
    dir:            Vector3;
    length:         float;
    structgen_pad0: [4] u8;
}

PxControllerShapeHit :: struct {
    controller:     *PxController;
    worldPos:       PxExtendedVec3;
    worldNormal:    Vector3;
    dir:            Vector3;
    length:         float;
    structgen_pad0: [4] u8;
    shape:          *PxShape;
    actor:          *PxRigidActor;
    triangleIndex:  u32;
    structgen_pad1: [4] u8;
}

PxControllersHit :: struct {
    controller:     *PxController;
    worldPos:       PxExtendedVec3;
    worldNormal:    Vector3;
    dir:            Vector3;
    length:         float;
    structgen_pad0: [4] u8;
    other:          *PxController;
}

PxControllerObstacleHit :: struct {
    controller:     *PxController;
    worldPos:       PxExtendedVec3;
    worldNormal:    Vector3;
    dir:            Vector3;
    length:         float;
    structgen_pad0: [4] u8;
    userData:       *void;
}

PxUserControllerHitReport :: struct {
    vtable_: *void;
}

PxControllerFilterCallback :: struct {
    vtable_: *void;
}

PxControllerFilters :: struct {
    mFilterData:        *PxFilterData;
    mFilterCallback:    *PxQueryFilterCallback;
    mFilterFlags:       u16;
    structgen_pad0:     [6] u8;
    mCCTFilterCallback: *PxControllerFilterCallback;
}

PxControllerDesc :: struct {
    structgen_pad0:           [8] u8;
    position:                 PxExtendedVec3;
    upDirection:              Vector3;
    slopeLimit:               float;
    invisibleWallHeight:      float;
    maxJumpHeight:            float;
    contactOffset:            float;
    stepOffset:               float;
    density:                  float;
    scaleCoeff:               float;
    volumeGrowth:             float;
    structgen_pad1:           [4] u8;
    reportCallback:           *PxUserControllerHitReport;
    behaviorCallback:         *PxControllerBehaviorCallback;
    nonWalkableMode:          s32;
    structgen_pad2:           [4] u8;
    material:                 *PxMaterial;
    registerDeletionListener: bool;
    clientID:                 u8;
    structgen_pad3:           [6] u8;
    userData:                 *void;
    structgen_pad4:           [8] u8;
}

PxController :: struct {
    vtable_: *void;
}

PxBoxControllerDesc :: struct {
    structgen_pad0:           [8] u8;
    position:                 PxExtendedVec3;
    upDirection:              Vector3;
    slopeLimit:               float;
    invisibleWallHeight:      float;
    maxJumpHeight:            float;
    contactOffset:            float;
    stepOffset:               float;
    density:                  float;
    scaleCoeff:               float;
    volumeGrowth:             float;
    structgen_pad1:           [4] u8;
    reportCallback:           *PxUserControllerHitReport;
    behaviorCallback:         *PxControllerBehaviorCallback;
    nonWalkableMode:          s32;
    structgen_pad2:           [4] u8;
    material:                 *PxMaterial;
    registerDeletionListener: bool;
    clientID:                 u8;
    structgen_pad3:           [6] u8;
    userData:                 *void;
    structgen_pad4:           [4] u8;
    halfHeight:               float;
    halfSideExtent:           float;
    halfForwardExtent:        float;
#place structgen_pad0; #as controller_desc: PxControllerDesc = ---;
}

PxBoxController :: struct {
    vtable_: *void;
#place vtable_; #as controller: PxController = ---;
}

PxCapsuleControllerDesc :: struct {
    structgen_pad0:           [8] u8;
    position:                 PxExtendedVec3;
    upDirection:              Vector3;
    slopeLimit:               float;
    invisibleWallHeight:      float;
    maxJumpHeight:            float;
    contactOffset:            float;
    stepOffset:               float;
    density:                  float;
    scaleCoeff:               float;
    volumeGrowth:             float;
    structgen_pad1:           [4] u8;
    reportCallback:           *PxUserControllerHitReport;
    behaviorCallback:         *PxControllerBehaviorCallback;
    nonWalkableMode:          s32;
    structgen_pad2:           [4] u8;
    material:                 *PxMaterial;
    registerDeletionListener: bool;
    clientID:                 u8;
    structgen_pad3:           [6] u8;
    userData:                 *void;
    structgen_pad4:           [4] u8;
    radius:                   float;
    height:                   float;
    climbingMode:             s32;
#place structgen_pad0; #as controller_desc: PxControllerDesc = ---;
}

PxCapsuleController :: struct {
    vtable_: *void;
#place vtable_; #as controller: PxController = ---;
}

PxControllerBehaviorCallback :: struct {
    vtable_: *void;
}

PxControllerManager :: struct {
    vtable_: *void;
}

PxDim3 :: struct {
    x: u32;
    y: u32;
    z: u32;
}

PxSDFDesc :: struct {
    sdf:                                            PxBoundedData;
    dims:                                           PxDim3;
    meshLower:                                      Vector3;
    spacing:                                        float;
    subgridSize:                                    u32;
    bitsPerSubgridPixel:                            s32;
    sdfSubgrids3DTexBlockDim:                       PxDim3;
    sdfSubgrids:                                    PxBoundedData;
    sdfStartSlots:                                  PxBoundedData;
    subgridsMinSdfValue:                            float;
    subgridsMaxSdfValue:                            float;
    sdfBounds:                                      PxBounds3;
    narrowBandThicknessRelativeToSdfBoundsDiagonal: float;
    numThreadsForSdfConstruction:                   u32;
}

PxConvexMeshDesc :: struct {
    points:         PxBoundedData;
    polygons:       PxBoundedData;
    indices:        PxBoundedData;
    flags:          u16;
    vertexLimit:    u16;
    polygonLimit:   u16;
    quantizedCount: u16;
    sdfDesc:        *PxSDFDesc;
}

PxTriangleMeshDesc :: struct {
    points:         PxBoundedData;
    triangles:      PxBoundedData;
    flags:          u16;
    structgen_pad0: [22] u8;
    sdfDesc:        *PxSDFDesc;
}

PxTetrahedronMeshDesc :: struct {
    structgen_pad0: [16] u8;
    points:         PxBoundedData;
    tetrahedrons:   PxBoundedData;
    flags:          u16;
    tetsPerElement: u16;
    structgen_pad1: [4] u8;
}

PxSoftBodySimulationDataDesc :: struct {
    vertexToTet: PxBoundedData;
}

PxBVH34MidphaseDesc :: struct {
    numPrimsPerLeaf: u32;
    buildStrategy:   s32;
    quantized:       bool;
    structgen_pad0:  [3] u8;
}

PxMidphaseDesc :: struct {
    structgen_pad0: [16] u8;
}

PxBVHDesc :: struct {
    bounds:          PxBoundedData;
    enlargement:     float;
    numPrimsPerLeaf: u32;
    buildStrategy:   s32;
    structgen_pad0:  [4] u8;
}

PxCookingParams :: struct {
    areaTestEpsilon:                float;
    planeTolerance:                 float;
    convexMeshCookingType:          s32;
    suppressTriangleMeshRemapTable: bool;
    buildTriangleAdjacencies:       bool;
    buildGPUData:                   bool;
    structgen_pad0:                 [1] u8;
    scale:                          PxTolerancesScale;
    meshPreprocessParams:           u32;
    meshWeldTolerance:              float;
    midphaseDesc:                   PxMidphaseDesc;
    gaussMapLimit:                  u32;
    maxWeightRatioInTet:            float;
}

PxDefaultMemoryOutputStream :: struct {
    structgen_pad0: [32] u8;
#place structgen_pad0; #as output_stream: PxOutputStream = ---;
}

PxDefaultMemoryInputData :: struct {
    structgen_pad0: [32] u8;
#place structgen_pad0; #as input_stream: PxInputStream = ---;
}

PxDefaultFileOutputStream :: struct {
    structgen_pad0: [16] u8;
}

PxDefaultFileInputData :: struct {
    structgen_pad0: [24] u8;
}

PxDefaultAllocator :: struct {
    vtable_: *void;
}

PxJoint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as base: PxBase = ---;
}

PxSpring :: struct {
    stiffness: float;
    damping:   float;
}

PxDistanceJoint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as joint: PxJoint = ---;
}

PxJacobianRow :: struct {
    linear0:  Vector3;
    linear1:  Vector3;
    angular0: Vector3;
    angular1: Vector3;
}

PxContactJoint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as joint: PxJoint = ---;
}

PxFixedJoint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as joint: PxJoint = ---;
}

PxJointLimitParameters :: struct {
    restitution:                float;
    bounceThreshold:            float;
    stiffness:                  float;
    damping:                    float;
    contactDistance_deprecated: float;
}

PxJointLinearLimit :: struct {
    restitution:                float;
    bounceThreshold:            float;
    stiffness:                  float;
    damping:                    float;
    contactDistance_deprecated: float;
    value:                      float;
}

PxJointLinearLimitPair :: struct {
    restitution:                float;
    bounceThreshold:            float;
    stiffness:                  float;
    damping:                    float;
    contactDistance_deprecated: float;
    upper:                      float;
    lower:                      float;
}

PxJointAngularLimitPair :: struct {
    restitution:                float;
    bounceThreshold:            float;
    stiffness:                  float;
    damping:                    float;
    contactDistance_deprecated: float;
    upper:                      float;
    lower:                      float;
}

PxJointLimitCone :: struct {
    restitution:                float;
    bounceThreshold:            float;
    stiffness:                  float;
    damping:                    float;
    contactDistance_deprecated: float;
    yAngle:                     float;
    zAngle:                     float;
}

PxJointLimitPyramid :: struct {
    restitution:                float;
    bounceThreshold:            float;
    stiffness:                  float;
    damping:                    float;
    contactDistance_deprecated: float;
    yAngleMin:                  float;
    yAngleMax:                  float;
    zAngleMin:                  float;
    zAngleMax:                  float;
}

PxPrismaticJoint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as joint: PxJoint = ---;
}

PxRevoluteJoint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as joint: PxJoint = ---;
}

PxSphericalJoint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as joint: PxJoint = ---;
}

PxD6JointDrive :: struct {
    stiffness:  float;
    damping:    float;
    forceLimit: float;
    flags:      u32;
}

PxD6Joint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as joint: PxJoint = ---;
}

PxGearJoint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
#place structgen_pad0; #as joint: PxJoint = ---;
}

PxRackAndPinionJoint :: struct {
    structgen_pad0: [16] u8;
    userData:       *void;
}

PxGroupsMask :: struct {
    bits0: u16;
    bits1: u16;
    bits2: u16;
    bits3: u16;
}

PxDefaultErrorCallback :: struct {
    vtable_: *void;
}

PxRigidActorExt :: struct {
    structgen_pad0: [1] u8;
}

PxMassProperties :: struct {
    inertiaTensor: PxMat33;
    centerOfMass:  Vector3;
    mass:          float;
}

PxRigidBodyExt :: struct {
    structgen_pad0: [1] u8;
}

PxShapeExt :: struct {
    structgen_pad0: [1] u8;
}

PxMeshOverlapUtil :: struct {
    structgen_pad0: [1040] u8;
}

PxBinaryConverter :: struct {}
PxXmlMiscParameter :: struct {
    upVector: Vector3;
    scale:    PxTolerancesScale;
}

PxSerialization :: struct {
    structgen_pad0: [1] u8;
}

PxDefaultCpuDispatcher :: struct {
    vtable_: *void;
}

PxStringTableExt :: struct {
    structgen_pad0: [1] u8;
}

PxBroadPhaseExt :: struct {
    structgen_pad0: [1] u8;
}

PxSceneQueryExt :: struct {
    structgen_pad0: [1] u8;
}

PxBatchQueryExt :: struct {
    vtable_: *void;
}

PxCustomSceneQuerySystem :: struct {
    vtable_: *void;
}

PxCustomSceneQuerySystemAdapter :: struct {
    vtable_: *void;
}

PxSamplingExt :: struct {
    structgen_pad0: [1] u8;
}

PxPoissonSampler :: struct {
    structgen_pad0: [8] u8;
}

PxTriangleMeshPoissonSampler :: struct {
    structgen_pad0: [8] u8;
}

PxTetrahedronMeshExt :: struct {
    structgen_pad0: [1] u8;
}

PxRepXObject :: struct {
    typeName:     *u8;
    serializable: *void;
    id:           u64;
}

PxCooking :: struct {}
PxRepXInstantiationArgs :: struct {
    structgen_pad0: [8] u8;
    cooker:         *PxCooking;
    stringTable:    *PxStringTable;
}

XmlMemoryAllocator :: struct {}
XmlWriter :: struct {}
XmlReader :: struct {}
MemoryBuffer :: struct {}
PxRepXSerializer :: struct {
    vtable_: *void;
}

PxVehicleWheels4SimData :: struct {}
PxVehicleWheels4DynData :: struct {}
PxVehicleTireForceCalculator :: struct {}
PxVehicleDrivableSurfaceToTireFrictionPairs :: struct {}
PxVehicleTelemetryData :: struct {}

PxPvd :: struct {
    vtable_: *void;
}

PxPvdTransport :: struct {
    vtable_: *void;
}

PxAllocatorCallback_delete :: (self: *PxAllocatorCallback) -> void #foreign libphysx;

PxAllocatorCallback_allocate :: (self: *PxAllocatorCallback, size: u64, typeName: *u8, filename: *u8, line: s32) -> *void #foreign libphysx "PxAllocatorCallback_allocate_mut";

PxAllocatorCallback_deallocate :: (self: *PxAllocatorCallback, ptr: *void) -> void #foreign libphysx "PxAllocatorCallback_deallocate_mut";

PxAssertHandler_delete :: (self: *PxAssertHandler) -> void #foreign libphysx;

PxGetAssertHandler :: () -> *PxAssertHandler #foreign libphysx "phys_PxGetAssertHandler";

PxSetAssertHandler :: (handler: *PxAssertHandler) -> void #foreign libphysx "phys_PxSetAssertHandler";

PxFoundation_release :: (self: *PxFoundation) -> void #foreign libphysx "PxFoundation_release_mut";

PxFoundation_getErrorCallback :: (self: *PxFoundation) -> *PxErrorCallback #foreign libphysx "PxFoundation_getErrorCallback_mut";

PxFoundation_setErrorLevel :: (self: *PxFoundation, mask: u32) -> void #foreign libphysx "PxFoundation_setErrorLevel_mut";

PxFoundation_getErrorLevel :: (self: *PxFoundation) -> u32 #foreign libphysx;

PxFoundation_getAllocatorCallback :: (self: *PxFoundation) -> *PxAllocatorCallback #foreign libphysx "PxFoundation_getAllocatorCallback_mut";

PxFoundation_getReportAllocationNames :: (self: *PxFoundation) -> bool #foreign libphysx;

PxFoundation_setReportAllocationNames :: (self: *PxFoundation, value: bool) -> void #foreign libphysx "PxFoundation_setReportAllocationNames_mut";

PxFoundation_registerAllocationListener :: (self: *PxFoundation, listener: *PxAllocationListener) -> void #foreign libphysx "PxFoundation_registerAllocationListener_mut";

PxFoundation_deregisterAllocationListener :: (self: *PxFoundation, listener: *PxAllocationListener) -> void #foreign libphysx "PxFoundation_deregisterAllocationListener_mut";

PxFoundation_registerErrorCallback :: (self: *PxFoundation, callback: *PxErrorCallback) -> void #foreign libphysx "PxFoundation_registerErrorCallback_mut";

PxFoundation_deregisterErrorCallback :: (self: *PxFoundation, callback: *PxErrorCallback) -> void #foreign libphysx "PxFoundation_deregisterErrorCallback_mut";

PxCreateFoundation :: (version: u32, allocator: *PxAllocatorCallback, errorCallback: *PxErrorCallback) -> *PxFoundation #foreign libphysx "phys_PxCreateFoundation";

PxSetFoundationInstance :: (foundation: *PxFoundation) -> void #foreign libphysx "phys_PxSetFoundationInstance";

PxGetFoundation :: () -> *PxFoundation #foreign libphysx "phys_PxGetFoundation";

PxGetProfilerCallback :: () -> *PxProfilerCallback #foreign libphysx "phys_PxGetProfilerCallback";

PxSetProfilerCallback :: (profiler: *PxProfilerCallback) -> void #foreign libphysx "phys_PxSetProfilerCallback";

PxGetAllocatorCallback :: () -> *PxAllocatorCallback #foreign libphysx "phys_PxGetAllocatorCallback";

PxGetBroadcastAllocator :: () -> *PxAllocatorCallback #foreign libphysx "phys_PxGetBroadcastAllocator";

PxGetErrorCallback :: () -> *PxErrorCallback #foreign libphysx "phys_PxGetErrorCallback";

PxGetBroadcastError :: () -> *PxErrorCallback #foreign libphysx "phys_PxGetBroadcastError";

PxGetWarnOnceTimeStamp :: () -> u32 #foreign libphysx "phys_PxGetWarnOnceTimeStamp";

PxDecFoundationRefCount :: () -> void #foreign libphysx "phys_PxDecFoundationRefCount";

PxIncFoundationRefCount :: () -> void #foreign libphysx "phys_PxIncFoundationRefCount";

PxAllocator_new :: (anon_param0: *u8) -> PxAllocator #foreign libphysx;

PxAllocator_allocate :: (self: *PxAllocator, size: u64, file: *u8, line: s32) -> *void #foreign libphysx "PxAllocator_allocate_mut";

PxAllocator_deallocate :: (self: *PxAllocator, ptr: *void) -> void #foreign libphysx "PxAllocator_deallocate_mut";

PxRawAllocator_new :: (anon_param0: *u8) -> PxRawAllocator #foreign libphysx;

PxRawAllocator_allocate :: (self: *PxRawAllocator, size: u64, anon_param1: *u8, anon_param2: s32) -> *void #foreign libphysx "PxRawAllocator_allocate_mut";

PxRawAllocator_deallocate :: (self: *PxRawAllocator, ptr: *void) -> void #foreign libphysx "PxRawAllocator_deallocate_mut";

PxVirtualAllocatorCallback_delete :: (self: *PxVirtualAllocatorCallback) -> void #foreign libphysx;

PxVirtualAllocatorCallback_allocate :: (self: *PxVirtualAllocatorCallback, size: u64, group: s32, file: *u8, line: s32) -> *void #foreign libphysx "PxVirtualAllocatorCallback_allocate_mut";

PxVirtualAllocatorCallback_deallocate :: (self: *PxVirtualAllocatorCallback, ptr: *void) -> void #foreign libphysx "PxVirtualAllocatorCallback_deallocate_mut";

PxVirtualAllocator_new :: (callback: *PxVirtualAllocatorCallback, group: s32) -> PxVirtualAllocator #foreign libphysx;

PxVirtualAllocator_allocate :: (self: *PxVirtualAllocator, size: u64, file: *u8, line: s32) -> *void #foreign libphysx "PxVirtualAllocator_allocate_mut";

PxVirtualAllocator_deallocate :: (self: *PxVirtualAllocator, ptr: *void) -> void #foreign libphysx "PxVirtualAllocator_deallocate_mut";

PxTempAllocatorChunk_new :: () -> PxTempAllocatorChunk #foreign libphysx;

PxTempAllocator_new :: (anon_param0: *u8) -> PxTempAllocator #foreign libphysx;

PxTempAllocator_allocate :: (self: *PxTempAllocator, size: u64, file: *u8, line: s32) -> *void #foreign libphysx "PxTempAllocator_allocate_mut";

PxTempAllocator_deallocate :: (self: *PxTempAllocator, ptr: *void) -> void #foreign libphysx "PxTempAllocator_deallocate_mut";

PxMemZero :: (dest: *void, count: u32) -> *void #foreign libphysx "phys_PxMemZero";

PxMemSet :: (dest: *void, c: s32, count: u32) -> *void #foreign libphysx "phys_PxMemSet";

PxMemCopy :: (dest: *void, src: *void, count: u32) -> *void #foreign libphysx "phys_PxMemCopy";

PxMemMove :: (dest: *void, src: *void, count: u32) -> *void #foreign libphysx "phys_PxMemMove";

PxMarkSerializedMemory :: (ptr: *void, byteSize: u32) -> void #foreign libphysx "phys_PxMarkSerializedMemory";

PxMemoryBarrier :: () -> void #foreign libphysx "phys_PxMemoryBarrier";

PxHighestSetBitUnsafe :: (v: u32) -> u32 #foreign libphysx "phys_PxHighestSetBitUnsafe";

PxLowestSetBitUnsafe :: (v: u32) -> u32 #foreign libphysx "phys_PxLowestSetBitUnsafe";

PxCountLeadingZeros :: (v: u32) -> u32 #foreign libphysx "phys_PxCountLeadingZeros";

PxPrefetchLine :: (ptr: *void, offset: u32) -> void #foreign libphysx "phys_PxPrefetchLine";

PxPrefetch :: (ptr: *void, count: u32) -> void #foreign libphysx "phys_PxPrefetch";

PxBitCount :: (v: u32) -> u32 #foreign libphysx "phys_PxBitCount";

PxIsPowerOfTwo :: (x: u32) -> bool #foreign libphysx "phys_PxIsPowerOfTwo";

PxNextPowerOfTwo :: (x: u32) -> u32 #foreign libphysx "phys_PxNextPowerOfTwo";

PxLowestSetBit :: (x: u32) -> u32 #foreign libphysx "phys_PxLowestSetBit";

PxHighestSetBit :: (x: u32) -> u32 #foreign libphysx "phys_PxHighestSetBit";

PxILog2 :: (num: u32) -> u32 #foreign libphysx "phys_PxILog2";

PxVec3_new :: () -> Vector3 #foreign libphysx;

PxVec3_new :: (anon_param0: s32) -> Vector3 #foreign libphysx "PxVec3_new_1";

PxVec3_new :: (a: float) -> Vector3 #foreign libphysx "PxVec3_new_2";

PxVec3_new :: (nx: float, ny: float, nz: float) -> Vector3 #foreign libphysx "PxVec3_new_3";

PxVec3_isZero :: (self: *Vector3) -> bool #foreign libphysx;

PxVec3_isFinite :: (self: *Vector3) -> bool #foreign libphysx;

PxVec3_isNormalized :: (self: *Vector3) -> bool #foreign libphysx;

PxVec3_magnitudeSquared :: (self: *Vector3) -> float #foreign libphysx;

PxVec3_magnitude :: (self: *Vector3) -> float #foreign libphysx;

PxVec3_dot :: (self: *Vector3, v: *Vector3) -> float #foreign libphysx;

PxVec3_cross :: (self: *Vector3, v: *Vector3) -> Vector3 #foreign libphysx;

PxVec3_getNormalized :: (self: *Vector3) -> Vector3 #foreign libphysx;

PxVec3_normalize :: (self: *Vector3) -> float #foreign libphysx "PxVec3_normalize_mut";

PxVec3_normalizeSafe :: (self: *Vector3) -> float #foreign libphysx "PxVec3_normalizeSafe_mut";

PxVec3_normalizeFast :: (self: *Vector3) -> float #foreign libphysx "PxVec3_normalizeFast_mut";

PxVec3_multiply :: (self: *Vector3, a: *Vector3) -> Vector3 #foreign libphysx;

PxVec3_minimum :: (self: *Vector3, v: *Vector3) -> Vector3 #foreign libphysx;

PxVec3_minElement :: (self: *Vector3) -> float #foreign libphysx;

PxVec3_maximum :: (self: *Vector3, v: *Vector3) -> Vector3 #foreign libphysx;

PxVec3_maxElement :: (self: *Vector3) -> float #foreign libphysx;

PxVec3_abs :: (self: *Vector3) -> Vector3 #foreign libphysx;

PxVec3Padded_new_alloc :: () -> *PxVec3Padded #foreign libphysx;

PxVec3Padded_delete :: (self: *PxVec3Padded) -> void #foreign libphysx;

PxVec3Padded_new_alloc :: (p: *Vector3) -> *PxVec3Padded #foreign libphysx "PxVec3Padded_new_alloc_1";

PxVec3Padded_new_alloc :: (f: float) -> *PxVec3Padded #foreign libphysx "PxVec3Padded_new_alloc_2";

PxQuat_new :: (anon_param0: s32) -> Quaternion #foreign libphysx "PxQuat_new_1";

PxQuat_new :: (r: float) -> Quaternion #foreign libphysx "PxQuat_new_2";

PxQuat_new :: (nx: float, ny: float, nz: float, nw: float) -> Quaternion #foreign libphysx "PxQuat_new_3";

PxQuat_new :: (angleRadians: float, unitAxis: *Vector3) -> Quaternion #foreign libphysx "PxQuat_new_4";

PxQuat_new :: (m: *PxMat33) -> Quaternion #foreign libphysx "PxQuat_new_5";

PxQuat_isIdentity :: (self: *Quaternion) -> bool #foreign libphysx;

PxQuat_isFinite :: (self: *Quaternion) -> bool #foreign libphysx;

PxQuat_isUnit :: (self: *Quaternion) -> bool #foreign libphysx;

PxQuat_isSane :: (self: *Quaternion) -> bool #foreign libphysx;

PxQuat_toRadiansAndUnitAxis :: (self: *Quaternion, angle: *float, axis: *Vector3) -> void #foreign libphysx;

PxQuat_getAngle :: (self: *Quaternion) -> float #foreign libphysx;

PxQuat_getAngle :: (self: *Quaternion, q: *Quaternion) -> float #foreign libphysx "PxQuat_getAngle_1";

PxQuat_magnitudeSquared :: (self: *Quaternion) -> float #foreign libphysx;

PxQuat_dot :: (self: *Quaternion, v: *Quaternion) -> float #foreign libphysx;

PxQuat_getNormalized :: (self: *Quaternion) -> Quaternion #foreign libphysx;

PxQuat_magnitude :: (self: *Quaternion) -> float #foreign libphysx;

PxQuat_normalize :: (self: *Quaternion) -> float #foreign libphysx "PxQuat_normalize_mut";

PxQuat_getConjugate :: (self: *Quaternion) -> Quaternion #foreign libphysx;

PxQuat_getImaginaryPart :: (self: *Quaternion) -> Vector3 #foreign libphysx;

PxQuat_getBasisVector0 :: (self: *Quaternion) -> Vector3 #foreign libphysx;

PxQuat_getBasisVector1 :: (self: *Quaternion) -> Vector3 #foreign libphysx;

PxQuat_getBasisVector2 :: (self: *Quaternion) -> Vector3 #foreign libphysx;

PxQuat_rotate :: (self: *Quaternion, v: *Vector3) -> Vector3 #foreign libphysx;

PxQuat_rotateInv :: (self: *Quaternion, v: *Vector3) -> Vector3 #foreign libphysx;

PxTransform_new :: (position: *Vector3) -> PxTransform #foreign libphysx "PxTransform_new_1";

PxTransform_new :: (anon_param0: s32) -> PxTransform #foreign libphysx "PxTransform_new_2";

PxTransform_new :: (orientation: *Quaternion) -> PxTransform #foreign libphysx "PxTransform_new_3";

PxTransform_new :: (x: float, y: float, z: float, aQ: Quaternion) -> PxTransform #foreign libphysx "PxTransform_new_4";

PxTransform_new :: (p0: *Vector3, q0: *Quaternion) -> PxTransform #foreign libphysx "PxTransform_new_5";

PxTransform_new :: (m: *PxMat44) -> PxTransform #foreign libphysx "PxTransform_new_6";

PxTransform_getInverse :: (self: *PxTransform) -> PxTransform #foreign libphysx;

PxTransform_transform :: (self: *PxTransform, input: *Vector3) -> Vector3 #foreign libphysx;

PxTransform_transformInv :: (self: *PxTransform, input: *Vector3) -> Vector3 #foreign libphysx;

PxTransform_rotate :: (self: *PxTransform, input: *Vector3) -> Vector3 #foreign libphysx;

PxTransform_rotateInv :: (self: *PxTransform, input: *Vector3) -> Vector3 #foreign libphysx;

PxTransform_transform :: (self: *PxTransform, src: *PxTransform) -> PxTransform #foreign libphysx "PxTransform_transform_1";

PxTransform_isValid :: (self: *PxTransform) -> bool #foreign libphysx;

PxTransform_isSane :: (self: *PxTransform) -> bool #foreign libphysx;

PxTransform_isFinite :: (self: *PxTransform) -> bool #foreign libphysx;

PxTransform_transformInv :: (self: *PxTransform, src: *PxTransform) -> PxTransform #foreign libphysx "PxTransform_transformInv_1";

PxTransform_getNormalized :: (self: *PxTransform) -> PxTransform #foreign libphysx;

PxMat33_new :: () -> PxMat33 #foreign libphysx;

PxMat33_new :: (col0: *Vector3, col1: *Vector3, col2: *Vector3) -> PxMat33 #foreign libphysx "PxMat33_new_3";

PxMat33_new :: (r: float) -> PxMat33 #foreign libphysx "PxMat33_new_4";

PxMat33_new :: (values: *float) -> PxMat33 #foreign libphysx "PxMat33_new_5";

PxMat33_new :: (q: *Quaternion) -> PxMat33 #foreign libphysx "PxMat33_new_6";

PxMat33_createDiagonal :: (d: *Vector3) -> PxMat33 #foreign libphysx;

PxMat33_outer :: (a: *Vector3, b: *Vector3) -> PxMat33 #foreign libphysx;

PxMat33_getTranspose :: (self: *PxMat33) -> PxMat33 #foreign libphysx;

PxMat33_getInverse :: (self: *PxMat33) -> PxMat33 #foreign libphysx;

PxMat33_getDeterminant :: (self: *PxMat33) -> float #foreign libphysx;

PxMat33_transform :: (self: *PxMat33, other: *Vector3) -> Vector3 #foreign libphysx;

PxMat33_transformTranspose :: (self: *PxMat33, other: *Vector3) -> Vector3 #foreign libphysx;

PxMat33_front :: (self: *PxMat33) -> *float #foreign libphysx;

PxBounds3_new :: () -> PxBounds3 #foreign libphysx;

PxBounds3_new :: (minimum: *Vector3, maximum: *Vector3) -> PxBounds3 #foreign libphysx "PxBounds3_new_1";

PxBounds3_empty :: () -> PxBounds3 #foreign libphysx;

PxBounds3_boundsOfPoints :: (v0: *Vector3, v1: *Vector3) -> PxBounds3 #foreign libphysx;

PxBounds3_centerExtents :: (center: *Vector3, extent: *Vector3) -> PxBounds3 #foreign libphysx;

PxBounds3_basisExtent :: (center: *Vector3, basis: *PxMat33, extent: *Vector3) -> PxBounds3 #foreign libphysx;

PxBounds3_poseExtent :: (pose: *PxTransform, extent: *Vector3) -> PxBounds3 #foreign libphysx;

PxBounds3_transformSafe :: (matrix: *PxMat33, bounds: *PxBounds3) -> PxBounds3 #foreign libphysx;

PxBounds3_transformFast :: (matrix: *PxMat33, bounds: *PxBounds3) -> PxBounds3 #foreign libphysx;

PxBounds3_transformSafe :: (transform: *PxTransform, bounds: *PxBounds3) -> PxBounds3 #foreign libphysx "PxBounds3_transformSafe_1";

PxBounds3_transformFast :: (transform: *PxTransform, bounds: *PxBounds3) -> PxBounds3 #foreign libphysx "PxBounds3_transformFast_1";

PxBounds3_setEmpty :: (self: *PxBounds3) -> void #foreign libphysx "PxBounds3_setEmpty_mut";

PxBounds3_setMaximal :: (self: *PxBounds3) -> void #foreign libphysx "PxBounds3_setMaximal_mut";

PxBounds3_include :: (self: *PxBounds3, v: *Vector3) -> void #foreign libphysx "PxBounds3_include_mut";

PxBounds3_include_mut :: (self: *PxBounds3, b: *PxBounds3) -> void #foreign libphysx "PxBounds3_include_mut_1";

PxBounds3_isEmpty :: (self: *PxBounds3) -> bool #foreign libphysx;

PxBounds3_intersects :: (self: *PxBounds3, b: *PxBounds3) -> bool #foreign libphysx;

PxBounds3_intersects1D :: (self: *PxBounds3, a: *PxBounds3, axis: u32) -> bool #foreign libphysx;

PxBounds3_contains :: (self: *PxBounds3, v: *Vector3) -> bool #foreign libphysx;

PxBounds3_isInside :: (self: *PxBounds3, box: *PxBounds3) -> bool #foreign libphysx;

PxBounds3_getCenter :: (self: *PxBounds3) -> Vector3 #foreign libphysx;

PxBounds3_getCenter :: (self: *PxBounds3, axis: u32) -> float #foreign libphysx "PxBounds3_getCenter_1";

PxBounds3_getExtents :: (self: *PxBounds3, axis: u32) -> float #foreign libphysx;

PxBounds3_getDimensions :: (self: *PxBounds3) -> Vector3 #foreign libphysx;

PxBounds3_getExtents :: (self: *PxBounds3) -> Vector3 #foreign libphysx "PxBounds3_getExtents_1";

PxBounds3_scaleSafe :: (self: *PxBounds3, scale: float) -> void #foreign libphysx "PxBounds3_scaleSafe_mut";

PxBounds3_scaleFast :: (self: *PxBounds3, scale: float) -> void #foreign libphysx "PxBounds3_scaleFast_mut";

PxBounds3_fattenSafe :: (self: *PxBounds3, distance: float) -> void #foreign libphysx "PxBounds3_fattenSafe_mut";

PxBounds3_fattenFast :: (self: *PxBounds3, distance: float) -> void #foreign libphysx "PxBounds3_fattenFast_mut";

PxBounds3_isFinite :: (self: *PxBounds3) -> bool #foreign libphysx;

PxBounds3_isValid :: (self: *PxBounds3) -> bool #foreign libphysx;

PxBounds3_closestPoint :: (self: *PxBounds3, p: *Vector3) -> Vector3 #foreign libphysx;

PxErrorCallback_delete :: (self: *PxErrorCallback) -> void #foreign libphysx;

PxErrorCallback_reportError :: (self: *PxErrorCallback, code: s32, message: *u8, file: *u8, line: s32) -> void #foreign libphysx "PxErrorCallback_reportError_mut";

PxAllocationListener_onAllocation :: (self: *PxAllocationListener, size: u64, typeName: *u8, filename: *u8, line: s32, allocatedMemory: *void) -> void #foreign libphysx "PxAllocationListener_onAllocation_mut";

PxAllocationListener_onDeallocation :: (self: *PxAllocationListener, allocatedMemory: *void) -> void #foreign libphysx "PxAllocationListener_onDeallocation_mut";

PxBroadcastingAllocator_new_alloc :: (allocator: *PxAllocatorCallback, error: *PxErrorCallback) -> *PxBroadcastingAllocator #foreign libphysx;

PxBroadcastingAllocator_delete :: (self: *PxBroadcastingAllocator) -> void #foreign libphysx;

PxBroadcastingAllocator_allocate :: (self: *PxBroadcastingAllocator, size: u64, typeName: *u8, filename: *u8, line: s32) -> *void #foreign libphysx "PxBroadcastingAllocator_allocate_mut";

PxBroadcastingAllocator_deallocate :: (self: *PxBroadcastingAllocator, ptr: *void) -> void #foreign libphysx "PxBroadcastingAllocator_deallocate_mut";

PxBroadcastingErrorCallback_new_alloc :: (errorCallback: *PxErrorCallback) -> *PxBroadcastingErrorCallback #foreign libphysx;

PxBroadcastingErrorCallback_delete :: (self: *PxBroadcastingErrorCallback) -> void #foreign libphysx;

PxBroadcastingErrorCallback_reportError :: (self: *PxBroadcastingErrorCallback, code: s32, message: *u8, file: *u8, line: s32) -> void #foreign libphysx "PxBroadcastingErrorCallback_reportError_mut";

PxEnableFPExceptions :: () -> void #foreign libphysx "phys_PxEnableFPExceptions";

PxDisableFPExceptions :: () -> void #foreign libphysx "phys_PxDisableFPExceptions";

PxInputStream_read :: (self: *PxInputStream, dest: *void, count: u32) -> u32 #foreign libphysx "PxInputStream_read_mut";

PxInputStream_delete :: (self: *PxInputStream) -> void #foreign libphysx;

PxInputData_getLength :: (self: *PxInputData) -> u32 #foreign libphysx;

PxInputData_seek :: (self: *PxInputData, offset: u32) -> void #foreign libphysx "PxInputData_seek_mut";

PxInputData_tell :: (self: *PxInputData) -> u32 #foreign libphysx;

PxInputData_delete :: (self: *PxInputData) -> void #foreign libphysx;

PxOutputStream_write :: (self: *PxOutputStream, src: *void, count: u32) -> u32 #foreign libphysx "PxOutputStream_write_mut";

PxOutputStream_delete :: (self: *PxOutputStream) -> void #foreign libphysx;

PxVec4_new :: () -> Vector4 #foreign libphysx;

PxVec4_new :: (anon_param0: s32) -> Vector4 #foreign libphysx "PxVec4_new_1";

PxVec4_new :: (a: float) -> Vector4 #foreign libphysx "PxVec4_new_2";

PxVec4_new :: (nx: float, ny: float, nz: float, nw: float) -> Vector4 #foreign libphysx "PxVec4_new_3";

PxVec4_new :: (v: *Vector3, nw: float) -> Vector4 #foreign libphysx "PxVec4_new_4";

PxVec4_new :: (v: *float) -> Vector4 #foreign libphysx "PxVec4_new_5";

PxVec4_isZero :: (self: *Vector4) -> bool #foreign libphysx;

PxVec4_isFinite :: (self: *Vector4) -> bool #foreign libphysx;

PxVec4_isNormalized :: (self: *Vector4) -> bool #foreign libphysx;

PxVec4_magnitudeSquared :: (self: *Vector4) -> float #foreign libphysx;

PxVec4_magnitude :: (self: *Vector4) -> float #foreign libphysx;

PxVec4_dot :: (self: *Vector4, v: *Vector4) -> float #foreign libphysx;

PxVec4_getNormalized :: (self: *Vector4) -> Vector4 #foreign libphysx;

PxVec4_normalize :: (self: *Vector4) -> float #foreign libphysx "PxVec4_normalize_mut";

PxVec4_multiply :: (self: *Vector4, a: *Vector4) -> Vector4 #foreign libphysx;

PxVec4_minimum :: (self: *Vector4, v: *Vector4) -> Vector4 #foreign libphysx;

PxVec4_maximum :: (self: *Vector4, v: *Vector4) -> Vector4 #foreign libphysx;

PxVec4_getXYZ :: (self: *Vector4) -> Vector3 #foreign libphysx;

PxMat44_new :: () -> PxMat44 #foreign libphysx;

PxMat44_new :: (col0: *Vector4, col1: *Vector4, col2: *Vector4, col3: *Vector4) -> PxMat44 #foreign libphysx "PxMat44_new_3";

PxMat44_new :: (r: float) -> PxMat44 #foreign libphysx "PxMat44_new_4";

PxMat44_new :: (col0: *Vector3, col1: *Vector3, col2: *Vector3, col3: *Vector3) -> PxMat44 #foreign libphysx "PxMat44_new_5";

PxMat44_new :: (values: *float) -> PxMat44 #foreign libphysx "PxMat44_new_6";

PxMat44_new :: (q: *Quaternion) -> PxMat44 #foreign libphysx "PxMat44_new_7";

PxMat44_new :: (diagonal: *Vector4) -> PxMat44 #foreign libphysx "PxMat44_new_8";

PxMat44_new :: (axes: *PxMat33, position: *Vector3) -> PxMat44 #foreign libphysx "PxMat44_new_9";

PxMat44_new :: (t: *PxTransform) -> PxMat44 #foreign libphysx "PxMat44_new_10";

PxMat44_getTranspose :: (self: *PxMat44) -> PxMat44 #foreign libphysx;

PxMat44_transform :: (self: *PxMat44, other: *Vector4) -> Vector4 #foreign libphysx;

PxMat44_transform :: (self: *PxMat44, other: *Vector3) -> Vector3 #foreign libphysx "PxMat44_transform_1";

PxMat44_rotate :: (self: *PxMat44, other: *Vector4) -> Vector4 #foreign libphysx;

PxMat44_rotate :: (self: *PxMat44, other: *Vector3) -> Vector3 #foreign libphysx "PxMat44_rotate_1";

PxMat44_getBasis :: (self: *PxMat44, num: u32) -> Vector3 #foreign libphysx;

PxMat44_getPosition :: (self: *PxMat44) -> Vector3 #foreign libphysx;

PxMat44_setPosition :: (self: *PxMat44, position: *Vector3) -> void #foreign libphysx "PxMat44_setPosition_mut";

PxMat44_front :: (self: *PxMat44) -> *float #foreign libphysx;

PxMat44_scale :: (self: *PxMat44, p: *Vector4) -> void #foreign libphysx "PxMat44_scale_mut";

PxMat44_inverseRT :: (self: *PxMat44) -> PxMat44 #foreign libphysx;

PxMat44_isFinite :: (self: *PxMat44) -> bool #foreign libphysx;

PxPlane_new :: () -> Plane3 #foreign libphysx;

PxPlane_new :: (nx: float, ny: float, nz: float, distance: float) -> Plane3 #foreign libphysx "PxPlane_new_1";

PxPlane_new :: (normal: *Vector3, distance: float) -> Plane3 #foreign libphysx "PxPlane_new_2";

PxPlane_new :: (point: *Vector3, normal: *Vector3) -> Plane3 #foreign libphysx "PxPlane_new_3";

PxPlane_new :: (p0: *Vector3, p1: *Vector3, p2: *Vector3) -> Plane3 #foreign libphysx "PxPlane_new_4";

PxPlane_distance :: (self: *Plane3, p: *Vector3) -> float #foreign libphysx;

PxPlane_contains :: (self: *Plane3, p: *Vector3) -> bool #foreign libphysx;

PxPlane_project :: (self: *Plane3, p: *Vector3) -> Vector3 #foreign libphysx;

PxPlane_pointInPlane :: (self: *Plane3) -> Vector3 #foreign libphysx;

PxPlane_normalize :: (self: *Plane3) -> void #foreign libphysx "PxPlane_normalize_mut";

PxPlane_transform :: (self: *Plane3, pose: *PxTransform) -> Plane3 #foreign libphysx;

PxPlane_inverseTransform :: (self: *Plane3, pose: *PxTransform) -> Plane3 #foreign libphysx;

PxShortestRotation :: (from: *Vector3, target: *Vector3) -> Quaternion #foreign libphysx "phys_PxShortestRotation";

PxDiagonalize :: (m: *PxMat33, axes: *Quaternion) -> Vector3 #foreign libphysx "phys_PxDiagonalize";

PxTransformFromSegment :: (p0: *Vector3, p1: *Vector3, halfHeight: *float) -> PxTransform #foreign libphysx "phys_PxTransformFromSegment";

PxTransformFromPlaneEquation :: (plane: *Plane3) -> PxTransform #foreign libphysx "phys_PxTransformFromPlaneEquation";

PxPlaneEquationFromTransform :: (pose: *PxTransform) -> Plane3 #foreign libphysx "phys_PxPlaneEquationFromTransform";

PxSlerp :: (t: float, left: *Quaternion, right: *Quaternion) -> Quaternion #foreign libphysx "phys_PxSlerp";

PxIntegrateTransform :: (curTrans: *PxTransform, linvel: *Vector3, angvel: *Vector3, timeStep: float, result: *PxTransform) -> void #foreign libphysx "phys_PxIntegrateTransform";

PxExp :: (v: *Vector3) -> Quaternion #foreign libphysx "phys_PxExp";

PxOptimizeBoundingBox :: (basis: *PxMat33) -> Vector3 #foreign libphysx "phys_PxOptimizeBoundingBox";

PxLog :: (q: *Quaternion) -> Vector3 #foreign libphysx "phys_PxLog";

PxLargestAxis :: (v: *Vector3) -> u32 #foreign libphysx "phys_PxLargestAxis";

PxTanHalf :: (sin: float, cos: float) -> float #foreign libphysx "phys_PxTanHalf";

PxEllipseClamp :: (point: *Vector3, radii: *Vector3) -> Vector3 #foreign libphysx "phys_PxEllipseClamp";

PxSeparateSwingTwist :: (q: *Quaternion, swing: *Quaternion, twist: *Quaternion) -> void #foreign libphysx "phys_PxSeparateSwingTwist";

PxComputeAngle :: (v0: *Vector3, v1: *Vector3) -> float #foreign libphysx "phys_PxComputeAngle";

PxComputeBasisVectors :: (dir: *Vector3, right: *Vector3, up: *Vector3) -> void #foreign libphysx "phys_PxComputeBasisVectors";

PxComputeBasisVectors_1 :: (p0: *Vector3, p1: *Vector3, dir: *Vector3, right: *Vector3, up: *Vector3) -> void #foreign libphysx "phys_PxComputeBasisVectors_1";

PxGetNextIndex3 :: (i: u32) -> u32 #foreign libphysx "phys_PxGetNextIndex3";

computeBarycentric :: (a: *Vector3, b: *Vector3, c: *Vector3, d: *Vector3, p: *Vector3, bary: *Vector4) -> void #foreign libphysx "phys_computeBarycentric";

computeBarycentric_1 :: (a: *Vector3, b: *Vector3, c: *Vector3, p: *Vector3, bary: *Vector4) -> void #foreign libphysx "phys_computeBarycentric_1";

Interpolation_PxLerp :: (a: float, b: float, t: float) -> float #foreign libphysx;

Interpolation_PxBiLerp :: (f00: float, f10: float, f01: float, f11: float, tx: float, ty: float) -> float #foreign libphysx;

Interpolation_PxTriLerp :: (f000: float, f100: float, f010: float, f110: float, f001: float, f101: float, f011: float, f111: float, tx: float, ty: float, tz: float) -> float #foreign libphysx;

Interpolation_PxSDFIdx :: (i: u32, j: u32, k: u32, nbX: u32, nbY: u32) -> u32 #foreign libphysx;

Interpolation_PxSDFSampleImpl :: (sdf: *float, localPos: *Vector3, sdfBoxLower: *Vector3, sdfBoxHigher: *Vector3, sdfDx: float, invSdfDx: float, dimX: u32, dimY: u32, dimZ: u32, tolerance: float) -> float #foreign libphysx;

PxSdfSample :: (sdf: *float, localPos: *Vector3, sdfBoxLower: *Vector3, sdfBoxHigher: *Vector3, sdfDx: float, invSdfDx: float, dimX: u32, dimY: u32, dimZ: u32, gradient: *Vector3, tolerance: float) -> float #foreign libphysx "phys_PxSdfSample";

PxMutexImpl_new_alloc :: () -> *PxMutexImpl #foreign libphysx;

PxMutexImpl_delete :: (self: *PxMutexImpl) -> void #foreign libphysx;

PxMutexImpl_lock :: (self: *PxMutexImpl) -> void #foreign libphysx "PxMutexImpl_lock_mut";

PxMutexImpl_trylock :: (self: *PxMutexImpl) -> bool #foreign libphysx "PxMutexImpl_trylock_mut";

PxMutexImpl_unlock :: (self: *PxMutexImpl) -> void #foreign libphysx "PxMutexImpl_unlock_mut";

PxMutexImpl_getSize :: () -> u32 #foreign libphysx;

PxReadWriteLock_new_alloc :: () -> *PxReadWriteLock #foreign libphysx;

PxReadWriteLock_delete :: (self: *PxReadWriteLock) -> void #foreign libphysx;

PxReadWriteLock_lockReader :: (self: *PxReadWriteLock, takeLock: bool) -> void #foreign libphysx "PxReadWriteLock_lockReader_mut";

PxReadWriteLock_lockWriter :: (self: *PxReadWriteLock) -> void #foreign libphysx "PxReadWriteLock_lockWriter_mut";

PxReadWriteLock_unlockReader :: (self: *PxReadWriteLock) -> void #foreign libphysx "PxReadWriteLock_unlockReader_mut";

PxReadWriteLock_unlockWriter :: (self: *PxReadWriteLock) -> void #foreign libphysx "PxReadWriteLock_unlockWriter_mut";

PxProfilerCallback_zoneStart :: (self: *PxProfilerCallback, eventName: *u8, detached: bool, contextId: u64) -> *void #foreign libphysx "PxProfilerCallback_zoneStart_mut";

PxProfilerCallback_zoneEnd :: (self: *PxProfilerCallback, profilerData: *void, eventName: *u8, detached: bool, contextId: u64) -> void #foreign libphysx "PxProfilerCallback_zoneEnd_mut";

PxProfileScoped_new_alloc :: (callback: *PxProfilerCallback, eventName: *u8, detached: bool, contextId: u64) -> *PxProfileScoped #foreign libphysx;

PxProfileScoped_delete :: (self: *PxProfileScoped) -> void #foreign libphysx;

PxSListEntry_new :: () -> PxSListEntry #foreign libphysx;

PxSListEntry_next :: (self: *PxSListEntry) -> *PxSListEntry #foreign libphysx "PxSListEntry_next_mut";

PxSListImpl_new_alloc :: () -> *PxSListImpl #foreign libphysx;

PxSListImpl_delete :: (self: *PxSListImpl) -> void #foreign libphysx;

PxSListImpl_push :: (self: *PxSListImpl, entry: *PxSListEntry) -> void #foreign libphysx "PxSListImpl_push_mut";

PxSListImpl_pop :: (self: *PxSListImpl) -> *PxSListEntry #foreign libphysx "PxSListImpl_pop_mut";

PxSListImpl_flush :: (self: *PxSListImpl) -> *PxSListEntry #foreign libphysx "PxSListImpl_flush_mut";

PxSListImpl_getSize :: () -> u32 #foreign libphysx;

PxSyncImpl_new_alloc :: () -> *PxSyncImpl #foreign libphysx;

PxSyncImpl_delete :: (self: *PxSyncImpl) -> void #foreign libphysx;

PxSyncImpl_wait :: (self: *PxSyncImpl, milliseconds: u32) -> bool #foreign libphysx "PxSyncImpl_wait_mut";

PxSyncImpl_set :: (self: *PxSyncImpl) -> void #foreign libphysx "PxSyncImpl_set_mut";

PxSyncImpl_reset :: (self: *PxSyncImpl) -> void #foreign libphysx "PxSyncImpl_reset_mut";

PxSyncImpl_getSize :: () -> u32 #foreign libphysx;

PxRunnable_new_alloc :: () -> *PxRunnable #foreign libphysx;

PxRunnable_delete :: (self: *PxRunnable) -> void #foreign libphysx;

PxRunnable_execute :: (self: *PxRunnable) -> void #foreign libphysx "PxRunnable_execute_mut";

PxTlsAlloc :: () -> u32 #foreign libphysx "phys_PxTlsAlloc";

PxTlsFree :: (index: u32) -> void #foreign libphysx "phys_PxTlsFree";

PxTlsGet :: (index: u32) -> *void #foreign libphysx "phys_PxTlsGet";

PxTlsGetValue :: (index: u32) -> u64 #foreign libphysx "phys_PxTlsGetValue";

PxTlsSet :: (index: u32, value: *void) -> u32 #foreign libphysx "phys_PxTlsSet";

PxTlsSetValue :: (index: u32, value: u64) -> u32 #foreign libphysx "phys_PxTlsSetValue";

PxCounterFrequencyToTensOfNanos_new :: (inNum: u64, inDenom: u64) -> PxCounterFrequencyToTensOfNanos #foreign libphysx;

PxCounterFrequencyToTensOfNanos_toTensOfNanos :: (self: *PxCounterFrequencyToTensOfNanos, inCounter: u64) -> u64 #foreign libphysx;

PxTime_getBootCounterFrequency :: () -> *PxCounterFrequencyToTensOfNanos #foreign libphysx;

PxTime_getCounterFrequency :: () -> PxCounterFrequencyToTensOfNanos #foreign libphysx;

PxTime_getCurrentCounterValue :: () -> u64 #foreign libphysx;

PxTime_getCurrentTimeInTensOfNanoSeconds :: () -> u64 #foreign libphysx;

PxTime_new :: () -> PxTime #foreign libphysx;

PxTime_getElapsedSeconds :: (self: *PxTime) -> float64 #foreign libphysx "PxTime_getElapsedSeconds_mut";

PxTime_peekElapsedSeconds :: (self: *PxTime) -> float64 #foreign libphysx "PxTime_peekElapsedSeconds_mut";

PxTime_getLastTime :: (self: *PxTime) -> float64 #foreign libphysx;

PxVec2_new :: () -> Vector2 #foreign libphysx;

PxVec2_new :: (anon_param0: s32) -> Vector2 #foreign libphysx "PxVec2_new_1";

PxVec2_new :: (a: float) -> Vector2 #foreign libphysx "PxVec2_new_2";

PxVec2_new :: (nx: float, ny: float) -> Vector2 #foreign libphysx "PxVec2_new_3";

PxVec2_isZero :: (self: *Vector2) -> bool #foreign libphysx;

PxVec2_isFinite :: (self: *Vector2) -> bool #foreign libphysx;

PxVec2_isNormalized :: (self: *Vector2) -> bool #foreign libphysx;

PxVec2_magnitudeSquared :: (self: *Vector2) -> float #foreign libphysx;

PxVec2_magnitude :: (self: *Vector2) -> float #foreign libphysx;

PxVec2_dot :: (self: *Vector2, v: *Vector2) -> float #foreign libphysx;

PxVec2_getNormalized :: (self: *Vector2) -> Vector2 #foreign libphysx;

PxVec2_normalize :: (self: *Vector2) -> float #foreign libphysx "PxVec2_normalize_mut";

PxVec2_multiply :: (self: *Vector2, a: *Vector2) -> Vector2 #foreign libphysx;

PxVec2_minimum :: (self: *Vector2, v: *Vector2) -> Vector2 #foreign libphysx;

PxVec2_minElement :: (self: *Vector2) -> float #foreign libphysx;

PxVec2_maximum :: (self: *Vector2, v: *Vector2) -> Vector2 #foreign libphysx;

PxVec2_maxElement :: (self: *Vector2) -> float #foreign libphysx;

PxStridedData_new :: () -> PxStridedData #foreign libphysx;

PxBoundedData_new :: () -> PxBoundedData #foreign libphysx;

PxDebugPoint_new :: (p: *Vector3, c: *u32) -> PxDebugPoint #foreign libphysx;

PxDebugLine_new :: (p0: *Vector3, p1: *Vector3, c: *u32) -> PxDebugLine #foreign libphysx;

PxDebugTriangle_new :: (p0: *Vector3, p1: *Vector3, p2: *Vector3, c: *u32) -> PxDebugTriangle #foreign libphysx;

PxDebugText_new :: () -> PxDebugText #foreign libphysx;

PxDebugText_new :: (pos: *Vector3, sz: *float, clr: *u32, str: *u8) -> PxDebugText #foreign libphysx "PxDebugText_new_1";

PxRenderBuffer_delete :: (self: *PxRenderBuffer) -> void #foreign libphysx;

PxRenderBuffer_getNbPoints :: (self: *PxRenderBuffer) -> u32 #foreign libphysx;

PxRenderBuffer_getPoints :: (self: *PxRenderBuffer) -> *PxDebugPoint #foreign libphysx;

PxRenderBuffer_addPoint :: (self: *PxRenderBuffer, point: *PxDebugPoint) -> void #foreign libphysx "PxRenderBuffer_addPoint_mut";

PxRenderBuffer_getNbLines :: (self: *PxRenderBuffer) -> u32 #foreign libphysx;

PxRenderBuffer_getLines :: (self: *PxRenderBuffer) -> *PxDebugLine #foreign libphysx;

PxRenderBuffer_addLine :: (self: *PxRenderBuffer, line: *PxDebugLine) -> void #foreign libphysx "PxRenderBuffer_addLine_mut";

PxRenderBuffer_reserveLines :: (self: *PxRenderBuffer, nbLines: u32) -> *PxDebugLine #foreign libphysx "PxRenderBuffer_reserveLines_mut";

PxRenderBuffer_reservePoints :: (self: *PxRenderBuffer, nbLines: u32) -> *PxDebugPoint #foreign libphysx "PxRenderBuffer_reservePoints_mut";

PxRenderBuffer_getNbTriangles :: (self: *PxRenderBuffer) -> u32 #foreign libphysx;

PxRenderBuffer_getTriangles :: (self: *PxRenderBuffer) -> *PxDebugTriangle #foreign libphysx;

PxRenderBuffer_addTriangle :: (self: *PxRenderBuffer, triangle: *PxDebugTriangle) -> void #foreign libphysx "PxRenderBuffer_addTriangle_mut";

PxRenderBuffer_append :: (self: *PxRenderBuffer, other: *PxRenderBuffer) -> void #foreign libphysx "PxRenderBuffer_append_mut";

PxRenderBuffer_clear :: (self: *PxRenderBuffer) -> void #foreign libphysx "PxRenderBuffer_clear_mut";

PxRenderBuffer_shift :: (self: *PxRenderBuffer, delta: *Vector3) -> void #foreign libphysx "PxRenderBuffer_shift_mut";

PxRenderBuffer_empty :: (self: *PxRenderBuffer) -> bool #foreign libphysx;

PxProcessPxBaseCallback_delete :: (self: *PxProcessPxBaseCallback) -> void #foreign libphysx;

PxProcessPxBaseCallback_process :: (self: *PxProcessPxBaseCallback, anon_param0: *PxBase) -> void #foreign libphysx "PxProcessPxBaseCallback_process_mut";

PxSerializationContext_registerReference :: (self: *PxSerializationContext, base: *PxBase, kind: u32, reference: u64) -> void #foreign libphysx "PxSerializationContext_registerReference_mut";

PxSerializationContext_getCollection :: (self: *PxSerializationContext) -> *PxCollection #foreign libphysx;

PxSerializationContext_writeData :: (self: *PxSerializationContext, data: *void, size: u32) -> void #foreign libphysx "PxSerializationContext_writeData_mut";

PxSerializationContext_alignData :: (self: *PxSerializationContext, alignment: u32) -> void #foreign libphysx "PxSerializationContext_alignData_mut";

PxSerializationContext_writeName :: (self: *PxSerializationContext, name: *u8) -> void #foreign libphysx "PxSerializationContext_writeName_mut";

PxDeserializationContext_resolveReference :: (self: *PxDeserializationContext, kind: u32, reference: u64) -> *PxBase #foreign libphysx;

PxDeserializationContext_readName :: (self: *PxDeserializationContext, name: **u8) -> void #foreign libphysx "PxDeserializationContext_readName_mut";

PxDeserializationContext_alignExtraData :: (self: *PxDeserializationContext, alignment: u32) -> void #foreign libphysx "PxDeserializationContext_alignExtraData_mut";

PxSerializationRegistry_registerSerializer :: (self: *PxSerializationRegistry, type: u16, serializer: *PxSerializer) -> void #foreign libphysx "PxSerializationRegistry_registerSerializer_mut";

PxSerializationRegistry_unregisterSerializer :: (self: *PxSerializationRegistry, type: u16) -> *PxSerializer #foreign libphysx "PxSerializationRegistry_unregisterSerializer_mut";

PxSerializationRegistry_getSerializer :: (self: *PxSerializationRegistry, type: u16) -> *PxSerializer #foreign libphysx;

PxSerializationRegistry_registerRepXSerializer :: (self: *PxSerializationRegistry, type: u16, serializer: *PxRepXSerializer) -> void #foreign libphysx "PxSerializationRegistry_registerRepXSerializer_mut";

PxSerializationRegistry_unregisterRepXSerializer :: (self: *PxSerializationRegistry, type: u16) -> *PxRepXSerializer #foreign libphysx "PxSerializationRegistry_unregisterRepXSerializer_mut";

PxSerializationRegistry_getRepXSerializer :: (self: *PxSerializationRegistry, typeName: *u8) -> *PxRepXSerializer #foreign libphysx;

PxSerializationRegistry_release :: (self: *PxSerializationRegistry) -> void #foreign libphysx "PxSerializationRegistry_release_mut";

PxCollection_add :: (self: *PxCollection, object: *PxBase, id: u64) -> void #foreign libphysx "PxCollection_add_mut";

PxCollection_remove :: (self: *PxCollection, object: *PxBase) -> void #foreign libphysx "PxCollection_remove_mut";

PxCollection_contains :: (self: *PxCollection, object: *PxBase) -> bool #foreign libphysx;

PxCollection_addId :: (self: *PxCollection, object: *PxBase, id: u64) -> void #foreign libphysx "PxCollection_addId_mut";

PxCollection_removeId :: (self: *PxCollection, id: u64) -> void #foreign libphysx "PxCollection_removeId_mut";

PxCollection_add_mut :: (self: *PxCollection, collection: *PxCollection) -> void #foreign libphysx "PxCollection_add_mut_1";

PxCollection_remove_mut :: (self: *PxCollection, collection: *PxCollection) -> void #foreign libphysx "PxCollection_remove_mut_1";

PxCollection_getNbObjects :: (self: *PxCollection) -> u32 #foreign libphysx;

PxCollection_getObject :: (self: *PxCollection, index: u32) -> *PxBase #foreign libphysx;

PxCollection_getObjects :: (self: *PxCollection, userBuffer: **PxBase, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxCollection_find :: (self: *PxCollection, id: u64) -> *PxBase #foreign libphysx;

PxCollection_getNbIds :: (self: *PxCollection) -> u32 #foreign libphysx;

PxCollection_getIds :: (self: *PxCollection, userBuffer: *u64, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxCollection_getId :: (self: *PxCollection, object: *PxBase) -> u64 #foreign libphysx;

PxCollection_release :: (self: *PxCollection) -> void #foreign libphysx "PxCollection_release_mut";

PxCreateCollection :: () -> *PxCollection #foreign libphysx "phys_PxCreateCollection";

PxBase_release :: (self: *PxBase) -> void #foreign libphysx "PxBase_release_mut";

PxBase_getConcreteTypeName :: (self: *PxBase) -> *u8 #foreign libphysx;

PxBase_getConcreteType :: (self: *PxBase) -> u16 #foreign libphysx;

PxBase_setBaseFlag :: (self: *PxBase, flag: s32, value: bool) -> void #foreign libphysx "PxBase_setBaseFlag_mut";

PxBase_setBaseFlags :: (self: *PxBase, inFlags: u16) -> void #foreign libphysx "PxBase_setBaseFlags_mut";

PxBase_getBaseFlags :: (self: *PxBase) -> u16 #foreign libphysx;

PxBase_isReleasable :: (self: *PxBase) -> bool #foreign libphysx;

PxRefCounted_release :: (self: *PxRefCounted) -> void #foreign libphysx "PxRefCounted_release_mut";

PxRefCounted_getReferenceCount :: (self: *PxRefCounted) -> u32 #foreign libphysx;

PxRefCounted_acquireReference :: (self: *PxRefCounted) -> void #foreign libphysx "PxRefCounted_acquireReference_mut";

PxTolerancesScale_new :: (defaultLength: float, defaultSpeed: float) -> PxTolerancesScale #foreign libphysx;

PxTolerancesScale_isValid :: (self: *PxTolerancesScale) -> bool #foreign libphysx;

PxStringTable_allocateStr :: (self: *PxStringTable, inSrc: *u8) -> *u8 #foreign libphysx "PxStringTable_allocateStr_mut";

PxStringTable_release :: (self: *PxStringTable) -> void #foreign libphysx "PxStringTable_release_mut";

PxSerializer_getConcreteTypeName :: (self: *PxSerializer) -> *u8 #foreign libphysx;

PxSerializer_requiresObjects :: (self: *PxSerializer, anon_param0: *PxBase, anon_param1: *PxProcessPxBaseCallback) -> void #foreign libphysx;

PxSerializer_isSubordinate :: (self: *PxSerializer) -> bool #foreign libphysx;

PxSerializer_exportExtraData :: (self: *PxSerializer, anon_param0: *PxBase, anon_param1: *PxSerializationContext) -> void #foreign libphysx;

PxSerializer_exportData :: (self: *PxSerializer, anon_param0: *PxBase, anon_param1: *PxSerializationContext) -> void #foreign libphysx;

PxSerializer_registerReferences :: (self: *PxSerializer, obj: *PxBase, s: *PxSerializationContext) -> void #foreign libphysx;

PxSerializer_getClassSize :: (self: *PxSerializer) -> u64 #foreign libphysx;

PxSerializer_createObject :: (self: *PxSerializer, address: **u8, context_pod: *PxDeserializationContext) -> *PxBase #foreign libphysx;

PxSerializer_delete :: (self: *PxSerializer) -> void #foreign libphysx;

PxInsertionCallback_buildObjectFromData :: (self: *PxInsertionCallback, type: s32, data: *void) -> *PxBase #foreign libphysx "PxInsertionCallback_buildObjectFromData_mut";

PxTaskManager_setCpuDispatcher :: (self: *PxTaskManager, ref: *PxCpuDispatcher) -> void #foreign libphysx "PxTaskManager_setCpuDispatcher_mut";

PxTaskManager_getCpuDispatcher :: (self: *PxTaskManager) -> *PxCpuDispatcher #foreign libphysx;

PxTaskManager_resetDependencies :: (self: *PxTaskManager) -> void #foreign libphysx "PxTaskManager_resetDependencies_mut";

PxTaskManager_startSimulation :: (self: *PxTaskManager) -> void #foreign libphysx "PxTaskManager_startSimulation_mut";

PxTaskManager_stopSimulation :: (self: *PxTaskManager) -> void #foreign libphysx "PxTaskManager_stopSimulation_mut";

PxTaskManager_taskCompleted :: (self: *PxTaskManager, task: *PxTask) -> void #foreign libphysx "PxTaskManager_taskCompleted_mut";

PxTaskManager_getNamedTask :: (self: *PxTaskManager, name: *u8) -> u32 #foreign libphysx "PxTaskManager_getNamedTask_mut";

PxTaskManager_submitNamedTask :: (self: *PxTaskManager, task: *PxTask, name: *u8, type: s32) -> u32 #foreign libphysx "PxTaskManager_submitNamedTask_mut";

PxTaskManager_submitUnnamedTask :: (self: *PxTaskManager, task: *PxTask, type: s32) -> u32 #foreign libphysx "PxTaskManager_submitUnnamedTask_mut";

PxTaskManager_getTaskFromID :: (self: *PxTaskManager, id: u32) -> *PxTask #foreign libphysx "PxTaskManager_getTaskFromID_mut";

PxTaskManager_release :: (self: *PxTaskManager) -> void #foreign libphysx "PxTaskManager_release_mut";

PxTaskManager_createTaskManager :: (errorCallback: *PxErrorCallback, anon_param1: *PxCpuDispatcher) -> *PxTaskManager #foreign libphysx;

PxCpuDispatcher_submitTask :: (self: *PxCpuDispatcher, task: *PxBaseTask) -> void #foreign libphysx "PxCpuDispatcher_submitTask_mut";

PxCpuDispatcher_getWorkerCount :: (self: *PxCpuDispatcher) -> u32 #foreign libphysx;

PxCpuDispatcher_delete :: (self: *PxCpuDispatcher) -> void #foreign libphysx;

PxBaseTask_run :: (self: *PxBaseTask) -> void #foreign libphysx "PxBaseTask_run_mut";

PxBaseTask_getName :: (self: *PxBaseTask) -> *u8 #foreign libphysx;

PxBaseTask_addReference :: (self: *PxBaseTask) -> void #foreign libphysx "PxBaseTask_addReference_mut";

PxBaseTask_removeReference :: (self: *PxBaseTask) -> void #foreign libphysx "PxBaseTask_removeReference_mut";

PxBaseTask_getReference :: (self: *PxBaseTask) -> s32 #foreign libphysx;

PxBaseTask_release :: (self: *PxBaseTask) -> void #foreign libphysx "PxBaseTask_release_mut";

PxBaseTask_getTaskManager :: (self: *PxBaseTask) -> *PxTaskManager #foreign libphysx;

PxBaseTask_setContextId :: (self: *PxBaseTask, id: u64) -> void #foreign libphysx "PxBaseTask_setContextId_mut";

PxBaseTask_getContextId :: (self: *PxBaseTask) -> u64 #foreign libphysx;

PxTask_release :: (self: *PxTask) -> void #foreign libphysx "PxTask_release_mut";

PxTask_finishBefore :: (self: *PxTask, taskID: u32) -> void #foreign libphysx "PxTask_finishBefore_mut";

PxTask_startAfter :: (self: *PxTask, taskID: u32) -> void #foreign libphysx "PxTask_startAfter_mut";

PxTask_addReference :: (self: *PxTask) -> void #foreign libphysx "PxTask_addReference_mut";

PxTask_removeReference :: (self: *PxTask) -> void #foreign libphysx "PxTask_removeReference_mut";

PxTask_getReference :: (self: *PxTask) -> s32 #foreign libphysx;

PxTask_getTaskID :: (self: *PxTask) -> u32 #foreign libphysx;

PxTask_submitted :: (self: *PxTask) -> void #foreign libphysx "PxTask_submitted_mut";

PxLightCpuTask_setContinuation :: (self: *PxLightCpuTask, tm: *PxTaskManager, c: *PxBaseTask) -> void #foreign libphysx "PxLightCpuTask_setContinuation_mut";

PxLightCpuTask_setContinuation_mut :: (self: *PxLightCpuTask, c: *PxBaseTask) -> void #foreign libphysx "PxLightCpuTask_setContinuation_mut_1";

PxLightCpuTask_getContinuation :: (self: *PxLightCpuTask) -> *PxBaseTask #foreign libphysx;

PxLightCpuTask_removeReference :: (self: *PxLightCpuTask) -> void #foreign libphysx "PxLightCpuTask_removeReference_mut";

PxLightCpuTask_getReference :: (self: *PxLightCpuTask) -> s32 #foreign libphysx;

PxLightCpuTask_addReference :: (self: *PxLightCpuTask) -> void #foreign libphysx "PxLightCpuTask_addReference_mut";

PxLightCpuTask_release :: (self: *PxLightCpuTask) -> void #foreign libphysx "PxLightCpuTask_release_mut";

PxGeometry_getType :: (self: *PxGeometry) -> s32 #foreign libphysx;

PxBoxGeometry_new :: (hx: float, hy: float, hz: float) -> PxBoxGeometry #foreign libphysx;

PxBoxGeometry_new :: (halfExtents: Vector3) -> PxBoxGeometry #foreign libphysx "PxBoxGeometry_new_1";

PxBoxGeometry_isValid :: (self: *PxBoxGeometry) -> bool #foreign libphysx;

PxBVHRaycastCallback_delete :: (self: *PxBVHRaycastCallback) -> void #foreign libphysx;

PxBVHRaycastCallback_reportHit :: (self: *PxBVHRaycastCallback, boundsIndex: u32, distance: *float) -> bool #foreign libphysx "PxBVHRaycastCallback_reportHit_mut";

PxBVHOverlapCallback_delete :: (self: *PxBVHOverlapCallback) -> void #foreign libphysx;

PxBVHOverlapCallback_reportHit :: (self: *PxBVHOverlapCallback, boundsIndex: u32) -> bool #foreign libphysx "PxBVHOverlapCallback_reportHit_mut";

PxBVHTraversalCallback_delete :: (self: *PxBVHTraversalCallback) -> void #foreign libphysx;

PxBVHTraversalCallback_visitNode :: (self: *PxBVHTraversalCallback, bounds: *PxBounds3) -> bool #foreign libphysx "PxBVHTraversalCallback_visitNode_mut";

PxBVHTraversalCallback_reportLeaf :: (self: *PxBVHTraversalCallback, nbPrims: u32, prims: *u32) -> bool #foreign libphysx "PxBVHTraversalCallback_reportLeaf_mut";

PxBVH_raycast :: (self: *PxBVH, origin: *Vector3, unitDir: *Vector3, maxDist: float, cb: *PxBVHRaycastCallback, queryFlags: u32) -> bool #foreign libphysx;

PxBVH_sweep :: (self: *PxBVH, geom: *PxGeometry, pose: *PxTransform, unitDir: *Vector3, maxDist: float, cb: *PxBVHRaycastCallback, queryFlags: u32) -> bool #foreign libphysx;

PxBVH_overlap :: (self: *PxBVH, geom: *PxGeometry, pose: *PxTransform, cb: *PxBVHOverlapCallback, queryFlags: u32) -> bool #foreign libphysx;

PxBVH_cull :: (self: *PxBVH, nbPlanes: u32, planes: *Plane3, cb: *PxBVHOverlapCallback, queryFlags: u32) -> bool #foreign libphysx;

PxBVH_getNbBounds :: (self: *PxBVH) -> u32 #foreign libphysx;

PxBVH_getBounds :: (self: *PxBVH) -> *PxBounds3 #foreign libphysx;

PxBVH_getBoundsForModification :: (self: *PxBVH) -> *PxBounds3 #foreign libphysx "PxBVH_getBoundsForModification_mut";

PxBVH_refit :: (self: *PxBVH) -> void #foreign libphysx "PxBVH_refit_mut";

PxBVH_updateBounds :: (self: *PxBVH, boundsIndex: u32, newBounds: *PxBounds3) -> bool #foreign libphysx "PxBVH_updateBounds_mut";

PxBVH_partialRefit :: (self: *PxBVH) -> void #foreign libphysx "PxBVH_partialRefit_mut";

PxBVH_traverse :: (self: *PxBVH, cb: *PxBVHTraversalCallback) -> bool #foreign libphysx;

PxBVH_getConcreteTypeName :: (self: *PxBVH) -> *u8 #foreign libphysx;

PxCapsuleGeometry_new :: (radius_: float, halfHeight_: float) -> PxCapsuleGeometry #foreign libphysx;

PxCapsuleGeometry_isValid :: (self: *PxCapsuleGeometry) -> bool #foreign libphysx;

PxConvexMesh_getNbVertices :: (self: *PxConvexMesh) -> u32 #foreign libphysx;

PxConvexMesh_getVertices :: (self: *PxConvexMesh) -> *Vector3 #foreign libphysx;

PxConvexMesh_getIndexBuffer :: (self: *PxConvexMesh) -> *u8 #foreign libphysx;

PxConvexMesh_getNbPolygons :: (self: *PxConvexMesh) -> u32 #foreign libphysx;

PxConvexMesh_getPolygonData :: (self: *PxConvexMesh, index: u32, data: *PxHullPolygon) -> bool #foreign libphysx;

PxConvexMesh_release :: (self: *PxConvexMesh) -> void #foreign libphysx "PxConvexMesh_release_mut";

PxConvexMesh_getMassInformation :: (self: *PxConvexMesh, mass: *float, localInertia: *PxMat33, localCenterOfMass: *Vector3) -> void #foreign libphysx;

PxConvexMesh_getLocalBounds :: (self: *PxConvexMesh) -> PxBounds3 #foreign libphysx;

PxConvexMesh_getSDF :: (self: *PxConvexMesh) -> *float #foreign libphysx;

PxConvexMesh_getConcreteTypeName :: (self: *PxConvexMesh) -> *u8 #foreign libphysx;

PxConvexMesh_isGpuCompatible :: (self: *PxConvexMesh) -> bool #foreign libphysx;

PxMeshScale_new :: () -> PxMeshScale #foreign libphysx;

PxMeshScale_new :: (r: float) -> PxMeshScale #foreign libphysx "PxMeshScale_new_1";

PxMeshScale_new :: (s: *Vector3) -> PxMeshScale #foreign libphysx "PxMeshScale_new_2";

PxMeshScale_new :: (s: *Vector3, r: *Quaternion) -> PxMeshScale #foreign libphysx "PxMeshScale_new_3";

PxMeshScale_isIdentity :: (self: *PxMeshScale) -> bool #foreign libphysx;

PxMeshScale_getInverse :: (self: *PxMeshScale) -> PxMeshScale #foreign libphysx;

PxMeshScale_toMat33 :: (self: *PxMeshScale) -> PxMat33 #foreign libphysx;

PxMeshScale_hasNegativeDeterminant :: (self: *PxMeshScale) -> bool #foreign libphysx;

PxMeshScale_transform :: (self: *PxMeshScale, v: *Vector3) -> Vector3 #foreign libphysx;

PxMeshScale_isValidForTriangleMesh :: (self: *PxMeshScale) -> bool #foreign libphysx;

PxMeshScale_isValidForConvexMesh :: (self: *PxMeshScale) -> bool #foreign libphysx;

PxConvexMeshGeometry_new :: (mesh: *PxConvexMesh, scaling: *PxMeshScale, flags: u8) -> PxConvexMeshGeometry #foreign libphysx;

PxConvexMeshGeometry_isValid :: (self: *PxConvexMeshGeometry) -> bool #foreign libphysx;

PxSphereGeometry_new :: (ir: float) -> PxSphereGeometry #foreign libphysx;

PxSphereGeometry_isValid :: (self: *PxSphereGeometry) -> bool #foreign libphysx;

PxPlaneGeometry_new :: () -> PxPlaneGeometry #foreign libphysx;

PxPlaneGeometry_isValid :: (self: *PxPlaneGeometry) -> bool #foreign libphysx;

PxTriangleMeshGeometry_new :: (mesh: *PxTriangleMesh, scaling: *PxMeshScale, flags: u8) -> PxTriangleMeshGeometry #foreign libphysx;

PxTriangleMeshGeometry_isValid :: (self: *PxTriangleMeshGeometry) -> bool #foreign libphysx;

PxHeightFieldGeometry_new :: (hf: *PxHeightField, flags: u8, heightScale_: float, rowScale_: float, columnScale_: float) -> PxHeightFieldGeometry #foreign libphysx;

PxHeightFieldGeometry_isValid :: (self: *PxHeightFieldGeometry) -> bool #foreign libphysx;

PxParticleSystemGeometry_new :: () -> PxParticleSystemGeometry #foreign libphysx;

PxParticleSystemGeometry_isValid :: (self: *PxParticleSystemGeometry) -> bool #foreign libphysx;

PxHairSystemGeometry_new :: () -> PxHairSystemGeometry #foreign libphysx;

PxHairSystemGeometry_isValid :: (self: *PxHairSystemGeometry) -> bool #foreign libphysx;

PxTetrahedronMeshGeometry_new :: (mesh: *PxTetrahedronMesh) -> PxTetrahedronMeshGeometry #foreign libphysx;

PxTetrahedronMeshGeometry_isValid :: (self: *PxTetrahedronMeshGeometry) -> bool #foreign libphysx;

PxQueryHit_new :: () -> PxQueryHit #foreign libphysx;

PxLocationHit_new :: () -> PxLocationHit #foreign libphysx;

PxLocationHit_hadInitialOverlap :: (self: *PxLocationHit) -> bool #foreign libphysx;

PxGeomRaycastHit_new :: () -> PxGeomRaycastHit #foreign libphysx;

PxGeomOverlapHit_new :: () -> PxGeomOverlapHit #foreign libphysx;

PxGeomSweepHit_new :: () -> PxGeomSweepHit #foreign libphysx;

PxGeomIndexPair_new :: () -> PxGeomIndexPair #foreign libphysx;

PxGeomIndexPair_new :: (_id0: u32, _id1: u32) -> PxGeomIndexPair #foreign libphysx "PxGeomIndexPair_new_1";

PxCustomGeometry_getUniqueID :: () -> u32 #foreign libphysx "phys_PxCustomGeometry_getUniqueID";

PxCustomGeometryType_new :: () -> PxCustomGeometryType #foreign libphysx;

PxCustomGeometryType_INVALID :: () -> PxCustomGeometryType #foreign libphysx;

PxCustomGeometryCallbacks_getCustomType :: (self: *PxCustomGeometryCallbacks) -> PxCustomGeometryType #foreign libphysx;

PxCustomGeometryCallbacks_getLocalBounds :: (self: *PxCustomGeometryCallbacks, geometry: *PxGeometry) -> PxBounds3 #foreign libphysx;

PxCustomGeometryCallbacks_raycast :: (self: *PxCustomGeometryCallbacks, origin: *Vector3, unitDir: *Vector3, geom: *PxGeometry, pose: *PxTransform, maxDist: float, hitFlags: u16, maxHits: u32, rayHits: *PxGeomRaycastHit, stride: u32, threadContext: *PxQueryThreadContext) -> u32 #foreign libphysx;

PxCustomGeometryCallbacks_overlap :: (self: *PxCustomGeometryCallbacks, geom0: *PxGeometry, pose0: *PxTransform, geom1: *PxGeometry, pose1: *PxTransform, threadContext: *PxQueryThreadContext) -> bool #foreign libphysx;

PxCustomGeometryCallbacks_sweep :: (self: *PxCustomGeometryCallbacks, unitDir: *Vector3, maxDist: float, geom0: *PxGeometry, pose0: *PxTransform, geom1: *PxGeometry, pose1: *PxTransform, sweepHit: *PxGeomSweepHit, hitFlags: u16, inflation: float, threadContext: *PxQueryThreadContext) -> bool #foreign libphysx;

PxCustomGeometryCallbacks_computeMassProperties :: (self: *PxCustomGeometryCallbacks, geometry: *PxGeometry, massProperties: *PxMassProperties) -> void #foreign libphysx;

PxCustomGeometryCallbacks_usePersistentContactManifold :: (self: *PxCustomGeometryCallbacks, geometry: *PxGeometry, breakingThreshold: *float) -> bool #foreign libphysx;

PxCustomGeometryCallbacks_delete :: (self: *PxCustomGeometryCallbacks) -> void #foreign libphysx;

PxCustomGeometry_new :: () -> PxCustomGeometry #foreign libphysx;

PxCustomGeometry_new :: (_callbacks: *PxCustomGeometryCallbacks) -> PxCustomGeometry #foreign libphysx "PxCustomGeometry_new_1";

PxCustomGeometry_isValid :: (self: *PxCustomGeometry) -> bool #foreign libphysx;

PxCustomGeometry_getCustomType :: (self: *PxCustomGeometry) -> PxCustomGeometryType #foreign libphysx;

PxGeometryHolder_getType :: (self: *PxGeometryHolder) -> s32 #foreign libphysx;

PxGeometryHolder_any :: (self: *PxGeometryHolder) -> *PxGeometry #foreign libphysx "PxGeometryHolder_any_mut";

PxGeometryHolder_sphere :: (self: *PxGeometryHolder) -> *PxSphereGeometry #foreign libphysx "PxGeometryHolder_sphere_mut";

PxGeometryHolder_plane :: (self: *PxGeometryHolder) -> *PxPlaneGeometry #foreign libphysx "PxGeometryHolder_plane_mut";

PxGeometryHolder_capsule :: (self: *PxGeometryHolder) -> *PxCapsuleGeometry #foreign libphysx "PxGeometryHolder_capsule_mut";

PxGeometryHolder_box :: (self: *PxGeometryHolder) -> *PxBoxGeometry #foreign libphysx "PxGeometryHolder_box_mut";

PxGeometryHolder_convexMesh :: (self: *PxGeometryHolder) -> *PxConvexMeshGeometry #foreign libphysx "PxGeometryHolder_convexMesh_mut";

PxGeometryHolder_tetMesh :: (self: *PxGeometryHolder) -> *PxTetrahedronMeshGeometry #foreign libphysx "PxGeometryHolder_tetMesh_mut";

PxGeometryHolder_triangleMesh :: (self: *PxGeometryHolder) -> *PxTriangleMeshGeometry #foreign libphysx "PxGeometryHolder_triangleMesh_mut";

PxGeometryHolder_heightField :: (self: *PxGeometryHolder) -> *PxHeightFieldGeometry #foreign libphysx "PxGeometryHolder_heightField_mut";

PxGeometryHolder_particleSystem :: (self: *PxGeometryHolder) -> *PxParticleSystemGeometry #foreign libphysx "PxGeometryHolder_particleSystem_mut";

PxGeometryHolder_hairSystem :: (self: *PxGeometryHolder) -> *PxHairSystemGeometry #foreign libphysx "PxGeometryHolder_hairSystem_mut";

PxGeometryHolder_custom :: (self: *PxGeometryHolder) -> *PxCustomGeometry #foreign libphysx "PxGeometryHolder_custom_mut";

PxGeometryHolder_storeAny :: (self: *PxGeometryHolder, geometry: *PxGeometry) -> void #foreign libphysx "PxGeometryHolder_storeAny_mut";

PxGeometryHolder_new :: () -> PxGeometryHolder #foreign libphysx;

PxGeometryHolder_new :: (geometry: *PxGeometry) -> PxGeometryHolder #foreign libphysx "PxGeometryHolder_new_1";

PxGeometryQuery_raycast :: (origin: *Vector3, unitDir: *Vector3, geom: *PxGeometry, pose: *PxTransform, maxDist: float, hitFlags: u16, maxHits: u32, rayHits: *PxGeomRaycastHit, stride: u32, queryFlags: u32, threadContext: *PxQueryThreadContext) -> u32 #foreign libphysx;

PxGeometryQuery_overlap :: (geom0: *PxGeometry, pose0: *PxTransform, geom1: *PxGeometry, pose1: *PxTransform, queryFlags: u32, threadContext: *PxQueryThreadContext) -> bool #foreign libphysx;

PxGeometryQuery_sweep :: (unitDir: *Vector3, maxDist: float, geom0: *PxGeometry, pose0: *PxTransform, geom1: *PxGeometry, pose1: *PxTransform, sweepHit: *PxGeomSweepHit, hitFlags: u16, inflation: float, queryFlags: u32, threadContext: *PxQueryThreadContext) -> bool #foreign libphysx;

PxGeometryQuery_computePenetration :: (direction: *Vector3, depth: *float, geom0: *PxGeometry, pose0: *PxTransform, geom1: *PxGeometry, pose1: *PxTransform, queryFlags: u32) -> bool #foreign libphysx;

PxGeometryQuery_pointDistance :: (point: *Vector3, geom: *PxGeometry, pose: *PxTransform, closestPoint: *Vector3, closestIndex: *u32, queryFlags: u32) -> float #foreign libphysx;

PxGeometryQuery_computeGeomBounds :: (bounds: *PxBounds3, geom: *PxGeometry, pose: *PxTransform, offset: float, inflation: float, queryFlags: u32) -> void #foreign libphysx;

PxGeometryQuery_isValid :: (geom: *PxGeometry) -> bool #foreign libphysx;

PxHeightFieldSample_tessFlag :: (self: *PxHeightFieldSample) -> u8 #foreign libphysx;

PxHeightFieldSample_setTessFlag :: (self: *PxHeightFieldSample) -> void #foreign libphysx "PxHeightFieldSample_setTessFlag_mut";

PxHeightFieldSample_clearTessFlag :: (self: *PxHeightFieldSample) -> void #foreign libphysx "PxHeightFieldSample_clearTessFlag_mut";

PxHeightField_release :: (self: *PxHeightField) -> void #foreign libphysx "PxHeightField_release_mut";

PxHeightField_saveCells :: (self: *PxHeightField, destBuffer: *void, destBufferSize: u32) -> u32 #foreign libphysx;

PxHeightField_modifySamples :: (self: *PxHeightField, startCol: s32, startRow: s32, subfieldDesc: *PxHeightFieldDesc, shrinkBounds: bool) -> bool #foreign libphysx "PxHeightField_modifySamples_mut";

PxHeightField_getNbRows :: (self: *PxHeightField) -> u32 #foreign libphysx;

PxHeightField_getNbColumns :: (self: *PxHeightField) -> u32 #foreign libphysx;

PxHeightField_getFormat :: (self: *PxHeightField) -> s32 #foreign libphysx;

PxHeightField_getSampleStride :: (self: *PxHeightField) -> u32 #foreign libphysx;

PxHeightField_getConvexEdgeThreshold :: (self: *PxHeightField) -> float #foreign libphysx;

PxHeightField_getFlags :: (self: *PxHeightField) -> u16 #foreign libphysx;

PxHeightField_getHeight :: (self: *PxHeightField, x: float, z: float) -> float #foreign libphysx;

PxHeightField_getTriangleMaterialIndex :: (self: *PxHeightField, triangleIndex: u32) -> u16 #foreign libphysx;

PxHeightField_getTriangleNormal :: (self: *PxHeightField, triangleIndex: u32) -> Vector3 #foreign libphysx;

PxHeightField_getSample :: (self: *PxHeightField, row: u32, column: u32) -> *PxHeightFieldSample #foreign libphysx;

PxHeightField_getTimestamp :: (self: *PxHeightField) -> u32 #foreign libphysx;

PxHeightField_getConcreteTypeName :: (self: *PxHeightField) -> *u8 #foreign libphysx;

PxHeightFieldDesc_new :: () -> PxHeightFieldDesc #foreign libphysx;

PxHeightFieldDesc_setToDefault :: (self: *PxHeightFieldDesc) -> void #foreign libphysx "PxHeightFieldDesc_setToDefault_mut";

PxHeightFieldDesc_isValid :: (self: *PxHeightFieldDesc) -> bool #foreign libphysx;

PxMeshQuery_getTriangle :: (triGeom: *PxTriangleMeshGeometry, transform: *PxTransform, triangleIndex: u32, triangle: *PxTriangle, vertexIndices: *u32, adjacencyIndices: *u32) -> void #foreign libphysx;

PxMeshQuery_getTriangle :: (hfGeom: *PxHeightFieldGeometry, transform: *PxTransform, triangleIndex: u32, triangle: *PxTriangle, vertexIndices: *u32, adjacencyIndices: *u32) -> void #foreign libphysx "PxMeshQuery_getTriangle_1";

PxMeshQuery_findOverlapTriangleMesh :: (geom: *PxGeometry, geomPose: *PxTransform, meshGeom: *PxTriangleMeshGeometry, meshPose: *PxTransform, results: *u32, maxResults: u32, startIndex: u32, overflow: *bool, queryFlags: u32) -> u32 #foreign libphysx;

PxMeshQuery_findOverlapHeightField :: (geom: *PxGeometry, geomPose: *PxTransform, hfGeom: *PxHeightFieldGeometry, hfPose: *PxTransform, results: *u32, maxResults: u32, startIndex: u32, overflow: *bool, queryFlags: u32) -> u32 #foreign libphysx;

PxMeshQuery_sweep :: (unitDir: *Vector3, distance: float, geom: *PxGeometry, pose: *PxTransform, triangleCount: u32, triangles: *PxTriangle, sweepHit: *PxGeomSweepHit, hitFlags: u16, cachedIndex: *u32, inflation: float, doubleSided: bool, queryFlags: u32) -> bool #foreign libphysx;

PxSimpleTriangleMesh_new :: () -> PxSimpleTriangleMesh #foreign libphysx;

PxSimpleTriangleMesh_setToDefault :: (self: *PxSimpleTriangleMesh) -> void #foreign libphysx "PxSimpleTriangleMesh_setToDefault_mut";

PxSimpleTriangleMesh_isValid :: (self: *PxSimpleTriangleMesh) -> bool #foreign libphysx;

PxTriangle_new_alloc :: () -> *PxTriangle #foreign libphysx;

PxTriangle_new_alloc :: (p0: *Vector3, p1: *Vector3, p2: *Vector3) -> *PxTriangle #foreign libphysx "PxTriangle_new_alloc_1";

PxTriangle_delete :: (self: *PxTriangle) -> void #foreign libphysx;

PxTriangle_normal :: (self: *PxTriangle, _normal: *Vector3) -> void #foreign libphysx;

PxTriangle_denormalizedNormal :: (self: *PxTriangle, _normal: *Vector3) -> void #foreign libphysx;

PxTriangle_area :: (self: *PxTriangle) -> float #foreign libphysx;

PxTriangle_pointFromUV :: (self: *PxTriangle, u: float, v: float) -> Vector3 #foreign libphysx;

PxTrianglePadded_new_alloc :: () -> *PxTrianglePadded #foreign libphysx;

PxTrianglePadded_delete :: (self: *PxTrianglePadded) -> void #foreign libphysx;

PxTriangleMesh_getNbVertices :: (self: *PxTriangleMesh) -> u32 #foreign libphysx;

PxTriangleMesh_getVertices :: (self: *PxTriangleMesh) -> *Vector3 #foreign libphysx;

PxTriangleMesh_getVerticesForModification :: (self: *PxTriangleMesh) -> *Vector3 #foreign libphysx "PxTriangleMesh_getVerticesForModification_mut";

PxTriangleMesh_refitBVH :: (self: *PxTriangleMesh) -> PxBounds3 #foreign libphysx "PxTriangleMesh_refitBVH_mut";

PxTriangleMesh_getNbTriangles :: (self: *PxTriangleMesh) -> u32 #foreign libphysx;

PxTriangleMesh_getTriangles :: (self: *PxTriangleMesh) -> *void #foreign libphysx;

PxTriangleMesh_getTriangleMeshFlags :: (self: *PxTriangleMesh) -> u8 #foreign libphysx;

PxTriangleMesh_getTrianglesRemap :: (self: *PxTriangleMesh) -> *u32 #foreign libphysx;

PxTriangleMesh_release :: (self: *PxTriangleMesh) -> void #foreign libphysx "PxTriangleMesh_release_mut";

PxTriangleMesh_getTriangleMaterialIndex :: (self: *PxTriangleMesh, triangleIndex: u32) -> u16 #foreign libphysx;

PxTriangleMesh_getLocalBounds :: (self: *PxTriangleMesh) -> PxBounds3 #foreign libphysx;

PxTriangleMesh_getSDF :: (self: *PxTriangleMesh) -> *float #foreign libphysx;

PxTriangleMesh_getSDFDimensions :: (self: *PxTriangleMesh, numX: *u32, numY: *u32, numZ: *u32) -> void #foreign libphysx;

PxTriangleMesh_setPreferSDFProjection :: (self: *PxTriangleMesh, preferProjection: bool) -> void #foreign libphysx "PxTriangleMesh_setPreferSDFProjection_mut";

PxTriangleMesh_getPreferSDFProjection :: (self: *PxTriangleMesh) -> bool #foreign libphysx;

PxTriangleMesh_getMassInformation :: (self: *PxTriangleMesh, mass: *float, localInertia: *PxMat33, localCenterOfMass: *Vector3) -> void #foreign libphysx;

PxTetrahedron_new_alloc :: () -> *PxTetrahedron #foreign libphysx;

PxTetrahedron_new_alloc :: (p0: *Vector3, p1: *Vector3, p2: *Vector3, p3: *Vector3) -> *PxTetrahedron #foreign libphysx "PxTetrahedron_new_alloc_1";

PxTetrahedron_delete :: (self: *PxTetrahedron) -> void #foreign libphysx;

PxSoftBodyAuxData_release :: (self: *PxSoftBodyAuxData) -> void #foreign libphysx "PxSoftBodyAuxData_release_mut";

PxTetrahedronMesh_getNbVertices :: (self: *PxTetrahedronMesh) -> u32 #foreign libphysx;

PxTetrahedronMesh_getVertices :: (self: *PxTetrahedronMesh) -> *Vector3 #foreign libphysx;

PxTetrahedronMesh_getNbTetrahedrons :: (self: *PxTetrahedronMesh) -> u32 #foreign libphysx;

PxTetrahedronMesh_getTetrahedrons :: (self: *PxTetrahedronMesh) -> *void #foreign libphysx;

PxTetrahedronMesh_getTetrahedronMeshFlags :: (self: *PxTetrahedronMesh) -> u8 #foreign libphysx;

PxTetrahedronMesh_getTetrahedraRemap :: (self: *PxTetrahedronMesh) -> *u32 #foreign libphysx;

PxTetrahedronMesh_getLocalBounds :: (self: *PxTetrahedronMesh) -> PxBounds3 #foreign libphysx;

PxTetrahedronMesh_release :: (self: *PxTetrahedronMesh) -> void #foreign libphysx "PxTetrahedronMesh_release_mut";

PxSoftBodyMesh_getCollisionMesh :: (self: *PxSoftBodyMesh) -> *PxTetrahedronMesh #foreign libphysx "PxSoftBodyMesh_getCollisionMesh_mut";

PxSoftBodyMesh_getSimulationMesh :: (self: *PxSoftBodyMesh) -> *PxTetrahedronMesh #foreign libphysx "PxSoftBodyMesh_getSimulationMesh_mut";

PxSoftBodyMesh_getSoftBodyAuxData :: (self: *PxSoftBodyMesh) -> *PxSoftBodyAuxData #foreign libphysx "PxSoftBodyMesh_getSoftBodyAuxData_mut";

PxSoftBodyMesh_release :: (self: *PxSoftBodyMesh) -> void #foreign libphysx "PxSoftBodyMesh_release_mut";

PxCollisionMeshMappingData_release :: (self: *PxCollisionMeshMappingData) -> void #foreign libphysx "PxCollisionMeshMappingData_release_mut";

PxCollisionTetrahedronMeshData_getMesh :: (self: *PxCollisionTetrahedronMeshData) -> *PxTetrahedronMeshData #foreign libphysx "PxCollisionTetrahedronMeshData_getMesh_mut";

PxCollisionTetrahedronMeshData_getData :: (self: *PxCollisionTetrahedronMeshData) -> *PxSoftBodyCollisionData #foreign libphysx "PxCollisionTetrahedronMeshData_getData_mut";

PxCollisionTetrahedronMeshData_release :: (self: *PxCollisionTetrahedronMeshData) -> void #foreign libphysx "PxCollisionTetrahedronMeshData_release_mut";

PxSimulationTetrahedronMeshData_getMesh :: (self: *PxSimulationTetrahedronMeshData) -> *PxTetrahedronMeshData #foreign libphysx "PxSimulationTetrahedronMeshData_getMesh_mut";

PxSimulationTetrahedronMeshData_getData :: (self: *PxSimulationTetrahedronMeshData) -> *PxSoftBodySimulationData #foreign libphysx "PxSimulationTetrahedronMeshData_getData_mut";

PxSimulationTetrahedronMeshData_release :: (self: *PxSimulationTetrahedronMeshData) -> void #foreign libphysx "PxSimulationTetrahedronMeshData_release_mut";

PxActor_release :: (self: *PxActor) -> void #foreign libphysx "PxActor_release_mut";

PxActor_getType :: (self: *PxActor) -> s32 #foreign libphysx;

PxActor_getScene :: (self: *PxActor) -> *PxScene #foreign libphysx;

PxActor_setName :: (self: *PxActor, name: *u8) -> void #foreign libphysx "PxActor_setName_mut";

PxActor_getName :: (self: *PxActor) -> *u8 #foreign libphysx;

PxActor_getWorldBounds :: (self: *PxActor, inflation: float) -> PxBounds3 #foreign libphysx;

PxActor_setActorFlag :: (self: *PxActor, flag: s32, value: bool) -> void #foreign libphysx "PxActor_setActorFlag_mut";

PxActor_setActorFlags :: (self: *PxActor, inFlags: u8) -> void #foreign libphysx "PxActor_setActorFlags_mut";

PxActor_getActorFlags :: (self: *PxActor) -> u8 #foreign libphysx;

PxActor_setDominanceGroup :: (self: *PxActor, dominanceGroup: u8) -> void #foreign libphysx "PxActor_setDominanceGroup_mut";

PxActor_getDominanceGroup :: (self: *PxActor) -> u8 #foreign libphysx;

PxActor_setOwnerClient :: (self: *PxActor, inClient: u8) -> void #foreign libphysx "PxActor_setOwnerClient_mut";

PxActor_getOwnerClient :: (self: *PxActor) -> u8 #foreign libphysx;

PxActor_getAggregate :: (self: *PxActor) -> *PxAggregate #foreign libphysx;

PxGetAggregateFilterHint :: (type: s32, enableSelfCollision: bool) -> u32 #foreign libphysx "phys_PxGetAggregateFilterHint";

PxGetAggregateSelfCollisionBit :: (hint: u32) -> u32 #foreign libphysx "phys_PxGetAggregateSelfCollisionBit";

PxGetAggregateType :: (hint: u32) -> s32 #foreign libphysx "phys_PxGetAggregateType";

PxAggregate_release :: (self: *PxAggregate) -> void #foreign libphysx "PxAggregate_release_mut";

PxAggregate_addActor :: (self: *PxAggregate, actor: *PxActor, bvh: *PxBVH) -> bool #foreign libphysx "PxAggregate_addActor_mut";

PxAggregate_removeActor :: (self: *PxAggregate, actor: *PxActor) -> bool #foreign libphysx "PxAggregate_removeActor_mut";

PxAggregate_addArticulation :: (self: *PxAggregate, articulation: *PxArticulationReducedCoordinate) -> bool #foreign libphysx "PxAggregate_addArticulation_mut";

PxAggregate_removeArticulation :: (self: *PxAggregate, articulation: *PxArticulationReducedCoordinate) -> bool #foreign libphysx "PxAggregate_removeArticulation_mut";

PxAggregate_getNbActors :: (self: *PxAggregate) -> u32 #foreign libphysx;

PxAggregate_getMaxNbShapes :: (self: *PxAggregate) -> u32 #foreign libphysx;

PxAggregate_getActors :: (self: *PxAggregate, userBuffer: **PxActor, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxAggregate_getScene :: (self: *PxAggregate) -> *PxScene #foreign libphysx "PxAggregate_getScene_mut";

PxAggregate_getSelfCollision :: (self: *PxAggregate) -> bool #foreign libphysx;

PxAggregate_getConcreteTypeName :: (self: *PxAggregate) -> *u8 #foreign libphysx;

PxConstraintInvMassScale_new :: () -> PxConstraintInvMassScale #foreign libphysx;

PxConstraintInvMassScale_new :: (lin0: float, ang0: float, lin1: float, ang1: float) -> PxConstraintInvMassScale #foreign libphysx "PxConstraintInvMassScale_new_1";

PxConstraintVisualizer_visualizeJointFrames :: (self: *PxConstraintVisualizer, parent: *PxTransform, child: *PxTransform) -> void #foreign libphysx "PxConstraintVisualizer_visualizeJointFrames_mut";

PxConstraintVisualizer_visualizeLinearLimit :: (self: *PxConstraintVisualizer, t0: *PxTransform, t1: *PxTransform, value: float, active: bool) -> void #foreign libphysx "PxConstraintVisualizer_visualizeLinearLimit_mut";

PxConstraintVisualizer_visualizeAngularLimit :: (self: *PxConstraintVisualizer, t0: *PxTransform, lower: float, upper: float, active: bool) -> void #foreign libphysx "PxConstraintVisualizer_visualizeAngularLimit_mut";

PxConstraintVisualizer_visualizeLimitCone :: (self: *PxConstraintVisualizer, t: *PxTransform, tanQSwingY: float, tanQSwingZ: float, active: bool) -> void #foreign libphysx "PxConstraintVisualizer_visualizeLimitCone_mut";

PxConstraintVisualizer_visualizeDoubleCone :: (self: *PxConstraintVisualizer, t: *PxTransform, angle: float, active: bool) -> void #foreign libphysx "PxConstraintVisualizer_visualizeDoubleCone_mut";

PxConstraintVisualizer_visualizeLine :: (self: *PxConstraintVisualizer, p0: *Vector3, p1: *Vector3, color: u32) -> void #foreign libphysx "PxConstraintVisualizer_visualizeLine_mut";

PxConstraintConnector_prepareData :: (self: *PxConstraintConnector) -> *void #foreign libphysx "PxConstraintConnector_prepareData_mut";

PxConstraintConnector_onConstraintRelease :: (self: *PxConstraintConnector) -> void #foreign libphysx "PxConstraintConnector_onConstraintRelease_mut";

PxConstraintConnector_onComShift :: (self: *PxConstraintConnector, actor: u32) -> void #foreign libphysx "PxConstraintConnector_onComShift_mut";

PxConstraintConnector_onOriginShift :: (self: *PxConstraintConnector, shift: *Vector3) -> void #foreign libphysx "PxConstraintConnector_onOriginShift_mut";

PxConstraintConnector_getSerializable :: (self: *PxConstraintConnector) -> *PxBase #foreign libphysx "PxConstraintConnector_getSerializable_mut";

PxConstraintConnector_getConstantBlock :: (self: *PxConstraintConnector) -> *void #foreign libphysx;

PxConstraintConnector_connectToConstraint :: (self: *PxConstraintConnector, anon_param0: *PxConstraint) -> void #foreign libphysx "PxConstraintConnector_connectToConstraint_mut";

PxConstraintConnector_delete :: (self: *PxConstraintConnector) -> void #foreign libphysx;

PxSolverBody_new :: () -> PxSolverBody #foreign libphysx;

PxSolverBodyData_projectVelocity :: (self: *PxSolverBodyData, lin: *Vector3, ang: *Vector3) -> float #foreign libphysx;

PxSolverConstraintPrepDesc_delete :: (self: *PxSolverConstraintPrepDesc) -> void #foreign libphysx;

PxConstraintAllocator_reserveConstraintData :: (self: *PxConstraintAllocator, byteSize: u32) -> *u8 #foreign libphysx "PxConstraintAllocator_reserveConstraintData_mut";

PxConstraintAllocator_reserveFrictionData :: (self: *PxConstraintAllocator, byteSize: u32) -> *u8 #foreign libphysx "PxConstraintAllocator_reserveFrictionData_mut";

PxConstraintAllocator_delete :: (self: *PxConstraintAllocator) -> void #foreign libphysx;

PxArticulationLimit_new :: () -> PxArticulationLimit #foreign libphysx;

PxArticulationLimit_new :: (low_: float, high_: float) -> PxArticulationLimit #foreign libphysx "PxArticulationLimit_new_1";

PxArticulationDrive_new :: () -> PxArticulationDrive #foreign libphysx;

PxArticulationDrive_new :: (stiffness_: float, damping_: float, maxForce_: float, driveType: s32) -> PxArticulationDrive #foreign libphysx "PxArticulationDrive_new_1";

PxTGSSolverBodyVel_projectVelocity :: (self: *PxTGSSolverBodyVel, lin: *Vector3, ang: *Vector3) -> float #foreign libphysx;

PxTGSSolverBodyData_projectVelocity :: (self: *PxTGSSolverBodyData, linear: *Vector3, angular: *Vector3) -> float #foreign libphysx;

PxTGSSolverConstraintPrepDesc_delete :: (self: *PxTGSSolverConstraintPrepDesc) -> void #foreign libphysx;

PxArticulationAttachment_setRestLength :: (self: *PxArticulationAttachment, restLength: float) -> void #foreign libphysx "PxArticulationAttachment_setRestLength_mut";

PxArticulationAttachment_getRestLength :: (self: *PxArticulationAttachment) -> float #foreign libphysx;

PxArticulationAttachment_setLimitParameters :: (self: *PxArticulationAttachment, parameters: *PxArticulationTendonLimit) -> void #foreign libphysx "PxArticulationAttachment_setLimitParameters_mut";

PxArticulationAttachment_getLimitParameters :: (self: *PxArticulationAttachment) -> PxArticulationTendonLimit #foreign libphysx;

PxArticulationAttachment_setRelativeOffset :: (self: *PxArticulationAttachment, offset: *Vector3) -> void #foreign libphysx "PxArticulationAttachment_setRelativeOffset_mut";

PxArticulationAttachment_getRelativeOffset :: (self: *PxArticulationAttachment) -> Vector3 #foreign libphysx;

PxArticulationAttachment_setCoefficient :: (self: *PxArticulationAttachment, coefficient: float) -> void #foreign libphysx "PxArticulationAttachment_setCoefficient_mut";

PxArticulationAttachment_getCoefficient :: (self: *PxArticulationAttachment) -> float #foreign libphysx;

PxArticulationAttachment_getLink :: (self: *PxArticulationAttachment) -> *PxArticulationLink #foreign libphysx;

PxArticulationAttachment_getParent :: (self: *PxArticulationAttachment) -> *PxArticulationAttachment #foreign libphysx;

PxArticulationAttachment_isLeaf :: (self: *PxArticulationAttachment) -> bool #foreign libphysx;

PxArticulationAttachment_getTendon :: (self: *PxArticulationAttachment) -> *PxArticulationSpatialTendon #foreign libphysx;

PxArticulationAttachment_release :: (self: *PxArticulationAttachment) -> void #foreign libphysx "PxArticulationAttachment_release_mut";

PxArticulationAttachment_getConcreteTypeName :: (self: *PxArticulationAttachment) -> *u8 #foreign libphysx;

PxArticulationTendonJoint_setCoefficient :: (self: *PxArticulationTendonJoint, axis: s32, coefficient: float, recipCoefficient: float) -> void #foreign libphysx "PxArticulationTendonJoint_setCoefficient_mut";

PxArticulationTendonJoint_getCoefficient :: (self: *PxArticulationTendonJoint, axis: *s32, coefficient: *float, recipCoefficient: *float) -> void #foreign libphysx;

PxArticulationTendonJoint_getLink :: (self: *PxArticulationTendonJoint) -> *PxArticulationLink #foreign libphysx;

PxArticulationTendonJoint_getParent :: (self: *PxArticulationTendonJoint) -> *PxArticulationTendonJoint #foreign libphysx;

PxArticulationTendonJoint_getTendon :: (self: *PxArticulationTendonJoint) -> *PxArticulationFixedTendon #foreign libphysx;

PxArticulationTendonJoint_release :: (self: *PxArticulationTendonJoint) -> void #foreign libphysx "PxArticulationTendonJoint_release_mut";

PxArticulationTendonJoint_getConcreteTypeName :: (self: *PxArticulationTendonJoint) -> *u8 #foreign libphysx;

PxArticulationTendon_setStiffness :: (self: *PxArticulationTendon, stiffness: float) -> void #foreign libphysx "PxArticulationTendon_setStiffness_mut";

PxArticulationTendon_getStiffness :: (self: *PxArticulationTendon) -> float #foreign libphysx;

PxArticulationTendon_setDamping :: (self: *PxArticulationTendon, damping: float) -> void #foreign libphysx "PxArticulationTendon_setDamping_mut";

PxArticulationTendon_getDamping :: (self: *PxArticulationTendon) -> float #foreign libphysx;

PxArticulationTendon_setLimitStiffness :: (self: *PxArticulationTendon, stiffness: float) -> void #foreign libphysx "PxArticulationTendon_setLimitStiffness_mut";

PxArticulationTendon_getLimitStiffness :: (self: *PxArticulationTendon) -> float #foreign libphysx;

PxArticulationTendon_setOffset :: (self: *PxArticulationTendon, offset: float, autowake: bool) -> void #foreign libphysx "PxArticulationTendon_setOffset_mut";

PxArticulationTendon_getOffset :: (self: *PxArticulationTendon) -> float #foreign libphysx;

PxArticulationTendon_getArticulation :: (self: *PxArticulationTendon) -> *PxArticulationReducedCoordinate #foreign libphysx;

PxArticulationTendon_release :: (self: *PxArticulationTendon) -> void #foreign libphysx "PxArticulationTendon_release_mut";

PxArticulationSpatialTendon_createAttachment :: (self: *PxArticulationSpatialTendon, parent: *PxArticulationAttachment, coefficient: float, relativeOffset: Vector3, link: *PxArticulationLink) -> *PxArticulationAttachment #foreign libphysx "PxArticulationSpatialTendon_createAttachment_mut";

PxArticulationSpatialTendon_getAttachments :: (self: *PxArticulationSpatialTendon, userBuffer: **PxArticulationAttachment, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxArticulationSpatialTendon_getNbAttachments :: (self: *PxArticulationSpatialTendon) -> u32 #foreign libphysx;

PxArticulationSpatialTendon_getConcreteTypeName :: (self: *PxArticulationSpatialTendon) -> *u8 #foreign libphysx;

PxArticulationFixedTendon_createTendonJoint :: (self: *PxArticulationFixedTendon, parent: *PxArticulationTendonJoint, axis: s32, coefficient: float, recipCoefficient: float, link: *PxArticulationLink) -> *PxArticulationTendonJoint #foreign libphysx "PxArticulationFixedTendon_createTendonJoint_mut";

PxArticulationFixedTendon_getTendonJoints :: (self: *PxArticulationFixedTendon, userBuffer: **PxArticulationTendonJoint, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxArticulationFixedTendon_getNbTendonJoints :: (self: *PxArticulationFixedTendon) -> u32 #foreign libphysx;

PxArticulationFixedTendon_setRestLength :: (self: *PxArticulationFixedTendon, restLength: float) -> void #foreign libphysx "PxArticulationFixedTendon_setRestLength_mut";

PxArticulationFixedTendon_getRestLength :: (self: *PxArticulationFixedTendon) -> float #foreign libphysx;

PxArticulationFixedTendon_setLimitParameters :: (self: *PxArticulationFixedTendon, parameter: *PxArticulationTendonLimit) -> void #foreign libphysx "PxArticulationFixedTendon_setLimitParameters_mut";

PxArticulationFixedTendon_getLimitParameters :: (self: *PxArticulationFixedTendon) -> PxArticulationTendonLimit #foreign libphysx;

PxArticulationFixedTendon_getConcreteTypeName :: (self: *PxArticulationFixedTendon) -> *u8 #foreign libphysx;

PxArticulationCache_new :: () -> PxArticulationCache #foreign libphysx;

PxArticulationCache_release :: (self: *PxArticulationCache) -> void #foreign libphysx "PxArticulationCache_release_mut";

PxArticulationSensor_release :: (self: *PxArticulationSensor) -> void #foreign libphysx "PxArticulationSensor_release_mut";

PxArticulationSensor_getForces :: (self: *PxArticulationSensor) -> PxSpatialForce #foreign libphysx;

PxArticulationSensor_getRelativePose :: (self: *PxArticulationSensor) -> PxTransform #foreign libphysx;

PxArticulationSensor_setRelativePose :: (self: *PxArticulationSensor, pose: *PxTransform) -> void #foreign libphysx "PxArticulationSensor_setRelativePose_mut";

PxArticulationSensor_getLink :: (self: *PxArticulationSensor) -> *PxArticulationLink #foreign libphysx;

PxArticulationSensor_getIndex :: (self: *PxArticulationSensor) -> u32 #foreign libphysx;

PxArticulationSensor_getArticulation :: (self: *PxArticulationSensor) -> *PxArticulationReducedCoordinate #foreign libphysx;

PxArticulationSensor_getFlags :: (self: *PxArticulationSensor) -> u8 #foreign libphysx;

PxArticulationSensor_setFlag :: (self: *PxArticulationSensor, flag: s32, enabled: bool) -> void #foreign libphysx "PxArticulationSensor_setFlag_mut";

PxArticulationSensor_getConcreteTypeName :: (self: *PxArticulationSensor) -> *u8 #foreign libphysx;

PxArticulationReducedCoordinate_getScene :: (self: *PxArticulationReducedCoordinate) -> *PxScene #foreign libphysx;

PxArticulationReducedCoordinate_setSolverIterationCounts :: (self: *PxArticulationReducedCoordinate, minPositionIters: u32, minVelocityIters: u32) -> void #foreign libphysx "PxArticulationReducedCoordinate_setSolverIterationCounts_mut";

PxArticulationReducedCoordinate_getSolverIterationCounts :: (self: *PxArticulationReducedCoordinate, minPositionIters: *u32, minVelocityIters: *u32) -> void #foreign libphysx;

PxArticulationReducedCoordinate_isSleeping :: (self: *PxArticulationReducedCoordinate) -> bool #foreign libphysx;

PxArticulationReducedCoordinate_setSleepThreshold :: (self: *PxArticulationReducedCoordinate, threshold: float) -> void #foreign libphysx "PxArticulationReducedCoordinate_setSleepThreshold_mut";

PxArticulationReducedCoordinate_getSleepThreshold :: (self: *PxArticulationReducedCoordinate) -> float #foreign libphysx;

PxArticulationReducedCoordinate_setStabilizationThreshold :: (self: *PxArticulationReducedCoordinate, threshold: float) -> void #foreign libphysx "PxArticulationReducedCoordinate_setStabilizationThreshold_mut";

PxArticulationReducedCoordinate_getStabilizationThreshold :: (self: *PxArticulationReducedCoordinate) -> float #foreign libphysx;

PxArticulationReducedCoordinate_setWakeCounter :: (self: *PxArticulationReducedCoordinate, wakeCounterValue: float) -> void #foreign libphysx "PxArticulationReducedCoordinate_setWakeCounter_mut";

PxArticulationReducedCoordinate_getWakeCounter :: (self: *PxArticulationReducedCoordinate) -> float #foreign libphysx;

PxArticulationReducedCoordinate_wakeUp :: (self: *PxArticulationReducedCoordinate) -> void #foreign libphysx "PxArticulationReducedCoordinate_wakeUp_mut";

PxArticulationReducedCoordinate_putToSleep :: (self: *PxArticulationReducedCoordinate) -> void #foreign libphysx "PxArticulationReducedCoordinate_putToSleep_mut";

PxArticulationReducedCoordinate_setMaxCOMLinearVelocity :: (self: *PxArticulationReducedCoordinate, maxLinearVelocity: float) -> void #foreign libphysx "PxArticulationReducedCoordinate_setMaxCOMLinearVelocity_mut";

PxArticulationReducedCoordinate_getMaxCOMLinearVelocity :: (self: *PxArticulationReducedCoordinate) -> float #foreign libphysx;

PxArticulationReducedCoordinate_setMaxCOMAngularVelocity :: (self: *PxArticulationReducedCoordinate, maxAngularVelocity: float) -> void #foreign libphysx "PxArticulationReducedCoordinate_setMaxCOMAngularVelocity_mut";

PxArticulationReducedCoordinate_getMaxCOMAngularVelocity :: (self: *PxArticulationReducedCoordinate) -> float #foreign libphysx;

PxArticulationReducedCoordinate_createLink :: (self: *PxArticulationReducedCoordinate, parent: *PxArticulationLink, pose: *PxTransform) -> *PxArticulationLink #foreign libphysx "PxArticulationReducedCoordinate_createLink_mut";

PxArticulationReducedCoordinate_release :: (self: *PxArticulationReducedCoordinate) -> void #foreign libphysx "PxArticulationReducedCoordinate_release_mut";

PxArticulationReducedCoordinate_getNbLinks :: (self: *PxArticulationReducedCoordinate) -> u32 #foreign libphysx;

PxArticulationReducedCoordinate_getLinks :: (self: *PxArticulationReducedCoordinate, userBuffer: **PxArticulationLink, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxArticulationReducedCoordinate_getNbShapes :: (self: *PxArticulationReducedCoordinate) -> u32 #foreign libphysx;

PxArticulationReducedCoordinate_setName :: (self: *PxArticulationReducedCoordinate, name: *u8) -> void #foreign libphysx "PxArticulationReducedCoordinate_setName_mut";

PxArticulationReducedCoordinate_getName :: (self: *PxArticulationReducedCoordinate) -> *u8 #foreign libphysx;

PxArticulationReducedCoordinate_getWorldBounds :: (self: *PxArticulationReducedCoordinate, inflation: float) -> PxBounds3 #foreign libphysx;

PxArticulationReducedCoordinate_getAggregate :: (self: *PxArticulationReducedCoordinate) -> *PxAggregate #foreign libphysx;

PxArticulationReducedCoordinate_setArticulationFlags :: (self: *PxArticulationReducedCoordinate, flags: u8) -> void #foreign libphysx "PxArticulationReducedCoordinate_setArticulationFlags_mut";

PxArticulationReducedCoordinate_setArticulationFlag :: (self: *PxArticulationReducedCoordinate, flag: s32, value: bool) -> void #foreign libphysx "PxArticulationReducedCoordinate_setArticulationFlag_mut";

PxArticulationReducedCoordinate_getArticulationFlags :: (self: *PxArticulationReducedCoordinate) -> u8 #foreign libphysx;

PxArticulationReducedCoordinate_getDofs :: (self: *PxArticulationReducedCoordinate) -> u32 #foreign libphysx;

PxArticulationReducedCoordinate_createCache :: (self: *PxArticulationReducedCoordinate) -> *PxArticulationCache #foreign libphysx;

PxArticulationReducedCoordinate_getCacheDataSize :: (self: *PxArticulationReducedCoordinate) -> u32 #foreign libphysx;

PxArticulationReducedCoordinate_zeroCache :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache) -> void #foreign libphysx;

PxArticulationReducedCoordinate_applyCache :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache, flags: u32, autowake: bool) -> void #foreign libphysx "PxArticulationReducedCoordinate_applyCache_mut";

PxArticulationReducedCoordinate_copyInternalStateToCache :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache, flags: u32) -> void #foreign libphysx;

PxArticulationReducedCoordinate_packJointData :: (self: *PxArticulationReducedCoordinate, maximum: *float, reduced: *float) -> void #foreign libphysx;

PxArticulationReducedCoordinate_unpackJointData :: (self: *PxArticulationReducedCoordinate, reduced: *float, maximum: *float) -> void #foreign libphysx;

PxArticulationReducedCoordinate_commonInit :: (self: *PxArticulationReducedCoordinate) -> void #foreign libphysx;

PxArticulationReducedCoordinate_computeGeneralizedGravityForce :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache) -> void #foreign libphysx;

PxArticulationReducedCoordinate_computeCoriolisAndCentrifugalForce :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache) -> void #foreign libphysx;

PxArticulationReducedCoordinate_computeGeneralizedExternalForce :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache) -> void #foreign libphysx;

PxArticulationReducedCoordinate_computeJointAcceleration :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache) -> void #foreign libphysx;

PxArticulationReducedCoordinate_computeJointForce :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache) -> void #foreign libphysx;

PxArticulationReducedCoordinate_computeDenseJacobian :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache, nRows: *u32, nCols: *u32) -> void #foreign libphysx;

PxArticulationReducedCoordinate_computeCoefficientMatrix :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache) -> void #foreign libphysx;

PxArticulationReducedCoordinate_computeLambda :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache, initialState: *PxArticulationCache, jointTorque: *float, maxIter: u32) -> bool #foreign libphysx;

PxArticulationReducedCoordinate_computeGeneralizedMassMatrix :: (self: *PxArticulationReducedCoordinate, cache: *PxArticulationCache) -> void #foreign libphysx;

PxArticulationReducedCoordinate_addLoopJoint :: (self: *PxArticulationReducedCoordinate, joint: *PxConstraint) -> void #foreign libphysx "PxArticulationReducedCoordinate_addLoopJoint_mut";

PxArticulationReducedCoordinate_removeLoopJoint :: (self: *PxArticulationReducedCoordinate, joint: *PxConstraint) -> void #foreign libphysx "PxArticulationReducedCoordinate_removeLoopJoint_mut";

PxArticulationReducedCoordinate_getNbLoopJoints :: (self: *PxArticulationReducedCoordinate) -> u32 #foreign libphysx;

PxArticulationReducedCoordinate_getLoopJoints :: (self: *PxArticulationReducedCoordinate, userBuffer: **PxConstraint, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxArticulationReducedCoordinate_getCoefficientMatrixSize :: (self: *PxArticulationReducedCoordinate) -> u32 #foreign libphysx;

PxArticulationReducedCoordinate_setRootGlobalPose :: (self: *PxArticulationReducedCoordinate, pose: *PxTransform, autowake: bool) -> void #foreign libphysx "PxArticulationReducedCoordinate_setRootGlobalPose_mut";

PxArticulationReducedCoordinate_getRootGlobalPose :: (self: *PxArticulationReducedCoordinate) -> PxTransform #foreign libphysx;

PxArticulationReducedCoordinate_setRootLinearVelocity :: (self: *PxArticulationReducedCoordinate, linearVelocity: *Vector3, autowake: bool) -> void #foreign libphysx "PxArticulationReducedCoordinate_setRootLinearVelocity_mut";

PxArticulationReducedCoordinate_getRootLinearVelocity :: (self: *PxArticulationReducedCoordinate) -> Vector3 #foreign libphysx;

PxArticulationReducedCoordinate_setRootAngularVelocity :: (self: *PxArticulationReducedCoordinate, angularVelocity: *Vector3, autowake: bool) -> void #foreign libphysx "PxArticulationReducedCoordinate_setRootAngularVelocity_mut";

PxArticulationReducedCoordinate_getRootAngularVelocity :: (self: *PxArticulationReducedCoordinate) -> Vector3 #foreign libphysx;

PxArticulationReducedCoordinate_getLinkAcceleration :: (self: *PxArticulationReducedCoordinate, linkId: u32) -> PxSpatialVelocity #foreign libphysx "PxArticulationReducedCoordinate_getLinkAcceleration_mut";

PxArticulationReducedCoordinate_getGpuArticulationIndex :: (self: *PxArticulationReducedCoordinate) -> u32 #foreign libphysx "PxArticulationReducedCoordinate_getGpuArticulationIndex_mut";

PxArticulationReducedCoordinate_createSpatialTendon :: (self: *PxArticulationReducedCoordinate) -> *PxArticulationSpatialTendon #foreign libphysx "PxArticulationReducedCoordinate_createSpatialTendon_mut";

PxArticulationReducedCoordinate_createFixedTendon :: (self: *PxArticulationReducedCoordinate) -> *PxArticulationFixedTendon #foreign libphysx "PxArticulationReducedCoordinate_createFixedTendon_mut";

PxArticulationReducedCoordinate_createSensor :: (self: *PxArticulationReducedCoordinate, link: *PxArticulationLink, relativePose: *PxTransform) -> *PxArticulationSensor #foreign libphysx "PxArticulationReducedCoordinate_createSensor_mut";

PxArticulationReducedCoordinate_getSpatialTendons :: (self: *PxArticulationReducedCoordinate, userBuffer: **PxArticulationSpatialTendon, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxArticulationReducedCoordinate_getNbSpatialTendons :: (self: *PxArticulationReducedCoordinate) -> u32 #foreign libphysx "PxArticulationReducedCoordinate_getNbSpatialTendons_mut";

PxArticulationReducedCoordinate_getFixedTendons :: (self: *PxArticulationReducedCoordinate, userBuffer: **PxArticulationFixedTendon, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxArticulationReducedCoordinate_getNbFixedTendons :: (self: *PxArticulationReducedCoordinate) -> u32 #foreign libphysx "PxArticulationReducedCoordinate_getNbFixedTendons_mut";

PxArticulationReducedCoordinate_getSensors :: (self: *PxArticulationReducedCoordinate, userBuffer: **PxArticulationSensor, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxArticulationReducedCoordinate_getNbSensors :: (self: *PxArticulationReducedCoordinate) -> u32 #foreign libphysx "PxArticulationReducedCoordinate_getNbSensors_mut";

PxArticulationReducedCoordinate_updateKinematic :: (self: *PxArticulationReducedCoordinate, flags: u8) -> void #foreign libphysx "PxArticulationReducedCoordinate_updateKinematic_mut";

PxArticulationJointReducedCoordinate_getParentArticulationLink :: (self: *PxArticulationJointReducedCoordinate) -> *PxArticulationLink #foreign libphysx;

PxArticulationJointReducedCoordinate_setParentPose :: (self: *PxArticulationJointReducedCoordinate, pose: *PxTransform) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setParentPose_mut";

PxArticulationJointReducedCoordinate_getParentPose :: (self: *PxArticulationJointReducedCoordinate) -> PxTransform #foreign libphysx;

PxArticulationJointReducedCoordinate_getChildArticulationLink :: (self: *PxArticulationJointReducedCoordinate) -> *PxArticulationLink #foreign libphysx;

PxArticulationJointReducedCoordinate_setChildPose :: (self: *PxArticulationJointReducedCoordinate, pose: *PxTransform) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setChildPose_mut";

PxArticulationJointReducedCoordinate_getChildPose :: (self: *PxArticulationJointReducedCoordinate) -> PxTransform #foreign libphysx;

PxArticulationJointReducedCoordinate_setJointType :: (self: *PxArticulationJointReducedCoordinate, jointType: s32) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setJointType_mut";

PxArticulationJointReducedCoordinate_getJointType :: (self: *PxArticulationJointReducedCoordinate) -> s32 #foreign libphysx;

PxArticulationJointReducedCoordinate_setMotion :: (self: *PxArticulationJointReducedCoordinate, axis: s32, motion: s32) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setMotion_mut";

PxArticulationJointReducedCoordinate_getMotion :: (self: *PxArticulationJointReducedCoordinate, axis: s32) -> s32 #foreign libphysx;

PxArticulationJointReducedCoordinate_setLimitParams :: (self: *PxArticulationJointReducedCoordinate, axis: s32, limit: *PxArticulationLimit) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setLimitParams_mut";

PxArticulationJointReducedCoordinate_getLimitParams :: (self: *PxArticulationJointReducedCoordinate, axis: s32) -> PxArticulationLimit #foreign libphysx;

PxArticulationJointReducedCoordinate_setDriveParams :: (self: *PxArticulationJointReducedCoordinate, axis: s32, drive: *PxArticulationDrive) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setDriveParams_mut";

PxArticulationJointReducedCoordinate_getDriveParams :: (self: *PxArticulationJointReducedCoordinate, axis: s32) -> PxArticulationDrive #foreign libphysx;

PxArticulationJointReducedCoordinate_setDriveTarget :: (self: *PxArticulationJointReducedCoordinate, axis: s32, target: float, autowake: bool) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setDriveTarget_mut";

PxArticulationJointReducedCoordinate_getDriveTarget :: (self: *PxArticulationJointReducedCoordinate, axis: s32) -> float #foreign libphysx;

PxArticulationJointReducedCoordinate_setDriveVelocity :: (self: *PxArticulationJointReducedCoordinate, axis: s32, targetVel: float, autowake: bool) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setDriveVelocity_mut";

PxArticulationJointReducedCoordinate_getDriveVelocity :: (self: *PxArticulationJointReducedCoordinate, axis: s32) -> float #foreign libphysx;

PxArticulationJointReducedCoordinate_setArmature :: (self: *PxArticulationJointReducedCoordinate, axis: s32, armature: float) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setArmature_mut";

PxArticulationJointReducedCoordinate_getArmature :: (self: *PxArticulationJointReducedCoordinate, axis: s32) -> float #foreign libphysx;

PxArticulationJointReducedCoordinate_setFrictionCoefficient :: (self: *PxArticulationJointReducedCoordinate, coefficient: float) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setFrictionCoefficient_mut";

PxArticulationJointReducedCoordinate_getFrictionCoefficient :: (self: *PxArticulationJointReducedCoordinate) -> float #foreign libphysx;

PxArticulationJointReducedCoordinate_setMaxJointVelocity :: (self: *PxArticulationJointReducedCoordinate, maxJointV: float) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setMaxJointVelocity_mut";

PxArticulationJointReducedCoordinate_getMaxJointVelocity :: (self: *PxArticulationJointReducedCoordinate) -> float #foreign libphysx;

PxArticulationJointReducedCoordinate_setJointPosition :: (self: *PxArticulationJointReducedCoordinate, axis: s32, jointPos: float) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setJointPosition_mut";

PxArticulationJointReducedCoordinate_getJointPosition :: (self: *PxArticulationJointReducedCoordinate, axis: s32) -> float #foreign libphysx;

PxArticulationJointReducedCoordinate_setJointVelocity :: (self: *PxArticulationJointReducedCoordinate, axis: s32, jointVel: float) -> void #foreign libphysx "PxArticulationJointReducedCoordinate_setJointVelocity_mut";

PxArticulationJointReducedCoordinate_getJointVelocity :: (self: *PxArticulationJointReducedCoordinate, axis: s32) -> float #foreign libphysx;

PxArticulationJointReducedCoordinate_getConcreteTypeName :: (self: *PxArticulationJointReducedCoordinate) -> *u8 #foreign libphysx;

PxShape_release :: (self: *PxShape) -> void #foreign libphysx "PxShape_release_mut";

PxShape_setGeometry :: (self: *PxShape, geometry: *PxGeometry) -> void #foreign libphysx "PxShape_setGeometry_mut";

PxShape_getGeometry :: (self: *PxShape) -> *PxGeometry #foreign libphysx;

PxShape_getActor :: (self: *PxShape) -> *PxRigidActor #foreign libphysx;

PxShape_setLocalPose :: (self: *PxShape, pose: *PxTransform) -> void #foreign libphysx "PxShape_setLocalPose_mut";

PxShape_getLocalPose :: (self: *PxShape) -> PxTransform #foreign libphysx;

PxShape_setSimulationFilterData :: (self: *PxShape, data: *PxFilterData) -> void #foreign libphysx "PxShape_setSimulationFilterData_mut";

PxShape_getSimulationFilterData :: (self: *PxShape) -> PxFilterData #foreign libphysx;

PxShape_setQueryFilterData :: (self: *PxShape, data: *PxFilterData) -> void #foreign libphysx "PxShape_setQueryFilterData_mut";

PxShape_getQueryFilterData :: (self: *PxShape) -> PxFilterData #foreign libphysx;

PxShape_setMaterials :: (self: *PxShape, materials: **PxMaterial, materialCount: u16) -> void #foreign libphysx "PxShape_setMaterials_mut";

PxShape_getNbMaterials :: (self: *PxShape) -> u16 #foreign libphysx;

PxShape_getMaterials :: (self: *PxShape, userBuffer: **PxMaterial, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxShape_getMaterialFromInternalFaceIndex :: (self: *PxShape, faceIndex: u32) -> *PxBaseMaterial #foreign libphysx;

PxShape_setContactOffset :: (self: *PxShape, contactOffset: float) -> void #foreign libphysx "PxShape_setContactOffset_mut";

PxShape_getContactOffset :: (self: *PxShape) -> float #foreign libphysx;

PxShape_setRestOffset :: (self: *PxShape, restOffset: float) -> void #foreign libphysx "PxShape_setRestOffset_mut";

PxShape_getRestOffset :: (self: *PxShape) -> float #foreign libphysx;

PxShape_setDensityForFluid :: (self: *PxShape, densityForFluid: float) -> void #foreign libphysx "PxShape_setDensityForFluid_mut";

PxShape_getDensityForFluid :: (self: *PxShape) -> float #foreign libphysx;

PxShape_setTorsionalPatchRadius :: (self: *PxShape, radius: float) -> void #foreign libphysx "PxShape_setTorsionalPatchRadius_mut";

PxShape_getTorsionalPatchRadius :: (self: *PxShape) -> float #foreign libphysx;

PxShape_setMinTorsionalPatchRadius :: (self: *PxShape, radius: float) -> void #foreign libphysx "PxShape_setMinTorsionalPatchRadius_mut";

PxShape_getMinTorsionalPatchRadius :: (self: *PxShape) -> float #foreign libphysx;

PxShape_setFlag :: (self: *PxShape, flag: s32, value: bool) -> void #foreign libphysx "PxShape_setFlag_mut";

PxShape_setFlags :: (self: *PxShape, inFlags: u8) -> void #foreign libphysx "PxShape_setFlags_mut";

PxShape_getFlags :: (self: *PxShape) -> u8 #foreign libphysx;

PxShape_isExclusive :: (self: *PxShape) -> bool #foreign libphysx;

PxShape_setName :: (self: *PxShape, name: *u8) -> void #foreign libphysx "PxShape_setName_mut";

PxShape_getName :: (self: *PxShape) -> *u8 #foreign libphysx;

PxShape_getConcreteTypeName :: (self: *PxShape) -> *u8 #foreign libphysx;

PxRigidActor_release :: (self: *PxRigidActor) -> void #foreign libphysx "PxRigidActor_release_mut";

PxRigidActor_getInternalActorIndex :: (self: *PxRigidActor) -> u32 #foreign libphysx;

PxRigidActor_getGlobalPose :: (self: *PxRigidActor) -> PxTransform #foreign libphysx;

PxRigidActor_setGlobalPose :: (self: *PxRigidActor, pose: *PxTransform, autowake: bool) -> void #foreign libphysx "PxRigidActor_setGlobalPose_mut";

PxRigidActor_attachShape :: (self: *PxRigidActor, shape: *PxShape) -> bool #foreign libphysx "PxRigidActor_attachShape_mut";

PxRigidActor_detachShape :: (self: *PxRigidActor, shape: *PxShape, wakeOnLostTouch: bool) -> void #foreign libphysx "PxRigidActor_detachShape_mut";

PxRigidActor_getNbShapes :: (self: *PxRigidActor) -> u32 #foreign libphysx;

PxRigidActor_getShapes :: (self: *PxRigidActor, userBuffer: **PxShape, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxRigidActor_getNbConstraints :: (self: *PxRigidActor) -> u32 #foreign libphysx;

PxRigidActor_getConstraints :: (self: *PxRigidActor, userBuffer: **PxConstraint, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxNodeIndex_new :: (id: u32, articLinkId: u32) -> PxNodeIndex #foreign libphysx;

PxNodeIndex_new :: (id: u32) -> PxNodeIndex #foreign libphysx "PxNodeIndex_new_1";

PxNodeIndex_index :: (self: *PxNodeIndex) -> u32 #foreign libphysx;

PxNodeIndex_articulationLinkId :: (self: *PxNodeIndex) -> u32 #foreign libphysx;

PxNodeIndex_isArticulation :: (self: *PxNodeIndex) -> u32 #foreign libphysx;

PxNodeIndex_isStaticBody :: (self: *PxNodeIndex) -> bool #foreign libphysx;

PxNodeIndex_isValid :: (self: *PxNodeIndex) -> bool #foreign libphysx;

PxNodeIndex_setIndices :: (self: *PxNodeIndex, index: u32, articLinkId: u32) -> void #foreign libphysx "PxNodeIndex_setIndices_mut";

PxNodeIndex_setIndices_mut :: (self: *PxNodeIndex, index: u32) -> void #foreign libphysx "PxNodeIndex_setIndices_mut_1";

PxNodeIndex_getInd :: (self: *PxNodeIndex) -> u64 #foreign libphysx;

PxRigidBody_setCMassLocalPose :: (self: *PxRigidBody, pose: *PxTransform) -> void #foreign libphysx "PxRigidBody_setCMassLocalPose_mut";

PxRigidBody_getCMassLocalPose :: (self: *PxRigidBody) -> PxTransform #foreign libphysx;

PxRigidBody_setMass :: (self: *PxRigidBody, mass: float) -> void #foreign libphysx "PxRigidBody_setMass_mut";

PxRigidBody_getMass :: (self: *PxRigidBody) -> float #foreign libphysx;

PxRigidBody_getInvMass :: (self: *PxRigidBody) -> float #foreign libphysx;

PxRigidBody_setMassSpaceInertiaTensor :: (self: *PxRigidBody, m: *Vector3) -> void #foreign libphysx "PxRigidBody_setMassSpaceInertiaTensor_mut";

PxRigidBody_getMassSpaceInertiaTensor :: (self: *PxRigidBody) -> Vector3 #foreign libphysx;

PxRigidBody_getMassSpaceInvInertiaTensor :: (self: *PxRigidBody) -> Vector3 #foreign libphysx;

PxRigidBody_setLinearDamping :: (self: *PxRigidBody, linDamp: float) -> void #foreign libphysx "PxRigidBody_setLinearDamping_mut";

PxRigidBody_getLinearDamping :: (self: *PxRigidBody) -> float #foreign libphysx;

PxRigidBody_setAngularDamping :: (self: *PxRigidBody, angDamp: float) -> void #foreign libphysx "PxRigidBody_setAngularDamping_mut";

PxRigidBody_getAngularDamping :: (self: *PxRigidBody) -> float #foreign libphysx;

PxRigidBody_getLinearVelocity :: (self: *PxRigidBody) -> Vector3 #foreign libphysx;

PxRigidBody_getAngularVelocity :: (self: *PxRigidBody) -> Vector3 #foreign libphysx;

PxRigidBody_setMaxLinearVelocity :: (self: *PxRigidBody, maxLinVel: float) -> void #foreign libphysx "PxRigidBody_setMaxLinearVelocity_mut";

PxRigidBody_getMaxLinearVelocity :: (self: *PxRigidBody) -> float #foreign libphysx;

PxRigidBody_setMaxAngularVelocity :: (self: *PxRigidBody, maxAngVel: float) -> void #foreign libphysx "PxRigidBody_setMaxAngularVelocity_mut";

PxRigidBody_getMaxAngularVelocity :: (self: *PxRigidBody) -> float #foreign libphysx;

PxRigidBody_addForce :: (self: *PxRigidBody, force: *Vector3, mode: s32, autowake: bool) -> void #foreign libphysx "PxRigidBody_addForce_mut";

PxRigidBody_addTorque :: (self: *PxRigidBody, torque: *Vector3, mode: s32, autowake: bool) -> void #foreign libphysx "PxRigidBody_addTorque_mut";

PxRigidBody_clearForce :: (self: *PxRigidBody, mode: s32) -> void #foreign libphysx "PxRigidBody_clearForce_mut";

PxRigidBody_clearTorque :: (self: *PxRigidBody, mode: s32) -> void #foreign libphysx "PxRigidBody_clearTorque_mut";

PxRigidBody_setForceAndTorque :: (self: *PxRigidBody, force: *Vector3, torque: *Vector3, mode: s32) -> void #foreign libphysx "PxRigidBody_setForceAndTorque_mut";

PxRigidBody_setRigidBodyFlag :: (self: *PxRigidBody, flag: s32, value: bool) -> void #foreign libphysx "PxRigidBody_setRigidBodyFlag_mut";

PxRigidBody_setRigidBodyFlags :: (self: *PxRigidBody, inFlags: u16) -> void #foreign libphysx "PxRigidBody_setRigidBodyFlags_mut";

PxRigidBody_getRigidBodyFlags :: (self: *PxRigidBody) -> u16 #foreign libphysx;

PxRigidBody_setMinCCDAdvanceCoefficient :: (self: *PxRigidBody, advanceCoefficient: float) -> void #foreign libphysx "PxRigidBody_setMinCCDAdvanceCoefficient_mut";

PxRigidBody_getMinCCDAdvanceCoefficient :: (self: *PxRigidBody) -> float #foreign libphysx;

PxRigidBody_setMaxDepenetrationVelocity :: (self: *PxRigidBody, biasClamp: float) -> void #foreign libphysx "PxRigidBody_setMaxDepenetrationVelocity_mut";

PxRigidBody_getMaxDepenetrationVelocity :: (self: *PxRigidBody) -> float #foreign libphysx;

PxRigidBody_setMaxContactImpulse :: (self: *PxRigidBody, maxImpulse: float) -> void #foreign libphysx "PxRigidBody_setMaxContactImpulse_mut";

PxRigidBody_getMaxContactImpulse :: (self: *PxRigidBody) -> float #foreign libphysx;

PxRigidBody_setContactSlopCoefficient :: (self: *PxRigidBody, slopCoefficient: float) -> void #foreign libphysx "PxRigidBody_setContactSlopCoefficient_mut";

PxRigidBody_getContactSlopCoefficient :: (self: *PxRigidBody) -> float #foreign libphysx;

PxRigidBody_getInternalIslandNodeIndex :: (self: *PxRigidBody) -> PxNodeIndex #foreign libphysx;

PxArticulationLink_release :: (self: *PxArticulationLink) -> void #foreign libphysx "PxArticulationLink_release_mut";

PxArticulationLink_getArticulation :: (self: *PxArticulationLink) -> *PxArticulationReducedCoordinate #foreign libphysx;

PxArticulationLink_getInboundJoint :: (self: *PxArticulationLink) -> *PxArticulationJointReducedCoordinate #foreign libphysx;

PxArticulationLink_getInboundJointDof :: (self: *PxArticulationLink) -> u32 #foreign libphysx;

PxArticulationLink_getNbChildren :: (self: *PxArticulationLink) -> u32 #foreign libphysx;

PxArticulationLink_getLinkIndex :: (self: *PxArticulationLink) -> u32 #foreign libphysx;

PxArticulationLink_getChildren :: (self: *PxArticulationLink, userBuffer: **PxArticulationLink, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxArticulationLink_setCfmScale :: (self: *PxArticulationLink, cfm: float) -> void #foreign libphysx "PxArticulationLink_setCfmScale_mut";

PxArticulationLink_getCfmScale :: (self: *PxArticulationLink) -> float #foreign libphysx;

PxArticulationLink_getLinearVelocity :: (self: *PxArticulationLink) -> Vector3 #foreign libphysx;

PxArticulationLink_getAngularVelocity :: (self: *PxArticulationLink) -> Vector3 #foreign libphysx;

PxArticulationLink_getConcreteTypeName :: (self: *PxArticulationLink) -> *u8 #foreign libphysx;

PxConeLimitedConstraint_new :: () -> PxConeLimitedConstraint #foreign libphysx;

PxConstraint_release :: (self: *PxConstraint) -> void #foreign libphysx "PxConstraint_release_mut";

PxConstraint_getScene :: (self: *PxConstraint) -> *PxScene #foreign libphysx;

PxConstraint_getActors :: (self: *PxConstraint, actor0: **PxRigidActor, actor1: **PxRigidActor) -> void #foreign libphysx;

PxConstraint_setActors :: (self: *PxConstraint, actor0: *PxRigidActor, actor1: *PxRigidActor) -> void #foreign libphysx "PxConstraint_setActors_mut";

PxConstraint_markDirty :: (self: *PxConstraint) -> void #foreign libphysx "PxConstraint_markDirty_mut";

PxConstraint_getFlags :: (self: *PxConstraint) -> u16 #foreign libphysx;

PxConstraint_setFlags :: (self: *PxConstraint, flags: u16) -> void #foreign libphysx "PxConstraint_setFlags_mut";

PxConstraint_setFlag :: (self: *PxConstraint, flag: s32, value: bool) -> void #foreign libphysx "PxConstraint_setFlag_mut";

PxConstraint_getForce :: (self: *PxConstraint, linear: *Vector3, angular: *Vector3) -> void #foreign libphysx;

PxConstraint_isValid :: (self: *PxConstraint) -> bool #foreign libphysx;

PxConstraint_setBreakForce :: (self: *PxConstraint, linear: float, angular: float) -> void #foreign libphysx "PxConstraint_setBreakForce_mut";

PxConstraint_getBreakForce :: (self: *PxConstraint, linear: *float, angular: *float) -> void #foreign libphysx;

PxConstraint_setMinResponseThreshold :: (self: *PxConstraint, threshold: float) -> void #foreign libphysx "PxConstraint_setMinResponseThreshold_mut";

PxConstraint_getMinResponseThreshold :: (self: *PxConstraint) -> float #foreign libphysx;

PxConstraint_getExternalReference :: (self: *PxConstraint, typeID: *u32) -> *void #foreign libphysx "PxConstraint_getExternalReference_mut";

PxConstraint_setConstraintFunctions :: (self: *PxConstraint, connector: *PxConstraintConnector, shaders: *PxConstraintShaderTable) -> void #foreign libphysx "PxConstraint_setConstraintFunctions_mut";

PxConstraint_getConcreteTypeName :: (self: *PxConstraint) -> *u8 #foreign libphysx;

PxContactStreamIterator_new :: (contactPatches: *u8, contactPoints: *u8, contactFaceIndices: *u32, nbPatches: u32, nbContacts: u32) -> PxContactStreamIterator #foreign libphysx;

PxContactStreamIterator_hasNextPatch :: (self: *PxContactStreamIterator) -> bool #foreign libphysx;

PxContactStreamIterator_getTotalContactCount :: (self: *PxContactStreamIterator) -> u32 #foreign libphysx;

PxContactStreamIterator_getTotalPatchCount :: (self: *PxContactStreamIterator) -> u32 #foreign libphysx;

PxContactStreamIterator_nextPatch :: (self: *PxContactStreamIterator) -> void #foreign libphysx "PxContactStreamIterator_nextPatch_mut";

PxContactStreamIterator_hasNextContact :: (self: *PxContactStreamIterator) -> bool #foreign libphysx;

PxContactStreamIterator_nextContact :: (self: *PxContactStreamIterator) -> void #foreign libphysx "PxContactStreamIterator_nextContact_mut";

PxContactStreamIterator_getContactNormal :: (self: *PxContactStreamIterator) -> *Vector3 #foreign libphysx;

PxContactStreamIterator_getInvMassScale0 :: (self: *PxContactStreamIterator) -> float #foreign libphysx;

PxContactStreamIterator_getInvMassScale1 :: (self: *PxContactStreamIterator) -> float #foreign libphysx;

PxContactStreamIterator_getInvInertiaScale0 :: (self: *PxContactStreamIterator) -> float #foreign libphysx;

PxContactStreamIterator_getInvInertiaScale1 :: (self: *PxContactStreamIterator) -> float #foreign libphysx;

PxContactStreamIterator_getMaxImpulse :: (self: *PxContactStreamIterator) -> float #foreign libphysx;

PxContactStreamIterator_getTargetVel :: (self: *PxContactStreamIterator) -> *Vector3 #foreign libphysx;

PxContactStreamIterator_getContactPoint :: (self: *PxContactStreamIterator) -> *Vector3 #foreign libphysx;

PxContactStreamIterator_getSeparation :: (self: *PxContactStreamIterator) -> float #foreign libphysx;

PxContactStreamIterator_getFaceIndex0 :: (self: *PxContactStreamIterator) -> u32 #foreign libphysx;

PxContactStreamIterator_getFaceIndex1 :: (self: *PxContactStreamIterator) -> u32 #foreign libphysx;

PxContactStreamIterator_getStaticFriction :: (self: *PxContactStreamIterator) -> float #foreign libphysx;

PxContactStreamIterator_getDynamicFriction :: (self: *PxContactStreamIterator) -> float #foreign libphysx;

PxContactStreamIterator_getRestitution :: (self: *PxContactStreamIterator) -> float #foreign libphysx;

PxContactStreamIterator_getDamping :: (self: *PxContactStreamIterator) -> float #foreign libphysx;

PxContactStreamIterator_getMaterialFlags :: (self: *PxContactStreamIterator) -> u32 #foreign libphysx;

PxContactStreamIterator_getMaterialIndex0 :: (self: *PxContactStreamIterator) -> u16 #foreign libphysx;

PxContactStreamIterator_getMaterialIndex1 :: (self: *PxContactStreamIterator) -> u16 #foreign libphysx;

PxContactStreamIterator_advanceToIndex :: (self: *PxContactStreamIterator, initialIndex: u32) -> bool #foreign libphysx "PxContactStreamIterator_advanceToIndex_mut";

PxContactSet_getPoint :: (self: *PxContactSet, i: u32) -> *Vector3 #foreign libphysx;

PxContactSet_setPoint :: (self: *PxContactSet, i: u32, p: *Vector3) -> void #foreign libphysx "PxContactSet_setPoint_mut";

PxContactSet_getNormal :: (self: *PxContactSet, i: u32) -> *Vector3 #foreign libphysx;

PxContactSet_setNormal :: (self: *PxContactSet, i: u32, n: *Vector3) -> void #foreign libphysx "PxContactSet_setNormal_mut";

PxContactSet_getSeparation :: (self: *PxContactSet, i: u32) -> float #foreign libphysx;

PxContactSet_setSeparation :: (self: *PxContactSet, i: u32, s: float) -> void #foreign libphysx "PxContactSet_setSeparation_mut";

PxContactSet_getTargetVelocity :: (self: *PxContactSet, i: u32) -> *Vector3 #foreign libphysx;

PxContactSet_setTargetVelocity :: (self: *PxContactSet, i: u32, v: *Vector3) -> void #foreign libphysx "PxContactSet_setTargetVelocity_mut";

PxContactSet_getInternalFaceIndex0 :: (self: *PxContactSet, i: u32) -> u32 #foreign libphysx;

PxContactSet_getInternalFaceIndex1 :: (self: *PxContactSet, i: u32) -> u32 #foreign libphysx;

PxContactSet_getMaxImpulse :: (self: *PxContactSet, i: u32) -> float #foreign libphysx;

PxContactSet_setMaxImpulse :: (self: *PxContactSet, i: u32, s: float) -> void #foreign libphysx "PxContactSet_setMaxImpulse_mut";

PxContactSet_getRestitution :: (self: *PxContactSet, i: u32) -> float #foreign libphysx;

PxContactSet_setRestitution :: (self: *PxContactSet, i: u32, r: float) -> void #foreign libphysx "PxContactSet_setRestitution_mut";

PxContactSet_getStaticFriction :: (self: *PxContactSet, i: u32) -> float #foreign libphysx;

PxContactSet_setStaticFriction :: (self: *PxContactSet, i: u32, f: float) -> void #foreign libphysx "PxContactSet_setStaticFriction_mut";

PxContactSet_getDynamicFriction :: (self: *PxContactSet, i: u32) -> float #foreign libphysx;

PxContactSet_setDynamicFriction :: (self: *PxContactSet, i: u32, f: float) -> void #foreign libphysx "PxContactSet_setDynamicFriction_mut";

PxContactSet_ignore :: (self: *PxContactSet, i: u32) -> void #foreign libphysx "PxContactSet_ignore_mut";

PxContactSet_size :: (self: *PxContactSet) -> u32 #foreign libphysx;

PxContactSet_getInvMassScale0 :: (self: *PxContactSet) -> float #foreign libphysx;

PxContactSet_getInvMassScale1 :: (self: *PxContactSet) -> float #foreign libphysx;

PxContactSet_getInvInertiaScale0 :: (self: *PxContactSet) -> float #foreign libphysx;

PxContactSet_getInvInertiaScale1 :: (self: *PxContactSet) -> float #foreign libphysx;

PxContactSet_setInvMassScale0 :: (self: *PxContactSet, scale: float) -> void #foreign libphysx "PxContactSet_setInvMassScale0_mut";

PxContactSet_setInvMassScale1 :: (self: *PxContactSet, scale: float) -> void #foreign libphysx "PxContactSet_setInvMassScale1_mut";

PxContactSet_setInvInertiaScale0 :: (self: *PxContactSet, scale: float) -> void #foreign libphysx "PxContactSet_setInvInertiaScale0_mut";

PxContactSet_setInvInertiaScale1 :: (self: *PxContactSet, scale: float) -> void #foreign libphysx "PxContactSet_setInvInertiaScale1_mut";

PxContactModifyCallback_onContactModify :: (self: *PxContactModifyCallback, pairs: *PxContactModifyPair, count: u32) -> void #foreign libphysx "PxContactModifyCallback_onContactModify_mut";

PxCCDContactModifyCallback_onCCDContactModify :: (self: *PxCCDContactModifyCallback, pairs: *PxContactModifyPair, count: u32) -> void #foreign libphysx "PxCCDContactModifyCallback_onCCDContactModify_mut";

PxDeletionListener_onRelease :: (self: *PxDeletionListener, observed: *PxBase, userData: *void, deletionEvent: s32) -> void #foreign libphysx "PxDeletionListener_onRelease_mut";

PxBaseMaterial_isKindOf :: (self: *PxBaseMaterial, name: *u8) -> bool #foreign libphysx;

PxFEMMaterial_setYoungsModulus :: (self: *PxFEMMaterial, young: float) -> void #foreign libphysx "PxFEMMaterial_setYoungsModulus_mut";

PxFEMMaterial_getYoungsModulus :: (self: *PxFEMMaterial) -> float #foreign libphysx;

PxFEMMaterial_setPoissons :: (self: *PxFEMMaterial, poisson: float) -> void #foreign libphysx "PxFEMMaterial_setPoissons_mut";

PxFEMMaterial_getPoissons :: (self: *PxFEMMaterial) -> float #foreign libphysx;

PxFEMMaterial_setDynamicFriction :: (self: *PxFEMMaterial, dynamicFriction: float) -> void #foreign libphysx "PxFEMMaterial_setDynamicFriction_mut";

PxFEMMaterial_getDynamicFriction :: (self: *PxFEMMaterial) -> float #foreign libphysx;

PxFilterData_new :: (anon_param0: s32) -> PxFilterData #foreign libphysx;

PxFilterData_new :: () -> PxFilterData #foreign libphysx "PxFilterData_new_1";

PxFilterData_new :: (w0: u32, w1: u32, w2: u32, w3: u32) -> PxFilterData #foreign libphysx "PxFilterData_new_2";

PxFilterData_setToDefault :: (self: *PxFilterData) -> void #foreign libphysx "PxFilterData_setToDefault_mut";

PxGetFilterObjectType :: (attr: u32) -> s32 #foreign libphysx "phys_PxGetFilterObjectType";

PxFilterObjectIsKinematic :: (attr: u32) -> bool #foreign libphysx "phys_PxFilterObjectIsKinematic";

PxFilterObjectIsTrigger :: (attr: u32) -> bool #foreign libphysx "phys_PxFilterObjectIsTrigger";

PxSimulationFilterCallback_pairFound :: (self: *PxSimulationFilterCallback, pairID: u32, attributes0: u32, filterData0: PxFilterData, a0: *PxActor, s0: *PxShape, attributes1: u32, filterData1: PxFilterData, a1: *PxActor, s1: *PxShape, pairFlags: *u16) -> u16 #foreign libphysx "PxSimulationFilterCallback_pairFound_mut";

PxSimulationFilterCallback_pairLost :: (self: *PxSimulationFilterCallback, pairID: u32, attributes0: u32, filterData0: PxFilterData, attributes1: u32, filterData1: PxFilterData, objectRemoved: bool) -> void #foreign libphysx "PxSimulationFilterCallback_pairLost_mut";

PxSimulationFilterCallback_statusChange :: (self: *PxSimulationFilterCallback, pairID: *u32, pairFlags: *u16, filterFlags: *u16) -> bool #foreign libphysx "PxSimulationFilterCallback_statusChange_mut";

PxLockedData_getDataAccessFlags :: (self: *PxLockedData) -> u8 #foreign libphysx "PxLockedData_getDataAccessFlags_mut";

PxLockedData_unlock :: (self: *PxLockedData) -> void #foreign libphysx "PxLockedData_unlock_mut";

PxLockedData_delete :: (self: *PxLockedData) -> void #foreign libphysx;

PxMaterial_setDynamicFriction :: (self: *PxMaterial, coef: float) -> void #foreign libphysx "PxMaterial_setDynamicFriction_mut";

PxMaterial_getDynamicFriction :: (self: *PxMaterial) -> float #foreign libphysx;

PxMaterial_setStaticFriction :: (self: *PxMaterial, coef: float) -> void #foreign libphysx "PxMaterial_setStaticFriction_mut";

PxMaterial_getStaticFriction :: (self: *PxMaterial) -> float #foreign libphysx;

PxMaterial_setRestitution :: (self: *PxMaterial, rest: float) -> void #foreign libphysx "PxMaterial_setRestitution_mut";

PxMaterial_getRestitution :: (self: *PxMaterial) -> float #foreign libphysx;

PxMaterial_setDamping :: (self: *PxMaterial, damping: float) -> void #foreign libphysx "PxMaterial_setDamping_mut";

PxMaterial_getDamping :: (self: *PxMaterial) -> float #foreign libphysx;

PxMaterial_setFlag :: (self: *PxMaterial, flag: s32, b: bool) -> void #foreign libphysx "PxMaterial_setFlag_mut";

PxMaterial_setFlags :: (self: *PxMaterial, flags: u16) -> void #foreign libphysx "PxMaterial_setFlags_mut";

PxMaterial_getFlags :: (self: *PxMaterial) -> u16 #foreign libphysx;

PxMaterial_setFrictionCombineMode :: (self: *PxMaterial, combMode: s32) -> void #foreign libphysx "PxMaterial_setFrictionCombineMode_mut";

PxMaterial_getFrictionCombineMode :: (self: *PxMaterial) -> s32 #foreign libphysx;

PxMaterial_setRestitutionCombineMode :: (self: *PxMaterial, combMode: s32) -> void #foreign libphysx "PxMaterial_setRestitutionCombineMode_mut";

PxMaterial_getRestitutionCombineMode :: (self: *PxMaterial) -> s32 #foreign libphysx;

PxMaterial_getConcreteTypeName :: (self: *PxMaterial) -> *u8 #foreign libphysx;

PxDiffuseParticleParams_new :: () -> PxDiffuseParticleParams #foreign libphysx;

PxDiffuseParticleParams_setToDefault :: (self: *PxDiffuseParticleParams) -> void #foreign libphysx "PxDiffuseParticleParams_setToDefault_mut";

PxParticleMaterial_setFriction :: (self: *PxParticleMaterial, friction: float) -> void #foreign libphysx "PxParticleMaterial_setFriction_mut";

PxParticleMaterial_getFriction :: (self: *PxParticleMaterial) -> float #foreign libphysx;

PxParticleMaterial_setDamping :: (self: *PxParticleMaterial, damping: float) -> void #foreign libphysx "PxParticleMaterial_setDamping_mut";

PxParticleMaterial_getDamping :: (self: *PxParticleMaterial) -> float #foreign libphysx;

PxParticleMaterial_setAdhesion :: (self: *PxParticleMaterial, adhesion: float) -> void #foreign libphysx "PxParticleMaterial_setAdhesion_mut";

PxParticleMaterial_getAdhesion :: (self: *PxParticleMaterial) -> float #foreign libphysx;

PxParticleMaterial_setGravityScale :: (self: *PxParticleMaterial, scale: float) -> void #foreign libphysx "PxParticleMaterial_setGravityScale_mut";

PxParticleMaterial_getGravityScale :: (self: *PxParticleMaterial) -> float #foreign libphysx;

PxParticleMaterial_setAdhesionRadiusScale :: (self: *PxParticleMaterial, scale: float) -> void #foreign libphysx "PxParticleMaterial_setAdhesionRadiusScale_mut";

PxParticleMaterial_getAdhesionRadiusScale :: (self: *PxParticleMaterial) -> float #foreign libphysx;

PxPhysics_release :: (self: *PxPhysics) -> void #foreign libphysx "PxPhysics_release_mut";

PxPhysics_getFoundation :: (self: *PxPhysics) -> *PxFoundation #foreign libphysx "PxPhysics_getFoundation_mut";

PxPhysics_createAggregate :: (self: *PxPhysics, maxActor: u32, maxShape: u32, filterHint: u32) -> *PxAggregate #foreign libphysx "PxPhysics_createAggregate_mut";

PxPhysics_getTolerancesScale :: (self: *PxPhysics) -> *PxTolerancesScale #foreign libphysx;

PxPhysics_createTriangleMesh :: (self: *PxPhysics, stream: *PxInputStream) -> *PxTriangleMesh #foreign libphysx "PxPhysics_createTriangleMesh_mut";

PxPhysics_getNbTriangleMeshes :: (self: *PxPhysics) -> u32 #foreign libphysx;

PxPhysics_getTriangleMeshes :: (self: *PxPhysics, userBuffer: **PxTriangleMesh, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxPhysics_createTetrahedronMesh :: (self: *PxPhysics, stream: *PxInputStream) -> *PxTetrahedronMesh #foreign libphysx "PxPhysics_createTetrahedronMesh_mut";

PxPhysics_createSoftBodyMesh :: (self: *PxPhysics, stream: *PxInputStream) -> *PxSoftBodyMesh #foreign libphysx "PxPhysics_createSoftBodyMesh_mut";

PxPhysics_getNbTetrahedronMeshes :: (self: *PxPhysics) -> u32 #foreign libphysx;

PxPhysics_getTetrahedronMeshes :: (self: *PxPhysics, userBuffer: **PxTetrahedronMesh, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxPhysics_createHeightField :: (self: *PxPhysics, stream: *PxInputStream) -> *PxHeightField #foreign libphysx "PxPhysics_createHeightField_mut";

PxPhysics_getNbHeightFields :: (self: *PxPhysics) -> u32 #foreign libphysx;

PxPhysics_getHeightFields :: (self: *PxPhysics, userBuffer: **PxHeightField, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxPhysics_createConvexMesh :: (self: *PxPhysics, stream: *PxInputStream) -> *PxConvexMesh #foreign libphysx "PxPhysics_createConvexMesh_mut";

PxPhysics_getNbConvexMeshes :: (self: *PxPhysics) -> u32 #foreign libphysx;

PxPhysics_getConvexMeshes :: (self: *PxPhysics, userBuffer: **PxConvexMesh, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxPhysics_createBVH :: (self: *PxPhysics, stream: *PxInputStream) -> *PxBVH #foreign libphysx "PxPhysics_createBVH_mut";

PxPhysics_getNbBVHs :: (self: *PxPhysics) -> u32 #foreign libphysx;

PxPhysics_getBVHs :: (self: *PxPhysics, userBuffer: **PxBVH, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxPhysics_createScene :: (self: *PxPhysics, sceneDesc: *PxSceneDesc) -> *PxScene #foreign libphysx "PxPhysics_createScene_mut";

PxPhysics_getNbScenes :: (self: *PxPhysics) -> u32 #foreign libphysx;

PxPhysics_getScenes :: (self: *PxPhysics, userBuffer: **PxScene, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxPhysics_createRigidStatic :: (self: *PxPhysics, pose: *PxTransform) -> *PxRigidStatic #foreign libphysx "PxPhysics_createRigidStatic_mut";

PxPhysics_createRigidDynamic :: (self: *PxPhysics, pose: *PxTransform) -> *PxRigidDynamic #foreign libphysx "PxPhysics_createRigidDynamic_mut";

PxPhysics_createPruningStructure :: (self: *PxPhysics, actors: **PxRigidActor, nbActors: u32) -> *PxPruningStructure #foreign libphysx "PxPhysics_createPruningStructure_mut";

PxPhysics_createShape :: (self: *PxPhysics, geometry: *PxGeometry, material: *PxMaterial, isExclusive: bool, shapeFlags: u8) -> *PxShape #foreign libphysx "PxPhysics_createShape_mut";

PxPhysics_createShape_mut :: (self: *PxPhysics, geometry: *PxGeometry, materials: **PxMaterial, materialCount: u16, isExclusive: bool, shapeFlags: u8) -> *PxShape #foreign libphysx "PxPhysics_createShape_mut_1";

PxPhysics_getNbShapes :: (self: *PxPhysics) -> u32 #foreign libphysx;

PxPhysics_getShapes :: (self: *PxPhysics, userBuffer: **PxShape, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxPhysics_createConstraint :: (self: *PxPhysics, actor0: *PxRigidActor, actor1: *PxRigidActor, connector: *PxConstraintConnector, shaders: *PxConstraintShaderTable, dataSize: u32) -> *PxConstraint #foreign libphysx "PxPhysics_createConstraint_mut";

PxPhysics_createArticulationReducedCoordinate :: (self: *PxPhysics) -> *PxArticulationReducedCoordinate #foreign libphysx "PxPhysics_createArticulationReducedCoordinate_mut";

PxPhysics_createMaterial :: (self: *PxPhysics, staticFriction: float, dynamicFriction: float, restitution: float) -> *PxMaterial #foreign libphysx "PxPhysics_createMaterial_mut";

PxPhysics_getNbMaterials :: (self: *PxPhysics) -> u32 #foreign libphysx;

PxPhysics_getMaterials :: (self: *PxPhysics, userBuffer: **PxMaterial, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxPhysics_registerDeletionListener :: (self: *PxPhysics, observer: *PxDeletionListener, deletionEvents: *u8, restrictedObjectSet: bool) -> void #foreign libphysx "PxPhysics_registerDeletionListener_mut";

PxPhysics_unregisterDeletionListener :: (self: *PxPhysics, observer: *PxDeletionListener) -> void #foreign libphysx "PxPhysics_unregisterDeletionListener_mut";

PxPhysics_registerDeletionListenerObjects :: (self: *PxPhysics, observer: *PxDeletionListener, observables: **PxBase, observableCount: u32) -> void #foreign libphysx "PxPhysics_registerDeletionListenerObjects_mut";

PxPhysics_unregisterDeletionListenerObjects :: (self: *PxPhysics, observer: *PxDeletionListener, observables: **PxBase, observableCount: u32) -> void #foreign libphysx "PxPhysics_unregisterDeletionListenerObjects_mut";

PxPhysics_getPhysicsInsertionCallback :: (self: *PxPhysics) -> *PxInsertionCallback #foreign libphysx "PxPhysics_getPhysicsInsertionCallback_mut";

PxCreatePhysics :: (version: u32, foundation: *PxFoundation, scale: *PxTolerancesScale, trackOutstandingAllocations: bool, pvd: *PxPvd, omniPvd: *PxOmniPvd) -> *PxPhysics #foreign libphysx "phys_PxCreatePhysics";

PxGetPhysics :: () -> *PxPhysics #foreign libphysx "phys_PxGetPhysics";

PxActorShape_new :: () -> PxActorShape #foreign libphysx;

PxActorShape_new :: (a: *PxRigidActor, s: *PxShape) -> PxActorShape #foreign libphysx "PxActorShape_new_1";

PxQueryCache_new :: () -> PxQueryCache #foreign libphysx;

PxQueryCache_new :: (s: *PxShape, findex: u32) -> PxQueryCache #foreign libphysx "PxQueryCache_new_1";

PxQueryFilterData_new :: () -> PxQueryFilterData #foreign libphysx;

PxQueryFilterData_new :: (fd: *PxFilterData, f: u16) -> PxQueryFilterData #foreign libphysx "PxQueryFilterData_new_1";

PxQueryFilterData_new :: (f: u16) -> PxQueryFilterData #foreign libphysx "PxQueryFilterData_new_2";

PxQueryFilterCallback_preFilter :: (self: *PxQueryFilterCallback, filterData: *PxFilterData, shape: *PxShape, actor: *PxRigidActor, queryFlags: *u16) -> s32 #foreign libphysx "PxQueryFilterCallback_preFilter_mut";

PxQueryFilterCallback_postFilter :: (self: *PxQueryFilterCallback, filterData: *PxFilterData, hit: *PxQueryHit, shape: *PxShape, actor: *PxRigidActor) -> s32 #foreign libphysx "PxQueryFilterCallback_postFilter_mut";

PxQueryFilterCallback_delete :: (self: *PxQueryFilterCallback) -> void #foreign libphysx;

PxRigidDynamic_setKinematicTarget :: (self: *PxRigidDynamic, destination: *PxTransform) -> void #foreign libphysx "PxRigidDynamic_setKinematicTarget_mut";

PxRigidDynamic_getKinematicTarget :: (self: *PxRigidDynamic, target: *PxTransform) -> bool #foreign libphysx;

PxRigidDynamic_isSleeping :: (self: *PxRigidDynamic) -> bool #foreign libphysx;

PxRigidDynamic_setSleepThreshold :: (self: *PxRigidDynamic, threshold: float) -> void #foreign libphysx "PxRigidDynamic_setSleepThreshold_mut";

PxRigidDynamic_getSleepThreshold :: (self: *PxRigidDynamic) -> float #foreign libphysx;

PxRigidDynamic_setStabilizationThreshold :: (self: *PxRigidDynamic, threshold: float) -> void #foreign libphysx "PxRigidDynamic_setStabilizationThreshold_mut";

PxRigidDynamic_getStabilizationThreshold :: (self: *PxRigidDynamic) -> float #foreign libphysx;

PxRigidDynamic_getRigidDynamicLockFlags :: (self: *PxRigidDynamic) -> u8 #foreign libphysx;

PxRigidDynamic_setRigidDynamicLockFlag :: (self: *PxRigidDynamic, flag: s32, value: bool) -> void #foreign libphysx "PxRigidDynamic_setRigidDynamicLockFlag_mut";

PxRigidDynamic_setRigidDynamicLockFlags :: (self: *PxRigidDynamic, flags: u8) -> void #foreign libphysx "PxRigidDynamic_setRigidDynamicLockFlags_mut";

PxRigidDynamic_getLinearVelocity :: (self: *PxRigidDynamic) -> Vector3 #foreign libphysx;

PxRigidDynamic_setLinearVelocity :: (self: *PxRigidDynamic, linVel: *Vector3, autowake: bool) -> void #foreign libphysx "PxRigidDynamic_setLinearVelocity_mut";

PxRigidDynamic_getAngularVelocity :: (self: *PxRigidDynamic) -> Vector3 #foreign libphysx;

PxRigidDynamic_setAngularVelocity :: (self: *PxRigidDynamic, angVel: *Vector3, autowake: bool) -> void #foreign libphysx "PxRigidDynamic_setAngularVelocity_mut";

PxRigidDynamic_setWakeCounter :: (self: *PxRigidDynamic, wakeCounterValue: float) -> void #foreign libphysx "PxRigidDynamic_setWakeCounter_mut";

PxRigidDynamic_getWakeCounter :: (self: *PxRigidDynamic) -> float #foreign libphysx;

PxRigidDynamic_wakeUp :: (self: *PxRigidDynamic) -> void #foreign libphysx "PxRigidDynamic_wakeUp_mut";

PxRigidDynamic_putToSleep :: (self: *PxRigidDynamic) -> void #foreign libphysx "PxRigidDynamic_putToSleep_mut";

PxRigidDynamic_setSolverIterationCounts :: (self: *PxRigidDynamic, minPositionIters: u32, minVelocityIters: u32) -> void #foreign libphysx "PxRigidDynamic_setSolverIterationCounts_mut";

PxRigidDynamic_getSolverIterationCounts :: (self: *PxRigidDynamic, minPositionIters: *u32, minVelocityIters: *u32) -> void #foreign libphysx;

PxRigidDynamic_getContactReportThreshold :: (self: *PxRigidDynamic) -> float #foreign libphysx;

PxRigidDynamic_setContactReportThreshold :: (self: *PxRigidDynamic, threshold: float) -> void #foreign libphysx "PxRigidDynamic_setContactReportThreshold_mut";

PxRigidDynamic_getConcreteTypeName :: (self: *PxRigidDynamic) -> *u8 #foreign libphysx;

PxRigidStatic_getConcreteTypeName :: (self: *PxRigidStatic) -> *u8 #foreign libphysx;

PxSceneQueryDesc_new :: () -> PxSceneQueryDesc #foreign libphysx;

PxSceneQueryDesc_setToDefault :: (self: *PxSceneQueryDesc) -> void #foreign libphysx "PxSceneQueryDesc_setToDefault_mut";

PxSceneQueryDesc_isValid :: (self: *PxSceneQueryDesc) -> bool #foreign libphysx;

PxSceneQuerySystemBase_setDynamicTreeRebuildRateHint :: (self: *PxSceneQuerySystemBase, dynamicTreeRebuildRateHint: u32) -> void #foreign libphysx "PxSceneQuerySystemBase_setDynamicTreeRebuildRateHint_mut";

PxSceneQuerySystemBase_getDynamicTreeRebuildRateHint :: (self: *PxSceneQuerySystemBase) -> u32 #foreign libphysx;

PxSceneQuerySystemBase_forceRebuildDynamicTree :: (self: *PxSceneQuerySystemBase, prunerIndex: u32) -> void #foreign libphysx "PxSceneQuerySystemBase_forceRebuildDynamicTree_mut";

PxSceneQuerySystemBase_setUpdateMode :: (self: *PxSceneQuerySystemBase, updateMode: s32) -> void #foreign libphysx "PxSceneQuerySystemBase_setUpdateMode_mut";

PxSceneQuerySystemBase_getUpdateMode :: (self: *PxSceneQuerySystemBase) -> s32 #foreign libphysx;

PxSceneQuerySystemBase_getStaticTimestamp :: (self: *PxSceneQuerySystemBase) -> u32 #foreign libphysx;

PxSceneQuerySystemBase_flushUpdates :: (self: *PxSceneQuerySystemBase) -> void #foreign libphysx "PxSceneQuerySystemBase_flushUpdates_mut";

PxSceneQuerySystemBase_raycast :: (self: *PxSceneQuerySystemBase, origin: *Vector3, unitDir: *Vector3, distance: float, hitCall: *PxRaycastCallback, hitFlags: u16, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback, cache: *PxQueryCache, queryFlags: u32) -> bool #foreign libphysx;

PxSceneQuerySystemBase_sweep :: (self: *PxSceneQuerySystemBase, geometry: *PxGeometry, pose: *PxTransform, unitDir: *Vector3, distance: float, hitCall: *PxSweepCallback, hitFlags: u16, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback, cache: *PxQueryCache, inflation: float, queryFlags: u32) -> bool #foreign libphysx;

PxSceneQuerySystemBase_overlap :: (self: *PxSceneQuerySystemBase, geometry: *PxGeometry, pose: *PxTransform, hitCall: *PxOverlapCallback, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback, cache: *PxQueryCache, queryFlags: u32) -> bool #foreign libphysx;

PxSceneSQSystem_setSceneQueryUpdateMode :: (self: *PxSceneSQSystem, updateMode: s32) -> void #foreign libphysx "PxSceneSQSystem_setSceneQueryUpdateMode_mut";

PxSceneSQSystem_getSceneQueryUpdateMode :: (self: *PxSceneSQSystem) -> s32 #foreign libphysx;

PxSceneSQSystem_getSceneQueryStaticTimestamp :: (self: *PxSceneSQSystem) -> u32 #foreign libphysx;

PxSceneSQSystem_flushQueryUpdates :: (self: *PxSceneSQSystem) -> void #foreign libphysx "PxSceneSQSystem_flushQueryUpdates_mut";

PxSceneSQSystem_forceDynamicTreeRebuild :: (self: *PxSceneSQSystem, rebuildStaticStructure: bool, rebuildDynamicStructure: bool) -> void #foreign libphysx "PxSceneSQSystem_forceDynamicTreeRebuild_mut";

PxSceneSQSystem_getStaticStructure :: (self: *PxSceneSQSystem) -> s32 #foreign libphysx;

PxSceneSQSystem_getDynamicStructure :: (self: *PxSceneSQSystem) -> s32 #foreign libphysx;

PxSceneSQSystem_sceneQueriesUpdate :: (self: *PxSceneSQSystem, completionTask: *PxBaseTask, controlSimulation: bool) -> void #foreign libphysx "PxSceneSQSystem_sceneQueriesUpdate_mut";

PxSceneSQSystem_checkQueries :: (self: *PxSceneSQSystem, block: bool) -> bool #foreign libphysx "PxSceneSQSystem_checkQueries_mut";

PxSceneSQSystem_fetchQueries :: (self: *PxSceneSQSystem, block: bool) -> bool #foreign libphysx "PxSceneSQSystem_fetchQueries_mut";

PxSceneQuerySystem_release :: (self: *PxSceneQuerySystem) -> void #foreign libphysx "PxSceneQuerySystem_release_mut";

PxSceneQuerySystem_acquireReference :: (self: *PxSceneQuerySystem) -> void #foreign libphysx "PxSceneQuerySystem_acquireReference_mut";

PxSceneQuerySystem_preallocate :: (self: *PxSceneQuerySystem, prunerIndex: u32, nbShapes: u32) -> void #foreign libphysx "PxSceneQuerySystem_preallocate_mut";

PxSceneQuerySystem_flushMemory :: (self: *PxSceneQuerySystem) -> void #foreign libphysx "PxSceneQuerySystem_flushMemory_mut";

PxSceneQuerySystem_addSQShape :: (self: *PxSceneQuerySystem, actor: *PxRigidActor, shape: *PxShape, bounds: *PxBounds3, transform: *PxTransform, compoundHandle: *u32, hasPruningStructure: bool) -> void #foreign libphysx "PxSceneQuerySystem_addSQShape_mut";

PxSceneQuerySystem_removeSQShape :: (self: *PxSceneQuerySystem, actor: *PxRigidActor, shape: *PxShape) -> void #foreign libphysx "PxSceneQuerySystem_removeSQShape_mut";

PxSceneQuerySystem_updateSQShape :: (self: *PxSceneQuerySystem, actor: *PxRigidActor, shape: *PxShape, transform: *PxTransform) -> void #foreign libphysx "PxSceneQuerySystem_updateSQShape_mut";

PxSceneQuerySystem_addSQCompound :: (self: *PxSceneQuerySystem, actor: *PxRigidActor, shapes: **PxShape, bvh: *PxBVH, transforms: *PxTransform) -> u32 #foreign libphysx "PxSceneQuerySystem_addSQCompound_mut";

PxSceneQuerySystem_removeSQCompound :: (self: *PxSceneQuerySystem, compoundHandle: u32) -> void #foreign libphysx "PxSceneQuerySystem_removeSQCompound_mut";

PxSceneQuerySystem_updateSQCompound :: (self: *PxSceneQuerySystem, compoundHandle: u32, compoundTransform: *PxTransform) -> void #foreign libphysx "PxSceneQuerySystem_updateSQCompound_mut";

PxSceneQuerySystem_shiftOrigin :: (self: *PxSceneQuerySystem, shift: *Vector3) -> void #foreign libphysx "PxSceneQuerySystem_shiftOrigin_mut";

PxSceneQuerySystem_merge :: (self: *PxSceneQuerySystem, pruningStructure: *PxPruningStructure) -> void #foreign libphysx "PxSceneQuerySystem_merge_mut";

PxSceneQuerySystem_getHandle :: (self: *PxSceneQuerySystem, actor: *PxRigidActor, shape: *PxShape, prunerIndex: *u32) -> u32 #foreign libphysx;

PxSceneQuerySystem_sync :: (self: *PxSceneQuerySystem, prunerIndex: u32, handles: *u32, indices: *u32, bounds: *PxBounds3, transforms: *PxTransformPadded, count: u32, ignoredIndices: *PxBitMap) -> void #foreign libphysx "PxSceneQuerySystem_sync_mut";

PxSceneQuerySystem_finalizeUpdates :: (self: *PxSceneQuerySystem) -> void #foreign libphysx "PxSceneQuerySystem_finalizeUpdates_mut";

PxSceneQuerySystem_prepareSceneQueryBuildStep :: (self: *PxSceneQuerySystem, prunerIndex: u32) -> *void #foreign libphysx "PxSceneQuerySystem_prepareSceneQueryBuildStep_mut";

PxSceneQuerySystem_sceneQueryBuildStep :: (self: *PxSceneQuerySystem, handle: *void) -> void #foreign libphysx "PxSceneQuerySystem_sceneQueryBuildStep_mut";

PxBroadPhaseDesc_new :: (type: s32) -> PxBroadPhaseDesc #foreign libphysx;

PxBroadPhaseDesc_isValid :: (self: *PxBroadPhaseDesc) -> bool #foreign libphysx;

PxGetBroadPhaseStaticFilterGroup :: () -> u32 #foreign libphysx "phys_PxGetBroadPhaseStaticFilterGroup";

PxGetBroadPhaseDynamicFilterGroup :: (id: u32) -> u32 #foreign libphysx "phys_PxGetBroadPhaseDynamicFilterGroup";

PxGetBroadPhaseKinematicFilterGroup :: (id: u32) -> u32 #foreign libphysx "phys_PxGetBroadPhaseKinematicFilterGroup";

PxBroadPhaseUpdateData_new :: (created: *u32, nbCreated: u32, updated: *u32, nbUpdated: u32, removed: *u32, nbRemoved: u32, bounds: *PxBounds3, groups: *u32, distances: *float, capacity: u32) -> PxBroadPhaseUpdateData #foreign libphysx;

PxBroadPhaseResults_new :: () -> PxBroadPhaseResults #foreign libphysx;

PxBroadPhaseRegions_getNbRegions :: (self: *PxBroadPhaseRegions) -> u32 #foreign libphysx;

PxBroadPhaseRegions_getRegions :: (self: *PxBroadPhaseRegions, userBuffer: *PxBroadPhaseRegionInfo, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxBroadPhaseRegions_addRegion :: (self: *PxBroadPhaseRegions, region: *PxBroadPhaseRegion, populateRegion: bool, bounds: *PxBounds3, distances: *float) -> u32 #foreign libphysx "PxBroadPhaseRegions_addRegion_mut";

PxBroadPhaseRegions_removeRegion :: (self: *PxBroadPhaseRegions, handle: u32) -> bool #foreign libphysx "PxBroadPhaseRegions_removeRegion_mut";

PxBroadPhaseRegions_getNbOutOfBoundsObjects :: (self: *PxBroadPhaseRegions) -> u32 #foreign libphysx;

PxBroadPhaseRegions_getOutOfBoundsObjects :: (self: *PxBroadPhaseRegions) -> *u32 #foreign libphysx;

PxBroadPhase_release :: (self: *PxBroadPhase) -> void #foreign libphysx "PxBroadPhase_release_mut";

PxBroadPhase_getType :: (self: *PxBroadPhase) -> s32 #foreign libphysx;

PxBroadPhase_getCaps :: (self: *PxBroadPhase, caps: *PxBroadPhaseCaps) -> void #foreign libphysx;

PxBroadPhase_getRegions :: (self: *PxBroadPhase) -> *PxBroadPhaseRegions #foreign libphysx "PxBroadPhase_getRegions_mut";

PxBroadPhase_getAllocator :: (self: *PxBroadPhase) -> *PxAllocatorCallback #foreign libphysx "PxBroadPhase_getAllocator_mut";

PxBroadPhase_getContextID :: (self: *PxBroadPhase) -> u64 #foreign libphysx;

PxBroadPhase_setScratchBlock :: (self: *PxBroadPhase, scratchBlock: *void, size: u32) -> void #foreign libphysx "PxBroadPhase_setScratchBlock_mut";

PxBroadPhase_update :: (self: *PxBroadPhase, updateData: *PxBroadPhaseUpdateData, continuation: *PxBaseTask) -> void #foreign libphysx "PxBroadPhase_update_mut";

PxBroadPhase_fetchResults :: (self: *PxBroadPhase, results: *PxBroadPhaseResults) -> void #foreign libphysx "PxBroadPhase_fetchResults_mut";

PxBroadPhase_update_mut :: (self: *PxBroadPhase, results: *PxBroadPhaseResults, updateData: *PxBroadPhaseUpdateData) -> void #foreign libphysx "PxBroadPhase_update_mut_1";

PxCreateBroadPhase :: (desc: *PxBroadPhaseDesc) -> *PxBroadPhase #foreign libphysx "phys_PxCreateBroadPhase";

PxAABBManager_release :: (self: *PxAABBManager) -> void #foreign libphysx "PxAABBManager_release_mut";

PxAABBManager_getBroadPhase :: (self: *PxAABBManager) -> *PxBroadPhase #foreign libphysx "PxAABBManager_getBroadPhase_mut";

PxAABBManager_getBounds :: (self: *PxAABBManager) -> *PxBounds3 #foreign libphysx;

PxAABBManager_getDistances :: (self: *PxAABBManager) -> *float #foreign libphysx;

PxAABBManager_getGroups :: (self: *PxAABBManager) -> *u32 #foreign libphysx;

PxAABBManager_getCapacity :: (self: *PxAABBManager) -> u32 #foreign libphysx;

PxAABBManager_addObject :: (self: *PxAABBManager, index: u32, bounds: *PxBounds3, group: u32, distance: float) -> void #foreign libphysx "PxAABBManager_addObject_mut";

PxAABBManager_removeObject :: (self: *PxAABBManager, index: u32) -> void #foreign libphysx "PxAABBManager_removeObject_mut";

PxAABBManager_updateObject :: (self: *PxAABBManager, index: u32, bounds: *PxBounds3, distance: *float) -> void #foreign libphysx "PxAABBManager_updateObject_mut";

PxAABBManager_update :: (self: *PxAABBManager, continuation: *PxBaseTask) -> void #foreign libphysx "PxAABBManager_update_mut";

PxAABBManager_fetchResults :: (self: *PxAABBManager, results: *PxBroadPhaseResults) -> void #foreign libphysx "PxAABBManager_fetchResults_mut";

PxAABBManager_update_mut :: (self: *PxAABBManager, results: *PxBroadPhaseResults) -> void #foreign libphysx "PxAABBManager_update_mut_1";

PxCreateAABBManager :: (broadphase: *PxBroadPhase) -> *PxAABBManager #foreign libphysx "phys_PxCreateAABBManager";

PxSceneLimits_new :: () -> PxSceneLimits #foreign libphysx;

PxSceneLimits_setToDefault :: (self: *PxSceneLimits) -> void #foreign libphysx "PxSceneLimits_setToDefault_mut";

PxSceneLimits_isValid :: (self: *PxSceneLimits) -> bool #foreign libphysx;

PxgDynamicsMemoryConfig_new :: () -> PxgDynamicsMemoryConfig #foreign libphysx;

PxgDynamicsMemoryConfig_isValid :: (self: *PxgDynamicsMemoryConfig) -> bool #foreign libphysx;

PxSceneDesc_new :: (scale: *PxTolerancesScale) -> PxSceneDesc #foreign libphysx;

PxSceneDesc_setToDefault :: (self: *PxSceneDesc, scale: *PxTolerancesScale) -> void #foreign libphysx "PxSceneDesc_setToDefault_mut";

PxSceneDesc_isValid :: (self: *PxSceneDesc) -> bool #foreign libphysx;

PxSceneDesc_getTolerancesScale :: (self: *PxSceneDesc) -> *PxTolerancesScale #foreign libphysx;

PxSimulationStatistics_getNbBroadPhaseAdds :: (self: *PxSimulationStatistics) -> u32 #foreign libphysx;

PxSimulationStatistics_getNbBroadPhaseRemoves :: (self: *PxSimulationStatistics) -> u32 #foreign libphysx;

PxSimulationStatistics_getRbPairStats :: (self: *PxSimulationStatistics, pairType: s32, g0: s32, g1: s32) -> u32 #foreign libphysx;

PxSimulationStatistics_new :: () -> PxSimulationStatistics #foreign libphysx;

PxPvdSceneClient_setScenePvdFlag :: (self: *PxPvdSceneClient, flag: s32, value: bool) -> void #foreign libphysx "PxPvdSceneClient_setScenePvdFlag_mut";

PxPvdSceneClient_setScenePvdFlags :: (self: *PxPvdSceneClient, flags: u8) -> void #foreign libphysx "PxPvdSceneClient_setScenePvdFlags_mut";

PxPvdSceneClient_getScenePvdFlags :: (self: *PxPvdSceneClient) -> u8 #foreign libphysx;

PxPvdSceneClient_updateCamera :: (self: *PxPvdSceneClient, name: *u8, origin: *Vector3, up: *Vector3, target: *Vector3) -> void #foreign libphysx "PxPvdSceneClient_updateCamera_mut";

PxPvdSceneClient_drawPoints :: (self: *PxPvdSceneClient, points: *PxDebugPoint, count: u32) -> void #foreign libphysx "PxPvdSceneClient_drawPoints_mut";

PxPvdSceneClient_drawLines :: (self: *PxPvdSceneClient, lines: *PxDebugLine, count: u32) -> void #foreign libphysx "PxPvdSceneClient_drawLines_mut";

PxPvdSceneClient_drawTriangles :: (self: *PxPvdSceneClient, triangles: *PxDebugTriangle, count: u32) -> void #foreign libphysx "PxPvdSceneClient_drawTriangles_mut";

PxPvdSceneClient_drawText :: (self: *PxPvdSceneClient, text: *PxDebugText) -> void #foreign libphysx "PxPvdSceneClient_drawText_mut";

PxDominanceGroupPair_new :: (a: u8, b: u8) -> PxDominanceGroupPair #foreign libphysx;

PxBroadPhaseCallback_delete :: (self: *PxBroadPhaseCallback) -> void #foreign libphysx;

PxBroadPhaseCallback_onObjectOutOfBounds :: (self: *PxBroadPhaseCallback, shape: *PxShape, actor: *PxActor) -> void #foreign libphysx "PxBroadPhaseCallback_onObjectOutOfBounds_mut";

PxBroadPhaseCallback_onObjectOutOfBounds_mut :: (self: *PxBroadPhaseCallback, aggregate: *PxAggregate) -> void #foreign libphysx "PxBroadPhaseCallback_onObjectOutOfBounds_mut_1";

PxScene_release :: (self: *PxScene) -> void #foreign libphysx "PxScene_release_mut";

PxScene_setFlag :: (self: *PxScene, flag: s32, value: bool) -> void #foreign libphysx "PxScene_setFlag_mut";

PxScene_getFlags :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_setLimits :: (self: *PxScene, limits: *PxSceneLimits) -> void #foreign libphysx "PxScene_setLimits_mut";

PxScene_getLimits :: (self: *PxScene) -> PxSceneLimits #foreign libphysx;

PxScene_getPhysics :: (self: *PxScene) -> *PxPhysics #foreign libphysx "PxScene_getPhysics_mut";

PxScene_getTimestamp :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_addArticulation :: (self: *PxScene, articulation: *PxArticulationReducedCoordinate) -> bool #foreign libphysx "PxScene_addArticulation_mut";

PxScene_removeArticulation :: (self: *PxScene, articulation: *PxArticulationReducedCoordinate, wakeOnLostTouch: bool) -> void #foreign libphysx "PxScene_removeArticulation_mut";

PxScene_addActor :: (self: *PxScene, actor: *PxActor, bvh: *PxBVH) -> bool #foreign libphysx "PxScene_addActor_mut";

PxScene_addActors :: (self: *PxScene, actors: **PxActor, nbActors: u32) -> bool #foreign libphysx "PxScene_addActors_mut";

PxScene_addActors_mut :: (self: *PxScene, pruningStructure: *PxPruningStructure) -> bool #foreign libphysx "PxScene_addActors_mut_1";

PxScene_removeActor :: (self: *PxScene, actor: *PxActor, wakeOnLostTouch: bool) -> void #foreign libphysx "PxScene_removeActor_mut";

PxScene_removeActors :: (self: *PxScene, actors: **PxActor, nbActors: u32, wakeOnLostTouch: bool) -> void #foreign libphysx "PxScene_removeActors_mut";

PxScene_addAggregate :: (self: *PxScene, aggregate: *PxAggregate) -> bool #foreign libphysx "PxScene_addAggregate_mut";

PxScene_removeAggregate :: (self: *PxScene, aggregate: *PxAggregate, wakeOnLostTouch: bool) -> void #foreign libphysx "PxScene_removeAggregate_mut";

PxScene_addCollection :: (self: *PxScene, collection: *PxCollection) -> bool #foreign libphysx "PxScene_addCollection_mut";

PxScene_getNbActors :: (self: *PxScene, types: u16) -> u32 #foreign libphysx;

PxScene_getActors :: (self: *PxScene, types: u16, userBuffer: **PxActor, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxScene_getActiveActors :: (self: *PxScene, nbActorsOut: *u32) -> **PxActor #foreign libphysx "PxScene_getActiveActors_mut";

PxScene_getNbArticulations :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_getArticulations :: (self: *PxScene, userBuffer: **PxArticulationReducedCoordinate, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxScene_getNbConstraints :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_getConstraints :: (self: *PxScene, userBuffer: **PxConstraint, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxScene_getNbAggregates :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_getAggregates :: (self: *PxScene, userBuffer: **PxAggregate, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxScene_setDominanceGroupPair :: (self: *PxScene, group1: u8, group2: u8, dominance: *PxDominanceGroupPair) -> void #foreign libphysx "PxScene_setDominanceGroupPair_mut";

PxScene_getDominanceGroupPair :: (self: *PxScene, group1: u8, group2: u8) -> PxDominanceGroupPair #foreign libphysx;

PxScene_getCpuDispatcher :: (self: *PxScene) -> *PxCpuDispatcher #foreign libphysx;

PxScene_createClient :: (self: *PxScene) -> u8 #foreign libphysx "PxScene_createClient_mut";

PxScene_setSimulationEventCallback :: (self: *PxScene, callback: *PxSimulationEventCallback) -> void #foreign libphysx "PxScene_setSimulationEventCallback_mut";

PxScene_getSimulationEventCallback :: (self: *PxScene) -> *PxSimulationEventCallback #foreign libphysx;

PxScene_setContactModifyCallback :: (self: *PxScene, callback: *PxContactModifyCallback) -> void #foreign libphysx "PxScene_setContactModifyCallback_mut";

PxScene_setCCDContactModifyCallback :: (self: *PxScene, callback: *PxCCDContactModifyCallback) -> void #foreign libphysx "PxScene_setCCDContactModifyCallback_mut";

PxScene_getContactModifyCallback :: (self: *PxScene) -> *PxContactModifyCallback #foreign libphysx;

PxScene_getCCDContactModifyCallback :: (self: *PxScene) -> *PxCCDContactModifyCallback #foreign libphysx;

PxScene_setBroadPhaseCallback :: (self: *PxScene, callback: *PxBroadPhaseCallback) -> void #foreign libphysx "PxScene_setBroadPhaseCallback_mut";

PxScene_getBroadPhaseCallback :: (self: *PxScene) -> *PxBroadPhaseCallback #foreign libphysx;

PxScene_setFilterShaderData :: (self: *PxScene, data: *void, dataSize: u32) -> void #foreign libphysx "PxScene_setFilterShaderData_mut";

PxScene_getFilterShaderData :: (self: *PxScene) -> *void #foreign libphysx;

PxScene_getFilterShaderDataSize :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_resetFiltering :: (self: *PxScene, actor: *PxActor) -> bool #foreign libphysx "PxScene_resetFiltering_mut";

PxScene_resetFiltering_mut :: (self: *PxScene, actor: *PxRigidActor, shapes: **PxShape, shapeCount: u32) -> bool #foreign libphysx "PxScene_resetFiltering_mut_1";

PxScene_getKinematicKinematicFilteringMode :: (self: *PxScene) -> s32 #foreign libphysx;

PxScene_getStaticKinematicFilteringMode :: (self: *PxScene) -> s32 #foreign libphysx;

PxScene_simulate :: (self: *PxScene, elapsedTime: float, completionTask: *PxBaseTask, scratchMemBlock: *void, scratchMemBlockSize: u32, controlSimulation: bool) -> bool #foreign libphysx "PxScene_simulate_mut";

PxScene_advance :: (self: *PxScene, completionTask: *PxBaseTask) -> bool #foreign libphysx "PxScene_advance_mut";

PxScene_collide :: (self: *PxScene, elapsedTime: float, completionTask: *PxBaseTask, scratchMemBlock: *void, scratchMemBlockSize: u32, controlSimulation: bool) -> bool #foreign libphysx "PxScene_collide_mut";

PxScene_checkResults :: (self: *PxScene, block: bool) -> bool #foreign libphysx "PxScene_checkResults_mut";

PxScene_fetchCollision :: (self: *PxScene, block: bool) -> bool #foreign libphysx "PxScene_fetchCollision_mut";

PxScene_fetchResults :: (self: *PxScene, block: bool, errorState: *u32) -> bool #foreign libphysx "PxScene_fetchResults_mut";

PxScene_fetchResultsStart :: (self: *PxScene, contactPairs: **PxContactPairHeader, nbContactPairs: *u32, block: bool) -> bool #foreign libphysx "PxScene_fetchResultsStart_mut";

PxScene_processCallbacks :: (self: *PxScene, continuation: *PxBaseTask) -> void #foreign libphysx "PxScene_processCallbacks_mut";

PxScene_fetchResultsFinish :: (self: *PxScene, errorState: *u32) -> void #foreign libphysx "PxScene_fetchResultsFinish_mut";

PxScene_fetchResultsParticleSystem :: (self: *PxScene) -> void #foreign libphysx "PxScene_fetchResultsParticleSystem_mut";

PxScene_flushSimulation :: (self: *PxScene, sendPendingReports: bool) -> void #foreign libphysx "PxScene_flushSimulation_mut";

PxScene_setGravity :: (self: *PxScene, vec: *Vector3) -> void #foreign libphysx "PxScene_setGravity_mut";

PxScene_getGravity :: (self: *PxScene) -> Vector3 #foreign libphysx;

PxScene_setBounceThresholdVelocity :: (self: *PxScene, t: float) -> void #foreign libphysx "PxScene_setBounceThresholdVelocity_mut";

PxScene_getBounceThresholdVelocity :: (self: *PxScene) -> float #foreign libphysx;

PxScene_setCCDMaxPasses :: (self: *PxScene, ccdMaxPasses: u32) -> void #foreign libphysx "PxScene_setCCDMaxPasses_mut";

PxScene_getCCDMaxPasses :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_setCCDMaxSeparation :: (self: *PxScene, t: float) -> void #foreign libphysx "PxScene_setCCDMaxSeparation_mut";

PxScene_getCCDMaxSeparation :: (self: *PxScene) -> float #foreign libphysx;

PxScene_setCCDThreshold :: (self: *PxScene, t: float) -> void #foreign libphysx "PxScene_setCCDThreshold_mut";

PxScene_getCCDThreshold :: (self: *PxScene) -> float #foreign libphysx;

PxScene_setMaxBiasCoefficient :: (self: *PxScene, t: float) -> void #foreign libphysx "PxScene_setMaxBiasCoefficient_mut";

PxScene_getMaxBiasCoefficient :: (self: *PxScene) -> float #foreign libphysx;

PxScene_setFrictionOffsetThreshold :: (self: *PxScene, t: float) -> void #foreign libphysx "PxScene_setFrictionOffsetThreshold_mut";

PxScene_getFrictionOffsetThreshold :: (self: *PxScene) -> float #foreign libphysx;

PxScene_setFrictionCorrelationDistance :: (self: *PxScene, t: float) -> void #foreign libphysx "PxScene_setFrictionCorrelationDistance_mut";

PxScene_getFrictionCorrelationDistance :: (self: *PxScene) -> float #foreign libphysx;

PxScene_getFrictionType :: (self: *PxScene) -> s32 #foreign libphysx;

PxScene_getSolverType :: (self: *PxScene) -> s32 #foreign libphysx;

PxScene_setVisualizationParameter :: (self: *PxScene, param: s32, value: float) -> bool #foreign libphysx "PxScene_setVisualizationParameter_mut";

PxScene_getVisualizationParameter :: (self: *PxScene, paramEnum: s32) -> float #foreign libphysx;

PxScene_setVisualizationCullingBox :: (self: *PxScene, box: *PxBounds3) -> void #foreign libphysx "PxScene_setVisualizationCullingBox_mut";

PxScene_getVisualizationCullingBox :: (self: *PxScene) -> PxBounds3 #foreign libphysx;

PxScene_getRenderBuffer :: (self: *PxScene) -> *PxRenderBuffer #foreign libphysx "PxScene_getRenderBuffer_mut";

PxScene_getSimulationStatistics :: (self: *PxScene, stats: *PxSimulationStatistics) -> void #foreign libphysx;

PxScene_getBroadPhaseType :: (self: *PxScene) -> s32 #foreign libphysx;

PxScene_getBroadPhaseCaps :: (self: *PxScene, caps: *PxBroadPhaseCaps) -> bool #foreign libphysx;

PxScene_getNbBroadPhaseRegions :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_getBroadPhaseRegions :: (self: *PxScene, userBuffer: *PxBroadPhaseRegionInfo, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxScene_addBroadPhaseRegion :: (self: *PxScene, region: *PxBroadPhaseRegion, populateRegion: bool) -> u32 #foreign libphysx "PxScene_addBroadPhaseRegion_mut";

PxScene_removeBroadPhaseRegion :: (self: *PxScene, handle: u32) -> bool #foreign libphysx "PxScene_removeBroadPhaseRegion_mut";

PxScene_getTaskManager :: (self: *PxScene) -> *PxTaskManager #foreign libphysx;

PxScene_lockRead :: (self: *PxScene, file: *u8, line: u32) -> void #foreign libphysx "PxScene_lockRead_mut";

PxScene_unlockRead :: (self: *PxScene) -> void #foreign libphysx "PxScene_unlockRead_mut";

PxScene_lockWrite :: (self: *PxScene, file: *u8, line: u32) -> void #foreign libphysx "PxScene_lockWrite_mut";

PxScene_unlockWrite :: (self: *PxScene) -> void #foreign libphysx "PxScene_unlockWrite_mut";

PxScene_setNbContactDataBlocks :: (self: *PxScene, numBlocks: u32) -> void #foreign libphysx "PxScene_setNbContactDataBlocks_mut";

PxScene_getNbContactDataBlocksUsed :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_getMaxNbContactDataBlocksUsed :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_getContactReportStreamBufferSize :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_setSolverBatchSize :: (self: *PxScene, solverBatchSize: u32) -> void #foreign libphysx "PxScene_setSolverBatchSize_mut";

PxScene_getSolverBatchSize :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_setSolverArticulationBatchSize :: (self: *PxScene, solverBatchSize: u32) -> void #foreign libphysx "PxScene_setSolverArticulationBatchSize_mut";

PxScene_getSolverArticulationBatchSize :: (self: *PxScene) -> u32 #foreign libphysx;

PxScene_getWakeCounterResetValue :: (self: *PxScene) -> float #foreign libphysx;

PxScene_shiftOrigin :: (self: *PxScene, shift: *Vector3) -> void #foreign libphysx "PxScene_shiftOrigin_mut";

PxScene_getScenePvdClient :: (self: *PxScene) -> *PxPvdSceneClient #foreign libphysx "PxScene_getScenePvdClient_mut";

PxScene_copyArticulationData :: (self: *PxScene, data: *void, index: *void, dataType: s32, nbCopyArticulations: u32, copyEvent: *void) -> void #foreign libphysx "PxScene_copyArticulationData_mut";

PxScene_applyArticulationData :: (self: *PxScene, data: *void, index: *void, dataType: s32, nbUpdatedArticulations: u32, waitEvent: *void, signalEvent: *void) -> void #foreign libphysx "PxScene_applyArticulationData_mut";

PxScene_copySoftBodyData :: (self: *PxScene, data: **void, dataSizes: *void, softBodyIndices: *void, flag: s32, nbCopySoftBodies: u32, maxSize: u32, copyEvent: *void) -> void #foreign libphysx "PxScene_copySoftBodyData_mut";

PxScene_applySoftBodyData :: (self: *PxScene, data: **void, dataSizes: *void, softBodyIndices: *void, flag: s32, nbUpdatedSoftBodies: u32, maxSize: u32, applyEvent: *void) -> void #foreign libphysx "PxScene_applySoftBodyData_mut";

PxScene_copyContactData :: (self: *PxScene, data: *void, maxContactPairs: u32, numContactPairs: *void, copyEvent: *void) -> void #foreign libphysx "PxScene_copyContactData_mut";

PxScene_copyBodyData :: (self: *PxScene, data: *PxGpuBodyData, index: *PxGpuActorPair, nbCopyActors: u32, copyEvent: *void) -> void #foreign libphysx "PxScene_copyBodyData_mut";

PxScene_applyActorData :: (self: *PxScene, data: *void, index: *PxGpuActorPair, flag: s32, nbUpdatedActors: u32, waitEvent: *void, signalEvent: *void) -> void #foreign libphysx "PxScene_applyActorData_mut";

PxScene_computeDenseJacobians :: (self: *PxScene, indices: *PxIndexDataPair, nbIndices: u32, computeEvent: *void) -> void #foreign libphysx "PxScene_computeDenseJacobians_mut";

PxScene_computeGeneralizedMassMatrices :: (self: *PxScene, indices: *PxIndexDataPair, nbIndices: u32, computeEvent: *void) -> void #foreign libphysx "PxScene_computeGeneralizedMassMatrices_mut";

PxScene_computeGeneralizedGravityForces :: (self: *PxScene, indices: *PxIndexDataPair, nbIndices: u32, computeEvent: *void) -> void #foreign libphysx "PxScene_computeGeneralizedGravityForces_mut";

PxScene_computeCoriolisAndCentrifugalForces :: (self: *PxScene, indices: *PxIndexDataPair, nbIndices: u32, computeEvent: *void) -> void #foreign libphysx "PxScene_computeCoriolisAndCentrifugalForces_mut";

PxScene_getGpuDynamicsConfig :: (self: *PxScene) -> PxgDynamicsMemoryConfig #foreign libphysx;

PxScene_applyParticleBufferData :: (self: *PxScene, indices: *u32, bufferIndexPair: *PxGpuParticleBufferIndexPair, flags: *u32, nbUpdatedBuffers: u32, waitEvent: *void, signalEvent: *void) -> void #foreign libphysx "PxScene_applyParticleBufferData_mut";

PxSceneReadLock_new_alloc :: (scene: *PxScene, file: *u8, line: u32) -> *PxSceneReadLock #foreign libphysx;

PxSceneReadLock_delete :: (self: *PxSceneReadLock) -> void #foreign libphysx;

PxSceneWriteLock_new_alloc :: (scene: *PxScene, file: *u8, line: u32) -> *PxSceneWriteLock #foreign libphysx;

PxSceneWriteLock_delete :: (self: *PxSceneWriteLock) -> void #foreign libphysx;

PxContactPairExtraDataItem_new :: () -> PxContactPairExtraDataItem #foreign libphysx;

PxContactPairVelocity_new :: () -> PxContactPairVelocity #foreign libphysx;

PxContactPairPose_new :: () -> PxContactPairPose #foreign libphysx;

PxContactPairIndex_new :: () -> PxContactPairIndex #foreign libphysx;

PxContactPairExtraDataIterator_new :: (stream: *u8, size: u32) -> PxContactPairExtraDataIterator #foreign libphysx;

PxContactPairExtraDataIterator_nextItemSet :: (self: *PxContactPairExtraDataIterator) -> bool #foreign libphysx "PxContactPairExtraDataIterator_nextItemSet_mut";

PxContactPairHeader_new :: () -> PxContactPairHeader #foreign libphysx;

PxContactPair_new :: () -> PxContactPair #foreign libphysx;

PxContactPair_extractContacts :: (self: *PxContactPair, userBuffer: *PxContactPairPoint, bufferSize: u32) -> u32 #foreign libphysx;

PxContactPair_bufferContacts :: (self: *PxContactPair, newPair: *PxContactPair, bufferMemory: *u8) -> void #foreign libphysx;

PxContactPair_getInternalFaceIndices :: (self: *PxContactPair) -> *u32 #foreign libphysx;

PxTriggerPair_new :: () -> PxTriggerPair #foreign libphysx;

PxConstraintInfo_new :: () -> PxConstraintInfo #foreign libphysx;

PxConstraintInfo_new :: (c: *PxConstraint, extRef: *void, t: u32) -> PxConstraintInfo #foreign libphysx "PxConstraintInfo_new_1";

PxSimulationEventCallback_onConstraintBreak :: (self: *PxSimulationEventCallback, constraints: *PxConstraintInfo, count: u32) -> void #foreign libphysx "PxSimulationEventCallback_onConstraintBreak_mut";

PxSimulationEventCallback_onWake :: (self: *PxSimulationEventCallback, actors: **PxActor, count: u32) -> void #foreign libphysx "PxSimulationEventCallback_onWake_mut";

PxSimulationEventCallback_onSleep :: (self: *PxSimulationEventCallback, actors: **PxActor, count: u32) -> void #foreign libphysx "PxSimulationEventCallback_onSleep_mut";

PxSimulationEventCallback_onContact :: (self: *PxSimulationEventCallback, pairHeader: *PxContactPairHeader, pairs: *PxContactPair, nbPairs: u32) -> void #foreign libphysx "PxSimulationEventCallback_onContact_mut";

PxSimulationEventCallback_onTrigger :: (self: *PxSimulationEventCallback, pairs: *PxTriggerPair, count: u32) -> void #foreign libphysx "PxSimulationEventCallback_onTrigger_mut";

PxSimulationEventCallback_onAdvance :: (self: *PxSimulationEventCallback, bodyBuffer: **PxRigidBody, poseBuffer: *PxTransform, count: u32) -> void #foreign libphysx "PxSimulationEventCallback_onAdvance_mut";

PxSimulationEventCallback_delete :: (self: *PxSimulationEventCallback) -> void #foreign libphysx;

PxFEMParameters_new :: () -> PxFEMParameters #foreign libphysx;

PxPruningStructure_release :: (self: *PxPruningStructure) -> void #foreign libphysx "PxPruningStructure_release_mut";

PxPruningStructure_getRigidActors :: (self: *PxPruningStructure, userBuffer: **PxRigidActor, bufferSize: u32, startIndex: u32) -> u32 #foreign libphysx;

PxPruningStructure_getNbRigidActors :: (self: *PxPruningStructure) -> u32 #foreign libphysx;

PxPruningStructure_getStaticMergeData :: (self: *PxPruningStructure) -> *void #foreign libphysx;

PxPruningStructure_getDynamicMergeData :: (self: *PxPruningStructure) -> *void #foreign libphysx;

PxPruningStructure_getConcreteTypeName :: (self: *PxPruningStructure) -> *u8 #foreign libphysx;

PxExtendedVec3_new :: () -> PxExtendedVec3 #foreign libphysx;

PxExtendedVec3_new :: (_x: float64, _y: float64, _z: float64) -> PxExtendedVec3 #foreign libphysx "PxExtendedVec3_new_1";

PxExtendedVec3_isZero :: (self: *PxExtendedVec3) -> bool #foreign libphysx;

PxExtendedVec3_dot :: (self: *PxExtendedVec3, v: *Vector3) -> float64 #foreign libphysx;

PxExtendedVec3_distanceSquared :: (self: *PxExtendedVec3, v: *PxExtendedVec3) -> float64 #foreign libphysx;

PxExtendedVec3_magnitudeSquared :: (self: *PxExtendedVec3) -> float64 #foreign libphysx;

PxExtendedVec3_magnitude :: (self: *PxExtendedVec3) -> float64 #foreign libphysx;

PxExtendedVec3_normalize :: (self: *PxExtendedVec3) -> float64 #foreign libphysx "PxExtendedVec3_normalize_mut";

PxExtendedVec3_isFinite :: (self: *PxExtendedVec3) -> bool #foreign libphysx;

PxExtendedVec3_maximum :: (self: *PxExtendedVec3, v: *PxExtendedVec3) -> void #foreign libphysx "PxExtendedVec3_maximum_mut";

PxExtendedVec3_minimum :: (self: *PxExtendedVec3, v: *PxExtendedVec3) -> void #foreign libphysx "PxExtendedVec3_minimum_mut";

PxExtendedVec3_set :: (self: *PxExtendedVec3, x_: float64, y_: float64, z_: float64) -> void #foreign libphysx "PxExtendedVec3_set_mut";

PxExtendedVec3_setPlusInfinity :: (self: *PxExtendedVec3) -> void #foreign libphysx "PxExtendedVec3_setPlusInfinity_mut";

PxExtendedVec3_setMinusInfinity :: (self: *PxExtendedVec3) -> void #foreign libphysx "PxExtendedVec3_setMinusInfinity_mut";

PxExtendedVec3_cross :: (self: *PxExtendedVec3, left: *PxExtendedVec3, right: *Vector3) -> void #foreign libphysx "PxExtendedVec3_cross_mut";

PxExtendedVec3_cross_mut :: (self: *PxExtendedVec3, left: *PxExtendedVec3, right: *PxExtendedVec3) -> void #foreign libphysx "PxExtendedVec3_cross_mut_1";

PxExtendedVec3_cross :: (self: *PxExtendedVec3, v: *PxExtendedVec3) -> PxExtendedVec3 #foreign libphysx;

PxExtendedVec3_cross_mut :: (self: *PxExtendedVec3, left: *Vector3, right: *PxExtendedVec3) -> void #foreign libphysx "PxExtendedVec3_cross_mut_2";

toVec3 :: (v: *PxExtendedVec3) -> Vector3 #foreign libphysx "phys_toVec3";

PxObstacle_getType :: (self: *PxObstacle) -> s32 #foreign libphysx;

PxBoxObstacle_new :: () -> PxBoxObstacle #foreign libphysx;

PxCapsuleObstacle_new :: () -> PxCapsuleObstacle #foreign libphysx;

PxObstacleContext_release :: (self: *PxObstacleContext) -> void #foreign libphysx "PxObstacleContext_release_mut";

PxObstacleContext_getControllerManager :: (self: *PxObstacleContext) -> *PxControllerManager #foreign libphysx;

PxObstacleContext_addObstacle :: (self: *PxObstacleContext, obstacle: *PxObstacle) -> u32 #foreign libphysx "PxObstacleContext_addObstacle_mut";

PxObstacleContext_removeObstacle :: (self: *PxObstacleContext, handle: u32) -> bool #foreign libphysx "PxObstacleContext_removeObstacle_mut";

PxObstacleContext_updateObstacle :: (self: *PxObstacleContext, handle: u32, obstacle: *PxObstacle) -> bool #foreign libphysx "PxObstacleContext_updateObstacle_mut";

PxObstacleContext_getNbObstacles :: (self: *PxObstacleContext) -> u32 #foreign libphysx;

PxObstacleContext_getObstacle :: (self: *PxObstacleContext, i: u32) -> *PxObstacle #foreign libphysx;

PxObstacleContext_getObstacleByHandle :: (self: *PxObstacleContext, handle: u32) -> *PxObstacle #foreign libphysx;

PxUserControllerHitReport_onShapeHit :: (self: *PxUserControllerHitReport, hit: *PxControllerShapeHit) -> void #foreign libphysx "PxUserControllerHitReport_onShapeHit_mut";

PxUserControllerHitReport_onControllerHit :: (self: *PxUserControllerHitReport, hit: *PxControllersHit) -> void #foreign libphysx "PxUserControllerHitReport_onControllerHit_mut";

PxUserControllerHitReport_onObstacleHit :: (self: *PxUserControllerHitReport, hit: *PxControllerObstacleHit) -> void #foreign libphysx "PxUserControllerHitReport_onObstacleHit_mut";

PxControllerFilterCallback_delete :: (self: *PxControllerFilterCallback) -> void #foreign libphysx;

PxControllerFilterCallback_filter :: (self: *PxControllerFilterCallback, a: *PxController, b: *PxController) -> bool #foreign libphysx "PxControllerFilterCallback_filter_mut";

PxControllerFilters_new :: (filterData: *PxFilterData, cb: *PxQueryFilterCallback, cctFilterCb: *PxControllerFilterCallback) -> PxControllerFilters #foreign libphysx;

PxControllerDesc_isValid :: (self: *PxControllerDesc) -> bool #foreign libphysx;

PxControllerDesc_getType :: (self: *PxControllerDesc) -> s32 #foreign libphysx;

PxController_getType :: (self: *PxController) -> s32 #foreign libphysx;

PxController_release :: (self: *PxController) -> void #foreign libphysx "PxController_release_mut";

PxController_move :: (self: *PxController, disp: *Vector3, minDist: float, elapsedTime: float, filters: *PxControllerFilters, obstacles: *PxObstacleContext) -> u8 #foreign libphysx "PxController_move_mut";

PxController_setPosition :: (self: *PxController, position: *PxExtendedVec3) -> bool #foreign libphysx "PxController_setPosition_mut";

PxController_getPosition :: (self: *PxController) -> *PxExtendedVec3 #foreign libphysx;

PxController_setFootPosition :: (self: *PxController, position: *PxExtendedVec3) -> bool #foreign libphysx "PxController_setFootPosition_mut";

PxController_getFootPosition :: (self: *PxController) -> PxExtendedVec3 #foreign libphysx;

PxController_getActor :: (self: *PxController) -> *PxRigidDynamic #foreign libphysx;

PxController_setStepOffset :: (self: *PxController, offset: float) -> void #foreign libphysx "PxController_setStepOffset_mut";

PxController_getStepOffset :: (self: *PxController) -> float #foreign libphysx;

PxController_setNonWalkableMode :: (self: *PxController, flag: s32) -> void #foreign libphysx "PxController_setNonWalkableMode_mut";

PxController_getNonWalkableMode :: (self: *PxController) -> s32 #foreign libphysx;

PxController_getContactOffset :: (self: *PxController) -> float #foreign libphysx;

PxController_setContactOffset :: (self: *PxController, offset: float) -> void #foreign libphysx "PxController_setContactOffset_mut";

PxController_getUpDirection :: (self: *PxController) -> Vector3 #foreign libphysx;

PxController_setUpDirection :: (self: *PxController, up: *Vector3) -> void #foreign libphysx "PxController_setUpDirection_mut";

PxController_getSlopeLimit :: (self: *PxController) -> float #foreign libphysx;

PxController_setSlopeLimit :: (self: *PxController, slopeLimit: float) -> void #foreign libphysx "PxController_setSlopeLimit_mut";

PxController_invalidateCache :: (self: *PxController) -> void #foreign libphysx "PxController_invalidateCache_mut";

PxController_getScene :: (self: *PxController) -> *PxScene #foreign libphysx "PxController_getScene_mut";

PxController_getUserData :: (self: *PxController) -> *void #foreign libphysx;

PxController_setUserData :: (self: *PxController, userData: *void) -> void #foreign libphysx "PxController_setUserData_mut";

PxController_getState :: (self: *PxController, state: *PxControllerState) -> void #foreign libphysx;

PxController_getStats :: (self: *PxController, stats: *PxControllerStats) -> void #foreign libphysx;

PxController_resize :: (self: *PxController, height: float) -> void #foreign libphysx "PxController_resize_mut";

PxBoxControllerDesc_new_alloc :: () -> *PxBoxControllerDesc #foreign libphysx;

PxBoxControllerDesc_delete :: (self: *PxBoxControllerDesc) -> void #foreign libphysx;

PxBoxControllerDesc_setToDefault :: (self: *PxBoxControllerDesc) -> void #foreign libphysx "PxBoxControllerDesc_setToDefault_mut";

PxBoxControllerDesc_isValid :: (self: *PxBoxControllerDesc) -> bool #foreign libphysx;

PxBoxController_getHalfHeight :: (self: *PxBoxController) -> float #foreign libphysx;

PxBoxController_getHalfSideExtent :: (self: *PxBoxController) -> float #foreign libphysx;

PxBoxController_getHalfForwardExtent :: (self: *PxBoxController) -> float #foreign libphysx;

PxBoxController_setHalfHeight :: (self: *PxBoxController, halfHeight: float) -> bool #foreign libphysx "PxBoxController_setHalfHeight_mut";

PxBoxController_setHalfSideExtent :: (self: *PxBoxController, halfSideExtent: float) -> bool #foreign libphysx "PxBoxController_setHalfSideExtent_mut";

PxBoxController_setHalfForwardExtent :: (self: *PxBoxController, halfForwardExtent: float) -> bool #foreign libphysx "PxBoxController_setHalfForwardExtent_mut";

PxCapsuleControllerDesc_new_alloc :: () -> *PxCapsuleControllerDesc #foreign libphysx;

PxCapsuleControllerDesc_delete :: (self: *PxCapsuleControllerDesc) -> void #foreign libphysx;

PxCapsuleControllerDesc_setToDefault :: (self: *PxCapsuleControllerDesc) -> void #foreign libphysx "PxCapsuleControllerDesc_setToDefault_mut";

PxCapsuleControllerDesc_isValid :: (self: *PxCapsuleControllerDesc) -> bool #foreign libphysx;

PxCapsuleController_getRadius :: (self: *PxCapsuleController) -> float #foreign libphysx;

PxCapsuleController_setRadius :: (self: *PxCapsuleController, radius: float) -> bool #foreign libphysx "PxCapsuleController_setRadius_mut";

PxCapsuleController_getHeight :: (self: *PxCapsuleController) -> float #foreign libphysx;

PxCapsuleController_setHeight :: (self: *PxCapsuleController, height: float) -> bool #foreign libphysx "PxCapsuleController_setHeight_mut";

PxCapsuleController_getClimbingMode :: (self: *PxCapsuleController) -> s32 #foreign libphysx;

PxCapsuleController_setClimbingMode :: (self: *PxCapsuleController, mode: s32) -> bool #foreign libphysx "PxCapsuleController_setClimbingMode_mut";

PxControllerBehaviorCallback_getBehaviorFlags :: (self: *PxControllerBehaviorCallback, shape: *PxShape, actor: *PxActor) -> u8 #foreign libphysx "PxControllerBehaviorCallback_getBehaviorFlags_mut";

PxControllerBehaviorCallback_getBehaviorFlags_mut :: (self: *PxControllerBehaviorCallback, controller: *PxController) -> u8 #foreign libphysx "PxControllerBehaviorCallback_getBehaviorFlags_mut_1";

PxControllerBehaviorCallback_getBehaviorFlags_mut :: (self: *PxControllerBehaviorCallback, obstacle: *PxObstacle) -> u8 #foreign libphysx "PxControllerBehaviorCallback_getBehaviorFlags_mut_2";

PxControllerManager_release :: (self: *PxControllerManager) -> void #foreign libphysx "PxControllerManager_release_mut";

PxControllerManager_getScene :: (self: *PxControllerManager) -> *PxScene #foreign libphysx;

PxControllerManager_getNbControllers :: (self: *PxControllerManager) -> u32 #foreign libphysx;

PxControllerManager_getController :: (self: *PxControllerManager, index: u32) -> *PxController #foreign libphysx "PxControllerManager_getController_mut";

PxControllerManager_createController :: (self: *PxControllerManager, desc: *PxControllerDesc) -> *PxController #foreign libphysx "PxControllerManager_createController_mut";

PxControllerManager_purgeControllers :: (self: *PxControllerManager) -> void #foreign libphysx "PxControllerManager_purgeControllers_mut";

PxControllerManager_getRenderBuffer :: (self: *PxControllerManager) -> *PxRenderBuffer #foreign libphysx "PxControllerManager_getRenderBuffer_mut";

PxControllerManager_setDebugRenderingFlags :: (self: *PxControllerManager, flags: u32) -> void #foreign libphysx "PxControllerManager_setDebugRenderingFlags_mut";

PxControllerManager_getNbObstacleContexts :: (self: *PxControllerManager) -> u32 #foreign libphysx;

PxControllerManager_getObstacleContext :: (self: *PxControllerManager, index: u32) -> *PxObstacleContext #foreign libphysx "PxControllerManager_getObstacleContext_mut";

PxControllerManager_createObstacleContext :: (self: *PxControllerManager) -> *PxObstacleContext #foreign libphysx "PxControllerManager_createObstacleContext_mut";

PxControllerManager_computeInteractions :: (self: *PxControllerManager, elapsedTime: float, cctFilterCb: *PxControllerFilterCallback) -> void #foreign libphysx "PxControllerManager_computeInteractions_mut";

PxControllerManager_setTessellation :: (self: *PxControllerManager, flag: bool, maxEdgeLength: float) -> void #foreign libphysx "PxControllerManager_setTessellation_mut";

PxControllerManager_setOverlapRecoveryModule :: (self: *PxControllerManager, flag: bool) -> void #foreign libphysx "PxControllerManager_setOverlapRecoveryModule_mut";

PxControllerManager_setPreciseSweeps :: (self: *PxControllerManager, flag: bool) -> void #foreign libphysx "PxControllerManager_setPreciseSweeps_mut";

PxControllerManager_setPreventVerticalSlidingAgainstCeiling :: (self: *PxControllerManager, flag: bool) -> void #foreign libphysx "PxControllerManager_setPreventVerticalSlidingAgainstCeiling_mut";

PxControllerManager_shiftOrigin :: (self: *PxControllerManager, shift: *Vector3) -> void #foreign libphysx "PxControllerManager_shiftOrigin_mut";

PxCreateControllerManager :: (scene: *PxScene, lockingEnabled: bool) -> *PxControllerManager #foreign libphysx "phys_PxCreateControllerManager";

PxDim3_new :: () -> PxDim3 #foreign libphysx;

PxSDFDesc_new :: () -> PxSDFDesc #foreign libphysx;

PxSDFDesc_isValid :: (self: *PxSDFDesc) -> bool #foreign libphysx;

PxConvexMeshDesc_new :: () -> PxConvexMeshDesc #foreign libphysx;

PxConvexMeshDesc_setToDefault :: (self: *PxConvexMeshDesc) -> void #foreign libphysx "PxConvexMeshDesc_setToDefault_mut";

PxConvexMeshDesc_isValid :: (self: *PxConvexMeshDesc) -> bool #foreign libphysx;

PxTriangleMeshDesc_new :: () -> PxTriangleMeshDesc #foreign libphysx;

PxTriangleMeshDesc_setToDefault :: (self: *PxTriangleMeshDesc) -> void #foreign libphysx "PxTriangleMeshDesc_setToDefault_mut";

PxTriangleMeshDesc_isValid :: (self: *PxTriangleMeshDesc) -> bool #foreign libphysx;

PxTetrahedronMeshDesc_new :: () -> PxTetrahedronMeshDesc #foreign libphysx;

PxTetrahedronMeshDesc_isValid :: (self: *PxTetrahedronMeshDesc) -> bool #foreign libphysx;

PxSoftBodySimulationDataDesc_new :: () -> PxSoftBodySimulationDataDesc #foreign libphysx;

PxSoftBodySimulationDataDesc_isValid :: (self: *PxSoftBodySimulationDataDesc) -> bool #foreign libphysx;

PxBVH34MidphaseDesc_setToDefault :: (self: *PxBVH34MidphaseDesc) -> void #foreign libphysx "PxBVH34MidphaseDesc_setToDefault_mut";

PxBVH34MidphaseDesc_isValid :: (self: *PxBVH34MidphaseDesc) -> bool #foreign libphysx;

PxMidphaseDesc_new :: () -> PxMidphaseDesc #foreign libphysx;

PxMidphaseDesc_getType :: (self: *PxMidphaseDesc) -> s32 #foreign libphysx;

PxMidphaseDesc_setToDefault :: (self: *PxMidphaseDesc, type: s32) -> void #foreign libphysx "PxMidphaseDesc_setToDefault_mut";

PxMidphaseDesc_isValid :: (self: *PxMidphaseDesc) -> bool #foreign libphysx;

PxBVHDesc_new :: () -> PxBVHDesc #foreign libphysx;

PxBVHDesc_setToDefault :: (self: *PxBVHDesc) -> void #foreign libphysx "PxBVHDesc_setToDefault_mut";

PxBVHDesc_isValid :: (self: *PxBVHDesc) -> bool #foreign libphysx;

PxCookingParams_new :: (sc: *PxTolerancesScale) -> PxCookingParams #foreign libphysx;

PxGetStandaloneInsertionCallback :: () -> *PxInsertionCallback #foreign libphysx "phys_PxGetStandaloneInsertionCallback";

PxCookBVH :: (desc: *PxBVHDesc, stream: *PxOutputStream) -> bool #foreign libphysx "phys_PxCookBVH";

PxCreateBVH :: (desc: *PxBVHDesc, insertionCallback: *PxInsertionCallback) -> *PxBVH #foreign libphysx "phys_PxCreateBVH";

PxCookHeightField :: (desc: *PxHeightFieldDesc, stream: *PxOutputStream) -> bool #foreign libphysx "phys_PxCookHeightField";

PxCreateHeightField :: (desc: *PxHeightFieldDesc, insertionCallback: *PxInsertionCallback) -> *PxHeightField #foreign libphysx "phys_PxCreateHeightField";

PxCookConvexMesh :: (params: *PxCookingParams, desc: *PxConvexMeshDesc, stream: *PxOutputStream, condition: *s32) -> bool #foreign libphysx "phys_PxCookConvexMesh";

PxCreateConvexMesh :: (params: *PxCookingParams, desc: *PxConvexMeshDesc, insertionCallback: *PxInsertionCallback, condition: *s32) -> *PxConvexMesh #foreign libphysx "phys_PxCreateConvexMesh";

PxValidateConvexMesh :: (params: *PxCookingParams, desc: *PxConvexMeshDesc) -> bool #foreign libphysx "phys_PxValidateConvexMesh";

PxComputeHullPolygons :: (params: *PxCookingParams, mesh: *PxSimpleTriangleMesh, inCallback: *PxAllocatorCallback, nbVerts: *u32, vertices: **Vector3, nbIndices: *u32, indices: **u32, nbPolygons: *u32, hullPolygons: **PxHullPolygon) -> bool #foreign libphysx "phys_PxComputeHullPolygons";

PxValidateTriangleMesh :: (params: *PxCookingParams, desc: *PxTriangleMeshDesc) -> bool #foreign libphysx "phys_PxValidateTriangleMesh";

PxCreateTriangleMesh :: (params: *PxCookingParams, desc: *PxTriangleMeshDesc, insertionCallback: *PxInsertionCallback, condition: *s32) -> *PxTriangleMesh #foreign libphysx "phys_PxCreateTriangleMesh";

PxCookTriangleMesh :: (params: *PxCookingParams, desc: *PxTriangleMeshDesc, stream: *PxOutputStream, condition: *s32) -> bool #foreign libphysx "phys_PxCookTriangleMesh";

PxDefaultMemoryOutputStream_new_alloc :: (allocator: *PxAllocatorCallback) -> *PxDefaultMemoryOutputStream #foreign libphysx;

PxDefaultMemoryOutputStream_delete :: (self: *PxDefaultMemoryOutputStream) -> void #foreign libphysx;

PxDefaultMemoryOutputStream_write :: (self: *PxDefaultMemoryOutputStream, src: *void, count: u32) -> u32 #foreign libphysx "PxDefaultMemoryOutputStream_write_mut";

PxDefaultMemoryOutputStream_getSize :: (self: *PxDefaultMemoryOutputStream) -> u32 #foreign libphysx;

PxDefaultMemoryOutputStream_getData :: (self: *PxDefaultMemoryOutputStream) -> *u8 #foreign libphysx;

PxDefaultMemoryInputData_new_alloc :: (data: *u8, length: u32) -> *PxDefaultMemoryInputData #foreign libphysx;

PxDefaultMemoryInputData_read :: (self: *PxDefaultMemoryInputData, dest: *void, count: u32) -> u32 #foreign libphysx "PxDefaultMemoryInputData_read_mut";

PxDefaultMemoryInputData_getLength :: (self: *PxDefaultMemoryInputData) -> u32 #foreign libphysx;

PxDefaultMemoryInputData_seek :: (self: *PxDefaultMemoryInputData, pos: u32) -> void #foreign libphysx "PxDefaultMemoryInputData_seek_mut";

PxDefaultMemoryInputData_tell :: (self: *PxDefaultMemoryInputData) -> u32 #foreign libphysx;

PxDefaultFileOutputStream_new_alloc :: (name: *u8) -> *PxDefaultFileOutputStream #foreign libphysx;

PxDefaultFileOutputStream_delete :: (self: *PxDefaultFileOutputStream) -> void #foreign libphysx;

PxDefaultFileOutputStream_write :: (self: *PxDefaultFileOutputStream, src: *void, count: u32) -> u32 #foreign libphysx "PxDefaultFileOutputStream_write_mut";

PxDefaultFileOutputStream_isValid :: (self: *PxDefaultFileOutputStream) -> bool #foreign libphysx "PxDefaultFileOutputStream_isValid_mut";

PxDefaultFileInputData_new_alloc :: (name: *u8) -> *PxDefaultFileInputData #foreign libphysx;

PxDefaultFileInputData_delete :: (self: *PxDefaultFileInputData) -> void #foreign libphysx;

PxDefaultFileInputData_read :: (self: *PxDefaultFileInputData, dest: *void, count: u32) -> u32 #foreign libphysx "PxDefaultFileInputData_read_mut";

PxDefaultFileInputData_seek :: (self: *PxDefaultFileInputData, pos: u32) -> void #foreign libphysx "PxDefaultFileInputData_seek_mut";

PxDefaultFileInputData_tell :: (self: *PxDefaultFileInputData) -> u32 #foreign libphysx;

PxDefaultFileInputData_getLength :: (self: *PxDefaultFileInputData) -> u32 #foreign libphysx;

PxDefaultFileInputData_isValid :: (self: *PxDefaultFileInputData) -> bool #foreign libphysx;

platformAlignedAlloc :: (size: u64) -> *void #foreign libphysx "phys_platformAlignedAlloc";

platformAlignedFree :: (ptr: *void) -> void #foreign libphysx "phys_platformAlignedFree";

PxDefaultAllocator_allocate :: (self: *PxDefaultAllocator, size: u64, anon_param1: *u8, anon_param2: *u8, anon_param3: s32) -> *void #foreign libphysx "PxDefaultAllocator_allocate_mut";

PxDefaultAllocator_deallocate :: (self: *PxDefaultAllocator, ptr: *void) -> void #foreign libphysx "PxDefaultAllocator_deallocate_mut";

PxDefaultAllocator_delete :: (self: *PxDefaultAllocator) -> void #foreign libphysx;

PxJoint_setActors :: (self: *PxJoint, actor0: *PxRigidActor, actor1: *PxRigidActor) -> void #foreign libphysx "PxJoint_setActors_mut";

PxJoint_getActors :: (self: *PxJoint, actor0: **PxRigidActor, actor1: **PxRigidActor) -> void #foreign libphysx;

PxJoint_setLocalPose :: (self: *PxJoint, actor: s32, localPose: *PxTransform) -> void #foreign libphysx "PxJoint_setLocalPose_mut";

PxJoint_getLocalPose :: (self: *PxJoint, actor: s32) -> PxTransform #foreign libphysx;

PxJoint_getRelativeTransform :: (self: *PxJoint) -> PxTransform #foreign libphysx;

PxJoint_getRelativeLinearVelocity :: (self: *PxJoint) -> Vector3 #foreign libphysx;

PxJoint_getRelativeAngularVelocity :: (self: *PxJoint) -> Vector3 #foreign libphysx;

PxJoint_setBreakForce :: (self: *PxJoint, force: float, torque: float) -> void #foreign libphysx "PxJoint_setBreakForce_mut";

PxJoint_getBreakForce :: (self: *PxJoint, force: *float, torque: *float) -> void #foreign libphysx;

PxJoint_setConstraintFlags :: (self: *PxJoint, flags: u16) -> void #foreign libphysx "PxJoint_setConstraintFlags_mut";

PxJoint_setConstraintFlag :: (self: *PxJoint, flag: s32, value: bool) -> void #foreign libphysx "PxJoint_setConstraintFlag_mut";

PxJoint_getConstraintFlags :: (self: *PxJoint) -> u16 #foreign libphysx;

PxJoint_setInvMassScale0 :: (self: *PxJoint, invMassScale: float) -> void #foreign libphysx "PxJoint_setInvMassScale0_mut";

PxJoint_getInvMassScale0 :: (self: *PxJoint) -> float #foreign libphysx;

PxJoint_setInvInertiaScale0 :: (self: *PxJoint, invInertiaScale: float) -> void #foreign libphysx "PxJoint_setInvInertiaScale0_mut";

PxJoint_getInvInertiaScale0 :: (self: *PxJoint) -> float #foreign libphysx;

PxJoint_setInvMassScale1 :: (self: *PxJoint, invMassScale: float) -> void #foreign libphysx "PxJoint_setInvMassScale1_mut";

PxJoint_getInvMassScale1 :: (self: *PxJoint) -> float #foreign libphysx;

PxJoint_setInvInertiaScale1 :: (self: *PxJoint, invInertiaScale: float) -> void #foreign libphysx "PxJoint_setInvInertiaScale1_mut";

PxJoint_getInvInertiaScale1 :: (self: *PxJoint) -> float #foreign libphysx;

PxJoint_getConstraint :: (self: *PxJoint) -> *PxConstraint #foreign libphysx;

PxJoint_setName :: (self: *PxJoint, name: *u8) -> void #foreign libphysx "PxJoint_setName_mut";

PxJoint_getName :: (self: *PxJoint) -> *u8 #foreign libphysx;

PxJoint_release :: (self: *PxJoint) -> void #foreign libphysx "PxJoint_release_mut";

PxJoint_getScene :: (self: *PxJoint) -> *PxScene #foreign libphysx;

PxJoint_getBinaryMetaData :: (stream: *PxOutputStream) -> void #foreign libphysx;

PxSpring_new :: (stiffness_: float, damping_: float) -> PxSpring #foreign libphysx;

PxSetJointGlobalFrame :: (joint: *PxJoint, wsAnchor: *Vector3, wsAxis: *Vector3) -> void #foreign libphysx "phys_PxSetJointGlobalFrame";

PxDistanceJointCreate :: (physics: *PxPhysics, actor0: *PxRigidActor, localFrame0: *PxTransform, actor1: *PxRigidActor, localFrame1: *PxTransform) -> *PxDistanceJoint #foreign libphysx "phys_PxDistanceJointCreate";

PxDistanceJoint_getDistance :: (self: *PxDistanceJoint) -> float #foreign libphysx;

PxDistanceJoint_setMinDistance :: (self: *PxDistanceJoint, distance: float) -> void #foreign libphysx "PxDistanceJoint_setMinDistance_mut";

PxDistanceJoint_getMinDistance :: (self: *PxDistanceJoint) -> float #foreign libphysx;

PxDistanceJoint_setMaxDistance :: (self: *PxDistanceJoint, distance: float) -> void #foreign libphysx "PxDistanceJoint_setMaxDistance_mut";

PxDistanceJoint_getMaxDistance :: (self: *PxDistanceJoint) -> float #foreign libphysx;

PxDistanceJoint_setTolerance :: (self: *PxDistanceJoint, tolerance: float) -> void #foreign libphysx "PxDistanceJoint_setTolerance_mut";

PxDistanceJoint_getTolerance :: (self: *PxDistanceJoint) -> float #foreign libphysx;

PxDistanceJoint_setStiffness :: (self: *PxDistanceJoint, stiffness: float) -> void #foreign libphysx "PxDistanceJoint_setStiffness_mut";

PxDistanceJoint_getStiffness :: (self: *PxDistanceJoint) -> float #foreign libphysx;

PxDistanceJoint_setDamping :: (self: *PxDistanceJoint, damping: float) -> void #foreign libphysx "PxDistanceJoint_setDamping_mut";

PxDistanceJoint_getDamping :: (self: *PxDistanceJoint) -> float #foreign libphysx;

PxDistanceJoint_setContactDistance :: (self: *PxDistanceJoint, contactDistance: float) -> void #foreign libphysx "PxDistanceJoint_setContactDistance_mut";

PxDistanceJoint_getContactDistance :: (self: *PxDistanceJoint) -> float #foreign libphysx;

PxDistanceJoint_setDistanceJointFlags :: (self: *PxDistanceJoint, flags: u16) -> void #foreign libphysx "PxDistanceJoint_setDistanceJointFlags_mut";

PxDistanceJoint_setDistanceJointFlag :: (self: *PxDistanceJoint, flag: s32, value: bool) -> void #foreign libphysx "PxDistanceJoint_setDistanceJointFlag_mut";

PxDistanceJoint_getDistanceJointFlags :: (self: *PxDistanceJoint) -> u16 #foreign libphysx;

PxDistanceJoint_getConcreteTypeName :: (self: *PxDistanceJoint) -> *u8 #foreign libphysx;

PxContactJointCreate :: (physics: *PxPhysics, actor0: *PxRigidActor, localFrame0: *PxTransform, actor1: *PxRigidActor, localFrame1: *PxTransform) -> *PxContactJoint #foreign libphysx "phys_PxContactJointCreate";

PxJacobianRow_new :: () -> PxJacobianRow #foreign libphysx;

PxJacobianRow_new :: (lin0: *Vector3, lin1: *Vector3, ang0: *Vector3, ang1: *Vector3) -> PxJacobianRow #foreign libphysx "PxJacobianRow_new_1";

PxContactJoint_setContact :: (self: *PxContactJoint, contact: *Vector3) -> void #foreign libphysx "PxContactJoint_setContact_mut";

PxContactJoint_setContactNormal :: (self: *PxContactJoint, contactNormal: *Vector3) -> void #foreign libphysx "PxContactJoint_setContactNormal_mut";

PxContactJoint_setPenetration :: (self: *PxContactJoint, penetration: float) -> void #foreign libphysx "PxContactJoint_setPenetration_mut";

PxContactJoint_getContact :: (self: *PxContactJoint) -> Vector3 #foreign libphysx;

PxContactJoint_getContactNormal :: (self: *PxContactJoint) -> Vector3 #foreign libphysx;

PxContactJoint_getPenetration :: (self: *PxContactJoint) -> float #foreign libphysx;

PxContactJoint_getRestitution :: (self: *PxContactJoint) -> float #foreign libphysx;

PxContactJoint_setRestitution :: (self: *PxContactJoint, restitution: float) -> void #foreign libphysx "PxContactJoint_setRestitution_mut";

PxContactJoint_getBounceThreshold :: (self: *PxContactJoint) -> float #foreign libphysx;

PxContactJoint_setBounceThreshold :: (self: *PxContactJoint, bounceThreshold: float) -> void #foreign libphysx "PxContactJoint_setBounceThreshold_mut";

PxContactJoint_getConcreteTypeName :: (self: *PxContactJoint) -> *u8 #foreign libphysx;

PxContactJoint_computeJacobians :: (self: *PxContactJoint, jacobian: *PxJacobianRow) -> void #foreign libphysx;

PxContactJoint_getNbJacobianRows :: (self: *PxContactJoint) -> u32 #foreign libphysx;

PxFixedJointCreate :: (physics: *PxPhysics, actor0: *PxRigidActor, localFrame0: *PxTransform, actor1: *PxRigidActor, localFrame1: *PxTransform) -> *PxFixedJoint #foreign libphysx "phys_PxFixedJointCreate";

PxFixedJoint_getConcreteTypeName :: (self: *PxFixedJoint) -> *u8 #foreign libphysx;

PxJointLimitParameters_new_alloc :: () -> *PxJointLimitParameters #foreign libphysx;

PxJointLimitParameters_isValid :: (self: *PxJointLimitParameters) -> bool #foreign libphysx;

PxJointLimitParameters_isSoft :: (self: *PxJointLimitParameters) -> bool #foreign libphysx;

PxJointLinearLimit_new :: (scale: *PxTolerancesScale, extent: float, contactDist_deprecated: float) -> PxJointLinearLimit #foreign libphysx;

PxJointLinearLimit_new :: (extent: float, spring: *PxSpring) -> PxJointLinearLimit #foreign libphysx "PxJointLinearLimit_new_1";

PxJointLinearLimit_isValid :: (self: *PxJointLinearLimit) -> bool #foreign libphysx;

PxJointLinearLimit_delete :: (self: *PxJointLinearLimit) -> void #foreign libphysx;

PxJointLinearLimitPair_new :: (scale: *PxTolerancesScale, lowerLimit: float, upperLimit: float, contactDist_deprecated: float) -> PxJointLinearLimitPair #foreign libphysx;

PxJointLinearLimitPair_new :: (lowerLimit: float, upperLimit: float, spring: *PxSpring) -> PxJointLinearLimitPair #foreign libphysx "PxJointLinearLimitPair_new_1";

PxJointLinearLimitPair_isValid :: (self: *PxJointLinearLimitPair) -> bool #foreign libphysx;

PxJointLinearLimitPair_delete :: (self: *PxJointLinearLimitPair) -> void #foreign libphysx;

PxJointAngularLimitPair_new :: (lowerLimit: float, upperLimit: float, contactDist_deprecated: float) -> PxJointAngularLimitPair #foreign libphysx;

PxJointAngularLimitPair_new :: (lowerLimit: float, upperLimit: float, spring: *PxSpring) -> PxJointAngularLimitPair #foreign libphysx "PxJointAngularLimitPair_new_1";

PxJointAngularLimitPair_isValid :: (self: *PxJointAngularLimitPair) -> bool #foreign libphysx;

PxJointAngularLimitPair_delete :: (self: *PxJointAngularLimitPair) -> void #foreign libphysx;

PxJointLimitCone_new :: (yLimitAngle: float, zLimitAngle: float, contactDist_deprecated: float) -> PxJointLimitCone #foreign libphysx;

PxJointLimitCone_new :: (yLimitAngle: float, zLimitAngle: float, spring: *PxSpring) -> PxJointLimitCone #foreign libphysx "PxJointLimitCone_new_1";

PxJointLimitCone_isValid :: (self: *PxJointLimitCone) -> bool #foreign libphysx;

PxJointLimitCone_delete :: (self: *PxJointLimitCone) -> void #foreign libphysx;

PxJointLimitPyramid_new :: (yLimitAngleMin: float, yLimitAngleMax: float, zLimitAngleMin: float, zLimitAngleMax: float, contactDist_deprecated: float) -> PxJointLimitPyramid #foreign libphysx;

PxJointLimitPyramid_new :: (yLimitAngleMin: float, yLimitAngleMax: float, zLimitAngleMin: float, zLimitAngleMax: float, spring: *PxSpring) -> PxJointLimitPyramid #foreign libphysx "PxJointLimitPyramid_new_1";

PxJointLimitPyramid_isValid :: (self: *PxJointLimitPyramid) -> bool #foreign libphysx;

PxJointLimitPyramid_delete :: (self: *PxJointLimitPyramid) -> void #foreign libphysx;

PxPrismaticJointCreate :: (physics: *PxPhysics, actor0: *PxRigidActor, localFrame0: *PxTransform, actor1: *PxRigidActor, localFrame1: *PxTransform) -> *PxPrismaticJoint #foreign libphysx "phys_PxPrismaticJointCreate";

PxPrismaticJoint_getPosition :: (self: *PxPrismaticJoint) -> float #foreign libphysx;

PxPrismaticJoint_getVelocity :: (self: *PxPrismaticJoint) -> float #foreign libphysx;

PxPrismaticJoint_setLimit :: (self: *PxPrismaticJoint, anon_param0: *PxJointLinearLimitPair) -> void #foreign libphysx "PxPrismaticJoint_setLimit_mut";

PxPrismaticJoint_getLimit :: (self: *PxPrismaticJoint) -> PxJointLinearLimitPair #foreign libphysx;

PxPrismaticJoint_setPrismaticJointFlags :: (self: *PxPrismaticJoint, flags: u16) -> void #foreign libphysx "PxPrismaticJoint_setPrismaticJointFlags_mut";

PxPrismaticJoint_setPrismaticJointFlag :: (self: *PxPrismaticJoint, flag: s32, value: bool) -> void #foreign libphysx "PxPrismaticJoint_setPrismaticJointFlag_mut";

PxPrismaticJoint_getPrismaticJointFlags :: (self: *PxPrismaticJoint) -> u16 #foreign libphysx;

PxPrismaticJoint_getConcreteTypeName :: (self: *PxPrismaticJoint) -> *u8 #foreign libphysx;

PxRevoluteJointCreate :: (physics: *PxPhysics, actor0: *PxRigidActor, localFrame0: *PxTransform, actor1: *PxRigidActor, localFrame1: *PxTransform) -> *PxRevoluteJoint #foreign libphysx "phys_PxRevoluteJointCreate";

PxRevoluteJoint_getAngle :: (self: *PxRevoluteJoint) -> float #foreign libphysx;

PxRevoluteJoint_getVelocity :: (self: *PxRevoluteJoint) -> float #foreign libphysx;

PxRevoluteJoint_setLimit :: (self: *PxRevoluteJoint, limits: *PxJointAngularLimitPair) -> void #foreign libphysx "PxRevoluteJoint_setLimit_mut";

PxRevoluteJoint_getLimit :: (self: *PxRevoluteJoint) -> PxJointAngularLimitPair #foreign libphysx;

PxRevoluteJoint_setDriveVelocity :: (self: *PxRevoluteJoint, velocity: float, autowake: bool) -> void #foreign libphysx "PxRevoluteJoint_setDriveVelocity_mut";

PxRevoluteJoint_getDriveVelocity :: (self: *PxRevoluteJoint) -> float #foreign libphysx;

PxRevoluteJoint_setDriveForceLimit :: (self: *PxRevoluteJoint, limit: float) -> void #foreign libphysx "PxRevoluteJoint_setDriveForceLimit_mut";

PxRevoluteJoint_getDriveForceLimit :: (self: *PxRevoluteJoint) -> float #foreign libphysx;

PxRevoluteJoint_setDriveGearRatio :: (self: *PxRevoluteJoint, ratio: float) -> void #foreign libphysx "PxRevoluteJoint_setDriveGearRatio_mut";

PxRevoluteJoint_getDriveGearRatio :: (self: *PxRevoluteJoint) -> float #foreign libphysx;

PxRevoluteJoint_setRevoluteJointFlags :: (self: *PxRevoluteJoint, flags: u16) -> void #foreign libphysx "PxRevoluteJoint_setRevoluteJointFlags_mut";

PxRevoluteJoint_setRevoluteJointFlag :: (self: *PxRevoluteJoint, flag: s32, value: bool) -> void #foreign libphysx "PxRevoluteJoint_setRevoluteJointFlag_mut";

PxRevoluteJoint_getRevoluteJointFlags :: (self: *PxRevoluteJoint) -> u16 #foreign libphysx;

PxRevoluteJoint_getConcreteTypeName :: (self: *PxRevoluteJoint) -> *u8 #foreign libphysx;

PxSphericalJointCreate :: (physics: *PxPhysics, actor0: *PxRigidActor, localFrame0: *PxTransform, actor1: *PxRigidActor, localFrame1: *PxTransform) -> *PxSphericalJoint #foreign libphysx "phys_PxSphericalJointCreate";

PxSphericalJoint_getLimitCone :: (self: *PxSphericalJoint) -> PxJointLimitCone #foreign libphysx;

PxSphericalJoint_setLimitCone :: (self: *PxSphericalJoint, limit: *PxJointLimitCone) -> void #foreign libphysx "PxSphericalJoint_setLimitCone_mut";

PxSphericalJoint_getSwingYAngle :: (self: *PxSphericalJoint) -> float #foreign libphysx;

PxSphericalJoint_getSwingZAngle :: (self: *PxSphericalJoint) -> float #foreign libphysx;

PxSphericalJoint_setSphericalJointFlags :: (self: *PxSphericalJoint, flags: u16) -> void #foreign libphysx "PxSphericalJoint_setSphericalJointFlags_mut";

PxSphericalJoint_setSphericalJointFlag :: (self: *PxSphericalJoint, flag: s32, value: bool) -> void #foreign libphysx "PxSphericalJoint_setSphericalJointFlag_mut";

PxSphericalJoint_getSphericalJointFlags :: (self: *PxSphericalJoint) -> u16 #foreign libphysx;

PxSphericalJoint_getConcreteTypeName :: (self: *PxSphericalJoint) -> *u8 #foreign libphysx;

PxD6JointCreate :: (physics: *PxPhysics, actor0: *PxRigidActor, localFrame0: *PxTransform, actor1: *PxRigidActor, localFrame1: *PxTransform) -> *PxD6Joint #foreign libphysx "phys_PxD6JointCreate";

PxD6JointDrive_new :: () -> PxD6JointDrive #foreign libphysx;

PxD6JointDrive_new :: (driveStiffness: float, driveDamping: float, driveForceLimit: float, isAcceleration: bool) -> PxD6JointDrive #foreign libphysx "PxD6JointDrive_new_1";

PxD6JointDrive_isValid :: (self: *PxD6JointDrive) -> bool #foreign libphysx;

PxD6Joint_setMotion :: (self: *PxD6Joint, axis: s32, type: s32) -> void #foreign libphysx "PxD6Joint_setMotion_mut";

PxD6Joint_getMotion :: (self: *PxD6Joint, axis: s32) -> s32 #foreign libphysx;

PxD6Joint_getTwistAngle :: (self: *PxD6Joint) -> float #foreign libphysx;

PxD6Joint_getSwingYAngle :: (self: *PxD6Joint) -> float #foreign libphysx;

PxD6Joint_getSwingZAngle :: (self: *PxD6Joint) -> float #foreign libphysx;

PxD6Joint_setDistanceLimit :: (self: *PxD6Joint, limit: *PxJointLinearLimit) -> void #foreign libphysx "PxD6Joint_setDistanceLimit_mut";

PxD6Joint_getDistanceLimit :: (self: *PxD6Joint) -> PxJointLinearLimit #foreign libphysx;

PxD6Joint_setLinearLimit :: (self: *PxD6Joint, axis: s32, limit: *PxJointLinearLimitPair) -> void #foreign libphysx "PxD6Joint_setLinearLimit_mut";

PxD6Joint_getLinearLimit :: (self: *PxD6Joint, axis: s32) -> PxJointLinearLimitPair #foreign libphysx;

PxD6Joint_setTwistLimit :: (self: *PxD6Joint, limit: *PxJointAngularLimitPair) -> void #foreign libphysx "PxD6Joint_setTwistLimit_mut";

PxD6Joint_getTwistLimit :: (self: *PxD6Joint) -> PxJointAngularLimitPair #foreign libphysx;

PxD6Joint_setSwingLimit :: (self: *PxD6Joint, limit: *PxJointLimitCone) -> void #foreign libphysx "PxD6Joint_setSwingLimit_mut";

PxD6Joint_getSwingLimit :: (self: *PxD6Joint) -> PxJointLimitCone #foreign libphysx;

PxD6Joint_setPyramidSwingLimit :: (self: *PxD6Joint, limit: *PxJointLimitPyramid) -> void #foreign libphysx "PxD6Joint_setPyramidSwingLimit_mut";

PxD6Joint_getPyramidSwingLimit :: (self: *PxD6Joint) -> PxJointLimitPyramid #foreign libphysx;

PxD6Joint_setDrive :: (self: *PxD6Joint, index: s32, drive: *PxD6JointDrive) -> void #foreign libphysx "PxD6Joint_setDrive_mut";

PxD6Joint_getDrive :: (self: *PxD6Joint, index: s32) -> PxD6JointDrive #foreign libphysx;

PxD6Joint_setDrivePosition :: (self: *PxD6Joint, pose: *PxTransform, autowake: bool) -> void #foreign libphysx "PxD6Joint_setDrivePosition_mut";

PxD6Joint_getDrivePosition :: (self: *PxD6Joint) -> PxTransform #foreign libphysx;

PxD6Joint_setDriveVelocity :: (self: *PxD6Joint, linear: *Vector3, angular: *Vector3, autowake: bool) -> void #foreign libphysx "PxD6Joint_setDriveVelocity_mut";

PxD6Joint_getDriveVelocity :: (self: *PxD6Joint, linear: *Vector3, angular: *Vector3) -> void #foreign libphysx;

PxD6Joint_setProjectionLinearTolerance :: (self: *PxD6Joint, tolerance: float) -> void #foreign libphysx "PxD6Joint_setProjectionLinearTolerance_mut";

PxD6Joint_getProjectionLinearTolerance :: (self: *PxD6Joint) -> float #foreign libphysx;

PxD6Joint_setProjectionAngularTolerance :: (self: *PxD6Joint, tolerance: float) -> void #foreign libphysx "PxD6Joint_setProjectionAngularTolerance_mut";

PxD6Joint_getProjectionAngularTolerance :: (self: *PxD6Joint) -> float #foreign libphysx;

PxD6Joint_getConcreteTypeName :: (self: *PxD6Joint) -> *u8 #foreign libphysx;

PxGearJointCreate :: (physics: *PxPhysics, actor0: *PxRigidActor, localFrame0: *PxTransform, actor1: *PxRigidActor, localFrame1: *PxTransform) -> *PxGearJoint #foreign libphysx "phys_PxGearJointCreate";

PxGearJoint_setHinges :: (self: *PxGearJoint, hinge0: *PxBase, hinge1: *PxBase) -> bool #foreign libphysx "PxGearJoint_setHinges_mut";

PxGearJoint_setGearRatio :: (self: *PxGearJoint, ratio: float) -> void #foreign libphysx "PxGearJoint_setGearRatio_mut";

PxGearJoint_getGearRatio :: (self: *PxGearJoint) -> float #foreign libphysx;

PxGearJoint_getConcreteTypeName :: (self: *PxGearJoint) -> *u8 #foreign libphysx;

PxRackAndPinionJointCreate :: (physics: *PxPhysics, actor0: *PxRigidActor, localFrame0: *PxTransform, actor1: *PxRigidActor, localFrame1: *PxTransform) -> *PxRackAndPinionJoint #foreign libphysx "phys_PxRackAndPinionJointCreate";

PxRackAndPinionJoint_setJoints :: (self: *PxRackAndPinionJoint, hinge: *PxBase, prismatic: *PxBase) -> bool #foreign libphysx "PxRackAndPinionJoint_setJoints_mut";

PxRackAndPinionJoint_setRatio :: (self: *PxRackAndPinionJoint, ratio: float) -> void #foreign libphysx "PxRackAndPinionJoint_setRatio_mut";

PxRackAndPinionJoint_getRatio :: (self: *PxRackAndPinionJoint) -> float #foreign libphysx;

PxRackAndPinionJoint_setData :: (self: *PxRackAndPinionJoint, nbRackTeeth: u32, nbPinionTeeth: u32, rackLength: float) -> bool #foreign libphysx "PxRackAndPinionJoint_setData_mut";

PxRackAndPinionJoint_getConcreteTypeName :: (self: *PxRackAndPinionJoint) -> *u8 #foreign libphysx;

PxGroupsMask_new_alloc :: () -> *PxGroupsMask #foreign libphysx;

PxGroupsMask_delete :: (self: *PxGroupsMask) -> void #foreign libphysx;

PxDefaultSimulationFilterShader :: (attributes0: u32, filterData0: PxFilterData, attributes1: u32, filterData1: PxFilterData, pairFlags: *u16, constantBlock: *void, constantBlockSize: u32) -> u16 #foreign libphysx "phys_PxDefaultSimulationFilterShader";

PxGetGroupCollisionFlag :: (group1: u16, group2: u16) -> bool #foreign libphysx "phys_PxGetGroupCollisionFlag";

PxSetGroupCollisionFlag :: (group1: u16, group2: u16, enable: bool) -> void #foreign libphysx "phys_PxSetGroupCollisionFlag";

PxGetGroup :: (actor: *PxActor) -> u16 #foreign libphysx "phys_PxGetGroup";

PxSetGroup :: (actor: *PxActor, collisionGroup: u16) -> void #foreign libphysx "phys_PxSetGroup";

PxGetFilterOps :: (op0: *s32, op1: *s32, op2: *s32) -> void #foreign libphysx "phys_PxGetFilterOps";

PxSetFilterOps :: (op0: *s32, op1: *s32, op2: *s32) -> void #foreign libphysx "phys_PxSetFilterOps";

PxGetFilterBool :: () -> bool #foreign libphysx "phys_PxGetFilterBool";

PxSetFilterBool :: (enable: bool) -> void #foreign libphysx "phys_PxSetFilterBool";

PxGetFilterConstants :: (c0: *PxGroupsMask, c1: *PxGroupsMask) -> void #foreign libphysx "phys_PxGetFilterConstants";

PxSetFilterConstants :: (c0: *PxGroupsMask, c1: *PxGroupsMask) -> void #foreign libphysx "phys_PxSetFilterConstants";

PxGetGroupsMask :: (actor: *PxActor) -> PxGroupsMask #foreign libphysx "phys_PxGetGroupsMask";

PxSetGroupsMask :: (actor: *PxActor, mask: *PxGroupsMask) -> void #foreign libphysx "phys_PxSetGroupsMask";

PxDefaultErrorCallback_new_alloc :: () -> *PxDefaultErrorCallback #foreign libphysx;

PxDefaultErrorCallback_delete :: (self: *PxDefaultErrorCallback) -> void #foreign libphysx;

PxDefaultErrorCallback_reportError :: (self: *PxDefaultErrorCallback, code: s32, message: *u8, file: *u8, line: s32) -> void #foreign libphysx "PxDefaultErrorCallback_reportError_mut";

PxRigidActorExt_createExclusiveShape :: (actor: *PxRigidActor, geometry: *PxGeometry, materials: **PxMaterial, materialCount: u16, shapeFlags: u8) -> *PxShape #foreign libphysx;

PxRigidActorExt_createExclusiveShape :: (actor: *PxRigidActor, geometry: *PxGeometry, material: *PxMaterial, shapeFlags: u8) -> *PxShape #foreign libphysx "PxRigidActorExt_createExclusiveShape_1";

PxRigidActorExt_getRigidActorShapeLocalBoundsList :: (actor: *PxRigidActor, numBounds: *u32) -> *PxBounds3 #foreign libphysx;

PxRigidActorExt_createBVHFromActor :: (physics: *PxPhysics, actor: *PxRigidActor) -> *PxBVH #foreign libphysx;

PxMassProperties_new :: () -> PxMassProperties #foreign libphysx;

PxMassProperties_new :: (m: float, inertiaT: *PxMat33, com: *Vector3) -> PxMassProperties #foreign libphysx "PxMassProperties_new_1";

PxMassProperties_new :: (geometry: *PxGeometry) -> PxMassProperties #foreign libphysx "PxMassProperties_new_2";

PxMassProperties_translate :: (self: *PxMassProperties, t: *Vector3) -> void #foreign libphysx "PxMassProperties_translate_mut";

PxMassProperties_getMassSpaceInertia :: (inertia: *PxMat33, massFrame: *Quaternion) -> Vector3 #foreign libphysx;

PxMassProperties_translateInertia :: (inertia: *PxMat33, mass: float, t: *Vector3) -> PxMat33 #foreign libphysx;

PxMassProperties_rotateInertia :: (inertia: *PxMat33, q: *Quaternion) -> PxMat33 #foreign libphysx;

PxMassProperties_scaleInertia :: (inertia: *PxMat33, scaleRotation: *Quaternion, scale: *Vector3) -> PxMat33 #foreign libphysx;

PxMassProperties_sum :: (props: *PxMassProperties, transforms: *PxTransform, count: u32) -> PxMassProperties #foreign libphysx;

PxRigidBodyExt_updateMassAndInertia :: (body: *PxRigidBody, shapeDensities: *float, shapeDensityCount: u32, massLocalPose: *Vector3, includeNonSimShapes: bool) -> bool #foreign libphysx;

PxRigidBodyExt_updateMassAndInertia :: (body: *PxRigidBody, density: float, massLocalPose: *Vector3, includeNonSimShapes: bool) -> bool #foreign libphysx "PxRigidBodyExt_updateMassAndInertia_1";

PxRigidBodyExt_setMassAndUpdateInertia :: (body: *PxRigidBody, shapeMasses: *float, shapeMassCount: u32, massLocalPose: *Vector3, includeNonSimShapes: bool) -> bool #foreign libphysx;

PxRigidBodyExt_setMassAndUpdateInertia :: (body: *PxRigidBody, mass: float, massLocalPose: *Vector3, includeNonSimShapes: bool) -> bool #foreign libphysx "PxRigidBodyExt_setMassAndUpdateInertia_1";

PxRigidBodyExt_computeMassPropertiesFromShapes :: (shapes: **PxShape, shapeCount: u32) -> PxMassProperties #foreign libphysx;

PxRigidBodyExt_addForceAtPos :: (body: *PxRigidBody, force: *Vector3, pos: *Vector3, mode: s32, wakeup: bool) -> void #foreign libphysx;

PxRigidBodyExt_addForceAtLocalPos :: (body: *PxRigidBody, force: *Vector3, pos: *Vector3, mode: s32, wakeup: bool) -> void #foreign libphysx;

PxRigidBodyExt_addLocalForceAtPos :: (body: *PxRigidBody, force: *Vector3, pos: *Vector3, mode: s32, wakeup: bool) -> void #foreign libphysx;

PxRigidBodyExt_addLocalForceAtLocalPos :: (body: *PxRigidBody, force: *Vector3, pos: *Vector3, mode: s32, wakeup: bool) -> void #foreign libphysx;

PxRigidBodyExt_getVelocityAtPos :: (body: *PxRigidBody, pos: *Vector3) -> Vector3 #foreign libphysx;

PxRigidBodyExt_getLocalVelocityAtLocalPos :: (body: *PxRigidBody, pos: *Vector3) -> Vector3 #foreign libphysx;

PxRigidBodyExt_getVelocityAtOffset :: (body: *PxRigidBody, pos: *Vector3) -> Vector3 #foreign libphysx;

PxRigidBodyExt_computeVelocityDeltaFromImpulse :: (body: *PxRigidBody, impulsiveForce: *Vector3, impulsiveTorque: *Vector3, deltaLinearVelocity: *Vector3, deltaAngularVelocity: *Vector3) -> void #foreign libphysx;

PxRigidBodyExt_computeVelocityDeltaFromImpulse :: (body: *PxRigidBody, globalPose: *PxTransform, point: *Vector3, impulse: *Vector3, invMassScale: float, invInertiaScale: float, deltaLinearVelocity: *Vector3, deltaAngularVelocity: *Vector3) -> void #foreign libphysx "PxRigidBodyExt_computeVelocityDeltaFromImpulse_1";

PxRigidBodyExt_computeLinearAngularImpulse :: (body: *PxRigidBody, globalPose: *PxTransform, point: *Vector3, impulse: *Vector3, invMassScale: float, invInertiaScale: float, linearImpulse: *Vector3, angularImpulse: *Vector3) -> void #foreign libphysx;

PxRigidBodyExt_linearSweepSingle :: (body: *PxRigidBody, scene: *PxScene, unitDir: *Vector3, distance: float, outputFlags: u16, closestHit: *PxSweepHit, shapeIndex: *u32, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback, cache: *PxQueryCache, inflation: float) -> bool #foreign libphysx;

PxRigidBodyExt_linearSweepMultiple :: (body: *PxRigidBody, scene: *PxScene, unitDir: *Vector3, distance: float, outputFlags: u16, touchHitBuffer: *PxSweepHit, touchHitShapeIndices: *u32, touchHitBufferSize: u32, block: *PxSweepHit, blockingShapeIndex: *s32, overflow: *bool, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback, cache: *PxQueryCache, inflation: float) -> u32 #foreign libphysx;

PxShapeExt_getGlobalPose :: (shape: *PxShape, actor: *PxRigidActor) -> PxTransform #foreign libphysx;

PxShapeExt_raycast :: (shape: *PxShape, actor: *PxRigidActor, rayOrigin: *Vector3, rayDir: *Vector3, maxDist: float, hitFlags: u16, maxHits: u32, rayHits: *PxRaycastHit) -> u32 #foreign libphysx;

PxShapeExt_overlap :: (shape: *PxShape, actor: *PxRigidActor, otherGeom: *PxGeometry, otherGeomPose: *PxTransform) -> bool #foreign libphysx;

PxShapeExt_sweep :: (shape: *PxShape, actor: *PxRigidActor, unitDir: *Vector3, distance: float, otherGeom: *PxGeometry, otherGeomPose: *PxTransform, sweepHit: *PxSweepHit, hitFlags: u16) -> bool #foreign libphysx;

PxShapeExt_getWorldBounds :: (shape: *PxShape, actor: *PxRigidActor, inflation: float) -> PxBounds3 #foreign libphysx;

PxMeshOverlapUtil_new_alloc :: () -> *PxMeshOverlapUtil #foreign libphysx;

PxMeshOverlapUtil_delete :: (self: *PxMeshOverlapUtil) -> void #foreign libphysx;

PxMeshOverlapUtil_findOverlap :: (self: *PxMeshOverlapUtil, geom: *PxGeometry, geomPose: *PxTransform, meshGeom: *PxTriangleMeshGeometry, meshPose: *PxTransform) -> u32 #foreign libphysx "PxMeshOverlapUtil_findOverlap_mut";

PxMeshOverlapUtil_findOverlap_mut :: (self: *PxMeshOverlapUtil, geom: *PxGeometry, geomPose: *PxTransform, hfGeom: *PxHeightFieldGeometry, hfPose: *PxTransform) -> u32 #foreign libphysx "PxMeshOverlapUtil_findOverlap_mut_1";

PxMeshOverlapUtil_getResults :: (self: *PxMeshOverlapUtil) -> *u32 #foreign libphysx;

PxMeshOverlapUtil_getNbResults :: (self: *PxMeshOverlapUtil) -> u32 #foreign libphysx;

PxComputeTriangleMeshPenetration :: (direction: *Vector3, depth: *float, geom: *PxGeometry, geomPose: *PxTransform, meshGeom: *PxTriangleMeshGeometry, meshPose: *PxTransform, maxIter: u32, usedIter: *u32) -> bool #foreign libphysx "phys_PxComputeTriangleMeshPenetration";

PxComputeHeightFieldPenetration :: (direction: *Vector3, depth: *float, geom: *PxGeometry, geomPose: *PxTransform, heightFieldGeom: *PxHeightFieldGeometry, heightFieldPose: *PxTransform, maxIter: u32, usedIter: *u32) -> bool #foreign libphysx "phys_PxComputeHeightFieldPenetration";

PxXmlMiscParameter_new :: () -> PxXmlMiscParameter #foreign libphysx;

PxXmlMiscParameter_new :: (inUpVector: *Vector3, inScale: PxTolerancesScale) -> PxXmlMiscParameter #foreign libphysx "PxXmlMiscParameter_new_1";

PxSerialization_isSerializable :: (collection: *PxCollection, sr: *PxSerializationRegistry, externalReferences: *PxCollection) -> bool #foreign libphysx;

PxSerialization_complete :: (collection: *PxCollection, sr: *PxSerializationRegistry, exceptFor: *PxCollection, followJoints: bool) -> void #foreign libphysx;

PxSerialization_createSerialObjectIds :: (collection: *PxCollection, base: u64) -> void #foreign libphysx;

PxSerialization_createCollectionFromXml :: (inputData: *PxInputData, cooking: *PxCooking, sr: *PxSerializationRegistry, externalRefs: *PxCollection, stringTable: *PxStringTable, outArgs: *PxXmlMiscParameter) -> *PxCollection #foreign libphysx;

PxSerialization_createCollectionFromBinary :: (memBlock: *void, sr: *PxSerializationRegistry, externalRefs: *PxCollection) -> *PxCollection #foreign libphysx;

PxSerialization_serializeCollectionToXml :: (outputStream: *PxOutputStream, collection: *PxCollection, sr: *PxSerializationRegistry, cooking: *PxCooking, externalRefs: *PxCollection, inArgs: *PxXmlMiscParameter) -> bool #foreign libphysx;

PxSerialization_serializeCollectionToBinary :: (outputStream: *PxOutputStream, collection: *PxCollection, sr: *PxSerializationRegistry, externalRefs: *PxCollection, exportNames: bool) -> bool #foreign libphysx;

PxSerialization_createSerializationRegistry :: (physics: *PxPhysics) -> *PxSerializationRegistry #foreign libphysx;

PxDefaultCpuDispatcher_release :: (self: *PxDefaultCpuDispatcher) -> void #foreign libphysx "PxDefaultCpuDispatcher_release_mut";

PxDefaultCpuDispatcher_setRunProfiled :: (self: *PxDefaultCpuDispatcher, runProfiled: bool) -> void #foreign libphysx "PxDefaultCpuDispatcher_setRunProfiled_mut";

PxDefaultCpuDispatcher_getRunProfiled :: (self: *PxDefaultCpuDispatcher) -> bool #foreign libphysx;

PxDefaultCpuDispatcherCreate :: (numThreads: u32, affinityMasks: *u32, mode: s32, yieldProcessorCount: u32) -> *PxDefaultCpuDispatcher #foreign libphysx "phys_PxDefaultCpuDispatcherCreate";

PxBuildSmoothNormals :: (nbTris: u32, nbVerts: u32, verts: *Vector3, dFaces: *u32, wFaces: *u16, normals: *Vector3, flip: bool) -> bool #foreign libphysx "phys_PxBuildSmoothNormals";

PxCreateDynamic :: (sdk: *PxPhysics, transform: *PxTransform, geometry: *PxGeometry, material: *PxMaterial, density: float, shapeOffset: *PxTransform) -> *PxRigidDynamic #foreign libphysx "phys_PxCreateDynamic";

PxCreateDynamic_1 :: (sdk: *PxPhysics, transform: *PxTransform, shape: *PxShape, density: float) -> *PxRigidDynamic #foreign libphysx "phys_PxCreateDynamic_1";

PxCreateKinematic :: (sdk: *PxPhysics, transform: *PxTransform, geometry: *PxGeometry, material: *PxMaterial, density: float, shapeOffset: *PxTransform) -> *PxRigidDynamic #foreign libphysx "phys_PxCreateKinematic";

PxCreateKinematic_1 :: (sdk: *PxPhysics, transform: *PxTransform, shape: *PxShape, density: float) -> *PxRigidDynamic #foreign libphysx "phys_PxCreateKinematic_1";

PxCreateStatic :: (sdk: *PxPhysics, transform: *PxTransform, geometry: *PxGeometry, material: *PxMaterial, shapeOffset: *PxTransform) -> *PxRigidStatic #foreign libphysx "phys_PxCreateStatic";

PxCreateStatic_1 :: (sdk: *PxPhysics, transform: *PxTransform, shape: *PxShape) -> *PxRigidStatic #foreign libphysx "phys_PxCreateStatic_1";

PxCloneShape :: (physicsSDK: *PxPhysics, shape: *PxShape, isExclusive: bool) -> *PxShape #foreign libphysx "phys_PxCloneShape";

PxCloneStatic :: (physicsSDK: *PxPhysics, transform: *PxTransform, actor: *PxRigidActor) -> *PxRigidStatic #foreign libphysx "phys_PxCloneStatic";

PxCloneDynamic :: (physicsSDK: *PxPhysics, transform: *PxTransform, body: *PxRigidDynamic) -> *PxRigidDynamic #foreign libphysx "phys_PxCloneDynamic";

PxCreatePlane :: (sdk: *PxPhysics, plane: *Plane3, material: *PxMaterial) -> *PxRigidStatic #foreign libphysx "phys_PxCreatePlane";

PxScaleRigidActor :: (actor: *PxRigidActor, scale: float, scaleMassProps: bool) -> void #foreign libphysx "phys_PxScaleRigidActor";

PxStringTableExt_createStringTable :: (inAllocator: *PxAllocatorCallback) -> *PxStringTable #foreign libphysx;

PxBroadPhaseExt_createRegionsFromWorldBounds :: (regions: *PxBounds3, globalBounds: *PxBounds3, nbSubdiv: u32, upAxis: u32) -> u32 #foreign libphysx;

PxSceneQueryExt_raycastAny :: (scene: *PxScene, origin: *Vector3, unitDir: *Vector3, distance: float, hit: *PxQueryHit, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback, cache: *PxQueryCache) -> bool #foreign libphysx;

PxSceneQueryExt_raycastSingle :: (scene: *PxScene, origin: *Vector3, unitDir: *Vector3, distance: float, outputFlags: u16, hit: *PxRaycastHit, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback, cache: *PxQueryCache) -> bool #foreign libphysx;

PxSceneQueryExt_raycastMultiple :: (scene: *PxScene, origin: *Vector3, unitDir: *Vector3, distance: float, outputFlags: u16, hitBuffer: *PxRaycastHit, hitBufferSize: u32, blockingHit: *bool, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback, cache: *PxQueryCache) -> s32 #foreign libphysx;

PxSceneQueryExt_sweepAny :: (scene: *PxScene, geometry: *PxGeometry, pose: *PxTransform, unitDir: *Vector3, distance: float, queryFlags: u16, hit: *PxQueryHit, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback, cache: *PxQueryCache, inflation: float) -> bool #foreign libphysx;

PxSceneQueryExt_sweepSingle :: (scene: *PxScene, geometry: *PxGeometry, pose: *PxTransform, unitDir: *Vector3, distance: float, outputFlags: u16, hit: *PxSweepHit, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback, cache: *PxQueryCache, inflation: float) -> bool #foreign libphysx;

PxSceneQueryExt_sweepMultiple :: (scene: *PxScene, geometry: *PxGeometry, pose: *PxTransform, unitDir: *Vector3, distance: float, outputFlags: u16, hitBuffer: *PxSweepHit, hitBufferSize: u32, blockingHit: *bool, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback, cache: *PxQueryCache, inflation: float) -> s32 #foreign libphysx;

PxSceneQueryExt_overlapMultiple :: (scene: *PxScene, geometry: *PxGeometry, pose: *PxTransform, hitBuffer: *PxOverlapHit, hitBufferSize: u32, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback) -> s32 #foreign libphysx;

PxSceneQueryExt_overlapAny :: (scene: *PxScene, geometry: *PxGeometry, pose: *PxTransform, hit: *PxOverlapHit, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback) -> bool #foreign libphysx;

PxBatchQueryExt_release :: (self: *PxBatchQueryExt) -> void #foreign libphysx "PxBatchQueryExt_release_mut";

PxBatchQueryExt_raycast :: (self: *PxBatchQueryExt, origin: *Vector3, unitDir: *Vector3, distance: float, maxNbTouches: u16, hitFlags: u16, filterData: *PxQueryFilterData, cache: *PxQueryCache) -> *PxRaycastBuffer #foreign libphysx "PxBatchQueryExt_raycast_mut";

PxBatchQueryExt_sweep :: (self: *PxBatchQueryExt, geometry: *PxGeometry, pose: *PxTransform, unitDir: *Vector3, distance: float, maxNbTouches: u16, hitFlags: u16, filterData: *PxQueryFilterData, cache: *PxQueryCache, inflation: float) -> *PxSweepBuffer #foreign libphysx "PxBatchQueryExt_sweep_mut";

PxBatchQueryExt_overlap :: (self: *PxBatchQueryExt, geometry: *PxGeometry, pose: *PxTransform, maxNbTouches: u16, filterData: *PxQueryFilterData, cache: *PxQueryCache) -> *PxOverlapBuffer #foreign libphysx "PxBatchQueryExt_overlap_mut";

PxBatchQueryExt_execute :: (self: *PxBatchQueryExt) -> void #foreign libphysx "PxBatchQueryExt_execute_mut";

PxCreateBatchQueryExt :: (scene: *PxScene, queryFilterCallback: *PxQueryFilterCallback, maxNbRaycasts: u32, maxNbRaycastTouches: u32, maxNbSweeps: u32, maxNbSweepTouches: u32, maxNbOverlaps: u32, maxNbOverlapTouches: u32) -> *PxBatchQueryExt #foreign libphysx "phys_PxCreateBatchQueryExt";

PxCreateBatchQueryExt_1 :: (scene: *PxScene, queryFilterCallback: *PxQueryFilterCallback, raycastBuffers: *PxRaycastBuffer, maxNbRaycasts: u32, raycastTouches: *PxRaycastHit, maxNbRaycastTouches: u32, sweepBuffers: *PxSweepBuffer, maxNbSweeps: u32, sweepTouches: *PxSweepHit, maxNbSweepTouches: u32, overlapBuffers: *PxOverlapBuffer, maxNbOverlaps: u32, overlapTouches: *PxOverlapHit, maxNbOverlapTouches: u32) -> *PxBatchQueryExt #foreign libphysx "phys_PxCreateBatchQueryExt_1";

PxCreateExternalSceneQuerySystem :: (desc: *PxSceneQueryDesc, contextID: u64) -> *PxSceneQuerySystem #foreign libphysx "phys_PxCreateExternalSceneQuerySystem";

PxCustomSceneQuerySystem_addPruner :: (self: *PxCustomSceneQuerySystem, primaryType: s32, secondaryType: s32, preallocated: u32) -> u32 #foreign libphysx "PxCustomSceneQuerySystem_addPruner_mut";

PxCustomSceneQuerySystem_startCustomBuildstep :: (self: *PxCustomSceneQuerySystem) -> u32 #foreign libphysx "PxCustomSceneQuerySystem_startCustomBuildstep_mut";

PxCustomSceneQuerySystem_customBuildstep :: (self: *PxCustomSceneQuerySystem, index: u32) -> void #foreign libphysx "PxCustomSceneQuerySystem_customBuildstep_mut";

PxCustomSceneQuerySystem_finishCustomBuildstep :: (self: *PxCustomSceneQuerySystem) -> void #foreign libphysx "PxCustomSceneQuerySystem_finishCustomBuildstep_mut";

PxCustomSceneQuerySystemAdapter_delete :: (self: *PxCustomSceneQuerySystemAdapter) -> void #foreign libphysx;

PxCustomSceneQuerySystemAdapter_getPrunerIndex :: (self: *PxCustomSceneQuerySystemAdapter, actor: *PxRigidActor, shape: *PxShape) -> u32 #foreign libphysx;

PxCustomSceneQuerySystemAdapter_processPruner :: (self: *PxCustomSceneQuerySystemAdapter, prunerIndex: u32, context_pod: *PxQueryThreadContext, filterData: *PxQueryFilterData, filterCall: *PxQueryFilterCallback) -> bool #foreign libphysx;

PxCreateCustomSceneQuerySystem :: (sceneQueryUpdateMode: s32, contextID: u64, adapter: *PxCustomSceneQuerySystemAdapter, usesTreeOfPruners: bool) -> *PxCustomSceneQuerySystem #foreign libphysx "phys_PxCreateCustomSceneQuerySystem";

PxFindFaceIndex :: (convexGeom: *PxConvexMeshGeometry, geomPose: *PxTransform, impactPos: *Vector3, unitDir: *Vector3) -> u32 #foreign libphysx "phys_PxFindFaceIndex";

PxPoissonSampler_setSamplingRadius :: (self: *PxPoissonSampler, samplingRadius: float) -> bool #foreign libphysx "PxPoissonSampler_setSamplingRadius_mut";

PxPoissonSampler_addSamplesInSphere :: (self: *PxPoissonSampler, sphereCenter: *Vector3, sphereRadius: float, createVolumeSamples: bool) -> void #foreign libphysx "PxPoissonSampler_addSamplesInSphere_mut";

PxPoissonSampler_addSamplesInBox :: (self: *PxPoissonSampler, axisAlignedBox: *PxBounds3, boxOrientation: *Quaternion, createVolumeSamples: bool) -> void #foreign libphysx "PxPoissonSampler_addSamplesInBox_mut";

PxPoissonSampler_delete :: (self: *PxPoissonSampler) -> void #foreign libphysx;

PxCreateShapeSampler :: (geometry: *PxGeometry, transform: *PxTransform, worldBounds: *PxBounds3, initialSamplingRadius: float, numSampleAttemptsAroundPoint: s32) -> *PxPoissonSampler #foreign libphysx "phys_PxCreateShapeSampler";

PxTriangleMeshPoissonSampler_isPointInTriangleMesh :: (self: *PxTriangleMeshPoissonSampler, p: *Vector3) -> bool #foreign libphysx "PxTriangleMeshPoissonSampler_isPointInTriangleMesh_mut";

PxTriangleMeshPoissonSampler_delete :: (self: *PxTriangleMeshPoissonSampler) -> void #foreign libphysx;

PxCreateTriangleMeshSampler :: (triangles: *u32, numTriangles: u32, vertices: *Vector3, numVertices: u32, initialSamplingRadius: float, numSampleAttemptsAroundPoint: s32) -> *PxTriangleMeshPoissonSampler #foreign libphysx "phys_PxCreateTriangleMeshSampler";

PxTetrahedronMeshExt_findTetrahedronContainingPoint :: (mesh: *PxTetrahedronMesh, point: *Vector3, bary: *Vector4, tolerance: float) -> s32 #foreign libphysx;

PxTetrahedronMeshExt_findTetrahedronClosestToPoint :: (mesh: *PxTetrahedronMesh, point: *Vector3, bary: *Vector4) -> s32 #foreign libphysx;

PxInitExtensions :: (physics: *PxPhysics, pvd: *PxPvd) -> bool #foreign libphysx "phys_PxInitExtensions";

PxCloseExtensions :: () -> void #foreign libphysx "phys_PxCloseExtensions";

PxRepXObject_new :: (inTypeName: *u8, inSerializable: *void, inId: u64) -> PxRepXObject #foreign libphysx;

PxRepXObject_isValid :: (self: *PxRepXObject) -> bool #foreign libphysx;

PxRepXInstantiationArgs_new :: (inPhysics: *PxPhysics, inCooking: *PxCooking, inStringTable: *PxStringTable) -> PxRepXInstantiationArgs #foreign libphysx;

PxRepXSerializer_getTypeName :: (self: *PxRepXSerializer) -> *u8 #foreign libphysx "PxRepXSerializer_getTypeName_mut";

PxRepXSerializer_objectToFile :: (self: *PxRepXSerializer, inLiveObject: *PxRepXObject, inCollection: *PxCollection, inWriter: *XmlWriter, inTempBuffer: *MemoryBuffer, inArgs: *PxRepXInstantiationArgs) -> void #foreign libphysx "PxRepXSerializer_objectToFile_mut";

PxRepXSerializer_fileToObject :: (self: *PxRepXSerializer, inReader: *XmlReader, inAllocator: *XmlMemoryAllocator, inArgs: *PxRepXInstantiationArgs, inCollection: *PxCollection) -> PxRepXObject #foreign libphysx "PxRepXSerializer_fileToObject_mut";

PxPvd_connect :: (self: *PxPvd, transport: *PxPvdTransport, flags: u8) -> bool #foreign libphysx "PxPvd_connect_mut";

PxPvd_disconnect :: (self: *PxPvd) -> void #foreign libphysx "PxPvd_disconnect_mut";

PxPvd_isConnected :: (self: *PxPvd, useCachedStatus: bool) -> bool #foreign libphysx "PxPvd_isConnected_mut";

PxPvd_getTransport :: (self: *PxPvd) -> *PxPvdTransport #foreign libphysx "PxPvd_getTransport_mut";

PxPvd_getInstrumentationFlags :: (self: *PxPvd) -> u8 #foreign libphysx "PxPvd_getInstrumentationFlags_mut";

PxPvd_release :: (self: *PxPvd) -> void #foreign libphysx "PxPvd_release_mut";

PxCreatePvd :: (foundation: *PxFoundation) -> *PxPvd #foreign libphysx "phys_PxCreatePvd";

PxPvdTransport_connect :: (self: *PxPvdTransport) -> bool #foreign libphysx "PxPvdTransport_connect_mut";

PxPvdTransport_disconnect :: (self: *PxPvdTransport) -> void #foreign libphysx "PxPvdTransport_disconnect_mut";

PxPvdTransport_isConnected :: (self: *PxPvdTransport) -> bool #foreign libphysx "PxPvdTransport_isConnected_mut";

PxPvdTransport_write :: (self: *PxPvdTransport, inBytes: *u8, inLength: u32) -> bool #foreign libphysx "PxPvdTransport_write_mut";

PxPvdTransport_lock :: (self: *PxPvdTransport) -> *PxPvdTransport #foreign libphysx "PxPvdTransport_lock_mut";

PxPvdTransport_unlock :: (self: *PxPvdTransport) -> void #foreign libphysx "PxPvdTransport_unlock_mut";

PxPvdTransport_flush :: (self: *PxPvdTransport) -> void #foreign libphysx "PxPvdTransport_flush_mut";

PxPvdTransport_getWrittenDataSize :: (self: *PxPvdTransport) -> u64 #foreign libphysx "PxPvdTransport_getWrittenDataSize_mut";

PxPvdTransport_release :: (self: *PxPvdTransport) -> void #foreign libphysx "PxPvdTransport_release_mut";

PxDefaultPvdSocketTransportCreate :: (host: *u8, port: s32, timeoutInMilliseconds: u32) -> *PxPvdTransport #foreign libphysx "phys_PxDefaultPvdSocketTransportCreate";

PxDefaultPvdFileTransportCreate :: (name: *u8) -> *PxPvdTransport #foreign libphysx "phys_PxDefaultPvdFileTransportCreate";

gAllocator: PxDefaultAllocator #elsewhere libphysx;
gErrorCallback: PxDefaultErrorCallback #elsewhere libphysx;

CollisionCallback :: #type (unknown0: *void, unknown1: *PxContactPairHeader, unknown2: *PxContactPair, unknown3: u32) -> void #c_call;

SimulationFilterShader :: #type (attributes0: *u32, filterData0: *PxFilterData, attributes1: *u32, filterData1: *PxFilterData, pairFlags: *PxPairFlags) -> u16 #c_call;

FilterShaderHandle :: struct {
    shader: SimulationFilterShader;
}

TriggerCallback :: #type (unknown0: *void, unknown1: *PxTriggerPair, unknown2: u32) -> void #c_call;
ConstraintBreakCallback :: #type (unknown0: *void, unknown1: *PxConstraintInfo, unknown2: u32) -> void #c_call;
WakeSleepCallback :: #type (unknown0: *void, unknown1: **PxActor, unknown2: u32, unknown3: bool) -> void #c_call;
AdvanceCallback :: #type (unknown0: *void, unknown1: **PxRigidBody, unknown2: *PxTransform, unknown3: u32) -> void #c_call;

SimulationEventCallbackInfo :: struct {
    // Callback for collision events.
    collisionCallback:       CollisionCallback = null;
    collisionUserData:       *void = null;

    // Callback for trigger shape events (an object entered or left a trigger shape).
    triggerCallback:         TriggerCallback = null;
    triggerUserData:         *void = null;

    // Callback for when a constraint breaks (such as a joint with a force limit)
    constraintBreakCallback: ConstraintBreakCallback = null;
    constraintBreakUserData: *void = null;

    // Callback for when an object falls asleep or is awoken.
    wakeSleepCallback:       WakeSleepCallback = null;
    wakeSleepUserData:       *void = null;

    // Callback to get the next pose early for objects (if flagged with eENABLE_POSE_INTEGRATION_PREVIEW).
    advanceCallback:         AdvanceCallback = null;
    advanceUserData:         *void = null;
}

RaycastHitCallback :: #type (actor: *PxRigidActor, filterData: *PxFilterData, shape: *PxShape, hitFlags: u32, userData: *void) -> s32 #c_call;
PostFilterCallback :: #type (filterData: *PxFilterData, hit: *PxQueryHit, userData: *void) -> s32 #c_call;

RaycastHitProcessTouchesCallback :: #type (buffer: *PxRaycastHit, nbHits: u32, userdata: *void) -> bool #c_call;
SweepHitProcessTouchesCallback :: #type (buffer: *PxSweepHit, nbHits: u32, userdata: *void) -> bool #c_call;
OverlapHitProcessTouchesCallback :: #type (buffer: *PxOverlapHit, nbHits: u32, userdata: *void) -> bool #c_call;
HitFinalizeQueryCallback :: #type (userdata: *void) -> void #c_call;

AllocCallback :: #type (size: u64, typeName: *u8, filename: *u8, line: s32, userdata: *void) -> *void #c_call;
DeallocCallback :: #type (ptr: *void, userdata: *void) -> void #c_call;

ZoneStartCallback :: #type (typeName: *u8, detached: bool, _context_pod: u64, userdata: *void) -> *void #c_call;
ZoneEndCallback :: #type (profilerData: *void, typeName: *u8, detached: bool, _context_pod: u64, userdata: *void) -> void #c_call;

ErrorCallback :: #type (code: s32, message: *u8, file: *u8, line: s32, userdata: *void) -> void #c_call;

AssertHandler :: #type (expr: *u8, file: *u8, line: s32, should_ignore: *bool, userdata: *void) -> void #c_call;

ShapeHitCallback :: #type (unknown0: *void, unknown1: *PxControllerShapeHit) -> void #c_call;
ControllerHitCallback :: #type (unknown0: *void, unknown1: *PxControllersHit) -> void #c_call;
ObstacleHitCallback :: #type (unknown0: *void, unknown1: *PxControllerObstacleHit) -> void #c_call;

UserControllerHitReportInfo :: struct {
    shapeHitCallback:      ShapeHitCallback = null;
    shapeHitUserData:      *void = null;
    controllerHitCallback: ControllerHitCallback = null;
    controllerHitUserData: *void = null;
    obstacleHitCallback:   ObstacleHitCallback = null;
    obstacleHitUserData:   *void = null;
}

ShapeBehaviorCallback :: #type (data: *void, shape: *PxShape, actor: *PxActor) -> PxControllerBehaviorFlags #c_call;
CharacterBehaviorCallback :: #type (data: *void, controller: *PxController) -> PxControllerBehaviorFlags #c_call;
ObstacleBehaviorCallback :: #type (data: *void, obstacle: *PxObstacle) -> PxControllerBehaviorFlags #c_call;

ControllerBehaviorCallbackInfo :: struct {
    shapeBehaviorCallback:      ShapeBehaviorCallback = null;
    shapeBehaviorUserData:      *void = null;
    controllerBehaviorCallback: CharacterBehaviorCallback = null;
    controllerBehaviorUserData: *void = null;
    obstacleBehaviorCallback:   ObstacleBehaviorCallback = null;
    obstacleBehaviorUserData:   *void = null;
}

OnContactModify :: #type (data: *void, pairs: *PxContactModifyPair, count: u32) -> void #c_call;

ContactModifyCallbackInfo :: struct {
    onContactModify:         OnContactModify = null;
    onContactModifyUserData: *void = null;
}

create_foundation :: () -> *PxFoundation #foreign libphysx "physx_create_foundation";

create_foundation_with_alloc :: (allocator: *PxAllocatorCallback) -> *PxFoundation #foreign libphysx "physx_create_foundation_with_alloc";

// fixme[tolsson]: this might be iffy on Windows with DLLs if we have multiple packages
// linking against the raw interface
get_default_allocator :: () -> *PxAllocatorCallback #foreign libphysx;

// fixme[tolsson]: this might be iffy on Windows with DLLs if we have multiple packages
// linking against the raw interface
get_default_error_callback :: () -> *PxErrorCallback #foreign libphysx;

create_physics :: (foundation: *PxFoundation) -> *PxPhysics #foreign libphysx "physx_create_physics";

create_raycast_filter_callback :: (actor_to_ignore: *PxRigidActor) -> *PxQueryFilterCallback #foreign libphysx;

destroy_raycast_filter_callback :: (callback: *PxQueryFilterCallback) -> void #foreign libphysx;

create_raycast_filter_callback_func :: (callback: RaycastHitCallback, userData: *void) -> *PxQueryFilterCallback #foreign libphysx;

destroy_raycast_filter_callback_func :: (callback: *PxQueryFilterCallback) -> void #foreign libphysx;

create_pre_and_post_raycast_filter_callback_func :: (preFilter: RaycastHitCallback, postFilter: PostFilterCallback, userData: *void) -> *PxQueryFilterCallback #foreign libphysx;

destroy_pre_and_post_raycast_filter_callback_func :: (callback: *PxQueryFilterCallback) -> void #foreign libphysx;

create_raycast_buffer :: () -> *PxRaycastCallback #foreign libphysx;

create_sweep_buffer :: () -> *PxSweepCallback #foreign libphysx;

create_overlap_buffer :: () -> *PxOverlapCallback #foreign libphysx;

create_raycast_callback :: (process_touches_callback: RaycastHitProcessTouchesCallback, finalize_query_callback: HitFinalizeQueryCallback, touchesBuffer: *PxRaycastHit, numTouches: u32, userdata: *void) -> *PxRaycastCallback #foreign libphysx;

delete_raycast_callback :: (callback: *PxRaycastCallback) -> void #foreign libphysx;

delete_sweep_callback :: (callback: *PxSweepCallback) -> void #foreign libphysx;

delete_overlap_callback :: (callback: *PxOverlapCallback) -> void #foreign libphysx;

create_sweep_callback :: (process_touches_callback: SweepHitProcessTouchesCallback, finalize_query_callback: HitFinalizeQueryCallback, touchesBuffer: *PxSweepHit, numTouches: u32, userdata: *void) -> *PxSweepCallback #foreign libphysx;

create_overlap_callback :: (process_touches_callback: OverlapHitProcessTouchesCallback, finalize_query_callback: HitFinalizeQueryCallback, touchesBuffer: *PxOverlapHit, numTouches: u32, userdata: *void) -> *PxOverlapCallback #foreign libphysx;

create_alloc_callback :: (alloc_callback: AllocCallback, dealloc_callback: DeallocCallback, userdata: *void) -> *PxAllocatorCallback #foreign libphysx;

get_alloc_callback_user_data :: (allocator: *PxAllocatorCallback) -> *void #foreign libphysx;

create_profiler_callback :: (zone_start_callback: ZoneStartCallback, zone_end_callback: ZoneEndCallback, userdata: *void) -> *PxProfilerCallback #foreign libphysx;

create_error_callback :: (error_callback: ErrorCallback, userdata: *void) -> *PxErrorCallback #foreign libphysx;

create_assert_handler :: (on_assert: AssertHandler, userdata: *void) -> *PxAssertHandler #foreign libphysx;

// simulation event
create_simulation_event_callbacks :: (callbacks: *SimulationEventCallbackInfo) -> *PxSimulationEventCallback #foreign libphysx;

get_simulation_event_info :: (callback: *PxSimulationEventCallback) -> *SimulationEventCallbackInfo #foreign libphysx;

destroy_simulation_event_callbacks :: (callback: *PxSimulationEventCallback) -> void #foreign libphysx;

// hit report
create_user_controller_hit_report :: (callbacks: *UserControllerHitReportInfo) -> *PxUserControllerHitReport #foreign libphysx;

get_user_controller_hit_info :: (callback: *PxUserControllerHitReport) -> *UserControllerHitReportInfo #foreign libphysx;

destroy_user_controller_hit_report :: (callback: *PxUserControllerHitReport) -> void #foreign libphysx;

// controller behavior
create_controller_behavior_callbacks :: (callbacks: *ControllerBehaviorCallbackInfo) -> *PxControllerBehaviorCallback #foreign libphysx;

get_controller_behavior_info :: (callback: *PxControllerBehaviorCallback) -> *ControllerBehaviorCallbackInfo #foreign libphysx;

destroy_controller_behavior_callbacks :: (callback: *PxControllerBehaviorCallback) -> void #foreign libphysx;

// contact modify
create_contact_modify_callbacks :: (callbacks: *ContactModifyCallbackInfo) -> *PxContactModifyCallback #foreign libphysx;

get_contact_modify_info :: (callback: *PxContactModifyCallback) -> *ContactModifyCallbackInfo #foreign libphysx;

destroy_contact_modify_callbacks :: (callback: *PxContactModifyCallback) -> void #foreign libphysx;

// ccd contact modify
create_ccd_contact_modify_callbacks :: (callbacks: *ContactModifyCallbackInfo) -> *PxCCDContactModifyCallback #foreign libphysx;

get_ccd_contact_modify_info :: (callback: *PxCCDContactModifyCallback) -> *ContactModifyCallbackInfo #foreign libphysx;

destroy_ccd_contact_modify_callbacks :: (callback: *PxCCDContactModifyCallback) -> void #foreign libphysx;

// filter shader
get_default_simulation_filter_shader :: () -> SimulationFilterShader #foreign libphysx;

set_default_filter_shader :: (desc: *PxSceneDesc) -> void #foreign libphysx;

create_custom_filter_shader :: (filter: SimulationFilterShader) -> *FilterShaderHandle #foreign libphysx;

destroy_custom_filter_shader :: (filterHandle: *FilterShaderHandle) -> void #foreign libphysx;

set_custom_filter_shader :: (desc: *PxSceneDesc, filterHandle: *FilterShaderHandle) -> void #foreign libphysx;

set_custom_filter_shader_with_default :: (desc: *PxSceneDesc, filterHandle: *FilterShaderHandle) -> void #foreign libphysx;

// Not generated, used only for testing and examples!
PxAssertHandler_opCall :: (self: *PxErrorCallback, expr: *u8, file: *u8, line: s32, ignore: *bool) -> void #foreign libphysx "PxAssertHandler_opCall_mut";

#scope_file

libphysx :: #library "linux/libphysx";
#import "Math";
#import "Socket";