PxImmediateMode.h

Go to the documentation of this file.

//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of NVIDIA CORPORATION nor the names of its
//    contributors may be used to endorse or promote products derived
//    from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2019 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  

#ifndef PX_PHYSICS_IMMEDIATE_MODE
#define PX_PHYSICS_IMMEDIATE_MODE

#include "PxPhysXConfig.h"
#include "solver/PxSolverDefs.h"
#include "collision/PxCollisionDefs.h"

#if !PX_DOXYGEN
namespace physx
{
#endif

#if !PX_DOXYGEN
namespace immediate
{
#endif

    struct PxRigidBodyData
    {
        PX_ALIGN(16, PxVec3 linearVelocity);    
        PxReal invMass;                         
        PxVec3 angularVelocity;                 
        PxReal maxDepenetrationVelocity;        
        PxVec3 invInertia;                      
        PxReal maxContactImpulse;               
        PxTransform body2World;                 
        PxReal linearDamping;                   
        PxReal angularDamping;                  
        PxReal maxLinearVelocitySq;             
        PxReal maxAngularVelocitySq;            
        PxU32 pad;                              
    };

    class PxContactRecorder
    {
    public:
        virtual bool recordContacts(const Gu::ContactPoint* contactPoints, const PxU32 nbContacts, const PxU32 index) = 0;

        virtual ~PxContactRecorder(){}
    };

    PX_C_EXPORT PX_PHYSX_CORE_API void PxConstructSolverBodies(const PxRigidBodyData* inRigidData, PxSolverBodyData* outSolverBodyData, const PxU32 nbBodies, const PxVec3& gravity, const PxReal dt);

    PX_C_EXPORT PX_PHYSX_CORE_API void PxConstructStaticSolverBody(const PxTransform& globalPose, PxSolverBodyData& solverBodyData);

    PX_C_EXPORT PX_PHYSX_CORE_API PxU32 PxBatchConstraints( const PxSolverConstraintDesc* solverConstraintDescs, const PxU32 nbConstraints, PxSolverBody* solverBodies, const PxU32 nbBodies,
                                                            PxConstraintBatchHeader* outBatchHeaders, PxSolverConstraintDesc* outOrderedConstraintDescs,
                                                            Dy::ArticulationV** articulations=NULL, const PxU32 nbArticulations=0);

    PX_C_EXPORT PX_PHYSX_CORE_API bool PxCreateContactConstraints(PxConstraintBatchHeader* batchHeaders, const PxU32 nbHeaders, PxSolverContactDesc* contactDescs,
        PxConstraintAllocator& allocator, const PxReal invDt, const PxReal bounceThreshold, const PxReal frictionOffsetThreshold, const PxReal correlationDistance);

    PX_C_EXPORT PX_PHYSX_CORE_API bool PxCreateJointConstraints(PxConstraintBatchHeader* batchHeaders, const PxU32 nbHeaders, PxSolverConstraintPrepDesc* jointDescs, PxConstraintAllocator& allocator, const PxReal dt, const PxReal invDt);

    PX_C_EXPORT PX_PHYSX_CORE_API bool PxCreateJointConstraintsWithShaders(PxConstraintBatchHeader* batchHeaders, const PxU32 nbBatchHeaders, PxConstraint** constraints, PxSolverConstraintPrepDesc* jointDescs, PxConstraintAllocator& allocator, const PxReal dt, const PxReal invDt);

    struct PxImmediateConstraint
    {
        PxConstraintSolverPrep  prep;
        const void*             constantBlock;
    };
    PX_C_EXPORT PX_PHYSX_CORE_API bool PxCreateJointConstraintsWithImmediateShaders(PxConstraintBatchHeader* batchHeaders, const PxU32 nbBatchHeaders, PxImmediateConstraint* constraints, PxSolverConstraintPrepDesc* jointDescs, PxConstraintAllocator& allocator, const PxReal dt, const PxReal invDt);

