GxCollision.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_PHYSICS_NAMESPACE_BEGIN()
//===========================================================================
//===========================================================================
class GxCollision : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxCollision, GxClassBase)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE( GxAllocatorList::ALLOCATOR_TYPE::PHYSICS )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE( GxCollision )
 
    class GxWorld;
    class GxObject;
 
    enum class COLLISION_SHAPE
    {
        ERROR_  = -1,   
        SPHERE  = 0,    
        BOX,            
        CYLINDER,       
        MULTISPHERE,    
        TRIMESH,        
        PLANE,          
        RAY,            
        BEAM,           
        CAPSULE,        
        CONVEX,         
        COMPOUND,       
        WHEEL,          
        MAX,            
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_COUNT(COLLISION_SHAPE, 7)
#endif //GX_DEVELOP
 
    struct  GxRayCallback;          
    struct  GxConvexCallback;       
    class   GxConditionInformation; 
    struct  GxRayResult;            
 
    typedef void (GxClassBaseRoot::* COLLISION_CALLBACK)(void);
 
    static const f32 BULLET_MARGIN;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxCollision(void);
 
    ~GxCollision(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void clearList(void);
 
    virtual GxObject* allocObject(void);
 
    virtual GxObject* createSphere(b32 active, u32 id, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeSphere& sphere);
    virtual GxObject* createBox(b32 active, u32 id, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeBox& box);
    virtual GxObject* createMultisphere(b32 active, u32 id, const GxMatrixAffine* pMatrix0, const GxVector3& offset0, const GxMatrixAffine* pMatrix1, const GxVector3& offset1, const GxShapeMultisphere& multisphere);
    virtual GxObject* createCylinder(b32 active, u32 id, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeCylinder& cylinder);
    virtual GxObject* createCapsule(b32 active, u32 id, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeCapsule& capsule);
 
    virtual GxObject* createMesh(u32 index, b32 active, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeTrimesh& trimesh, btTriangleIndexVertexArray* pVertex, b32 isCompress = true, GxVector3* pAabbMin = nullptr, GxVector3* pAabbMax = nullptr);
    virtual GxObject* createMesh(u32 index, b32 active, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeTrimesh& trimesh, btBvhTriangleMeshShape* pTrimeshShape);
 
    GxObject* getObject(u32 index);
 
    virtual void deleteObject( GxObject* pObject );
 
    virtual void detachObject( GxObject* pObject );
 
    virtual void initialize(GxWorld* pRegistWorld, GxUnitBase* pUnit, GxCollision::COLLISION_CALLBACK pCallback, u32 threadIndex);
 
    virtual void prepareCheck(void);
 
    virtual void update(void);
 
    constexpr GxWorld* getWorld(void) const { return _pRegisterWorld; }
protected:
    constexpr void setWorldNull(void) { _pRegisterWorld = nullptr; }
public:
    constexpr GxUnitBase* getUnit(void) const { return _pUnit; }
 
    GX_FORCE_INLINE virtual void initializeActiveOn(void) {}
 
    GX_FORCE_INLINE virtual void initializeActiveOff(void) {}
 
    GX_FORCE_INLINE virtual void initializeUpdate(void) {}
 
    virtual void executePostCheckCallback(void);
 
#if GX_DEVELOP
    virtual void developDrawObject(const GxColor& color = GxColor::WHITE, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE);
#endif //GX_DEVELOP
 
protected:
    virtual GxObject* addObject(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE void setHitCallback(GxCollision::COLLISION_CALLBACK pCallback) { _pCallback = pCallback; }
 
    GX_FORCE_INLINE b32 isActive(void) const { return _active; }
 
    void setActive(b32 active);
 
    constexpr u32 getObjectCount(void) const { return _listObject.getCount(); }
 
#if GX_DEVELOP
    constexpr u32 getActiveObjectCount( void ) const { return _activeObjectCount; }
    constexpr u32 getMeshTriangleCount( void ) const { return _meshTriangleCount; }
    GX_FORCE_INLINE void setUnitName(GX_CSTR name) { _unitName = name; }
    GX_FORCE_INLINE GX_CSTR getUnitName(void) { return _unitName.getString(); }
#endif // GX_DEVELOP
 
    GX_FORCE_INLINE void getPropertyActive(void* const pValue) { *static_cast<b32*>(pValue) = _active; }
    GX_FORCE_INLINE void setPropertyActive(const void* const pValue) { setActive( *static_cast<b32*>(const_cast<void*>(pValue))); }
 
    GX_FORCE_INLINE void getPropertyObject(void* const pValue, u32 index){ *static_cast<GxObject**>(pValue) = getObject(index); }
    constexpr void setPropertyObject(const void* const /*pValue*/, u32 /*index*/) {}
    constexpr u32 getPropertyObjectCount(void) const { return getObjectCount(); }
    constexpr void setPropertyObjectCount(u32 /*count*/) {}
 
protected:
    GX_FORCE_INLINE void setOffsetAdjustVector(const GxVector3& offset){ _offsetAdjustVector = offset; }
    GX_FORCE_INLINE GxVector3 getOffsetAdjustVector(void){ return _offsetAdjustVector; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxWorld*            _pRegisterWorld;    
    COLLISION_CALLBACK  _pCallback;         
 
#if GX_DEVELOP
    u32                 _activeObjectCount; 
    u32                 _meshTriangleCount; 
    GxString            _unitName;          
#endif // GX_DEVELOP
 
    GxArrayClassBase    _listObject;        
 
private:
    GxUnitBase*         _pUnit;             
    b32                 _active;            
    GxVector3           _offsetAdjustVector;
 
};
 
//===========================================================================
//===========================================================================
class GxCollision::GxWorld : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxCollision::GxWorld, GxClassBase )
    // new, delete定義
    GX_OPERATOR_NEW_DELETE( GxAllocatorList::ALLOCATOR_TYPE::PHYSICS )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxWorld)
 
    
    static constexpr u32 COLLISION_ALGORITHM_NUM = GxMath::VALUE_2;
    static constexpr u32 GX_COLLISION_DEFAULT_STACK_ALLOCATOR_SIZE = GxMath::VALUE_64K;
    static constexpr u32 GX_COLLISION_DEFAULT_MAX_PERSISTENT_MANIFOLD_POOL_SIZE = GxMath::VALUE_8;
    static constexpr u32 GX_COLLISION_DEFAULT_MAX_COLLISION_ALGORITHM_POOL_SIZE = GxMath::VALUE_8;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxWorld(void);
 
    ~GxWorld(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    virtual b32 alloc(u32 meshCount, const GxVector3& worldAabbMin, const GxVector3& worldAabbMax, u16 maxHandles,
                        u32 stackAllocatorSize = GX_COLLISION_DEFAULT_STACK_ALLOCATOR_SIZE,
                        u32 maxPersistentManifoldPoolSize = GX_COLLISION_DEFAULT_MAX_PERSISTENT_MANIFOLD_POOL_SIZE,
                        u32 maxCollisionAlgorithmPoolSize = GX_COLLISION_DEFAULT_MAX_COLLISION_ALGORITHM_POOL_SIZE);
 
private:
    void free(void);
 
public:
    virtual void prepareCheck(void);
 
    virtual void check(void);
 
    // note:旧update()
    virtual void preBulletUpdate(void);
 
    //  note:旧hit()
    GX_FORCE_INLINE virtual void postBulletUpdate(void) {}
 
    // note:旧adjust()
    virtual void executePostCheckCallback(void);
 
    GX_FORCE_INLINE virtual void postCheck( void ){}
 
    static void customNearCallback(btBroadphasePair& collisionPair, btCollisionDispatcher& dispatcher, const btDispatcherInfo& dispatchInfo);
 
    //---- この関数はGxPhysics外では使用しないでください ----------
    virtual void registerObject(GxCollision::GxObject* pObject);
    void banObject(GxCollision::GxObject* pObject);
    //---- ここまで
 
    void addClass( u32 threadIndex, GxCollision* pObject );
    void detachClass(GxCollision* pCollision);
 
    void detachObjectFromBullet( GxObject* pObject );
 
    constexpr btCollisionWorld* getBulletWorld( void ) const { return _pBulletWorld; }
 
    b32 createBulletWorld( void );
 
    b32 deleteBulletWorld( void );
 
    void freeMesh(void);
 
    b32 addMesh(u32 index, GxCollision::GxObject* pMesh);
 
    b32 eraseMesh(GxCollision::GxObject* pMesh);
 
    virtual GxCollision::GxRayCallback* createRayCallback(const btVector3& rayFrom, const btVector3& rayEnd, GxConditionInformation* pConditionInfo);
 
    b32 checkRayClosestVsWorld(GxCollision::GxRayResult& rayResult, const GxVector3& startPosition, const GxVector3& endPosition, GxConditionInformation* pConditionInfo = nullptr);
 
    b32 checkRayClosestVsSingle(GxCollision::GxRayResult& rayResult, GxObject* pTargetObject, const GxVector3& startPosition, const GxVector3& endPosition, GxConditionInformation* pConditionInfo = nullptr);
 
    virtual GxCollision::GxConvexCallback* createConvexCallback(const btVector3& checkFrom, const btVector3& checkEnd, GxConditionInformation* pConditionInfo);
 
    b32 checkCapsuleClosestVsWorld(GxCollision::GxRayResult& rayResult, const GxVector3& startPosition, const GxVector3& endPosition, f32 radius, GxConditionInformation* pConditionInfo = nullptr);
 
    b32 checkCapsuleClosestVsSingle(GxCollision::GxRayResult& rayResult, GxObject* pTargetObject, const GxVector3& startPosition, const GxVector3& endPosition, f32 radius, GxConditionInformation* pConditionInfo = nullptr);
 
private:
    void freeListClass(void);
    void clearListClass(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE void setActive(b32 active) { _active = active; }
    GX_FORCE_INLINE b32 isActive(void) { return _active; }
 
#if GX_DEVELOP
    // 名前の設定
    GX_FORCE_INLINE void setName( GX_CSTR name ) { _name = name; }
    // 名前の取得
    constexpr GX_CSTR getName( void ) const { return _name.getString(); }
#endif // GX_DEVELOP
 
    b32 setMeshCount(u32 count);
 
    GxCollision::GxObject* getMesh(u32 index);
 
    constexpr u32 getMeshCount(void) const { return _meshCount; }
 
    u32 getActiveMeshCount(void);
 
    constexpr u32 getListClassCount(void) const { return _listClassCount; }
    b32 setListClassCount(u32 count);
    constexpr GxArrayClassBase* getListClass(u32 index) const { return index >= _listClassCount ? nullptr : _ppCollisionList[index]; }
 
    constexpr u32 getCollisionCount(void) const { return _collisionList.getCount(); }
    GX_FORCE_INLINE GxArrayClassBase* getCollisionList( void ) { return &_collisionList; }
 
#if GX_DEVELOP
    constexpr u32 getObjectCount(void) const { return _objectCount; }
    constexpr u32 getActiveObjectCount( void ) const { return _activeObjectCount; }
    constexpr u32 getMeshTriangleCount( void ) const { return _meshTriangleCount; }
#endif // GX_DEVELOP
 
protected:
    GX_FORCE_INLINE void getPropertyList(void* const pValue, u32 index) { *static_cast<GxArrayClassBase**>(pValue) = getListClass(index); }
    GX_FORCE_INLINE void setPropertyList(const void* const /*pValue*/, u32 /*index*/) {}
    GX_FORCE_INLINE void setPropertyListClassCount(u32 count) { setListClassCount(count); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32         _active;            
 
    u32                             _listClassCount;            
    GxArrayClassBase**              _ppCollisionList;           
    GxArrayClassBase                _collisionList;             
    btCollisionConfiguration*       _pBulletConfiguration;      
    btCollisionDispatcher*          _pBulletDispatcher;         
    btAxisSweep3*                   _pBulletBroadphase;         
    btCollisionWorld*               _pBulletWorld;              
    btCollisionAlgorithmCreateFunc* _pBulletAlgorithmCreateFunction[COLLISION_ALGORITHM_NUM];   
 
    GxVector3                       _worldAabbMin;              
    GxVector3                       _worldAabbMax;              
    u16                             _maxHandles;                
    u32                             _btStackAllocatorSize;      
    u32                             _btMaxPersistentManifoldPoolSize;   
    u32                             _btMaxCollisionAlgorithmPoolSize;   
 
private:
    GxCollision::GxObject**     _ppMesh;                    
    u32                             _meshCount;                 
 
#if GX_DEVELOP
    GxString                        _name;                      
    u32                             _objectCount;               
    u32                             _activeObjectCount;         
    u32                             _meshTriangleCount;         
#endif // GX_DEVELOP
 
    GxCriticalSection               _bulletWorldCriticalSection;   
    GxCriticalSection               _collisionListCriticalSection; 
 
};
 
//===========================================================================
//===========================================================================
class GxCollision::GxObject : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxCollision::GxObject, GxClassBase )
    // new, delete定義
    GX_OPERATOR_NEW_DELETE( GxAllocatorList::ALLOCATOR_TYPE::PHYSICS )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxObject)
 
    
    enum
    {
        ACTIVE_FLAG_ACTIVE                  = (1UL << 0),       
        ACTIVE_FLAG_ACTIVE_OLD              = (1UL << 1),       
        ACTIVE_FLAG_REQUEST_REGISTER        = (1UL << 2),       
        ACTIVE_FLAG_REQUEST_BAN             = (1UL << 3),       
        ACTIVE_FLAG_REQUEST_DELETE          = (1UL << 4),       
    };
 
    static constexpr u32 CHECK_FLAG_ALL = 0x7fffffff;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxObject(void);
    ~GxObject(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    virtual void prepareCheck(void);
 
    virtual void update(void);
 
    void addOffset(const GxVector3& offset);
 
    virtual b32 isNeedCheck(GxObject* pCollisionObject);
 
    virtual b32 isHitCheckFlag(u32 targetFlag);
 
    virtual b32 isHitCheckFlagTrimesh(u32 triangleIndex, u32 targetFlag);
 
    GX_FORCE_INLINE virtual void initializeActiveOn(void) {}
 
    GX_FORCE_INLINE virtual void initializeActiveOff(void) {}
 
    GX_FORCE_INLINE virtual void initializeUpdate(void) {}
 
    virtual b32 createSphere(b32 active, u32 id, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeSphere& sphere);
 
    virtual b32 createBox(b32 active, u32 id, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeBox& box);
 
    virtual b32 createMultisphere(b32 active, u32 id, const GxMatrixAffine* pMatrix0, const GxVector3& offset0, const GxMatrixAffine* pMatrix1, const GxVector3& offset1, const GxShapeMultisphere& multisphere);
 
    virtual b32 createCylinder(b32 active, u32 id, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeCylinder& cylinder);
 
    virtual b32 createCapsule(b32 active, u32 id, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeCapsule& capsule);
 
    virtual b32 createMesh(b32 active, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeTrimesh& trimesh, btTriangleIndexVertexArray* pVertex, b32 isCompress, GxVector3* pAabbMin = nullptr, GxVector3* pAabbMax = nullptr);
    virtual b32 createMesh(b32 active, const GxMatrixAffine* pMatrix, const GxVector3& offset, const GxShapeTrimesh& trimesh, btBvhTriangleMeshShape* pBtTrimeshShape);
 
    void resetBulletShape(btCollisionShape* pBtShapeNew);
 
#if GX_DEVELOP
    virtual void developDraw(const GxColor& color, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE);
 
    virtual void developDrawTrimesh(GxShapeTrimesh* pTrimesh, const GxColor& color, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE);
#endif // GX_DEVELOP
 
protected:
    GX_FORCE_INLINE void updateActiveFlag(void){ setActiveFlag(ACTIVE_FLAG_ACTIVE_OLD, isActive()); }
 
    virtual void initialize(b32 active, u32 id, const GxMatrixAffine* pMatrix0, const GxVector3& offset0, const GxMatrixAffine* pMatrix1, const GxVector3& offset1);
 
    GX_FORCE_INLINE void updateUnitPointer(void) { GX_UPDATE_UNIT_POINTER(_pUnit); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr GxShape* getShape(void) const { return _pShape; }
    constexpr COLLISION_SHAPE getShapeType(void) const { return _shapeType; }
 
    constexpr GxCollision::GxWorld* getRegisterWorld(void) const { return _pRegisterWorld; }
    constexpr void setRegisterWorld(GxCollision::GxWorld* pWorld) { _pRegisterWorld = pWorld; }
 
    GX_FORCE_INLINE const GxMatrixAffine* getMatrixAddress0(void) const { return _pMatrix0; }
    GX_FORCE_INLINE const GxMatrixAffine* getMatrixAddress1(void) const { return _pMatrix1; }
    GX_FORCE_INLINE void setMatrixAddress0(const GxMatrixAffine* pMatrix) { _pMatrix0 = pMatrix; }
    GX_FORCE_INLINE void setMatrixAddress1(const GxMatrixAffine* pMatrix) { _pMatrix1 = pMatrix; }
 
    GX_FORCE_INLINE GxMatrixAffine getMatrix0(void) const { if( _pMatrix0 ) { return *_pMatrix0; } return GxMatrixAffine::IDENTITY; }
    GX_FORCE_INLINE GxMatrixAffine getMatrix1(void) const { if( _pMatrix1 ) { return *_pMatrix1; } return GxMatrixAffine::IDENTITY; }
 
    GX_FORCE_INLINE const GxVector3& getOffset0(void) const { return _offset0; }
    GX_FORCE_INLINE const GxVector3& getOffset1(void) const { return _offset1; }
    GX_FORCE_INLINE void setOffset0(const GxVector3& offset) { _offset0 = offset; }
    GX_FORCE_INLINE void setOffset1(const GxVector3& offset) { _offset1 = offset; }
 
    GX_FORCE_INLINE const GxQuaternion& getQuaternion(void) { return _quaternion; }
    GX_FORCE_INLINE void setQuaternion(const GxQuaternion& quaternion) { _quaternion = quaternion; _rotateMatrix.setRotate(_quaternion); }
 
    GX_FORCE_INLINE b32 getActiveFlag(u32 flag) const { return (_activeFlag & flag) ? true : false; }
    constexpr u32 getActiveFlagAll(void) const { return _activeFlag; }
    GX_FORCE_INLINE void setActiveFlag(u32 flag, b32 value) { _activeFlag = (value) ? (_activeFlag | flag) : (_activeFlag & ~flag); }
 
    GX_FORCE_INLINE b32 isActive(void) const { return getActiveFlag(ACTIVE_FLAG_ACTIVE); }
    void setActive(b32 active);
 
    GX_FORCE_INLINE b32 isActiveOld(void) const { return getActiveFlag(ACTIVE_FLAG_ACTIVE_OLD); }
 
    constexpr GxUnitBase* getUnit(void) const { return _pUnit; }
    GX_FORCE_INLINE void setUnit(GxUnitBase* pUnit) { _pUnit = pUnit; }
 
    constexpr u32 getId(void) const { return _id; }
    constexpr void setId(u32 id) { _id = id; }
 
    constexpr s32 getMaterial(void) const { return _material; }
    constexpr void setMaterial(s32 material) { _material = material; }
 
    constexpr u32 getCheckFlag(void) const { return _checkFlag; }
    constexpr void setCheckFlag(u32 flag) { _checkFlag = flag; }
    constexpr void onCheckFlag(u32 flag) { _checkFlag |= flag; }
    constexpr void offCheckFlag(u32 flag) { _checkFlag &= ~flag; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr s16 getGroup( void ) const { return _group; }
    constexpr s16   getMask( void ) const { return _mask; }
    void setGroupMask( s16 group, s16 mask );
 
    b32 setSphereRadius(f32 radius);
 
    b32 setMultisphereRadius(f32 radius0, f32 radius1);
 
    b32 setCapsuleRadius(f32 radius);
 
    b32 setBoxExtent(const GxVector3& extent);
 
    b32 setCylinderExtent(const f32 radius, const f32 heightHalf );
 
    b32 transformMeshVertex(const GxMatrixAffine& matrix);
 
    void getCenterPosition( GxVector3& centerPosition );
 
    const GxMatrixAffine getCenterMatrix(void);
 
    f32 getRadiusMin(void);
 
    const GxVector3 getNormal(const GxVector3& position);
 
    GX_FORCE_INLINE btCollisionObject* getBulletCollisionObject(void) { return &_btObject; }
    constexpr btCollisionShape* getBulletCollisionShape(void) const { return _pBtShape; }
 
    GX_FORCE_INLINE void getPropertyActiveOld(void* const pValue) { *static_cast<b32*>(pValue) = getActiveFlag(ACTIVE_FLAG_ACTIVE_OLD); }
    GX_FORCE_INLINE void getPropertyActive(void* const pValue) { *static_cast<b32*>(pValue) = getActiveFlag(ACTIVE_FLAG_ACTIVE); }
 
    constexpr void setPropertyActiveOld(const void* const /*pValue*/)   {}
    GX_FORCE_INLINE void setPropertyActive(const void* const pValue) { setActive(*static_cast<b32*>(const_cast<void*>(pValue))); }
 
    constexpr void setCollision(GxCollision* pCollision) { _pCollision = pCollision; }
 
    constexpr GxCollision* getCollision(void) const { return _pCollision; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    btCollisionShape*           _pBtShape;              
 
private:
    btCollisionObject           _btObject;              
    GxCollision::GxWorld*   _pRegisterWorld;        
    GxUnitBase*                 _pUnit;                 
    GxShape*                    _pShape;                
    COLLISION_SHAPE             _shapeType;             
    b32                         _isOwnsBtShape;         
 
    const GxMatrixAffine*       _pMatrix0;              
    const GxMatrixAffine*       _pMatrix1;              
    GxVector3                   _offset0;               
    GxVector3                   _offset1;               
    GxQuaternion                _quaternion;            
    GxMatrixAffine              _rotateMatrix;          
    u32                         _activeFlag;            
    u32                         _id;                    
    u32                         _checkFlag;             
    s32                         _material;              
    GxCollision*                _pCollision;            
 
    // note:グループとマスクについて
    //  BulletがBroadPhaseで利用するフラグ。
    //  _maskには当たる相手の_groupを指定する。
    //  _checkFlagはcustomNearCallback()でのフラグ判定なので、それより先に行われる。
    //  メモ：Bulletのワールドへの登録時に設定するので、再設定にはbanとregisterが必要。
    s16                         _group;                 
    s16                         _mask;                  
 
};
 
//===========================================================================
// 判定条件
//===========================================================================
class GxCollision::GxConditionInformation : public GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxCollision::GxConditionInformation, GxClassBase )
    // new, delete定義
    GX_OPERATOR_NEW_DELETE( GxAllocatorList::ALLOCATOR_TYPE::PHYSICS )
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConditionInformation(void) : _mask(-1), _checkFlag(0xffffffff) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    //  グループとマスクついては
    //  GxCollision::GxObject::setGroupMask()
    //  のコメントを参照してください。
    s16         _mask;          
    u32         _checkFlag;     
 
};
 
//===========================================================================
//===========================================================================
struct GxCollision::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 GxCollision::GxConvexCallback : public btCollisionWorld::ClosestConvexResultCallback
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxConvexCallback( const btVector3& rayFromWorld, const btVector3& rayToWorld, GxConditionInformation* pConditionInfo )
        : ClosestConvexResultCallback(rayFromWorld, rayToWorld)
        , _pConditionInfo( pConditionInfo )
        , _triangleIndex(0)
    {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    bool needsCollision(btBroadphaseProxy* pProxy) const override;
 
    btScalar addSingleResult(btCollisionWorld::LocalConvexResult& convexResult, bool normalInWorldSpace) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConditionInformation* _pConditionInfo;    
    u32                     _triangleIndex;     
 
};
 
//===========================================================================
//===========================================================================
struct GxCollision::GxRayResult
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxRayResult(void)
        : _position(GxVector3::ZERO)
        , _normal(GxVector3::ZERO)
        , _pObject(nullptr)
        , _triangleIndex(-1)
        , _checkFlag(0)
        , _fraction( 0.f )
        , _hasHit( false )
    {}
    virtual ~GxRayResult(void) {};
 
    const GxRayResult& operator = (const GxRayResult& rayResult)
    {
        _position       = rayResult._position;
        _normal         = rayResult._normal;
        _pObject        = rayResult._pObject;
        _triangleIndex  = rayResult._triangleIndex;
        _checkFlag      = rayResult._checkFlag;
        _fraction       = rayResult._fraction;
        _hasHit         = rayResult._hasHit;
        return *this;
    }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void setResult(GxCollision::GxRayCallback& resultCallback);
    void setResult(GxCollision::GxConvexCallback& resultCallback);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxVector3                   _position;      
    GxVector3                   _normal;        
    GxCollision::GxObject*  _pObject;       
    s32                         _triangleIndex; 
    u32                         _checkFlag;     
    //  値域は0.f<= _fraction <= 1.f
    //
    //  レイチェックの場合は _pos = start + _fraction * (end - start)
    //
    // カプセルチェックの場合は 
    //  start + _fraction * (end - start)
    //  に球を置くと_posに接するような最小の値が_fractionとなる。
    f32                         _fraction;      
    b32                         _hasHit;        
 
};
 
GX_PHYSICS_NAMESPACE_END()