GxDynamicsBullet.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#if PLATFORM_BULLET_SUPPORT
 
GX_PHYSICS_NAMESPACE_BEGIN()
//===========================================================================
//===========================================================================
class GxDynamicsBullet : public GxDynamics
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS(GxDynamicsBullet, GxDynamics)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxDynamicsBullet)
 
    class   GxWorld;
    class   GxObject;
    class   GxConstraint;
    class   GxConditionInformation;
    struct  GxRayResult;
 
    struct GxParamRevolute : public GxStructBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        // RTTI定義
        GX_RTTI_STRUCT(GxParamRevolute);
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GxParamRevolute(void)
            : _swingLimitMin(0)
            , _swingLimitMax(PI2)
            , _disableCollision(false)
        {}
        ~GxParamRevolute(void){}
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        // MinとMaxの間の角度しか移動できない
        f32 _swingLimitMin;     
        f32 _swingLimitMax;     
        b32 _disableCollision;  
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxDynamicsBullet(void) {}
    ~GxDynamicsBullet(void) override {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxDynamics::GxObject* allocObject(void) override;
    GxDynamics::GxConstraint* allocConstraint(void) override;
 
    GxDynamicsBullet::GxObject* createMesh(u32 index, b32 active, GxMatrixAffine* pMatrix, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeTrimesh& trimesh, btBvhTriangleMeshShape* pBtTrimeshShape, f32 friction = 0.5f, f32 margin = DYNAMICS_COLLISION_MARGIN);
 
    GxDynamicsBullet::GxConstraint* createConstraintFixed(b32 active, GxDynamics::GxObject* pObject0, GxDynamics::GxObject* pObject1, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1);
 
};
 
//===========================================================================
//===========================================================================
class GxDynamicsBullet::GxWorld : public GxDynamics::GxWorld
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxDynamicsBullet::GxWorld, GxDynamics::GxWorld);
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxWorld);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    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 registerConstraint(GxDynamics::GxConstraint* pConstraint, b32 disableCollisions) override;
    void banConstraint(GxDynamics::GxConstraint* pConstraint) override;
 
    void reset(void) override;
 
    void setGravity(const GxVector3& gravity = GxDynamics::GxWorld::DYNAMICS_GRAVITY) 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 void     customNearCallback(btBroadphasePair& collisionPair, btCollisionDispatcher& dispatcher, const btDispatcherInfo& dispatcherInfo);
 
    virtual GxRayCallback* createRayCallback( const btVector3& rayFrom, const btVector3& rayEnd, GxConditionInformation* pConditionInformation );
 
    void detachObjectFromWorld(GxDynamics::GxObject* pObject) override;
 
    //memo: Nxにあるグループの処理はBulletには存在しないので同じ物を独自実装しています
    GX_FORCE_INLINE b32 isGroupColide( u32 group1, u32 group2 ) const
    {
        if (group1 >= 32 || group2 >= 32)
        {
            return false;
        }
        return ((_groupCollide[group1]>>group2) & 0x1) ? true : false;
    }
public:
    b32 createBulletWorld(void);
    b32 deleteBulletWorld(void);
 
    void detachConstraintFromBullet(GxConstraint* pObject);
 
#if (GX_DEVELOP)
    void setBtDebugDrawer(btIDebugDraw* pDrawer);
#endif //(GX_DEVELOP)
 
    btDefaultVehicleRaycaster* createBtVehicleRaycaster(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    btCollisionConfiguration*               _pBulletCollisionConfiguration;     
    btCollisionDispatcher*                  _pDispatcher;                       
    btAxisSweep3*                           _pBroadphase;                       
    btSequentialImpulseConstraintSolver*    _pSolver;                           
    btDiscreteDynamicsWorld*                _pBulletWorld;                      
    btCollisionAlgorithmCreateFunc*         _pDynamicsAlgorithmCreateFunction[DYNAMICS_ALGORITHM_NUM];  
    GxVector3                               _worldAabbMin;                      
    GxVector3                               _worldAabbMax;                      
    u16                                     _maxHandles;                        
    u32                                     _btStackAllocatorSize;              
    u32                                     _btMaxPersistentManifoldPoolSize;   
    u32                                     _btMaxCollisionAlgorithmPoolSize;   
 
    btOverlapFilterCallback*                _btFilterCallback;                  
 
};
 
//===========================================================================
//===========================================================================
class GxDynamicsBullet::GxObject : public GxDynamics::GxObject
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxDynamicsBullet::GxObject, GxDynamics::GxObject);
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxObject);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    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 createMesh(b32 active, GxMatrixAffine* pMatrix, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeTrimesh& trimesh, btBvhTriangleMeshShape* pBtTrimeshShape, f32 friction = 0.5f, f32 margin = DYNAMICS_COLLISION_MARGIN);
 
    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;
 
    void applyForce(const GxVector3& force, const GxVector3& position) override;
    void applyImpulse(const GxVector3& impulse, const GxVector3& position) override;
 
    GX_FORCE_INLINE btRigidBody* getBtRigidBody(void) const { return _pBtRigidBody; }
    b32 createRigidBody(btCollisionShape* pShape, const GxMatrixAffine& matrix, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxRigidBodyParam& rigidParam, f32 margin = DYNAMICS_COLLISION_MARGIN);
 
    GX_FORCE_INLINE u32 getBtActivationState(void) const { return _pBtRigidBody ? _pBtRigidBody->getActivationState() : 0; }
    GX_FORCE_INLINE void setBtActivationState(u32 state) { if (_pBtRigidBody) _pBtRigidBody->setActivationState(state); }
 
