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-2018 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 << 1)
        };
    };

    
    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                  linVel;
        PxVec3                  angVel;
        PxVec3                  linAcel;
        PxVec3                  angAcel;
    };

    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() : coefficentMatrix(NULL), lambda(NULL)
        {}

        Cm::SpatialVector*      externalForces; // N total number of links
        PxKinematicJacobian*    jacobian; //this store jacobian matrix
        PxReal*                 massMatrix; //N X N (dof X dof)
        PxReal*                 jointVelocity; //N total Dofs
        PxReal*                 jointAcceleration; //N total Dofs
        PxReal*                 jointPosition; //N total Dofs
        PxReal*                 jointForce; //N total Dofs

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

        //root link data
        PxArticulationRootLinkData  rootLinkData;

        //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                        computeCoefficentMatrix(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                       getCoefficentMatrixSize() 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