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