PxController.h

Go to the documentation of this file.

//
// 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-2021 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_CCT_CONTROLLER
#define PX_PHYSICS_CCT_CONTROLLER

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

    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) : mType(t)
{
    upDirection                 = PxVec3(0.0f, 1.0f, 0.0f);
    slopeLimit                  = 0.707f;
    contactOffset               = 0.1f;
    stepOffset                  = 0.5f;
    density                     = 10.0f;
    scaleCoeff                  = 0.8f;
    volumeGrowth                = 1.5f;
    reportCallback              = NULL;
    behaviorCallback            = NULL;
    userData                    = NULL;
    nonWalkableMode             = PxControllerNonWalkableMode::ePREVENT_CLIMBING;
    position.x                  = PxExtended(0.0);
    position.y                  = PxExtended(0.0);
    position.z                  = PxExtended(0.0);
    material                    = NULL;
    invisibleWallHeight         = 0.0f;
    maxJumpHeight               = 0.0f;
    registerDeletionListener    = true;
}

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

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