include/PxArticulationReducedCoordinate.h

File members: include/PxArticulationReducedCoordinate.h

// 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-2024 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_ARTICULATION_RC_H
#define PX_ARTICULATION_RC_H

#include "PxPhysXConfig.h"
#include "common/PxBase.h"
#include "foundation/PxVec3.h"
#include "foundation/PxBounds3.h"
#include "foundation/PxTransform.h"
#include "solver/PxSolverDefs.h"
#include "PxArticulationFlag.h"
#include "PxArticulationTendon.h"
#include "PxResidual.h"
#include "PxArticulationMimicJoint.h"
#include "PxArticulationFlag.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 PxConstraint;
    class PxScene;

    struct PxArticulationRootLinkData
    {
        PxTransform transform;
        // The velocities and accelerations below are with respect to the center of mass (COM) of the root link. The COM and actor frame origin may not coincide.
        PxVec3      worldLinVel;
        PxVec3      worldAngVel;
        PxVec3      worldLinAccel;
        PxVec3      worldAngAccel;
    };

    class PxArticulationCache
    {
    public:
        PxArticulationCache() :
            externalForces              (NULL),
            denseJacobian               (NULL),
            massMatrix                  (NULL),
            coriolisForce               (NULL),
            gravityCompensationForce    (NULL),
            centroidalMomentumMatrix    (NULL),
            centroidalMomentumBias      (NULL),
            jointVelocity               (NULL),
            jointAcceleration           (NULL),
            jointPosition               (NULL),
            jointForce                  (NULL),
            jointTargetPositions        (NULL),
            jointTargetVelocities       (NULL),
            linkVelocity                (NULL),
            linkAcceleration            (NULL),
            linkIncomingJointForce      (NULL),
            linkForce                   (NULL),
            linkTorque                  (NULL),
            rootLinkData                (NULL),
            coefficientMatrix           (NULL),
            lambda                      (NULL),
            scratchMemory               (NULL),
            scratchAllocator            (NULL),
            version                     (0)
        {}

        PX_PHYSX_CORE_API void      release();

        PxSpatialForce*             externalForces;

        PxReal*                     denseJacobian;

        PxReal*                     massMatrix;

        PxReal*                     coriolisForce;

        PxReal*                     gravityCompensationForce;

        PxReal*                     centroidalMomentumMatrix;

        PxReal*                     centroidalMomentumBias;

        PxReal*                     jointVelocity;

        PxReal*                     jointAcceleration;

        PxReal*                     jointPosition;

        PxReal*                     jointForce;

        PxReal*                     jointTargetPositions;

        PxReal*                     jointTargetVelocities;

        PxSpatialVelocity*          linkVelocity;

        PxSpatialVelocity*          linkAcceleration;

        PxSpatialForce*         linkIncomingJointForce;

        PxVec3*                 linkForce;

        PxVec3*                 linkTorque;

        PxArticulationRootLinkData* rootLinkData;

        // Members and memory below here are not zeroed when zeroCache is called, and are not included in the size returned by PxArticulationReducedCoordinate::getCacheDataSize.

        PX_DEPRECATED PxReal*           coefficientMatrix;

        PX_DEPRECATED PxReal*           lambda;

        void*                       scratchMemory;
        void*                       scratchAllocator;
        PxU32                       version;
    };

    struct PxArticulationKinematicFlag
    {
        enum Enum
        {
            ePOSITION = 1 << 0,
            eVELOCITY = 1 << 1
        };
    };

    typedef physx::PxFlags<PxArticulationKinematicFlag::Enum, PxU8> PxArticulationKinematicFlags;
    PX_FLAGS_OPERATORS(PxArticulationKinematicFlag::Enum, PxU8)

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

    class PxArticulationReducedCoordinate : public PxBase
    {
    public:

        virtual     PxScene*        getScene()  const = 0;

        virtual     void                setSolverIterationCounts(PxU32 minPositionIters, PxU32 minVelocityIters = 1) = 0;

        virtual     void                getSolverIterationCounts(PxU32& minPositionIters, PxU32& minVelocityIters) const = 0;

        virtual     bool                isSleeping() const = 0;

        virtual     void                setSleepThreshold(PxReal threshold) = 0;

        virtual     PxReal              getSleepThreshold() const = 0;

        virtual     void                setStabilizationThreshold(PxReal threshold) = 0;

        virtual     PxReal              getStabilizationThreshold() const = 0;

        virtual     void                setWakeCounter(PxReal wakeCounterValue) = 0;

        virtual     PxReal              getWakeCounter() const = 0;

        virtual     void                wakeUp() = 0;

        virtual     void                putToSleep() = 0;

        PX_DEPRECATED virtual       void                setMaxCOMLinearVelocity(const PxReal maxLinearVelocity) = 0;

        PX_DEPRECATED virtual       PxReal              getMaxCOMLinearVelocity() const = 0;

        PX_DEPRECATED virtual       void                setMaxCOMAngularVelocity(const PxReal maxAngularVelocity) = 0;

        PX_DEPRECATED virtual       PxReal              getMaxCOMAngularVelocity() const = 0;

        virtual     PxArticulationLink* createLink(PxArticulationLink* parent, const PxTransform& pose) = 0;

        virtual     void                release() = 0;

        virtual     PxU32               getNbLinks() const = 0;

        virtual     PxU32               getLinks(PxArticulationLink** userBuffer, PxU32 bufferSize, PxU32 startIndex = 0)   const = 0;

        virtual     PxU32               getNbShapes() const = 0;

        virtual     void                setName(const char* name) = 0;

        virtual     const char*         getName()           const = 0;

        virtual     PxBounds3           getWorldBounds(float inflation = 1.01f) const = 0;

        virtual     PxAggregate*        getAggregate() const = 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) const = 0;

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

        virtual     void                    copyInternalStateToCache(PxArticulationCache& cache, const PxArticulationCacheFlags flags) 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                    computeGravityCompensation(PxArticulationCache& cache) const = 0;

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

        virtual     void                    computeCoriolisCompensation(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 PX_DEPRECATED   void        computeCoefficientMatrix(PxArticulationCache& cache) const = 0;

        virtual PX_DEPRECATED   bool        computeLambda(PxArticulationCache& cache, PxArticulationCache& initialState, const PxReal* const jointTorque, const PxU32 maxIter) const = 0;

        virtual PX_DEPRECATED   void        computeGeneralizedMassMatrix(PxArticulationCache& cache) const = 0;

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

        virtual     PxVec3              computeArticulationCOM(const bool rootFrame = false) const = 0;

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

        virtual PX_DEPRECATED   void        addLoopJoint(PxConstraint* joint) = 0;

        virtual PX_DEPRECATED   void        removeLoopJoint(PxConstraint* joint) = 0;

        virtual PX_DEPRECATED   PxU32       getNbLoopJoints() const = 0;

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

        virtual PX_DEPRECATED   PxU32       getCoefficientMatrixSize() const = 0;

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

        virtual     PxTransform             getRootGlobalPose() const = 0;

        virtual     void                    setRootLinearVelocity(const PxVec3& linearVelocity, bool autowake = true) = 0;

        virtual     PxVec3                  getRootLinearVelocity() const = 0;

        virtual     void                    setRootAngularVelocity(const PxVec3& angularVelocity, bool autowake = true) = 0;

        virtual     PxVec3                  getRootAngularVelocity() const = 0;

        virtual     PxSpatialVelocity       getLinkAcceleration(const PxU32 linkId) = 0;

        virtual     PX_DEPRECATED PxU32                 getGpuArticulationIndex() = 0;

        virtual     PxArticulationGPUIndex              getGPUIndex() const = 0;

        virtual     PxArticulationSpatialTendon*    createSpatialTendon() = 0;

        virtual     PxArticulationFixedTendon*      createFixedTendon() = 0;

        virtual     PxU32                   getSpatialTendons(PxArticulationSpatialTendon** userBuffer, PxU32 bufferSize, PxU32 startIndex = 0) const = 0;

        virtual     PxU32                   getNbSpatialTendons() const = 0;

        virtual     PxU32                   getFixedTendons(PxArticulationFixedTendon** userBuffer, PxU32 bufferSize, PxU32 startIndex = 0) const = 0;

        virtual     PxU32                   getNbFixedTendons() const = 0;

        virtual     PxArticulationMimicJoint*       createMimicJoint(
                const PxArticulationJointReducedCoordinate& jointA, PxArticulationAxis::Enum axisA,
                const PxArticulationJointReducedCoordinate& jointB, PxArticulationAxis::Enum axisB,
                PxReal gearRatio, PxReal offset,
                PxReal naturalFrequency = 0.0f, PxReal dampingRatio = 0.0f) = 0;

        virtual     PxU32                           getMimicJoints(PxArticulationMimicJoint** userBuffer, PxU32 bufferSize, PxU32 startIndex = 0)   const = 0;

        virtual      PxU32                          getNbMimicJoints() const = 0;

        virtual     void                    updateKinematic(PxArticulationKinematicFlags flags) = 0;

        virtual     PxArticulationResidual  getSolverResidual() const = 0;

        virtual     const char*             getConcreteTypeName() const PX_OVERRIDE PX_FINAL { return "PxArticulationReducedCoordinate"; }

        virtual                             ~PxArticulationReducedCoordinate() {}

        void*                               userData;

    protected:
        PX_INLINE                           PxArticulationReducedCoordinate(PxType concreteType, PxBaseFlags baseFlags) : PxBase(concreteType, baseFlags) {}
        PX_INLINE                           PxArticulationReducedCoordinate(PxBaseFlags baseFlags) : PxBase(baseFlags) {}

        virtual     bool            isKindOf(const char* name) const { PX_IS_KIND_OF(name, "PxArticulationReducedCoordinate", PxBase); }
    };

#if PX_VC
#pragma warning(pop)
#endif

#if !PX_DOXYGEN
} // namespace physx
#endif

#endif