PxRigidBody.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_RIGIDBODY
#define PX_PHYSICS_NX_RIGIDBODY

#include "PxRigidActor.h"
#include "PxForceMode.h"

#if !PX_DOXYGEN
namespace physx
{
#endif


struct PxRigidBodyFlag
{
    enum Enum
    {

        eKINEMATIC                                  = (1<<0),       

        eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES     = (1<<1),

        eENABLE_CCD                 = (1<<2),       

        eENABLE_CCD_FRICTION            = (1<<3),

        eENABLE_POSE_INTEGRATION_PREVIEW    = (1 << 4),

        eENABLE_SPECULATIVE_CCD             = (1 << 5),

        eENABLE_CCD_MAX_CONTACT_IMPULSE = (1 << 6),

        eRETAIN_ACCELERATIONS = (1<<7),

        eFORCE_KINE_KINE_NOTIFICATIONS = (1<<8),

        eFORCE_STATIC_KINE_NOTIFICATIONS = (1<<9),

        eRESERVED = (1<<15)
    };
};

typedef PxFlags<PxRigidBodyFlag::Enum,PxU16> PxRigidBodyFlags;
PX_FLAGS_OPERATORS(PxRigidBodyFlag::Enum,PxU16)


class PxRigidBody : public PxRigidActor
{
public:
    // Runtime modifications

/************************************************************************************************/
    virtual     void            setCMassLocalPose(const PxTransform& pose) = 0;


    virtual     PxTransform     getCMassLocalPose() const = 0;


    virtual     void            setMass(PxReal mass) = 0;

    virtual     PxReal          getMass() const = 0;

    virtual     PxReal          getInvMass() const = 0;

    virtual     void            setMassSpaceInertiaTensor(const PxVec3& m) = 0;

    virtual     PxVec3          getMassSpaceInertiaTensor()         const = 0;

    virtual     PxVec3          getMassSpaceInvInertiaTensor()          const = 0;

    /************************************************************************************************/
    virtual     void                setLinearDamping(PxReal linDamp) = 0;

    virtual     PxReal              getLinearDamping() const = 0;

    virtual     void                setAngularDamping(PxReal angDamp) = 0;

    virtual     PxReal              getAngularDamping() const = 0;


/************************************************************************************************/
    virtual     PxVec3          getLinearVelocity()     const = 0;

    virtual     void            setLinearVelocity(const PxVec3& linVel, bool autowake = true ) = 0;



    virtual     PxVec3          getAngularVelocity()    const = 0;


    virtual     void            setAngularVelocity(const PxVec3& angVel, bool autowake = true ) = 0;

    virtual     void                setMaxAngularVelocity(PxReal maxAngVel) = 0;

    virtual     PxReal              getMaxAngularVelocity() const = 0;


    virtual     void                setMaxLinearVelocity(PxReal maxLinVel) = 0;

    virtual     PxReal              getMaxLinearVelocity()  const = 0;


/************************************************************************************************/
    virtual     void            addForce(const PxVec3& force, PxForceMode::Enum mode = PxForceMode::eFORCE, bool autowake = true) = 0;

    virtual     void            addTorque(const PxVec3& torque, PxForceMode::Enum mode = PxForceMode::eFORCE, bool autowake = true) = 0;

    virtual     void            clearForce(PxForceMode::Enum mode = PxForceMode::eFORCE) = 0;

    virtual     void            clearTorque(PxForceMode::Enum mode = PxForceMode::eFORCE) = 0;


    virtual     void            setForceAndTorque(const PxVec3& force, const PxVec3& torque, PxForceMode::Enum mode = PxForceMode::eFORCE) = 0;

    virtual     void                setRigidBodyFlag(PxRigidBodyFlag::Enum flag, bool value) = 0;
    virtual     void                setRigidBodyFlags(PxRigidBodyFlags inFlags) = 0;

    virtual     PxRigidBodyFlags    getRigidBodyFlags() const = 0;

    virtual void setMinCCDAdvanceCoefficient(PxReal advanceCoefficient) = 0;

    virtual PxReal getMinCCDAdvanceCoefficient() const = 0;


    virtual void setMaxDepenetrationVelocity(PxReal biasClamp) = 0;

    virtual PxReal getMaxDepenetrationVelocity() const = 0;


    virtual void setMaxContactImpulse(PxReal maxImpulse) = 0;

    virtual PxReal getMaxContactImpulse() const = 0;

    virtual PxU32 getInternalIslandNodeIndex() const = 0;


protected:
    PX_INLINE                   PxRigidBody(PxType concreteType, PxBaseFlags baseFlags) : PxRigidActor(concreteType, baseFlags) {}
    PX_INLINE                   PxRigidBody(PxBaseFlags baseFlags) : PxRigidActor(baseFlags) {}
    virtual                     ~PxRigidBody()  {}
    virtual     bool            isKindOf(const char* name)const {   return !::strcmp("PxRigidBody", name) || PxRigidActor::isKindOf(name); }
};


#if !PX_DOXYGEN
} // namespace physx
#endif

#endif