    PX_C_EXPORT PX_PHYSX_CORE_API void PxSolveConstraints(const PxConstraintBatchHeader* batchHeaders, const PxU32 nbBatchHeaders, const PxSolverConstraintDesc* solverConstraintDescs,
        const PxSolverBody* solverBodies, PxVec3* linearMotionVelocity, PxVec3* angularMotionVelocity, const PxU32 nbSolverBodies, const PxU32 nbPositionIterations, const PxU32 nbVelocityIterations,
        const float dt=0.0f, const float invDt=0.0f, const PxU32 nbSolverArticulations=0, Dy::ArticulationV** solverArticulations=NULL);

    PX_C_EXPORT PX_PHYSX_CORE_API void PxIntegrateSolverBodies(PxSolverBodyData* solverBodyData, PxSolverBody* solverBody, const PxVec3* linearMotionVelocity, const PxVec3* angularMotionState, const PxU32 nbBodiesToIntegrate, const PxReal dt);

    PX_C_EXPORT PX_PHYSX_CORE_API bool PxGenerateContacts(const PxGeometry* const * geom0, const PxGeometry* const * geom1, const PxTransform* pose0, const PxTransform* pose1, PxCache* contactCache, const PxU32 nbPairs, PxContactRecorder& contactRecorder,
        const PxReal contactDistance, const PxReal meshContactMargin, const PxReal toleranceLength, PxCacheAllocator& allocator);

    PX_C_EXPORT PX_PHYSX_CORE_API void PxRegisterImmediateArticulations();

    struct PxArticulationJointData
    {
        PxTransform parentPose;
        PxTransform childPose;
    };

    struct PxFeatherstoneArticulationJointData : PxArticulationJointData
    {
        PxArticulationJointType::Enum   type;
        PxArticulationMotion::Enum      motion[PxArticulationAxis::eCOUNT];
        PxArticulationLimit             limits[PxArticulationAxis::eCOUNT];
        PxArticulationDrive             drives[PxArticulationAxis::eCOUNT];
        PxReal                          targetPos[PxArticulationAxis::eCOUNT];
        PxReal                          targetVel[PxArticulationAxis::eCOUNT];
        PxReal                          frictionCoefficient;
        PxReal                          maxJointVelocity;
    };

    struct PxFeatherstoneArticulationData
    {
        PxArticulationFlags     flags;
    };

    struct PxMutableLinkData
    {
        PxVec3  inverseInertia;
        float   inverseMass;
        float   linearDamping;
        float   angularDamping;
        float   maxLinearVelocitySq;
        float   maxAngularVelocitySq;
        bool    disableGravity;
    };

    struct PxLinkData
    {
        PxTransform pose;
        PxVec3      linearVelocity;
        PxVec3      angularVelocity;
    };

    struct PxFeatherstoneArticulationLinkData : PxMutableLinkData
    {
        PxFeatherstoneArticulationLinkData()    { initData();   }

        void    initData()
        {
            inboundJoint.type                   = PxArticulationJointType::eUNDEFINED;  // For root
            inboundJoint.parentPose             = PxTransform(PxIdentity);
            inboundJoint.childPose              = PxTransform(PxIdentity);
            inboundJoint.frictionCoefficient    = 0.05f;
            inboundJoint.maxJointVelocity       = 100.0f;

            pose                    = PxTransform(PxIdentity);
            parent                  = 0;
            inverseInertia          = PxVec3(1.0f);
            inverseMass             = 1.0f;
            linearDamping           = 0.05f;
            angularDamping          = 0.05f;
            maxLinearVelocitySq     = 100.0f * 100.0f;
            maxAngularVelocitySq    = 50.0f * 50.0f;
            disableGravity          = false;

            for(PxU32 i=0;i<PxArticulationAxis::eCOUNT;i++)
            {
                inboundJoint.motion[i] = PxArticulationMotion::eLOCKED;
                inboundJoint.limits[i].low = inboundJoint.limits[i].high = 0.0f;
                inboundJoint.drives[i].stiffness = 0.0f;
                inboundJoint.drives[i].damping = 0.0f;
                inboundJoint.drives[i].maxForce = 0.0f;
                inboundJoint.drives[i].driveType = PxArticulationDriveType::eFORCE;
            }
            memset(inboundJoint.targetPos, 0xff, sizeof(PxReal)*PxArticulationAxis::eCOUNT);
            memset(inboundJoint.targetVel, 0xff, sizeof(PxReal)*PxArticulationAxis::eCOUNT);
        }

