PxArticulationReducedCoordinate.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-2021 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_NX_ARTICULATION_RC
#define PX_PHYSICS_NX_ARTICULATION_RC

#include "PxArticulationBase.h"
#include "foundation/PxVec3.h"
#include "foundation/PxTransform.h"
#include "solver/PxSolverDefs.h"

#if !PX_DOXYGEN
namespace physx
{
#endif

    PX_ALIGN_PREFIX(16)
    struct PxSpatialForce
    {
        PxVec3 force;
        PxReal pad0;
        PxVec3 torque;
        PxReal pad1;
    }
    PX_ALIGN_SUFFIX(16);

    PX_ALIGN_PREFIX(16)
    struct PxSpatialVelocity
    {
        PxVec3 linear;
        PxReal pad0;
        PxVec3 angular;
        PxReal pad1;
    }
    PX_ALIGN_SUFFIX(16);

    class PxJoint;

    struct PxArticulationRootLinkData
    {
        PxTransform transform;
        PxVec3      worldLinVel;
        PxVec3      worldAngVel;
        PxVec3      worldLinAccel;
        PxVec3      worldAngAccel;
    };

    class PxArticulationCache
    {
    public:
        enum Enum
        {
            eVELOCITY           = (1 << 0),     
            eACCELERATION       = (1 << 1),     
            ePOSITION           = (1 << 2),     
            eFORCE              = (1 << 3),     
            eLINKVELOCITY       = (1 << 4),     
            eLINKACCELERATION   = (1 << 5),     
            eROOT               = (1 << 6),     
            eALL                = (eVELOCITY | eACCELERATION | ePOSITION| eLINKVELOCITY | eLINKACCELERATION | eROOT )
        };
        PxArticulationCache() :
            externalForces      (NULL),
            denseJacobian       (NULL),
            massMatrix          (NULL),
            jointVelocity       (NULL),
            jointAcceleration   (NULL),
            jointPosition       (NULL),
            jointForce          (NULL),
            rootLinkData        (NULL),
            coefficientMatrix   (NULL),
            lambda              (NULL),
            scratchMemory       (NULL),
            scratchAllocator    (NULL),
            version             (0)
        {}

        PxSpatialForce*             externalForces;         // N = getNbLinks()
        PxReal*                     denseJacobian;          // N = 6*getDofs()*NumJoints, NumJoints = getNbLinks() - 1
        PxReal*                     massMatrix;             // N = getDofs()*getDofs()
        PxReal*                     jointVelocity;          // N = getDofs()
        PxReal*                     jointAcceleration;      // N = getDofs()
        PxReal*                     jointPosition;          // N = getDofs()
        PxReal*                     jointForce;             // N = getDofs()
        PxSpatialVelocity*          linkVelocity;           // N = getNbLinks()
        PxSpatialVelocity*          linkAcceleration;       // N = getNbLinks()
        PxArticulationRootLinkData* rootLinkData;           // root link Data

        //application need to allocate those memory and assign them to the cache
        PxReal*                     coefficientMatrix; 
        PxReal*                     lambda;

        //These three members won't be set to zero when zeroCache get called 
        void*                       scratchMemory;      //this is used for internal calculation
        void*                       scratchAllocator;
        PxU32                       version;            //cache version. If the articulation configuration change, the cache is invalid
    };

    typedef PxFlags<PxArticulationCache::Enum, PxU8> PxArticulationCacheFlags;
    PX_FLAGS_OPERATORS(PxArticulationCache::Enum, PxU8)

    
#if PX_VC
#pragma warning(push)
#pragma warning(disable : 4435)
#endif

    class PxArticulationReducedCoordinate : public PxArticulationBase
    {
    public:

        virtual     void                    release() = 0;

        virtual     void                    setArticulationFlags(PxArticulationFlags flags) = 0;

        virtual     void                    setArticulationFlag(PxArticulationFlag::Enum flag, bool value) = 0;

        virtual     PxArticulationFlags     getArticulationFlags() const = 0;

        virtual         PxU32               getDofs() const = 0;

        virtual     PxArticulationCache*    createCache() const = 0;

        virtual     PxU32                   getCacheDataSize() const = 0;

        virtual     void                    zeroCache(PxArticulationCache& cache) = 0;

        virtual     void                    applyCache(PxArticulationCache& cache, const PxArticulationCacheFlags flag, bool autowake = true) = 0;

        virtual     void                    copyInternalStateToCache(PxArticulationCache& cache, const PxArticulationCacheFlags flag) const = 0;

        virtual     void                    releaseCache(PxArticulationCache& cache) const = 0;

        virtual     void                    packJointData(const PxReal* maximum, PxReal* reduced) const = 0;

        virtual     void                    unpackJointData(const PxReal* reduced, PxReal* maximum) const = 0;

        virtual     void                    commonInit() const = 0;

        virtual     void                    computeGeneralizedGravityForce(PxArticulationCache& cache) const = 0;

        virtual     void                    computeCoriolisAndCentrifugalForce(PxArticulationCache& cache) const = 0;

        virtual     void                    computeGeneralizedExternalForce(PxArticulationCache& cache) const = 0;

        virtual     void                    computeJointAcceleration(PxArticulationCache& cache) const = 0;

        virtual     void                    computeJointForce(PxArticulationCache& cache) const = 0;

        virtual     void                    computeDenseJacobian(PxArticulationCache& cache, PxU32& nRows, PxU32& nCols) const = 0;


        virtual     void                    computeCoefficientMatrix(PxArticulationCache& cache) const = 0;
        
        virtual     bool                    computeLambda(PxArticulationCache& cache, PxArticulationCache& initialState, const PxReal* const jointTorque, const PxU32 maxIter) const = 0;
        
        virtual     void                    computeGeneralizedMassMatrix(PxArticulationCache& cache) const = 0;
    
        virtual     void                    addLoopJoint(PxJoint* joint) = 0;

        virtual     void                    removeLoopJoint(PxJoint* joint) = 0;

        virtual     PxU32                   getNbLoopJoints() const = 0;

        virtual     PxU32                   getLoopJoints(PxJoint** userBuffer, PxU32 bufferSize, PxU32 startIndex = 0) const = 0;

        virtual     PxU32                   getCoefficientMatrixSize() const = 0;

        virtual     void                    teleportRootLink(const PxTransform& pose, bool autowake) = 0;


        virtual     PxSpatialVelocity       getLinkVelocity(const PxU32 linkId) = 0;


        virtual     PxSpatialVelocity       getLinkAcceleration(const PxU32 linkId) = 0;

    protected:
        PX_INLINE                           PxArticulationReducedCoordinate(PxType concreteType, PxBaseFlags baseFlags) : PxArticulationBase(concreteType, baseFlags) {}
        PX_INLINE                           PxArticulationReducedCoordinate(PxBaseFlags baseFlags) : PxArticulationBase(baseFlags) {}
        virtual                             ~PxArticulationReducedCoordinate() {}
    };

#if PX_VC
#pragma warning(pop)
#endif

#if !PX_DOXYGEN
} // namespace physx
#endif

#endif