GxDynamics.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#define DYNAMICS_COLLISION_SKIN_WIDTH                       (0.025f)    
#define DYNAMICS_COLLISION_MARGIN                           (0.05f)     
#define DYNAMICS_DEFAULT_STACK_ALLOCATOR_SIZE               (GxMath::VALUE_32K) 
#define DYNAMICS_DEFAULT_MAX_PERSISTENT_MANIFOLD_POOL_SIZE  (1)         
#define DYNAMICS_DEFAULT_MAX_COLLISION_ALGORITHM_POOL_SIZE  (1)         
#define DYNAMICS_ALGORITHM_NUM                              (2)         
 
GX_PHYSICS_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxDynamics : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS(GxDynamics, GxClassBase)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE( GxAllocatorList::ALLOCATOR_TYPE::PHYSICS )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE( GxDynamics )
 
    
    static const GxColor COLOR_OBJECT;  
 
    class   GxWorld;
    class   GxObject;
    class   GxConstraint;
    struct  GxRigidBodyParam;       
    struct  GxRayCallback;          
    struct  GxConvexCallback;       
    class   GxConditionInformation; 
    struct  GxRayResult;            
 
    static constexpr u32 FLAG_ALL = 0x7fffffff;
 
    struct GxParamConeTwist : public GxStructBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        // RTTI定義
        GX_RTTI_STRUCT(GxParamConeTwist);
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        GxParamConeTwist()
            : _twistLimit( PI_2 )
            , _swingLimit1( PI_2 )
            , _swingLimit2( PI_2 )
            , _disableCollision( true )
        {}
        ~GxParamConeTwist(void){}
 
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        f32 _twistLimit;        
        f32 _swingLimit1;       
        f32 _swingLimit2;       
        b32 _disableCollision;  
 
    };
 
    typedef void (GxClassBaseRoot::* DYNAMICS_CALLBACK)(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxDynamics(void);
    ~GxDynamics(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void clearList(void);
 
    GX_FORCE_INLINE virtual GxObject* allocObject(void) { return nullptr; }
 
    GxObject* getObject(u32 index);
 
    u32 getObjectCount(void);
 
    virtual void deleteObject(GxObject* pObject);
 
    virtual void detachObject(GxObject* pObject);
 
    virtual void detachConstraint(GxConstraint* pConstraint);
 
    GxObject* createSphere(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeSphere& sphere, const GxRigidBodyParam& rigidParam, f32 margin = DYNAMICS_COLLISION_MARGIN);
 
    GxObject* createBox(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeBox& box, const GxRigidBodyParam& rigidParam, f32 margin = DYNAMICS_COLLISION_MARGIN);
 
    GxObject* createCylinder(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeCylinder& cylinder, const GxRigidBodyParam& rigidParam, f32 margin = DYNAMICS_COLLISION_MARGIN);
 
    GxObject* createMultisphere(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeMultisphere& multisphere, const GxRigidBodyParam& rigidParam, f32 margin = DYNAMICS_COLLISION_MARGIN);
 
    GxObject* createCapsule(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxShapeCapsule& capsule, const GxRigidBodyParam& rigidParam, f32 margin = DYNAMICS_COLLISION_MARGIN);
 
    virtual GxObject* createConvexShape(b32 active, GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, const GxVector3* pVertex, u32 numVertex, const GxRigidBodyParam& rigidParam, f32 margin);
 
    GxObject* createMesh(u32 index, 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);
 
    GxObject* createCompoundObject(GxMatrixAffine* pMatrix, s32 jointIndex, const GxVector3& offset, const GxQuaternion& rotateOffset, f32 margin = DYNAMICS_COLLISION_MARGIN);
 
    GX_FORCE_INLINE b32 isActive(void) const { return _active; }
 
    void setActive(b32 active);
 
    virtual GxConstraint* allocConstraint(void);
 
    GxConstraint* getConstraint(u32 index);
 
    u32     getConstraintCount(void);
 
    virtual void deleteConstraint(GxDynamics::GxConstraint* pConstraint);
 
    GxConstraint* createConstraintSpherical(b32 active, GxDynamics::GxObject* pObject0, GxDynamics::GxObject* pObject1, const GxVector3& pivot0, const GxVector3& pivot1, b32 disableCollisions = false);
 
    GxConstraint* createConstraintRevolute(b32 active, GxDynamics::GxObject* pObject0, GxDynamics::GxObject* pObject1, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1, b32 disableCollisions = false);
    GxConstraint* 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 = false);
 
    GxConstraint* createConstraintConeTwist(b32 active, GxDynamics::GxObject* pObject0, GxDynamics::GxObject* pObject1, const GxMatrixAffine& matrix0, const GxMatrixAffine& matrix1, const GxParamConeTwist& param);
 
    GxConstraint* createConstraintFixed(b32 active, GxDynamics::GxObject* pObject0, GxDynamics::GxObject* pObject1, const GxVector3& pivot0, const GxVector3& pivot1 );
 
    virtual void initialize(GxDynamics::GxWorld* pRegisterWorld, GxUnitBase* pUnit, GxDynamics::DYNAMICS_CALLBACK, u32 threadIndex);
 
    virtual void prepareCheck(void);
 
    virtual void preUpdate(void);
 
    virtual void postUpdate(void);
 
    void setActiveAll(b32 active);
 
    constexpr GxWorld* getWorld(void) const { return _pRegisterWorld; }
 
protected:
    constexpr void setWorldNull( void ) { _pRegisterWorld = nullptr; }
public:
 
    GX_FORCE_INLINE void setCallback(DYNAMICS_CALLBACK pCallback) { _pCallback = pCallback; }
    void executeCallback(void);
 
#if GX_DEVELOP
    virtual void developDrawObject(const GxColor color = GxColor::WHITE, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE);
 
    GX_FORCE_INLINE static void setDevelopDraw( b32 display ) { getGxSysMain()->setDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_DYNAMICS, display); }
    GX_FORCE_INLINE static void setDevelopDrawConstraint( b32 display) { getGxSysMain()->setDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_DYNAMICS_CONSTRAINT, display); }
 
    GX_FORCE_INLINE static b32 getDevelopDraw( void ) { return getGxSysMain()->isOnDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_DYNAMICS); }
    GX_FORCE_INLINE static b32 getDevelopDrawConstraint( void ) { return getGxSysMain()->isOnDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_DYNAMICS_CONSTRAINT); }