        PxFeatherstoneArticulationJointData inboundJoint;

        // Non-mutable link data
        PxTransform                 pose;
        Dy::ArticulationLinkHandle  parent;
    };

    // PT: Design note: I use Dy::ArticulationV* to be consistent with PxSolverDefs.h
    PX_C_EXPORT PX_PHYSX_CORE_API Dy::ArticulationV*    PxCreateFeatherstoneArticulation(const PxFeatherstoneArticulationData& data);

    PX_C_EXPORT PX_PHYSX_CORE_API void  PxReleaseArticulation(Dy::ArticulationV* articulation);

    PX_C_EXPORT PX_PHYSX_CORE_API Dy::ArticulationLinkHandle    PxAddArticulationLink(Dy::ArticulationV* articulation, const PxFeatherstoneArticulationLinkData& data, bool isLastLink=false);

    PX_C_EXPORT PX_PHYSX_CORE_API Dy::ArticulationV*    PxGetLinkArticulation(const Dy::ArticulationLinkHandle link);

    PX_C_EXPORT PX_PHYSX_CORE_API PxU32 PxGetLinkIndex(const Dy::ArticulationLinkHandle link);

    PX_C_EXPORT PX_PHYSX_CORE_API bool  PxGetLinkData(const Dy::ArticulationLinkHandle link, PxLinkData& data);

    PX_C_EXPORT PX_PHYSX_CORE_API PxU32 PxGetAllLinkData(const Dy::ArticulationV* articulation, PxLinkData* data);

    PX_C_EXPORT PX_PHYSX_CORE_API bool  PxGetMutableLinkData(const Dy::ArticulationLinkHandle link, PxMutableLinkData& data);

    PX_C_EXPORT PX_PHYSX_CORE_API bool  PxSetMutableLinkData(Dy::ArticulationLinkHandle link, const PxMutableLinkData& data);

    PX_C_EXPORT PX_PHYSX_CORE_API bool  PxGetJointData(const Dy::ArticulationLinkHandle link, PxFeatherstoneArticulationJointData& data);

    PX_C_EXPORT PX_PHYSX_CORE_API bool  PxSetJointData(Dy::ArticulationLinkHandle link, const PxFeatherstoneArticulationJointData& data);

    PX_C_EXPORT PX_PHYSX_CORE_API void  PxComputeUnconstrainedVelocities(Dy::ArticulationV* articulation, const PxVec3& gravity, const PxReal dt);

    PX_C_EXPORT PX_PHYSX_CORE_API void  PxUpdateArticulationBodies(Dy::ArticulationV* articulation, const PxReal dt);

    PX_C_EXPORT PX_PHYSX_CORE_API void  PxComputeUnconstrainedVelocitiesTGS(Dy::ArticulationV* articulation, const PxVec3& gravity, const PxReal dt, const PxReal totalDt, const PxReal invDt, const PxReal invTotalDt);

    PX_C_EXPORT PX_PHYSX_CORE_API void  PxUpdateArticulationBodiesTGS(Dy::ArticulationV* articulation, const PxReal dt);


    PX_C_EXPORT PX_PHYSX_CORE_API void PxConstructSolverBodiesTGS(const PxRigidBodyData* inRigidData, PxTGSSolverBodyVel* outSolverBodyVel, PxTGSSolverBodyTxInertia* outSolverBodyTxInertia, PxTGSSolverBodyData* outSolverBodyData, const PxU32 nbBodies, const PxVec3& gravity, const PxReal dt);

