---

       

---

PxArticulationReducedCoordinate.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed to you
// under a form of NVIDIA software license agreement provided separately to you.
//
// Notice
// NVIDIA Corporation and its licensors retain all intellectual property and
// proprietary rights in and to this software and related documentation and
// any modifications thereto. Any use, reproduction, disclosure, or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA Corporation is strictly prohibited.
//
// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
//
// Information and code furnished is believed to be accurate and reliable.
// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// 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;
    };

    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;
        
        PxTransform             rootTransform;
        PxVec3                  rootLinVel;
        PxVec3                  rootAngVel;

        //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     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

---

Copyright © 2008-2018 NVIDIA Corporation, 2701 San Tomas Expressway, Santa Clara, CA 95050 U.S.A. All rights reserved. www.nvidia.com