#endif // GX_DEVELOP
 
protected:
    virtual GxObject* addObject(void);
 
    GxConstraint* addConstraint(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32                     _active;            
    DYNAMICS_CALLBACK       _pCallback;         
    GxArrayClassBase        _listObject;        
    GxArrayClassBase        _listConstraint;    
 
    GxWorld*                _pRegisterWorld;    
    GxUnitBase*             _pUnit;             
 
};
 
//===========================================================================
//===========================================================================
class GxDynamics::GxWorld : public gx::core::GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxDynamics::GxWorld, gx::core::GxClassBase );
    // new, delete定義
    GX_OPERATOR_NEW_DELETE( GxAllocatorList::ALLOCATOR_TYPE::PHYSICS );
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxWorld);
 
    static const GxVector3 DYNAMICS_GRAVITY;
 
#if (USE_VEHICLE)
    static constexpr u32 MAX_NUM_VEHICLE_COUNT = GxMath::VALUE_16;
    static constexpr u32 MAX_NUM_SURFACE_TYPES = 1;
    static constexpr u32 DEFAULT_SURFACE_TYPE  = 0;  
#endif //USE_VEHICLE
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxWorld(void);
 
    ~GxWorld(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    virtual 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);
 
    virtual void free(void);
 
    virtual void prepareCheck(void);
 
    virtual void check(void);
 
    virtual void preUpdate(void);
 
    virtual void update(void) {}
 
    virtual void postUpdate(void);
    
    //---- この関数はGxPhysics外では使わないでほしい
    GX_FORCE_INLINE virtual void registerObject(GxDynamics::GxObject* /*pObject*/) {}
    GX_FORCE_INLINE virtual void banObject(GxDynamics::GxObject* /*pObject*/) {}
 
    GX_FORCE_INLINE virtual void registerConstraint(GxDynamics::GxConstraint* /*pConstraint*/, b32 /*disableCollisions*/) {}
    GX_FORCE_INLINE virtual void banConstraint(GxDynamics::GxConstraint* /*pConstraint*/) {}
    //---- ここまで
 
    void addClass(u32 threadIndex, GxDynamics* pDynamics );
    void detachClass( GxDynamics* pDynamics );
 
    GX_FORCE_INLINE void setActive(b32 active) { _active = active; }
    GX_FORCE_INLINE b32 isActive(void) const { return _active; }
 
    GX_FORCE_INLINE virtual void reset(void) {}
 
    virtual void setGravity(const GxVector3& gravity = GxDynamics::GxWorld::DYNAMICS_GRAVITY);
    GX_FORCE_INLINE virtual void setGravity(const f32 /*gravityX*/, const f32 /*gravityY*/, const f32 /*gravityZ*/) {}
 
    void setMaxTimeStep( f32 timeStep = 1.0f / 60.f, u32 maxIteration = 8 );
 
    GX_FORCE_INLINE void setEnableMaxTimeStep(b32 enable){ _enableMaxTimeStep = enable; }
 
    GX_FORCE_INLINE virtual void detachObjectFromWorld(GxObject* /*pObject*/) {}
 
    b32 setMeshCount(u32 count);
 
    void freeMesh(void);
 
    b32 addMesh(u32 index, GxDynamics::GxObject* pMesh);
 
    b32 eraseMesh(GxDynamics::GxObject* pMesh);
 
    GxDynamics::GxObject* getMesh(u32 index);
 
    constexpr u32 getMeshCount(void) const { return _meshCount; }
 
    u32 getActiveMeshCount(void);
 
    u32 getFreeMeshIndex(void);
 
    virtual b32 checkRayClosestVsWorld(GxDynamics::GxRayResult* /*pRayResult*/, const GxVector3& /*startPosition*/, const GxVector3& /*endPosition*/, GxConditionInformation* /*pConditionInformation*/ = nullptr) { return false; }
 
    virtual b32 checkRayClosestVsSingle(GxDynamics::GxRayResult* /*pRayResult*/, GxObject* /*pTargetObject*/, const GxVector3& /*startPosition*/, const GxVector3& /*endPosition*/, GxConditionInformation* /*pConditionInformation*/ = nullptr) { return false; }
 
    constexpr u32 getListClassCount(void) const { return _listClassCount; }
 
    b32 setListClassCount(u32 count);
 
    GxArrayClassBase* getListClass(u32 index);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void setGroupCollision( u16 group1, u16 group2, b32 isColide );
 
