NVIDIA(R) PhysX(R) SDK 3.4 API Reference: PxController.h Source File

00001 // This code contains NVIDIA Confidential Information and is disclosed to you
+00002 // under a form of NVIDIA software license agreement provided separately to you.
+00003 //
+00004 // Notice
+00005 // NVIDIA Corporation and its licensors retain all intellectual property and
+00006 // proprietary rights in and to this software and related documentation and
+00007 // any modifications thereto. Any use, reproduction, disclosure, or
+00008 // distribution of this software and related documentation without an express
+00009 // license agreement from NVIDIA Corporation is strictly prohibited.
+00010 //
+00011 // ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+00012 // NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+00013 // THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+00014 // MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+00015 //
+00016 // Information and code furnished is believed to be accurate and reliable.
+00017 // However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+00018 // information or for any infringement of patents or other rights of third parties that may
+00019 // result from its use. No license is granted by implication or otherwise under any patent
+00020 // or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+00021 // This code supersedes and replaces all information previously supplied.
+00022 // NVIDIA Corporation products are not authorized for use as critical
+00023 // components in life support devices or systems without express written approval of
+00024 // NVIDIA Corporation.
+00025 //
+00026 // Copyright (c) 2008-2016 NVIDIA Corporation. All rights reserved.
+00027 // Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
+00028 // Copyright (c) 2001-2004 NovodeX AG. All rights reserved.  
+00029 
+00030 
+00031 
+00032 #ifndef PX_PHYSICS_CCT_CONTROLLER
+00033 #define PX_PHYSICS_CCT_CONTROLLER
+00034 
+00038 #include "characterkinematic/PxCharacter.h"
+00039 #include "characterkinematic/PxExtended.h"
+00040 #include "characterkinematic/PxControllerObstacles.h"
+00041 #include "PxQueryFiltering.h"
+00042 #include "foundation/PxErrorCallback.h"
+00043 
+00044 #if !PX_DOXYGEN
+00045 namespace physx
+00046 {
+00047 #endif
+00048 
+00052 struct PxControllerShapeType
+00053 {
+00054     enum Enum
+00055     {
+00061         eBOX,
+00062 
+00068         eCAPSULE,
+00069 
+00070         eFORCE_DWORD = 0x7fffffff
+00071     };
+00072 };
+00073 
+00074 class PxShape;
+00075 class PxScene;
+00076 class PxController;
+00077 class PxRigidDynamic;
+00078 class PxMaterial;
+00079 struct PxFilterData;
+00080 class PxQueryFilterCallback;
+00081 class PxControllerBehaviorCallback;
+00082 class PxObstacleContext;
+00083 class PxObstacle;
+00084 
+00090 struct PxControllerNonWalkableMode
+00091 {
+00092     enum Enum
+00093     {
+00094         ePREVENT_CLIMBING,                      
+00095         ePREVENT_CLIMBING_AND_FORCE_SLIDING     
+00096     };
+00097 };
+00098 
+00102 struct PxControllerCollisionFlag
+00103 {
+00104     enum Enum
+00105     {
+00106         eCOLLISION_SIDES    = (1<<0),   
+00107         eCOLLISION_UP       = (1<<1),   
+00108         eCOLLISION_DOWN     = (1<<2)    
+00109     };
+00110 };
+00111 
+00117 typedef PxFlags<PxControllerCollisionFlag::Enum, PxU8> PxControllerCollisionFlags;
+00118 PX_FLAGS_OPERATORS(PxControllerCollisionFlag::Enum, PxU8)
+00119 
+00120 
+00121 
+00124 struct PxControllerState
+00125 {
+00126     PxVec3          deltaXP;            
+00127     PxShape*        touchedShape;       
+00128     PxRigidActor*   touchedActor;       
+00129     ObstacleHandle  touchedObstacleHandle;  // Obstacle on which the CCT is standing
+00130     PxU32           collisionFlags;     
+00131     bool            standOnAnotherCCT;  
+00132     bool            standOnObstacle;    
+00133     bool            isMovingUp;         
+00134 };
+00135 
+00139 struct PxControllerStats
+00140 {
+00141     PxU16           nbIterations;
+00142     PxU16           nbFullUpdates;
+00143     PxU16           nbPartialUpdates;
+00144     PxU16           nbTessellation;
+00145 };
+00146 
+00150 struct PxControllerHit
+00151 {
+00152     PxController*   controller;     
+00153     PxExtendedVec3  worldPos;       
+00154     PxVec3          worldNormal;    
+00155     PxVec3          dir;            
+00156     PxF32           length;         
+00157 };
+00158 
+00164 struct PxControllerShapeHit : public PxControllerHit
+00165 {
+00166     PxShape*        shape;          
+00167     PxRigidActor*   actor;          
+00168     PxU32           triangleIndex;  
+00169 };
+00170 
+00176 struct PxControllersHit : public PxControllerHit
+00177 {
+00178     PxController*   other;          
+00179 };
+00180 
+00186 struct PxControllerObstacleHit : public PxControllerHit
+00187 {
+00188     const void*     userData;
+00189 };
+00190 
+00198 class PxUserControllerHitReport
+00199 {
+00200 public:
+00201 
+00211     virtual void onShapeHit(const PxControllerShapeHit& hit) = 0;
+00212 
+00220     virtual void onControllerHit(const PxControllersHit& hit) = 0;
+00221 
+00229     virtual void onObstacleHit(const PxControllerObstacleHit& hit) = 0;
+00230 
+00231 protected:
+00232     virtual ~PxUserControllerHitReport(){}
+00233 };
+00234 
+00235 
+00247 class PxControllerFilterCallback
+00248 {
+00249 public:
+00250     virtual ~PxControllerFilterCallback(){}
+00251 
+00259     virtual bool filter(const PxController& a, const PxController& b) = 0;
+00260 };
+00261 
+00279 class PxControllerFilters
+00280 {
+00281     public:
+00282 
+00283     PX_INLINE                   PxControllerFilters(const PxFilterData* filterData=NULL, PxQueryFilterCallback* cb=NULL, PxControllerFilterCallback* cctFilterCb=NULL) :
+00284                                     mFilterData         (filterData),
+00285                                     mFilterCallback     (cb),
+00286                                     mFilterFlags        (PxQueryFlag::eSTATIC|PxQueryFlag::eDYNAMIC|PxQueryFlag::ePREFILTER),
+00287                                     mCCTFilterCallback  (cctFilterCb)
+00288                                 {}
+00289 
+00290     // CCT-vs-shapes:
+00291     const PxFilterData*         mFilterData;            
+00292 
+00293     PxQueryFilterCallback*      mFilterCallback;        
+00294     PxQueryFlags                mFilterFlags;           
+00295     // CCT-vs-CCT:
+00296     PxControllerFilterCallback* mCCTFilterCallback;     
+00297 };
+00298 
+00304 class PxControllerDesc
+00305 {
+00306 public:
+00307 
+00313     PX_INLINE virtual   bool                        isValid()       const;
+00314 
+00322     PX_INLINE           PxControllerShapeType::Enum     getType()       const   { return mType;     }
+00323 
+00331     PxExtendedVec3              position;
+00332 
+00341     PxVec3                      upDirection;
+00342 
+00357     PxF32                       slopeLimit;
+00358 
+00370     PxF32                       invisibleWallHeight;
+00371 
+00395     PxF32                       maxJumpHeight;
+00396 
+00408     PxF32                       contactOffset;
+00409 
+00421     PxF32                       stepOffset;
+00422 
+00430     PxF32                       density;
+00431 
+00440     PxF32                       scaleCoeff;
+00441 
+00450     PxF32                       volumeGrowth;
+00451 
+00463     PxUserControllerHitReport*  reportCallback;
+00464 
+00476     PxControllerBehaviorCallback*   behaviorCallback;
+00477 
+00487     PxControllerNonWalkableMode::Enum   nonWalkableMode;
+00488 
+00498     PxMaterial*                 material;
+00499 
+00511     bool                        registerDeletionListener;
+00512 
+00518     void*                       userData;
+00519 
+00520 protected:
+00521     const PxControllerShapeType::Enum mType;        
+00522 
+00526     PX_INLINE                                       PxControllerDesc(PxControllerShapeType::Enum);
+00527     PX_INLINE virtual                               ~PxControllerDesc();
+00528 
+00532     PX_INLINE                                       PxControllerDesc(const PxControllerDesc&);
+00533 
+00537     PX_INLINE PxControllerDesc&                     operator=(const PxControllerDesc&);
+00538 
+00539     PX_INLINE void                                  copy(const PxControllerDesc&);
+00540 };
+00541 
+00542 PX_INLINE PxControllerDesc::PxControllerDesc(PxControllerShapeType::Enum t) : mType(t)
+00543 {
+00544     upDirection         = PxVec3(0.0f, 1.0f, 0.0f);
+00545     slopeLimit          = 0.707f;
+00546     contactOffset       = 0.1f;
+00547     stepOffset          = 0.5f;
+00548     density             = 10.0f;
+00549     scaleCoeff          = 0.8f;
+00550     volumeGrowth        = 1.5f;
+00551     reportCallback      = NULL;
+00552     behaviorCallback    = NULL;
+00553     userData            = NULL;
+00554     nonWalkableMode     = PxControllerNonWalkableMode::ePREVENT_CLIMBING;
+00555     position.x          = PxExtended(0.0);
+00556     position.y          = PxExtended(0.0);
+00557     position.z          = PxExtended(0.0);
+00558     material            = NULL;
+00559     invisibleWallHeight = 0.0f;
+00560     maxJumpHeight       = 0.0f;
+00561     registerDeletionListener = true;
+00562 }
+00563 
+00564 PX_INLINE PxControllerDesc::PxControllerDesc(const PxControllerDesc& other) : mType(other.mType)
+00565 {
+00566     copy(other);
+00567 }
+00568 
+00569 PX_INLINE PxControllerDesc& PxControllerDesc::operator=(const PxControllerDesc& other)
+00570 {
+00571     copy(other);
+00572     return *this;
+00573 }
+00574 
+00575 PX_INLINE void PxControllerDesc::copy(const PxControllerDesc& other)
+00576 {
+00577     upDirection         = other.upDirection;
+00578     slopeLimit          = other.slopeLimit;
+00579     contactOffset       = other.contactOffset;
+00580     stepOffset          = other.stepOffset;
+00581     density             = other.density;
+00582     scaleCoeff          = other.scaleCoeff;
+00583     volumeGrowth        = other.volumeGrowth;
+00584     reportCallback      = other.reportCallback;
+00585     behaviorCallback    = other.behaviorCallback;
+00586     userData            = other.userData;
+00587     nonWalkableMode     = other.nonWalkableMode;
+00588     position.x          = other.position.x;
+00589     position.y          = other.position.y;
+00590     position.z          = other.position.z;
+00591     material            = other.material;
+00592     invisibleWallHeight = other.invisibleWallHeight;
+00593     maxJumpHeight       = other.maxJumpHeight;
+00594     registerDeletionListener = other.registerDeletionListener;
+00595 }
+00596 
+00597 PX_INLINE PxControllerDesc::~PxControllerDesc()
+00598 {
+00599 }
+00600 
+00601 PX_INLINE bool PxControllerDesc::isValid() const
+00602 {
+00603     if(     mType!=PxControllerShapeType::eBOX
+00604         &&  mType!=PxControllerShapeType::eCAPSULE)
+00605         return false;
+00606     if(scaleCoeff<0.0f)     return false;
+00607     if(volumeGrowth<1.0f)   return false;
+00608     if(density<0.0f)        return false;
+00609     if(slopeLimit<0.0f)     return false;
+00610     if(stepOffset<0.0f)     return false;
+00611     if(contactOffset<=0.0f) return false;
+00612     if(!material)           return false;
+00613 
+00614     return true;
+00615 }
+00616 
+00617 
+00623 class PxController
+00624 {
+00625 public:
+00626     //*********************************************************************
+00627     // DEPRECATED FUNCTIONS:
+00628     //
+00629     //  PX_DEPRECATED virtual   void                        setInteraction(PxCCTInteractionMode::Enum flag) = 0;
+00630     //  PX_DEPRECATED virtual   PxCCTInteractionMode::Enum  getInteraction()                    const       = 0;
+00631     //  PX_DEPRECATED virtual   void                        setGroupsBitmask(PxU32 bitmask)                 = 0;
+00632     //  PX_DEPRECATED virtual   PxU32                       getGroupsBitmask()                  const       = 0;
+00633     //
+00634     //  => replaced with:
+00635     //
+00636     //  PxControllerFilters::mCCTFilterCallback. Please define a PxControllerFilterCallback object and emulate the old interaction mode there.
+00637     //
+00638     //*********************************************************************
+00639 
+00645     virtual     PxControllerShapeType::Enum getType()       const           = 0;
+00646 
+00650     virtual     void                    release() = 0;
+00651 
+00663     virtual     PxControllerCollisionFlags  move(const PxVec3& disp, PxF32 minDist, PxF32 elapsedTime, const PxControllerFilters& filters, const PxObstacleContext* obstacles=NULL) = 0;
+00664 
+00680     virtual     bool                    setPosition(const PxExtendedVec3& position) = 0;
+00681 
+00695     virtual     const PxExtendedVec3&   getPosition()           const   = 0;
+00696 
+00713     virtual     bool                    setFootPosition(const PxExtendedVec3& position) = 0;
+00714 
+00724     virtual     PxExtendedVec3          getFootPosition()       const   = 0;
+00725 
+00733     virtual     PxRigidDynamic*         getActor()              const   = 0;
+00734 
+00742     virtual     void                    setStepOffset(const PxF32 offset) =0;
+00743 
+00751     virtual     PxF32                   getStepOffset()                     const       =0;
+00752 
+00760     virtual     void                        setNonWalkableMode(PxControllerNonWalkableMode::Enum flag)  = 0;
+00761 
+00769     virtual     PxControllerNonWalkableMode::Enum   getNonWalkableMode()                const       = 0;
+00770 
+00778     virtual     PxF32                   getContactOffset()                  const       =0;
+00779 
+00787     virtual     void                    setContactOffset(PxF32 offset)                  =0;
+00788 
+00796     virtual     PxVec3                  getUpDirection()                    const       =0;
+00797 
+00805     virtual     void                    setUpDirection(const PxVec3& up)                =0;
+00806 
+00814     virtual     PxF32                   getSlopeLimit()                     const       =0;
+00815 
+00827     virtual     void                    setSlopeLimit(PxF32 slopeLimit)                 =0;
+00828 
+00844     virtual     void                    invalidateCache()           = 0;
+00845 
+00851     virtual     PxScene*                getScene()                      = 0;
+00852 
+00860     virtual     void*                   getUserData()       const       = 0;
+00861 
+00869     virtual     void                    setUserData(void* userData)     = 0;
+00870 
+00878     virtual     void                    getState(PxControllerState& state)  const       = 0;
+00879 
+00887     virtual     void                    getStats(PxControllerStats& stats)  const       = 0;
+00888 
+00899     virtual     void                    resize(PxReal height)   = 0;
+00900 
+00901 protected:
+00902     PX_INLINE                           PxController()                  {}
+00903     virtual                             ~PxController()                 {}
+00904 };
+00905 
+00906 #if !PX_DOXYGEN
+00907 } // namespace physx
+00908 #endif
+00909 
+00911 #endif
+