    PX_C_EXPORT PX_PHYSX_CORE_API void PxConstructStaticSolverBodyTGS(const PxTransform& globalPose, PxTGSSolverBodyVel& solverBodyVel, PxTGSSolverBodyTxInertia& solverBodyTxInertia, PxTGSSolverBodyData& solverBodyData);

    PX_C_EXPORT PX_PHYSX_CORE_API PxU32 PxBatchConstraintsTGS(const PxSolverConstraintDesc* solverConstraintDescs, const PxU32 nbConstraints, PxTGSSolverBodyVel* solverBodies, const PxU32 nbBodies,
        PxConstraintBatchHeader* outBatchHeaders, PxSolverConstraintDesc* outOrderedConstraintDescs,
        Dy::ArticulationV** articulations = NULL, const PxU32 nbArticulations = 0);


    PX_C_EXPORT PX_PHYSX_CORE_API bool PxCreateContactConstraintsTGS(PxConstraintBatchHeader* batchHeaders, const PxU32 nbHeaders, PxTGSSolverContactDesc* contactDescs,
        PxConstraintAllocator& allocator, const PxReal invDt, const PxReal invTotalDt, const PxReal bounceThreshold, const PxReal frictionOffsetThreshold, const PxReal correlationDistance);

    PX_C_EXPORT PX_PHYSX_CORE_API bool PxCreateJointConstraintsTGS(PxConstraintBatchHeader* batchHeaders, const PxU32 nbHeaders,
        PxTGSSolverConstraintPrepDesc* jointDescs, PxConstraintAllocator& allocator, const PxReal dt, const PxReal totalDt, const PxReal invDt,
        const PxReal invTotalDt, const PxReal lengthScale);

    PX_C_EXPORT PX_PHYSX_CORE_API bool PxCreateJointConstraintsWithShadersTGS(PxConstraintBatchHeader* batchHeaders, const PxU32 nbBatchHeaders, PxConstraint** constraints, PxTGSSolverConstraintPrepDesc* jointDescs, PxConstraintAllocator& allocator, const PxReal dt, 
        const PxReal totalDt, const PxReal invDt, const PxReal invTotalDt, const PxReal lengthScale);

    PX_C_EXPORT PX_PHYSX_CORE_API bool PxCreateJointConstraintsWithImmediateShadersTGS(PxConstraintBatchHeader* batchHeaders, const PxU32 nbBatchHeaders, PxImmediateConstraint* constraints, PxTGSSolverConstraintPrepDesc* jointDescs,
        PxConstraintAllocator& allocator, const PxReal dt, const PxReal totalDt, const PxReal invDt, const PxReal invTotalDt, const PxReal lengthScale);


    PX_C_EXPORT PX_PHYSX_CORE_API void PxSolveConstraintsTGS(const PxConstraintBatchHeader* batchHeaders, const PxU32 nbBatchHeaders, const PxSolverConstraintDesc* solverConstraintDescs,
        PxTGSSolverBodyVel* solverBodies, PxTGSSolverBodyTxInertia* txInertias, const PxU32 nbSolverBodies, const PxU32 nbPositionIterations, const PxU32 nbVelocityIterations,
        const float dt, const float invDt, const PxU32 nbSolverArticulations, Dy::ArticulationV** solverArticulations);

    PX_C_EXPORT PX_PHYSX_CORE_API void PxIntegrateSolverBodiesTGS(PxTGSSolverBodyVel* solverBody, PxTGSSolverBodyTxInertia* txInertia, PxTransform* poses, const PxU32 nbBodiesToIntegrate, const PxReal dt);


#if !PX_DOXYGEN
}
#endif

#if !PX_DOXYGEN
}
#endif

#endif