GxAdjustHit.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_PHYSICS_NAMESPACE_BEGIN()
//===========================================================================
//===========================================================================
class GxAdjustHit : public GxCollision
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxAdjustHit, GxCollision )
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxAdjustHit)
 
    class GxWorld;
    class GxObject;
 
protected:
    enum class ADJUST_FLAG_INDEX
    {
        END,                
        THROUGH_ONCE,       
        THROUGH_ONCE_OLD,   
    };
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxAdjustHit(void);
 
    ~GxAdjustHit(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxCollision::GxObject* allocObject(void) override;
 
    GxObject* getObject(u32 index);
 
    void initializeActiveOn(void) override;
 
    void initializeActiveOff(void) override;
 
    void initializeUpdate(void) override;
 
private:
    void initializeAdjustParameter( void );
public:
    virtual void initializeCheck(void);
 
    virtual void checkOldPosition( GxRayResult& result, const GxVector3& moveVector, const GxVector3& offset, GxCollision::GxConditionInformation* pCondition = nullptr );
 
    virtual const GxVector3& calculateAdjustVector( void );
 
protected:
    GX_FORCE_INLINE void setAdjustVector( const GxVector3& vector ) { _adjustVector = vector; }
public:
    GX_FORCE_INLINE const GxVector3& getAdjustVector(void) const { return _adjustVector; }
    GX_FORCE_INLINE b32 isNeedAdjust(const GxVector3& vector) { return (vector.getLengthSquare() > FLT_EPSILON ) ? true : false; }
 
    GX_FORCE_INLINE b32 isAdjustEnd(void) { return _adjustHitFlag.isFlag(ADJUST_FLAG_INDEX::END); }
    GX_FORCE_INLINE void setAdjustEnd(b32 value) { _adjustHitFlag.setFlag(ADJUST_FLAG_INDEX::END, value); }
 
    GX_FORCE_INLINE void setIsAdjustOldPositionThroughOnce(b32 value) { _adjustHitFlag.setFlag(ADJUST_FLAG_INDEX::THROUGH_ONCE, value); }
    GX_FORCE_INLINE b32 isAdjustOldPositionThroughOnce(void) const { return _adjustHitFlag.isFlag(ADJUST_FLAG_INDEX::THROUGH_ONCE); }
 
    void onAttributeAll(u32 attribute);
    void offAttributeAll(u32 attribute);
 
#if GX_DEVELOP
    void developDrawObject(const GxColor& color = GxColor::WHITE, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE) override;
#endif // GX_DEVELOP
 
protected:
    GxCollision::GxObject* addObject(void) override;
 
    const GxVector3 calculateNormalAdjustVector(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr static void setCheckMargin(f32 margin) { _checkMargin = margin; }
    GX_FORCE_INLINE static f32 getCheckMargin(void) { return _checkMargin; }
 
    void setObjectWeightAll(f32 weight);
 
protected:
    GX_FORCE_INLINE void getPropertyCheckMargin(void* const pValue) { *static_cast<f32*>(pValue) = _checkMargin; }
    constexpr void setPropertyCheckMargin(const void* const pValue) { _checkMargin = *static_cast<f32*>(const_cast<void*>(pValue)); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    static const f32                    _distanceMin;           
    static const f32                    _againstRadian;         
    static f32                          _checkMargin;           
 
private:
    GxVector3                           _adjustVectorOld;       
    GxVector3                           _adjustVector;          
    GxFlag32Index<ADJUST_FLAG_INDEX>    _adjustHitFlag;         
 
};
 
//===========================================================================
//===========================================================================
class GxAdjustHit::GxWorld : public GxCollision::GxWorld
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS( GxAdjustHit::GxWorld, GxCollision::GxWorld )
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxWorld)
 
protected:
    struct GxAdjustInfo
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxAdjustInfo(void) : _normal(0.f, 0.f, 0.f), _adjustLength(0.0f){}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        btVector3   _normal;        
        btScalar    _adjustLength;  
#if GX_DEVELOP
        btVector3   _hitOnB;        
#endif // GX_DEVELOP
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxWorld(void);
    ~GxWorld( void ) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void check(void) override;
 
    //  note:旧hit()
    void postBulletUpdate(void) override;
 
    // note:旧adjust()
    void executePostCheckCallback(void) override;
 
protected:
    void calculateAdjustInformation(btPersistentManifold* pPersistentManifold);
 
    virtual void calculateAdjustVector( GxObject* pObjectA, GxObject* pObjectB, const GxAdjustInfo& adjustInfo );
 
    void addAdjustInformation( GxObject* pObject, const f32 length, const GxVector3& normal );
 
    virtual f32 calculateAdjustRate( GxObject* pObjectA, GxObject* pObjectB);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    u32 _checkLoopMax;  
 
};
 
//===========================================================================
//===========================================================================
class GxAdjustHit::GxObject : public GxCollision::GxObject
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxAdjustHit::GxObject, GxCollision::GxObject )
    // ClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxObject)
 