#if GX_DEVELOP
    void developDraw(const GxColor& color, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE) override;
    void developDrawSub(btCollisionShape* pShape, GxMatrixAffine& worldMatrix, const GxColor& color, PRIMITIVE_FILL_MODE fillMode);
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void setLinearVelocity(const GxVector3& velocity) override;
    void getLinearVelocity(GxVector3& velocity) override;
 
    void setAngularVelocity(const GxVector3& angular) override;
    void getAngularVelocity(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                                    setMatrix(const GxMatrixAffine& matrix) override;
    GxMatrixAffine                          getMatrix(void) override;
 
    GX_FORCE_INLINE b32                     isSleeping(void) const { return false; }    
    GX_FORCE_INLINE void                    setLineCheck( const b32 isLineCheck ){ _isLineCheck = isLineCheck; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
    void setGroup( u16 group );
    u16 getGroup( void );
    constexpr s16 getMask( void ) const { return _mask; }
    void setGroupMask( s16 group, s16 mask );
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    // note:グループとマスクについて
    //  BulletがBroadPhaseで利用するフラグ。
    //  _maskには当たる相手の_groupを指定する。
    //  _checkFlagはcustomNearCallback()でのフラグ判定なので、それより先に行われる。
    //  メモ：Bulletのワールドへの登録時に設定するので、再設定にはbanとregisterが必要。
    btCollisionShape*               _pBtShape;                      
    btRigidBody*                    _pBtRigidBody;                  
    btTransform                     _oldTransform;                  
    b32                             _isLineCheck;                   
    s16                             _mask;                          
    btTriangleIndexVertexArray*     _pBtTriangleIndexVertexArray;   
 
};
 
//===========================================================================
//===========================================================================
class GxDynamicsBullet::GxConstraint : public GxDynamics::GxConstraint
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxDynamicsBullet::GxConstraint, GxDynamics::GxConstraint);
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxConstraint);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConstraint(void) : _pBtConstraint(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 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, const GxParamRevolute& param);
 
    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;
    b32 createConstraintFixed(b32 active, GxDynamics::GxObject* pObject0, GxDynamics::GxObject* pObject1, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1);
 
    void setParameterRevolute(const f32 lowerLimit, const f32 upperLimit) override;
 
#if GX_DEVELOP
    void developDraw(void) override;
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr btTypedConstraint* getBtConstraint(void) const { return _pBtConstraint; }
    GxMatrixAffine  getMatrix(void) override;
    // todo:コールバックの実装
    void setBreakParam(b32 isBrakable, f32 maxForce, f32 maxTorque) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    btTypedConstraint*          _pBtConstraint;     
 
};
 
//===========================================================================
// 判定条件
//===========================================================================
class GxDynamicsBullet::GxConditionInformation : public GxDynamics::GxConditionInformation
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxDynamicsBullet::GxConditionInformation, GxDynamics::GxConditionInformation);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConditionInformation(void)
        : _mask(-1)
    {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    s16  _mask;         
 
};
 
//===========================================================================
//===========================================================================
struct GxDynamics::GxRayCallback : public btCollisionWorld::ClosestRayResultCallback
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxRayCallback( const btVector3& rayFromWorld, const btVector3& rayToWorld, GxConditionInformation* pConditionInfo )
        : ClosestRayResultCallback(rayFromWorld, rayToWorld)
        , _pConditionInfo( pConditionInfo )
        , _triangleIndex(0)
    {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    bool needsCollision(btBroadphaseProxy* pProxy) const override;
 
    btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult, bool normalInWorldSpace) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConditionInformation* _pConditionInfo;    
    u32                     _triangleIndex;     
 
};
 
//===========================================================================
//===========================================================================
struct GxDynamics::GxConvexCallback : public btCollisionWorld::ClosestConvexResultCallback
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxConvexCallback( const btVector3& rayFromWorld, const btVector3& rayToWorld, GxConditionInformation* pConditionInfo )
        : ClosestConvexResultCallback(rayFromWorld, rayToWorld)
        , _pConditionInfo( pConditionInfo )
        , _triangleIndex(0)
    {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    bool needsCollision(btBroadphaseProxy* proxy0) const override;
 
    btScalar addSingleResult(btCollisionWorld::LocalConvexResult& convexResult, bool normalInWorldSpace) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConditionInformation* _pConditionInfo;    
    u32                     _triangleIndex;     
 
};
 
//===========================================================================
//===========================================================================
struct GxDynamicsBullet::GxRayResult : public GxDynamics::GxRayResult
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxRayResult(void){}
    ~GxRayResult(void) override {};
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void setResult(GxDynamics::GxRayCallback& resultCallback);
    void setResult(GxDynamics::GxConvexCallback& resultCallback);
 
};
 
GX_PHYSICS_NAMESPACE_END()
 
#endif //PLATFORM_BULLET_SUPPORT