GxEventHit.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_PHYSICS_NAMESPACE_BEGIN()
//===========================================================================
//===========================================================================
class GxEventHit : public GxCollision
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxEventHit, GxCollision )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxEventHit)
 
    
    static const GxColor COLOR_OBJECT;  
 
    class GxWorld;
    class GxObject;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxEventHit(void);
 
    ~GxEventHit(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxCollision::GxObject* allocObject(void) override;
 
    void initialize(GxCollision::GxWorld* pRegisterWorld, GxUnitBase* pUnit, GxCollision::COLLISION_CALLBACK pCallback, u32 threadIndex) override;
 
#if GX_DEVELOP
    // developDraw用に継承。必要に応じてGX_DEVELOPをはずすこと。
    void initializeCheck(void);
#endif // GX_DEVELOP
 
#if GX_DEVELOP
    void developDrawObject(const GxColor& color = GxColor::WHITE, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE) override;
    GX_FORCE_INLINE static void setDevelopDrawEventHit(b32 display) { getGxSysMain()->setDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_EVENT_HIT, display); }
    GX_FORCE_INLINE static b32 getDevelopDrawEventHit(void) { return getGxSysMain()->isOnDevelopFlag(DEVELOP_FLAG_COLLISION_DRAW_EVENT_HIT); }
#endif // GX_DEVELOP
 
protected:
    GxCollision::GxObject* addObject(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr GxClassBaseRoot* getEventExecutant( void ) const { return _pEventExecutant; }
    constexpr void setEventExecutant( GxClassBaseRoot* pEventExecutant ) { _pEventExecutant = pEventExecutant; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    GxClassBaseRoot*    _pEventExecutant;       
 
};
 
//===========================================================================
//===========================================================================
class GxEventHit::GxWorld : public GxCollision::GxWorld
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS( GxEventHit::GxWorld, GxCollision::GxWorld )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxWorld)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxWorld(void);
    ~GxWorld( void ) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
#if GX_DEVELOP
    void check(void) override;
#endif // GX_DEVELOP
 
    //  note:旧hit()
    void postBulletUpdate(void) override;
 
    void calculateHitObject(btPersistentManifold* pPersistentManifold);
    
};
 
//===========================================================================
//===========================================================================
class GxEventHit::GxObject : public GxCollision::GxObject
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS( GxEventHit::GxObject, GxCollision::GxObject )
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE( GxObject )
 
    
    enum class TYPE
    {
        PUSHER = 0,     
        SWITCH,         
        ERROR_,         
        MAX,            
    };
#if GX_DEVELOP
    GX_ENUM_TABLE_MAX(TYPE)
#endif //GX_DEVELOP
 
    enum GROUP
    {
        GROUP_PUSHER    = (0x01 << 0),  
        GROUP_SWITCH    = (0x01 << 1),  
    };
 
    typedef void (GxClassBaseRoot::* HIT_CALLBACK)(GxEventHit::GxObject* pHitObject );
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxObject(void);
    ~GxObject( void ) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
#if GX_DEVELOP
    // 必要に応じてGX_DEVELOPをはずすこと。
    void initializeCheck(void);
#endif // GX_DEVELOP
 
    b32 isNeedCheck(GxCollision::GxObject* pCollisionObject) override;
 
#if GX_DEVELOP
    void developDraw(const GxColor& color, PRIMITIVE_FILL_MODE fillMode = PRIMITIVE_FILL_MODE::WIRE) override;
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    constexpr TYPE getType(void) const { return _type; }
    void setType(TYPE type);
 
    // 管理クラスの取得
    GX_FORCE_INLINE GxEventHit* getManagementClass(void) const { return gx_cast<GxEventHit*>(getCollision()); }
    GX_FORCE_INLINE HIT_CALLBACK getHitCallback(void) const { return _pHitCallback; }
    GX_FORCE_INLINE void setHitCallback(HIT_CALLBACK pCallBack) { _pHitCallback = pCallBack; }
    constexpr void setTarget(GxObject* pTarget) { _pTarget = pTarget; }
    constexpr GxObject* getTarget(void) const { return _pTarget; }
 
    constexpr GxClassBaseRoot* getEventExecutant( void ) const { return _pEventExecutant; }
    constexpr void setEventExecutant( GxClassBaseRoot* pEventExecutant ) { _pEventExecutant = pEventExecutant; }
 
    GX_FORCE_INLINE void      setHitPosition(const GxVector3& hitPosition){ _hitPosition = hitPosition; }
    GX_FORCE_INLINE void      setHitNormal(const GxVector3& hitNormal){ _hitNormal = hitNormal; }
    GX_FORCE_INLINE GxVector3 getHitPosition(void) const { return _hitPosition; }
    GX_FORCE_INLINE GxVector3 getHitNormal(void) const { return _hitNormal; }
 
#if GX_DEVELOP
    GX_FORCE_INLINE b32     isHitDevelop(void) { return _isHitDevelop; }
    GX_FORCE_INLINE void    setIsHitDevelop(b32 isHit) { _isHitDevelop = isHit; }
#endif // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    HIT_CALLBACK                _pHitCallback;      
    GxEventHit::GxObject*       _pTarget;           
    GxClassBaseRoot*            _pEventExecutant;   
    GxVector3                   _hitPosition;       
    GxVector3                   _hitNormal;         
 
    TYPE                        _type;              
 
#if GX_DEVELOP
    b32                         _isHitDevelop;      
#endif // GX_DEVELOP
 
};
 
GX_PHYSICS_NAMESPACE_END()