protected:
    enum class SHIFT
    {
        POSITION_OLD_CHECK = 0,             
        DISABLE_POSITION_OLD_CHECK_ONCE,    
        ADJUST_HIT_DUMMY_0,                 
        ADJUST_HIT_DUMMY_1,                 
        ADJUST_HIT_MAX,                     
    };
public:
    enum ATTRIBUTE 
    {
        ATTRIBUTE_POSITION_OLD_CHECK                = (1L << static_cast<s32>(SHIFT::POSITION_OLD_CHECK)),              
        ATTRIBUTE_DISABLE_POSITION_OLD_CHECK_ONCE   = (1L << static_cast<s32>(SHIFT::DISABLE_POSITION_OLD_CHECK_ONCE)), 
    };
 
#if GX_DEVELOP
    struct GxPenetration : public GxStructBase
    {
        //-------------------------------------------------------------
        //-------------------------------------------------------------
 
        // RTTI定義
        GX_RTTI_STRUCT(GxPenetration);
        // new, delete定義
        GX_OPERATOR_NEW_DELETE_USE_ARRAY(GxAllocatorList::ALLOCATOR_TYPE::DEVELOP);
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxPenetration(void) : _depth(0.f) {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GxVector3   _hitPosition;   
        GxVector3   _normal;        
        f32         _depth;         
 
    };
 
    static constexpr u32 HIT_TRIMESH_INDEX_INCREMENT = 10;
    static constexpr u32 PENETRATION_MAX = 10;              
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxObject(void);
 
    ~GxObject(void) override;
 
    void initialize(b32 active, u32 id, const GxMatrixAffine* pMatrix0, const GxVector3& offset0, const GxMatrixAffine* pMatrix1, const GxVector3& offset1) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void initializeActiveOn(void) override;
 
    void initializeActiveOff(void) override;
 
private:
    void initializeAdjustParameter( void );
 
public:
    void initializeUpdate(void) override;
 
    void initializeCheck(void);
 
    b32 isNeedCheck(GxCollision::GxObject* pCollisionObject) override;
 
    b32 isAdjustEnd(void);
 
    void checkOldPosition( GxRayResult& result, const GxVector3& moveVector, const GxVector3& offset, GxCollision::GxConditionInformation* pCondition );
 
#if GX_DEVELOP
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index = 0);
 
    void developDraw(const GxColor& color, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE) override;
 
    void developDrawTrimesh(GxShapeTrimesh* pTrimesh, const GxColor& color, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE) override;
 
    void drawPenetration(const GxColor& color, const f32 ratio);
    void addPenetration(const GxVector3& hitPosition, const f32 depth, const GxVector3& normal);
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr u32 getAttribute(void) const { return _attribute; }
    constexpr void setAttribute(u32 attribute) { _attribute = attribute; }
    constexpr void onAttribute(u32 attribute) { _attribute |= attribute; }
    constexpr void offAttribute(u32 attribute) { _attribute &= ~attribute; }
 
    GX_FORCE_INLINE const GxVector3& getPlaneNormal(void) const { return _planeNormal; }
    GX_FORCE_INLINE void setPlaneNormal(const GxVector3& normal) { _planeNormal = normal; }
 
    GX_FORCE_INLINE const GxVector3& getAdjustVector(void) const { return _adjustVector; }
    GX_FORCE_INLINE void setAdjustVector(const GxVector3& vector) { _adjustVector = vector; }
 
    constexpr f32 getWeight(void) const { return _weight; }
    constexpr void setWeight(f32 weight) { _weight = weight; }
 
#if GX_DEVELOP
    GX_FORCE_INLINE b32 isHitDevelop(void) const { return _isHitDevelop; }
    GX_FORCE_INLINE void setIsHitDevelop(b32 isHit) { _isHitDevelop = isHit; }
    constexpr u32 getCountHitTrimeshIndex(void) const { return _countHitTrimeshIndex; }
    constexpr void setCountHitTrimeshIndex(u32 count) { _countHitTrimeshIndex = count; }
 
    void    getPropertyHitTrimeshIndex(void* pValue, u32 index);
    void    setPropertyHitTrimeshIndex(const void* pValue, u32 index);
    u32     getPropertyHitTrimeshIndexCount(void) const;
    void    setPropertyHitTrimeshIndexCount(u32 count);
 
    constexpr u32 getPenetrationIndex(void) const { return _penetrationIndex; }
    GX_FORCE_INLINE const GxPenetration& getPenetration(u32 index) const { return _pPenetration[index]; }
#endif //GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxVector3   _planeNormal;           
    GxVector3   _adjustVector;          
    u32         _attribute;             
    f32         _weight;                
 
#if GX_DEVELOP
    b32             _isHitDevelop;          
    s32*            _pHitTrimeshIndex;      
    u32             _countHitTrimeshIndex;  
    u32             _maxHitTrimeshIndex;    
 
    GxPenetration*  _pPenetration;          
    u32             _penetrationIndex;      
#endif // GX_DEVELOP
 
};
 
GX_PHYSICS_NAMESPACE_END()