protected:
    GX_FORCE_INLINE void getPropertyList(void* const pValue, u32 index) { *static_cast<GxArrayClassBase**>(pValue) = getListClass(index); }
    constexpr void setPropertyList(const void* const /*pValue*/, u32 /*index*/) {}
 
    GX_FORCE_INLINE void setPropListClassCount(u32 count){ setListClassCount(count); }
 
private:
    void freeListClass(void);
 
    void clearListClass(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    b32                                     _active;                            
    GxDynamics::GxObject**                  _ppMesh;                            
    u32                                     _meshCount;                         
    u32                                     _listClassCount;                    
    GxArrayClassBase**                      _ppDynamicsList;                    
 
protected:
    GxArrayClassBase                        _dynamicsList;                      
    b32                                     _enableMaxTimeStep;                 
    f32                                     _timeStep;                          
    u32                                     _maxIteration;                      
    u32                                     _groupCollide[32];                  
 
};
 
//===========================================================================
//===========================================================================
class GxDynamics::GxObject : public gx::core::GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxDynamics::GxObject, gx::core::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_REGISTERED              = (1UL << 1),       
        ACTIVE_FLAG_REQUEST_REGISTER        = (1UL << 2),       
        ACTIVE_FLAG_REQUEST_BAN             = (1UL << 3),       
        ACTIVE_FLAG_REQUEST_DELETE          = (1UL << 4),       
    };
 
    enum class RIGID_BODY_TYPE
    {
        DYNAMIC = 0,    
        STATIC,         
        KINEMATIC,      
        MAX,            
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(RIGID_BODY_TYPE)
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxObject(void);
    ~GxObject(void) override;
 
    GX_FORCE_INLINE virtual void initialize(b32 /*active*/, GxMatrixAffine* /*pMatrix*/, const GxVector3& /*offset*/, const GxQuaternion& /*rotateOffset*/) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    virtual void prepareCheck(void);
 
    GX_FORCE_INLINE virtual void preUpdate(void) {}
    GX_FORCE_INLINE virtual void postUpdate(void) {}
 
    GX_FORCE_INLINE virtual void reset(void) {}
 
    GX_FORCE_INLINE virtual void applyForce(const GxVector3& /*force*/, const GxVector3& /*position*/) {}
 
    GX_FORCE_INLINE virtual void applyImpulse(const GxVector3& /*impulse*/, const GxVector3& /*position*/) {}
 
    GX_FORCE_INLINE virtual b32 createSphere(b32 /*active*/, GxMatrixAffine* /*pMatrix*/, s32 /*jointIndex*/, const GxVector3& /*offset*/, const GxQuaternion& /*rotateOffset*/, const GxShapeSphere& /*sphere*/, const GxRigidBodyParam& /*rigidParam*/, f32 /*margin*/) { return false; }
 
    GX_FORCE_INLINE virtual b32 createBox(b32 /*active*/, GxMatrixAffine* /*pMatrix*/, s32 /*jointIndex*/, const GxVector3& /*offset*/, const GxQuaternion& /*rotateOffset*/, const GxShapeBox& /*box*/, const GxRigidBodyParam& /*rigidParam*/, f32 /*margin*/) { return false; }
 
    GX_FORCE_INLINE virtual b32 createCylinder(b32 /*active*/, GxMatrixAffine* /*pMatrix*/, s32 /*jointIndex*/, const GxVector3& /*offset*/, const GxQuaternion& /*rotateOffset*/, const GxShapeCylinder& /*cylinder*/, const GxRigidBodyParam& /*rigidParam*/, f32 /*margin*/) { return false; }
 
    GX_FORCE_INLINE virtual b32 createMultisphere(b32 /*active*/, GxMatrixAffine* /*pMatrix*/, s32 /*jointIndex*/, const GxVector3& /*offset*/, const GxQuaternion& /*rotateOffset*/, const GxShapeMultisphere& /*multiSphere*/, const GxRigidBodyParam& /*rigidParam*/, f32 /*margin*/) { return false; }
 
    GX_FORCE_INLINE virtual b32 createCapsule(b32 /*active*/, GxMatrixAffine* /*pMatrix*/, s32 /*jointIndex*/, const GxVector3& /*offset*/, const GxQuaternion& /*rotateOffset*/, const GxShapeCapsule& /*capsule*/, const GxRigidBodyParam& /*rigidParam*/, f32 /*margin*/) { return false; }
 
    GX_FORCE_INLINE virtual b32 createConvexShape(b32 /*active*/, GxMatrixAffine* /*pMatrix*/, s32 /*jointIndex*/, const GxVector3& /*offset*/, const GxQuaternion& /*rotateOffset*/, const GxVector3* /*pVertex*/, u32 /*numVertex*/, const GxRigidBodyParam& /*rigidParam*/, f32 /*margin*/) { return false; }
 
    GX_FORCE_INLINE virtual b32 createCompoundObject(GxMatrixAffine* /*pMatrix*/, s32 /*jointIndex*/, const GxVector3& /*offset*/, const GxQuaternion& /*rotateOffset*/, f32 /*margin*/) { return false; }
 
    GX_FORCE_INLINE virtual 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) { return false; }
 
    GX_FORCE_INLINE virtual b32 addCompoundSphere(const GxVector3& /*offset*/, const GxShapeSphere& /*sphere*/) { return false; }
    GX_FORCE_INLINE virtual b32 addCompoundBox(const GxVector3& /*offset*/, const GxQuaternion& /*rotateOffset*/, const GxShapeBox& /*box*/) { return false; }
    GX_FORCE_INLINE virtual b32 addCompoundCapsule(const GxVector3& /*offset*/, const GxQuaternion& /*rotateOffset*/, const GxShapeCapsule& /*capsule*/) { return false; }
    GX_FORCE_INLINE virtual b32 addCompoundConvex(const GxVector3& /*offset*/, const GxQuaternion& /*rotateOffset*/, const GxVector3* /*pVertex*/, u32 /*numVertex*/) { return false; }
    GX_FORCE_INLINE virtual b32 endAddCompound(b32 /*isActive*/, const GxRigidBodyParam& /*rigidParam*/) { return false; }
 
