GxDynamicsPhysX.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#if PLATFORM_PHYSX_SUPPORT
#include "PxRigidDynamic.h"
#include "PxPhysicsAPI.h"
 
GX_PHYSICS_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
struct GxShapeDescForPhysX3 : public GxStructBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    // RTTI宣言
    GX_RTTI_STRUCT(GxShapeDescForPhysX3);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxShapeDescForPhysX3(void)
    : _pUserData(nullptr)
    , _pConvexMeshData(nullptr)
    , _pTriangleMeshData(nullptr)
    {}
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    PxVec3          _position;                  
    PxQuat          _quaternion;                
    //スフィア・カプセル用
    PxF32           _radius;                    
    //ボックス  
    PxVec3          _dimensions;                
    //カプセル
    PxF32           _height;                    
    //複合形状・背景メッシュ
    void*           _pUserData;                 
    //複合形状
    PxConvexMesh*   _pConvexMeshData;           
    //背景メッシュ
    PxTriangleMesh* _pTriangleMeshData;         
 
    GxCollision::COLLISION_SHAPE    _shapeType; 
 
};
 
//===========================================================================
//===========================================================================
class GxDynamicsPhysX : public GxDynamics
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS(GxDynamicsPhysX, GxDynamics)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxDynamicsPhysX)
 
    class   GxWorld;
    class   GxObject;
    class   GxConstraint;
    struct  GxRayResult;
 
    //note: pHitには自身に当たったオブジェクトが入ります
    typedef void (GxClassBaseRoot::* DYNAMICS_HIT_CALLBACK)(GxObject* pHit);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxDynamicsPhysX(void) : _pHitCallback(nullptr) {}
    ~GxDynamicsPhysX(void) override {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxDynamics::GxObject* allocObject(void) override;
    GxDynamics::GxConstraint* allocConstraint(void) override;
 
    GxDynamics::GxObject* createConvexShape(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxVector3* pVertex, u32 numVertex, const GxRigidBodyParam& rigidParam, f32 margin = DYNAMICS_COLLISION_SKIN_WIDTH) override
    {
        return Super::createConvexShape(active, pMatrix, jointIndex, offset, rotateOffset, pVertex, numVertex, rigidParam, margin);
    }
 
#if USE_VEHICLE
    GxDynamics::GxObject* createVehicle(b32     active,
                            GxMatrixAffine*     pMatrix,
                            const GxVector3&    offset,
                            const GxQuaternion& rotateOffset,
                            const GxVector3*    pChassisVertex,
                            u32                 numChassisVertex,
                            f32                 chassisMass,
                            f32                 chassisFriction,
                            u32                 chassisGroup,
                            u32                 chassisAgainstGroup,
                            const GxVector3*    pWheelVertex,
                            const u32           numWheelVertex,
                            f32                 wheelMass,
                            f32                 wheelFriction,
                            u32                 wheelGroup,
                            u32                 wheelAgainstGroup,
                            GxVector3&          wheelOffset0,
                            GxVector3&          wheelOffset1,
                            GxVector3&          wheelOffset2,
                            GxVector3&          wheelOffset3);
#endif //USE_VEHICLE
 
public:
    GX_FORCE_INLINE void setHitCallback(DYNAMICS_HIT_CALLBACK pCallback){ _pHitCallback = pCallback; }
    GX_FORCE_INLINE DYNAMICS_HIT_CALLBACK getHitCallback(void){ return _pHitCallback; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    DYNAMICS_HIT_CALLBACK   _pHitCallback;      
 
};
 
//===========================================================================
//===========================================================================
class GxDynamicsPhysX::GxWorld : public GxDynamics::GxWorld
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxDynamicsPhysX::GxWorld, GxDynamics::GxWorld);
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxWorld);
 
    class GxContactModifyCallback : public PxContactModifyCallback
    {
    public:
        virtual void onContactModify(PxContactModifyPair* const pPairs, PxU32 count);
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxWorld(void);
 
    ~GxWorld(void) override {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    b32 alloc(u32 meshCount, const GxVector3& worldAabbMin, const GxVector3& worldAabbMax, u16 maxHandles,
                        u32 stackAllocatorSize = DYNAMICS_DEFAULT_STACK_ALLOCATOR_SIZE,
                        u32 maxPersistentManifoldPoolSize = DYNAMICS_DEFAULT_MAX_PERSISTENT_MANIFOLD_POOL_SIZE,
                        u32 maxCollisionAlgorithmPoolSize = DYNAMICS_DEFAULT_MAX_COLLISION_ALGORITHM_POOL_SIZE) override;
 
    void free(void) override;
 
    void update(void) override;
 
    void registerObject(GxDynamics::GxObject* pObject) override;
    void banObject(GxDynamics::GxObject* pObject) override;
 
    void setGravity(const f32 gravityX, const f32 gravityY, const f32 gravityZ) override;
 
    b32 checkRayClosestVsWorld(GxDynamics::GxRayResult* pRayResult, const GxVector3& startPosition, const GxVector3& endPosition, GxDynamics::GxConditionInformation* pConditionInformation = nullptr) override;
 
    b32 checkRayClosestVsSingle(GxDynamics::GxRayResult* pRayResult, GxDynamics::GxObject* pTargetObject, const GxVector3& startPosition, const GxVector3& endPosition, GxDynamics::GxConditionInformation* pConditionInformation = nullptr) override;
 
    static PxFilterFlags    filter( PxFilterObjectAttributes attributes0, 
                                    PxFilterData filterData0, 
                                    PxFilterObjectAttributes attributes1, 
                                    PxFilterData filterData1,
                                    PxPairFlags& pairFlags,
                                    const void* pConstantBlock,
                                    PxU32 constantBlockSize);
 
public:
    b32 createNxScene( void );
    b32 deleteNxScene( void );
    
    virtual void fetchPhysicsResults( void );
    virtual void startPhysics( void );
    virtual f32 getDeltaTime( void );
    constexpr PxScene* getNxScene( void ) const { return _pNxScene; }
    void updateGroupCollision( void );
 
    void detachObjectFromWorld(GxDynamics::GxObject* pObject) override;
 
#if (USE_VEHICLE)
public:
    void updateVehicle(void);
    u32  getVehicleCount(void);
    void getVehicleObject(GxList& list);
    GX_FORCE_INLINE const PxVehicleDrivableSurfaceType* getDrivableSurfaceType(u32 index){ return &_vehicleDrivableSurfaceTypes[index]; }
#endif //USE_VEHICLE
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    PxScene*                                _pNxScene;                          
    GxContactModifyCallback                 _contactModifyCallback;             
    
#if (USE_VEHICLE)
    PxBatchQuery*                           _pWheelRaycastBatchQuery;           
    PxVehicle4WSceneQueryData<MAX_NUM_VEHICLE_CNT>  _sceneQueryDataFowWheel;    
    PxVehicleDrivableSurfaceType            PX_ALIGN(16, _vehicleDrivableSurfaceTypes[MAX_NUM_SURFACE_TYPES]);  
#endif //USE_VEHICLE
    
};
 
//===========================================================================
//===========================================================================
class GxDynamicsPhysX::GxObject : public GxDynamics::GxObject
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxDynamicsPhysX::GxObject, GxDynamics::GxObject);
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxObject);
 
    enum
    {
        ACTIVE_FLAG_STAY_HERE               = (1UL << 5),       
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxObject(void);
    ~GxObject(void) override;
 
    void initialize(b32 active, GxMatrixAffine* pMatrix, const GxVector3& offset, const GxQuaternion& rotateOffset) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void preUpdate(void) override;
    void postUpdate(void) override;
 
    b32 createSphere(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeSphere& sphere, const GxRigidBodyParam& rigidParam, f32 margin) override;
    b32 createBox(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeBox& box, const GxRigidBodyParam& rigidParam, f32 margin) override;
    b32 createCylinder(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeCylinder& cylinder, const GxRigidBodyParam& rigidParam, f32 margin) override;
    b32 createMultisphere(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeMultisphere& multiSphere, const GxRigidBodyParam& rigidParam, f32 margin) override;
    b32 createCapsule(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeCapsule& capsule, const GxRigidBodyParam& rigidParam, f32 margin) override;
    b32 createConvexShape(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxVector3* pVertex, u32 numVertex, const GxRigidBodyParam& rigidParam, f32 margin) override;
    b32 createCompoundObject(GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, f32 margin) override;
    b32 createMesh(b32 active, GxMatrixAffine* pMatrix, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeTrimesh& trimesh, f32 friction = 0.5f, b32 isCompress = true, GxVector3* pAabbMin = nullptr, GxVector3* pAabbMax = nullptr, f32 margin = DYNAMICS_COLLISION_MARGIN) override;
 
    b32 addCompoundSphere(const GxVector3& offset, const GxShapeSphere& sphere) override;
    b32 addCompoundBox(const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeBox& box) override;
    b32 addCompoundCapsule(const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeCapsule& capsule) override;
    b32 addCompoundConvex(const GxVector3& offset, const GxQuaternion& rotateOffset, const GxVector3* pVertex, u32 numVertex) override;
    b32 endAddCompound(b32 isActive, const GxRigidBodyParam& rigidParam) override;
 
#if GX_DEVELOP
    void developDraw(const GxColor& color, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE) override;
#endif // GX_DEVELOP
 
    void reset(void) override;
 
    void applyForce(const GxVector3& force, const GxVector3& position) override;
    void applyImpulse(const GxVector3& impulse, const GxVector3& position) override;
 
#if (USE_VEHICLE)
private:
    b32 createChassisInfomation(const GxVector3* pVertex,
                                const u32 numVertex,
                                f32 mass,
                                f32 friction,
                                PxConvexMesh** ppChassisConvexMesh,
                                PxVec3* pChassisMOI,
                                PxVec3* pChassisDims);
 
    b32 createWheelInfomation(const GxVector3* pVertex,
                                const u32 numVertex,
                                PxConvexMesh** ppWheelConvexMesh,
                                f32* pWheelWidth,
                                f32* pWheelRadii);
public:
    b32 createVehicle(b32 active,
                               GxMatrixAffine* pMatrix,
                               const GxVector3& offset,
                               const GxQuaternion& rotateOffset,
                               const GxVector3* pChassisVertex,
                               u32 numChassisVertex,
                               f32 chassisMass,
                               f32 chassisFriction,
                               u32 chassisGroup,
                               u32 chassisAgainstGroup,
                               const GxVector3* pWheelVertex,
                               const u32 numWheelVertex,
                               f32 wheelMass,
                               f32 wheelFriction,
                               u32 wheelGroup,
                               u32 wheelAgainstGroup,
                               GxVector3& wheelOffset0,
                               GxVector3& wheelOffset1,
                               GxVector3& wheelOffset2,
                               GxVector3& wheelOffset3);
    constexpr PxVehicle4W* getVehecle4W(void) const { return _pVehecle4W; }
    void         setAccel(f32 accel);
    void         setBrake(f32 brake);
    void         setSteer(f32 steer);
    b32 getChassisWorldMatrix(GxMatrixAffine& matrix);
    b32 getFrontLeftWheelWorldMatrix(GxMatrixAffine& matrix);
    b32 getFrontRightWheelWorldMatrix(GxMatrixAffine& matrix);
    b32 getRearLeftWheelWorldMatrix(GxMatrixAffine& matrix);
    b32 getRearRightWheelWorldMatrix(GxMatrixAffine& matrix);
#endif //USE_VEHICLE
 
    constexpr PxActor* getNxActor(void) const { return _pNxActor; }
    constexpr void setNxActorNull(void) { _pNxActor = nullptr; }
    b32 createActor(GxShapeDescForPhysX3* pShapeDesc, const GxMatrixAffine* pMatrix, const GxRigidBodyParam& rigidParam);
    constexpr PxConvexMesh* getNxConvexMesh(void) const { return _pNxConvexMesh; }
    b32 putToSleep(void);
    b32 isSleeping(void) const;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void setLinearVelocity(const GxVector3& velocity) override;
    void getLinearVelocity(GxVector3& velocity) override;
 
    void setAngularVelocity(const GxVector3& angular) override;
 
    void setPosition(const GxVector3& position) override;
    void getPosition(GxVector3& position) override;
    void setQuaternion(const GxQuaternion& quaternion) override;
    void getQuaternion(GxQuaternion& quaternion) override;
    void setDampingRatio(f32 linearDamping, f32 angularDamping) override;
    void setDeactivationTime(f32 time) override;
    void setSleepingThresholds(f32 linear, f32 angular) override;
    void setFriction(f32 friction) override;
 
    void setRestitution(f32 restitution) override;
 
    void                                    setMatrix(const GxMatrixAffine& matrix) override;
    GxMatrixAffine                          getMatrix(void) override;
 
    b32                                     getShapeMatrix(u32 index, GxMatrixAffine& matrix);
 
    void                                    setActive(b32 active) override;
    void                                    setStayHere(b32 active);
    GX_FORCE_INLINE b32                     isStayHere(void){ return _activeFlag.isFlag(ACTIVE_FLAG_STAY_HERE); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    constexpr void setGroup(u16 group) { _group = group; }
 
    constexpr u16 getGroup(void) const { return _group; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    PxCooking*                      _pNxCooking;        
    PxActor*                        _pNxActor;          
    PxMaterial*                     _pNxMaterial;       
    PxTriangleMeshDesc*             _pNxMeshDesc;       
    PxTriangleMesh*                 _pNxMesh;           
    PxConvexMeshDesc*               _pNxConvexDesc;     
    PxConvexMesh*                   _pNxConvexMesh;     
    GxArray                         _listNxConvexDesc;  
    GxArray                         _listNxConvexMesh;  
#if (USE_VEHICLE)
    PxVehicle4W*                    _pVehecle4W;        
#endif //USE_VEHICLE
 
};
 
//===========================================================================
//===========================================================================
class GxDynamicsPhysX::GxConstraint : public GxDynamics::GxConstraint
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxDynamicsPhysX::GxConstraint, GxDynamics::GxConstraint);
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxConstraint);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConstraint(void) : _pNxJoint(nullptr) {}
 
    ~GxConstraint(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    b32 createConstraintSpherical(b32 active, GxDynamics::GxObject* pObject0, GxDynamics::GxObject* pObject1, const GxVector3& pivot0, const GxVector3& pivot1, b32 disableCollisions) override;
 
    b32 createConstraintRevolute(b32 active, GxDynamics::GxObject* pObject0, GxDynamics::GxObject* pObject1, const GxMatrixAffine& mat0, const GxMatrixAffine& mat1, b32 disableCollisions) override;
    b32 createConstraintRevolute(b32 active, GxDynamics::GxObject* pObject0, GxDynamics::GxObject* pObject1, const GxVector3& pivot0, const GxVector3& pivot1, const GxVector3& axis0, const GxVector3& axis1, const GxVector3& base0, const GxVector3& base1, b32 disableCollisions) override;
 
    b32 createConstraintConeTwist(b32 active, GxDynamics::GxObject* pObject0, GxDynamics::GxObject* pObject1, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1, const GxParamConeTwist& param) override;
 
    b32 createConstraintFixed(b32 active, GxDynamics::GxObject* pObject0, GxDynamics::GxObject* pObject1, const GxVector3& pivot0, const GxVector3& pivot1) override;
 
    void setParameterRevolute(const f32 lowerLimit, const f32 upperLimit) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr PxJoint* getNxJoint( void ) const { return _pNxJoint; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    PxJoint*                    _pNxJoint;          
    GxVector3                   _pivot0;            
    GxVector3                   _axis0;             
    GxVector3                   _base0;             
 
};
 
//===========================================================================
//===========================================================================
struct GxDynamicsPhysX::GxRayResult : public GxDynamics::GxRayResult
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxRayResult(void) {}
    ~GxRayResult(void) override {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void setResult( const PxRaycastHit& result, f32 hitFraction );
 
};
 
//===========================================================================
//===========================================================================
class GxShapeDynamicsCompoundPhysX : public GxShapeDynamicsCompound
{
    //-------------------------------------------------------------------
    //-------------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxShapeDynamicsCompoundPhysX, GxShapeDynamicsCompound);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxShapeDynamicsCompoundPhysX(void) {}
    ~GxShapeDynamicsCompoundPhysX( void ) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void addShapeDesc( GxShapeDescForPhysX3* pDesc );
    void deleteShapeDescAll( void );
 
};
 
GX_PHYSICS_NAMESPACE_END()
 
#endif //PLATFORM_PHYSX_SUPPORT