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

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

#if !PX_DOXYGEN
namespace physx
{
#endif

    namespace Cm
    {
        class SpatialVector;
    }

    class PxContactJoint;

    struct PxArticulationFlag
    {
        enum Enum
        {
            eFIX_BASE = (1 << 0)
        };
    };

    class PxJoint;

    typedef PxFlags<PxArticulationFlag::Enum, PxU8> PxArticulationFlags;
    PX_FLAGS_OPERATORS(PxArticulationFlag::Enum, PxU8)

    //PxKinematicJacobian is in world space 6x6 matrix
    class PxKinematicJacobian
    {
    public:
        //in each single column, top part is angular term and bottom is linear term
        PxReal j[6][6];//[column][row]

        PxU32   nbColumns;
    };

    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),     
            eROOT           = (1 << 4),     
            eALL            = (eVELOCITY | eACCELERATION | ePOSITION| eROOT)
        };
        PxArticulationCache() : coefficientMatrix(NULL), lambda(NULL)
        {}

        Cm::SpatialVector*          externalForces;     // N = getNbLinks()
        PxKinematicJacobian*        jacobian;           // Jacobian matrix, N = NumJoints, NumJoints = getNbLinks() - 1
        PxReal*                     denseJacobian;      // Dense Jacobian, 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()
        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 configulation 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                    computeKinematicJacobian(const PxU32 linkID, 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;

    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