PxRigidBody.h

Go to the documentation of this file.

/*
 * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, 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.
 */
// 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"

#ifndef 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)
    };
};

typedef PX_DEPRECATED PxRigidBodyFlag PxRigidDynamicFlag;

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


typedef PxFlags<PxRigidDynamicFlag::Enum,PxU8> PxRigidDynamicFlags;


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

    PX_DEPRECATED virtual   void    setRigidDynamicFlag(PxRigidDynamicFlag::Enum flag, bool value) = 0;
    PX_DEPRECATED virtual   void    setRigidDynamicFlags(PxRigidDynamicFlags inFlags) = 0;

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

    PX_DEPRECATED virtual   PxRigidDynamicFlags getRigidDynamicFlags()  const = 0;

    virtual     PxRigidBodyFlags    getRigidBodyFlags() const = 0;

    virtual void setMinCCDAdvanceCoefficient(PxReal advanceCoefficient) = 0;

    virtual PxReal getMinCCDAdvanceCoefficient() const = 0;


    virtual void setMaxDepenetrationVelocity(const PxReal biasClamp) = 0;

    virtual PxReal getMaxDepenetrationVelocity() 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); }
};

PX_DEPRECATED PX_INLINE PxRigidBody*        PxActor::isRigidBody()              { return is<PxRigidBody>();         }
PX_DEPRECATED PX_INLINE const PxRigidBody*  PxActor::isRigidBody()      const   { return is<PxRigidBody>();         }


#ifndef PX_DOXYGEN
} // namespace physx
#endif

#endif