#if GX_DEVELOP
    GX_FORCE_INLINE 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
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GX_FORCE_INLINE virtual void setLinearVelocity(const GxVector3& /*velocity*/) {}
    GX_FORCE_INLINE virtual void getLinearVelocity(GxVector3& /*velocity*/) {}
 
    GX_FORCE_INLINE virtual void setAngularVelocity(const GxVector3& /*angular*/) {}
    GX_FORCE_INLINE virtual void getAngularVelocity(GxVector3& /*angular*/) {}
 
    GX_FORCE_INLINE virtual void setPosition(const GxVector3& /*position*/) {}
    GX_FORCE_INLINE virtual void getPosition(GxVector3& /*position*/) {}
 
    GX_FORCE_INLINE virtual void setQuaternion(const GxQuaternion& /*quaternion*/) {}
    GX_FORCE_INLINE virtual void getQuaternion(GxQuaternion& /*quaternion*/) {}
 
    GX_FORCE_INLINE virtual void setDampingRatio(f32 /*linearDamping*/, f32 /*angularDamping*/) {}
 
    GX_FORCE_INLINE virtual void setDeactivationTime(f32 /*time*/) {}
 
    GX_FORCE_INLINE virtual void setSleepingThresholds(f32 /*linear*/, f32 /*angular*/) {}
 
    GX_FORCE_INLINE virtual void setFriction(f32 /*friction*/) {}
 
    GX_FORCE_INLINE virtual void setRestitution(f32 /*restitution*/) {}
 
    constexpr void setRegisterWorld(GxDynamics::GxWorld* pWorld) { _pRegisterWorld = pWorld; }
    constexpr GxDynamics::GxWorld* getRegisterWorld(void) const { return _pRegisterWorld; }
 
    constexpr GxShape* getShape(void) const { return _pShape; }
    constexpr GxCollision::COLLISION_SHAPE getShapeType(void) const { return _shapeType; }
 
    GX_FORCE_INLINE virtual void setMatrix(const GxMatrixAffine& /*matrix*/) {}
    GX_FORCE_INLINE virtual GxMatrixAffine getMatrix(void) { return GxMatrixAffine(); }
 
    //  マトリクス設定
    constexpr void setMatrixAddress(GxMatrixAffine* pMatrix){ _pMatrix = pMatrix; }
    //  マトリクス取得
    constexpr const GxMatrixAffine* getMatrixAddress(void) const { return _pMatrix; }
 
    constexpr s32 getJointIndex(void) const { return _jointIndex; }
 
    virtual void setActive(b32 active);
    GX_FORCE_INLINE b32 isActive(void) const { return _activeFlag.isFlag(ACTIVE_FLAG_ACTIVE); }
 
    constexpr u32 getActiveFlagAll(void) const { return _activeFlag.getFlag(); }
    GX_FORCE_INLINE b32 getActiveFlag(u32 flag) const { return _activeFlag.isFlag(flag); }
    GX_FORCE_INLINE void setActiveFlag(u32 flag, b32 value) { return _activeFlag.setFlag(flag, value); }
 
    constexpr void setUnit(GxUnitBase* pUnit) { _pUnit = pUnit; }
    constexpr GxUnitBase* getUnit(void) const { return _pUnit;  }
 
    constexpr u32 getCheckFlag(void) const { return _checkFlag; }
    constexpr void setCheckFlag(u32 flag) { _checkFlag = flag; }
    constexpr RIGID_BODY_TYPE getType(void) const { return _type; }
 
    constexpr void setManagementClass(GxDynamics* pManagementClass) { _pManagementClass = pManagementClass; }
    constexpr GxDynamics* getManagementClass(void) const { return _pManagementClass; }
 
    GX_FORCE_INLINE const GxVector3& getOffset(void) const { return _offset; }
    GX_FORCE_INLINE void setOffset(const GxVector3& offset) { _offset = offset; }
    constexpr f32 getMass(void) const { return _mass; }
 
    GX_FORCE_INLINE const GxQuaternion& getRotateOffset(void) const { return _rotateOffset; }
    GX_FORCE_INLINE void setRotateOffset(const GxQuaternion& offset) { _rotateOffset = offset; }
 
    virtual b32 isNeedCheck(GxObject* pCollisionObject);
 
    virtual b32 isHitCheckFlag( u32 targetFlag );
 
    virtual b32 isHitCheckFlagTrimesh( u32 triangleIndex, u32 targetFlag );
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxFlag32Bit                     _activeFlag;        
    GxShape*                        _pShape;            
    GxCollision::COLLISION_SHAPE    _shapeType;         
    GxMatrixAffine*                 _pMatrix;           
    s32                             _jointIndex;        
    RIGID_BODY_TYPE                 _type;              
    GxDynamics::GxWorld*            _pRegisterWorld;    
    GxUnitBase*                     _pUnit;             
    b32                             _isOwnsBtShape;     
    GxDynamics*                 _pManagementClass;  
    f32                             _mass;              
    GxVector3                       _offset;            
    GxQuaternion                    _rotateOffset;      
    u32                             _checkFlag;         
    s16                             _group;             
 
};
 
//===========================================================================
//===========================================================================
class GxDynamics::GxConstraint : public gx::core::GxClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxDynamics::GxConstraint, gx::core::GxClassBase);
    // new, delete定義
    GX_OPERATOR_NEW_DELETE( GxAllocatorList::ALLOCATOR_TYPE::PHYSICS );
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxConstraint);
 
    enum 
    {
        ACTIVE_FLAG_ACTIVE                  = (1UL << 0),       
        ACTIVE_FLAG_REGISTERED              = (1UL << 1),       
        ACTIVE_FLAG_REQUEST_REGISTER        = (1UL << 2),       
        ACTIVE_FLAG_REQUEST_BAN             = (1UL << 3),       
        ACTIVE_FLAG_REQUEST_LINKED_BODIES   = (1UL << 4),       
        ACTIVE_FLAG_REQUEST_DELETE          = (1UL << 5),       
    };
 
    enum class TYPE
    {
        ERROR_ = 0,     
        SPHERICAL,      
        REVOLUTE,       
        CONE_TWIST,     
        PRISMATIC,      
        POINT_IN_PLANE, 
        POINT_ON_LINE,  
        PULLEY,         
        _6DOF,          
        FIXED,          
        MAX,            
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConstraint(void);
 
    ~GxConstraint(void) override {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GX_FORCE_INLINE virtual b32 createConstraintSpherical(b32 /*active*/, GxDynamics::GxObject* /*pObject0*/, GxDynamics::GxObject* /*pObject1*/, const GxVector3& /*pivot0*/, const GxVector3& /*pivot1*/, b32 /*disableCollisions*/) { return false; }
 
    GX_FORCE_INLINE virtual b32 createConstraintRevolute(b32 /*active*/, GxDynamics::GxObject* /*pObject0*/, GxDynamics::GxObject* /*pObject1*/, const GxMatrixAffine& /*mat0*/, const GxMatrixAffine& /*mat1*/, b32 /*disableCollisions*/) { return false; }
    GX_FORCE_INLINE virtual 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*/) { return false; }
 
    GX_FORCE_INLINE virtual b32 createConstraintConeTwist(b32 /*active*/, GxDynamics::GxObject* /*pObject0*/, GxDynamics::GxObject* /*pObject1*/, const GxMatrixAffine& /*matrix0*/, const GxMatrixAffine& /*matrix1*/, const GxParamConeTwist& /*param*/) { return false; }
 
    GX_FORCE_INLINE virtual b32 createConstraintFixed(b32 /*active*/, GxDynamics::GxObject* /*pObject0*/, GxDynamics::GxObject* /*pObject1*/, const GxVector3& /*pivot0*/, const GxVector3& /*pivot1*/) { return false; }
 
    virtual void prepareCheck(void);
 
    GX_FORCE_INLINE virtual void setParameterRevolute(const f32 /*lowerLimit*/, const f32 /*upperLimit*/) {}
 
    // TODO: spring, motorの設定
 
#if GX_DEVELOP
    GX_FORCE_INLINE virtual void developDraw(void) {}
#endif // GX_DEVELOP
 
protected:
    virtual void initialize(b32 active, TYPE type, b32 disableCollisions);
 
    constexpr void reset(void) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr TYPE getType(void) const { return _type; }
 
    constexpr GxDynamics::GxWorld* getRegisterWorld(void) const { return _pRegisterWorld; }
 
    constexpr void setRegisterWorld(GxDynamics::GxWorld* pWorld){ _pRegisterWorld = pWorld; }
 
    void setActive(b32 active);
    GX_FORCE_INLINE b32 isActive(void) const { return _activeFlag.isFlag(ACTIVE_FLAG_ACTIVE); }
 
    constexpr u32 getActiveFlagAll(void) const { return _activeFlag.getFlag(); }
    GX_FORCE_INLINE b32 getActiveFlag(u32 flag) const { return _activeFlag.isFlag(flag); }
    GX_FORCE_INLINE void setActiveFlag(u32 flag, b32 value){ return _activeFlag.setFlag(flag, value); }
 
    GX_FORCE_INLINE virtual GxMatrixAffine  getMatrix(void) { return GxMatrixAffine(); }
 
    constexpr void setManagementClass(GxDynamics * pManagementClass) { _pManagementClass = pManagementClass; }
 
    constexpr GxDynamics* getManagementClass(void) const { return _pManagementClass; }
 
    // todo:コールバックの実装
    GX_FORCE_INLINE virtual void setBreakParam(b32 /*isBrakable*/, f32 /*maxForce*/, f32 /*maxTorque*/) {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxFlag32Bit                 _activeFlag;        
    TYPE                        _type;              
    GxDynamics::GxWorld*        _pRegisterWorld;    
    GxDynamics*                 _pManagementClass;  
 
#if GX_DEVELOP
    f32                         _swingLimit0;       
    f32                         _swingLimit1;       
    f32                         _twistLimit;        
 
    GxMatrix33                  _constraintDirection0;  
    GxMatrix33                  _constraintDirection1;  
#endif // GX_DEVELOP
 
};
 
//===========================================================================
//===========================================================================
struct GxDynamics::GxRigidBodyParam : public GxStructBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_STRUCT( GxDynamics::GxRigidBodyParam );
 
    GxRigidBodyParam(void)
        : _mass( 1.f )
        , _friction(0.5f)
        , _type( GxObject::RIGID_BODY_TYPE::DYNAMIC )
        , _inertiaScale(1.f, 1.f, 1.f)
        , _linearDamping( 0.5f )
        , _angularDamping( 0.5f )
    {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    f32                         _mass;      
 
    f32                         _friction;  
 
    GxObject::RIGID_BODY_TYPE   _type;      
 
    //  慣性モーメントは、回転運動のしにくさを表現するパラメタで、
    //  値が大きいほど回転しにくくなります。\n
    //  値は質量と形状から自動で計算されます。\n
    //  サイズが小さい物体、すなわち慣性モーメントが小さい物体は、
    //  挙動が不安定になりやすいので、 \n
    //  このスケールを利用して大きめの値になるように設定してください。\n
    //  0.fを設定した軸方向は回転しなくなるので、
    //  特定の軸に関してのみ回転運動させたい場合に利用できます。 \n
    GxVector3                   _inertiaScale;      
 
    // 減衰率に関して、詳しくはGxObject::setDampingRatio()を参照してください。
    f32                         _linearDamping;     
    f32                         _angularDamping;    
    
};      
 
//===========================================================================
// 判定条件
//===========================================================================
class GxDynamics::GxConditionInformation : public gx::core::GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxDynamics::GxConditionInformation, gx::core::GxClassBase );
    // new, delete定義
    GX_OPERATOR_NEW_DELETE( GxAllocatorList::ALLOCATOR_TYPE::PHYSICS );
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxConditionInformation(void)
        : _groupFlag( GxDynamics::FLAG_ALL )
        , _checkFlag( GxDynamics::FLAG_ALL )        
    {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    s32 _groupFlag;     
 
    u32 _checkFlag;     
 
};
 
