Program Listing for include/characterkinematic/PxController.h
↰ Return to documentation for include/characterkinematic/PxController.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-2022 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_CONTROLLER_H
#define PX_CONTROLLER_H
#include "characterkinematic/PxExtended.h"
#include "characterkinematic/PxControllerObstacles.h"
#include "PxQueryFiltering.h"
#include "foundation/PxErrorCallback.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
struct PxControllerShapeType
{
enum Enum
{
eBOX,
eCAPSULE,
eFORCE_DWORD = 0x7fffffff
};
};
class PxShape;
class PxScene;
class PxController;
class PxRigidDynamic;
class PxMaterial;
struct PxFilterData;
class PxQueryFilterCallback;
class PxControllerBehaviorCallback;
class PxObstacleContext;
class PxObstacle;
struct PxControllerNonWalkableMode
{
enum Enum
{
ePREVENT_CLIMBING,
ePREVENT_CLIMBING_AND_FORCE_SLIDING
};
};
struct PxControllerCollisionFlag
{
enum Enum
{
eCOLLISION_SIDES = (1<<0),
eCOLLISION_UP = (1<<1),
eCOLLISION_DOWN = (1<<2)
};
};
typedef PxFlags<PxControllerCollisionFlag::Enum, PxU8> PxControllerCollisionFlags;
PX_FLAGS_OPERATORS(PxControllerCollisionFlag::Enum, PxU8)
struct PxControllerState
{
PxVec3 deltaXP;
PxShape* touchedShape;
PxRigidActor* touchedActor;
PxObstacleHandle touchedObstacleHandle; // Obstacle on which the CCT is standing
PxU32 collisionFlags;
bool standOnAnotherCCT;
bool standOnObstacle;
bool isMovingUp;
};
struct PxControllerStats
{
PxU16 nbIterations;
PxU16 nbFullUpdates;
PxU16 nbPartialUpdates;
PxU16 nbTessellation;
};
struct PxControllerHit
{
PxController* controller;
PxExtendedVec3 worldPos;
PxVec3 worldNormal;
PxVec3 dir;
PxF32 length;
};
struct PxControllerShapeHit : public PxControllerHit
{
PxShape* shape;
PxRigidActor* actor;
PxU32 triangleIndex;
};
struct PxControllersHit : public PxControllerHit
{
PxController* other;
};
struct PxControllerObstacleHit : public PxControllerHit
{
const void* userData;
};
class PxUserControllerHitReport
{
public:
virtual void onShapeHit(const PxControllerShapeHit& hit) = 0;
virtual void onControllerHit(const PxControllersHit& hit) = 0;
virtual void onObstacleHit(const PxControllerObstacleHit& hit) = 0;
protected:
virtual ~PxUserControllerHitReport(){}
};
class PxControllerFilterCallback
{
public:
virtual ~PxControllerFilterCallback(){}
virtual bool filter(const PxController& a, const PxController& b) = 0;
};
class PxControllerFilters
{
public:
PX_INLINE PxControllerFilters(const PxFilterData* filterData=NULL, PxQueryFilterCallback* cb=NULL, PxControllerFilterCallback* cctFilterCb=NULL) :
mFilterData (filterData),
mFilterCallback (cb),
mFilterFlags (PxQueryFlag::eSTATIC|PxQueryFlag::eDYNAMIC|PxQueryFlag::ePREFILTER),
mCCTFilterCallback (cctFilterCb)
{}
// CCT-vs-shapes:
const PxFilterData* mFilterData;
PxQueryFilterCallback* mFilterCallback;
PxQueryFlags mFilterFlags;
// CCT-vs-CCT:
PxControllerFilterCallback* mCCTFilterCallback;
};
class PxControllerDesc
{
public:
PX_INLINE virtual bool isValid() const;
PX_INLINE PxControllerShapeType::Enum getType() const { return mType; }
PxExtendedVec3 position;
PxVec3 upDirection;
PxF32 slopeLimit;
PxF32 invisibleWallHeight;
PxF32 maxJumpHeight;
PxF32 contactOffset;
PxF32 stepOffset;
PxF32 density;
PxF32 scaleCoeff;
PxF32 volumeGrowth;
PxUserControllerHitReport* reportCallback;
PxControllerBehaviorCallback* behaviorCallback;
PxControllerNonWalkableMode::Enum nonWalkableMode;
PxMaterial* material;
bool registerDeletionListener;
PxClientID clientID;
void* userData;
protected:
const PxControllerShapeType::Enum mType;
PX_INLINE PxControllerDesc(PxControllerShapeType::Enum);
PX_INLINE virtual ~PxControllerDesc();
PX_INLINE PxControllerDesc(const PxControllerDesc&);
PX_INLINE PxControllerDesc& operator=(const PxControllerDesc&);
PX_INLINE void copy(const PxControllerDesc&);
};
PX_INLINE PxControllerDesc::PxControllerDesc(PxControllerShapeType::Enum t) :
position (PxExtended(0.0), PxExtended(0.0), PxExtended(0.0)),
upDirection (0.0f, 1.0f, 0.0f),
slopeLimit (0.707f),
invisibleWallHeight (0.0f),
maxJumpHeight (0.0f),
contactOffset (0.1f),
stepOffset (0.5f),
density (10.0f),
scaleCoeff (0.8f),
volumeGrowth (1.5f),
reportCallback (NULL),
behaviorCallback (NULL),
nonWalkableMode (PxControllerNonWalkableMode::ePREVENT_CLIMBING),
material (NULL),
registerDeletionListener (true),
clientID (PX_DEFAULT_CLIENT),
userData (NULL),
mType (t)
{
}
PX_INLINE PxControllerDesc::PxControllerDesc(const PxControllerDesc& other) : mType(other.mType)
{
copy(other);
}
PX_INLINE PxControllerDesc& PxControllerDesc::operator=(const PxControllerDesc& other)
{
copy(other);
return *this;
}
PX_INLINE void PxControllerDesc::copy(const PxControllerDesc& other)
{
upDirection = other.upDirection;
slopeLimit = other.slopeLimit;
contactOffset = other.contactOffset;
stepOffset = other.stepOffset;
density = other.density;
scaleCoeff = other.scaleCoeff;
volumeGrowth = other.volumeGrowth;
reportCallback = other.reportCallback;
behaviorCallback = other.behaviorCallback;
userData = other.userData;
nonWalkableMode = other.nonWalkableMode;
position.x = other.position.x;
position.y = other.position.y;
position.z = other.position.z;
material = other.material;
invisibleWallHeight = other.invisibleWallHeight;
maxJumpHeight = other.maxJumpHeight;
registerDeletionListener = other.registerDeletionListener;
clientID = other.clientID;
}
PX_INLINE PxControllerDesc::~PxControllerDesc()
{
}
PX_INLINE bool PxControllerDesc::isValid() const
{
if( mType!=PxControllerShapeType::eBOX
&& mType!=PxControllerShapeType::eCAPSULE)
return false;
if(scaleCoeff<0.0f)
return false;
if(volumeGrowth<1.0f)
return false;
if(density<0.0f)
return false;
if(slopeLimit<0.0f)
return false;
if(stepOffset<0.0f)
return false;
if(contactOffset<=0.0f)
return false;
if(!material)
return false;
if(!toVec3(position).isFinite())
return false; //the float version needs to be finite otherwise actor creation will fail.
return true;
}
class PxController
{
public:
//*********************************************************************
// DEPRECATED FUNCTIONS:
//
// PX_DEPRECATED virtual void setInteraction(PxCCTInteractionMode::Enum flag) = 0;
// PX_DEPRECATED virtual PxCCTInteractionMode::Enum getInteraction() const = 0;
// PX_DEPRECATED virtual void setGroupsBitmask(PxU32 bitmask) = 0;
// PX_DEPRECATED virtual PxU32 getGroupsBitmask() const = 0;
//
// => replaced with:
//
// PxControllerFilters::mCCTFilterCallback. Please define a PxControllerFilterCallback object and emulate the old interaction mode there.
//
//*********************************************************************
virtual PxControllerShapeType::Enum getType() const = 0;
virtual void release() = 0;
virtual PxControllerCollisionFlags move(const PxVec3& disp, PxF32 minDist, PxF32 elapsedTime, const PxControllerFilters& filters, const PxObstacleContext* obstacles=NULL) = 0;
virtual bool setPosition(const PxExtendedVec3& position) = 0;
virtual const PxExtendedVec3& getPosition() const = 0;
virtual bool setFootPosition(const PxExtendedVec3& position) = 0;
virtual PxExtendedVec3 getFootPosition() const = 0;
virtual PxRigidDynamic* getActor() const = 0;
virtual void setStepOffset(const PxF32 offset) =0;
virtual PxF32 getStepOffset() const =0;
virtual void setNonWalkableMode(PxControllerNonWalkableMode::Enum flag) = 0;
virtual PxControllerNonWalkableMode::Enum getNonWalkableMode() const = 0;
virtual PxF32 getContactOffset() const =0;
virtual void setContactOffset(PxF32 offset) =0;
virtual PxVec3 getUpDirection() const =0;
virtual void setUpDirection(const PxVec3& up) =0;
virtual PxF32 getSlopeLimit() const =0;
virtual void setSlopeLimit(PxF32 slopeLimit) =0;
virtual void invalidateCache() = 0;
virtual PxScene* getScene() = 0;
virtual void* getUserData() const = 0;
virtual void setUserData(void* userData) = 0;
virtual void getState(PxControllerState& state) const = 0;
virtual void getStats(PxControllerStats& stats) const = 0;
virtual void resize(PxReal height) = 0;
protected:
PX_INLINE PxController() {}
virtual ~PxController() {}
};
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif