---

       

---

PxRigidBody.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_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)
    };
};

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


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

---

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