//===========================================================================
//===========================================================================
struct GxDynamics::GxRayResult
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxRayResult(void)
        : _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;
    }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxVector3                   _position;      
    GxVector3                   _normal;        
    GxDynamics::GxObject*       _pObject;       
    s32                         _triangleIndex; 
    u32                         _checkFlag;     
    //  レイチェックの場合は _pos = start + _fraction * (end - start)
    //  値域は0.f<= _fraction <= 1.f
    //
    // カプセルチェックの場合は 
    //  start + _fraction * (end - start)
    //  に球を置くと_posに接するような最小の値が_fractionとなる。
    //  値域は0.f< _fraction <= 1.f
    f32                         _fraction;      
    b32                         _hasHit;        
 
};
 
//===========================================================================
//===========================================================================
class GxShapeDynamicsCompound : public GxShape
{
    //-------------------------------------------------------------------
    //-------------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxShapeDynamicsCompound, GxShape);
    // new, delete定義
    GX_OPERATOR_NEW_DELETE( GxAllocatorList::ALLOCATOR_TYPE::PHYSICS );
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxShapeDynamicsCompound(void) : _listDesc(GxAllocatorList::ALLOCATOR_TYPE::PHYSICS) {}
    ~GxShapeDynamicsCompound(void) override {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    const GxVector3 getNormal(const GxVector3& /*position*/) const override { return GxVector3::ZERO; }
    GX_FORCE_INLINE GxArray* getListDesc( void ) { return &_listDesc; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxArray _listDesc;      
 
};
 
GX_PHYSICS_NAMESPACE_END()