GxUnitBase.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
class GxToolUnitProperty;
class GxModUnitBase;
#if GX_DEVELOP
class GxToolBase;
#endif //GX_DEVELOP
 
enum class UPDATE_TYPE
{
    PRE_ASYNC = 0,  
    ASYNC,          
    POST_ASYNC,     
    SEQUENTIAL,     
    FORCE_ASYNC,    
    MAX,            
};
#if GX_DEVELOP
GX_FLAG_BEGIN(UPDATE_TYPE)
    GX_FLAG_VALUE("PreAsync", UPDATE_TYPE::PRE_ASYNC),
    GX_FLAG_VALUE("Async", UPDATE_TYPE::ASYNC),
    GX_FLAG_VALUE("PostAsync", UPDATE_TYPE::POST_ASYNC),
    GX_FLAG_VALUE("Sequential", UPDATE_TYPE::SEQUENTIAL),
    GX_FLAG_VALUE("ForceAsync", UPDATE_TYPE::FORCE_ASYNC),
GX_FLAG_END()
#endif //GX_DEVELOP
 
//===========================================================================
//===========================================================================
class GxUnitBase : public GxClassBaseReference
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    friend class GxSysUnit;
    class GxScopeProfiler;
 
    // RTTI宣言
    GX_RTTI_CLASS(GxUnitBase, GxClassBaseReference)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::UNIT)
    // GxClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxUnitBase)
 
    
    enum class STATE
    {
        SETUP,      
        RUNNING,    
        DELETE_,    
    };
 
    enum ATTRIBUTE
    {
        ATTRIBUTE_UPDATE        = (1 << 0),     
        ATTRIBUTE_SELECTED      = (1 << 1),     
        ATTRIBUTE_LOCK          = (1 << 2),     
        ATTRIBUTE_SLOW          = (1 << 3),     
        ATTRIBUTE_NOSERIALIZE   = (1 << 4),     
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxUnitBase(void);
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    virtual b32 setup(void);
    virtual void preAsyncUpdate(void);
    virtual void asyncUpdate(void);
    virtual void postAsyncUpdate(void);
    virtual void sequentialUpdate(void);
    virtual void forceAsyncUpdate(void);
    virtual void render(void);
    virtual b32 setRenderMaterial(GxRenderMaterial* pMaterial, const GxResModel::GxMeshGroup* pMeshGroup);
 
    template<typename T> T* addModule(void)
    {
#if GX_DEVELOP
        for (auto* pModule : _modules)
        {
            if (static_cast<GxModUnitBase*>(pModule)->getRtti().isDerived(T::GX_RTTI)
                || T::GX_RTTI.isDerived(static_cast<GxModUnitBase*>(pModule)->getRtti()))
            {
                GX_ERROR(false, "Module(%s) is already craeted", T::GX_RTTI.getName());
                return nullptr;
            }
        }
#endif //GX_DEVELOP
        if(getRtti().isDerived(T::getOwnerDerivedRtti()))
        {
            auto pModule = static_cast<T*>(T::GX_RTTI.GX_CREATE_INSTANCE());
            GX_ASSERT(pModule, "Module(%s) create error", T::GX_RTTI.getName());
            pModule->setOwner(this);
            _modules.addBottom(pModule);
            _updateEnable |= pModule->getUpdateEnable();
            return pModule;
        }
        return nullptr;
    }
protected:
    template<typename T> void removeModule(void)
    {
        for (u32 i = 0; i < _modules.getCount(); i++)
        {
            auto* pModule = static_cast<GxModUnitBase*>(_modules[i]);
            if (pModule->getRtti() == T::GX_RTTI)
            {
                _modules.remove(i);
                GX_SAFE_DELETE(pModule);
                break;
            }
        }
    }
private:
    void addModuleCallback(GxClassBaseRoot* pValue);
 
public:
    void sleep(f32 time);
 
    template<typename T> T* createAndAddChild(u32 listProcessNumber = U32_MAX, u32 listKindNumber = U32_MAX, b32 isSerialize = false, const GxRtti* pRtti = nullptr)
    {
        T* pUnit = static_cast<T*>(createAndAddBottom(listProcessNumber, listKindNumber, pRtti ? *pRtti : T::GX_RTTI));
        pUnit->setAttribute(ATTRIBUTE_LOCK, true);
        pUnit->setAttribute(ATTRIBUTE_NOSERIALIZE, !isSerialize);
        pUnit->setParent(this);
        return pUnit;
    }
private:
    GxUnitBase* createAndAddBottom(u32 listProcessNumber, u32 listKindNumber, const GxRtti& rtti);
public:
    virtual void kill(void);
 
#if GX_USE_UNIT_PROFILE
private:
    void preAsyncUpdateProfile(void);
    void asyncUpdateProfile(void);
    void postAsyncUpdateProfile(void);
    void sequentialUpdateProfile(void);
    void forceAsyncUpdateProfile(void);
#endif //GX_USE_UNIT_PROFILE
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr f32 getDeltaTimeFactor(void) const { return _deltaTimeFactor; }
    constexpr void setDeltaTimeFactor(f32 deltaTimeFactor){ _deltaTimeFactor = deltaTimeFactor; }
    constexpr f32   getDeltaTime(void) const { return _deltaTime; }
    constexpr void setDeltaTime(f32 deltaTime){ _deltaTime = deltaTime; }
    constexpr f32   getDeltaTimeRatio(void) const { return _deltaTimeRatio; }
    constexpr void setDeltaTimeRatio(f32 deltaTimeRatio){ _deltaTimeRatio = deltaTimeRatio; }
    constexpr STATE getState(void) const { return _state; }
    constexpr void setState(STATE state) { _state = state; }
    GX_FORCE_INLINE b32 isEnable(void) const { return (_state == STATE::RUNNING) || (_state == STATE::SETUP); }
    constexpr u32 getAttribute(void) const { return _attribute; }
    GX_FORCE_INLINE b32 isAttribute(ATTRIBUTE attribute) const { return _attribute & attribute ? true : false; }
    GX_FORCE_INLINE void setAttribute(ATTRIBUTE attribute, b32 enable){ enable ? _attribute |= attribute : _attribute &= ~attribute; }
    GX_FORCE_INLINE b32 isRender(void) const { return _isRender; }
    void setRender(b32 enable, b32 withChildren = false);
    GX_FORCE_INLINE GxFlag32Index<RENDER_VIEW> getRenderViewFlag(void) const { return _renderView; }
    GX_FORCE_INLINE b32 isRenderView(RENDER_VIEW view) const { return _renderView.isFlag(view); }
    GX_FORCE_INLINE void setRenderView(RENDER_VIEW view, b32 enable){ _renderView.setFlag(view, enable); }
    GX_FORCE_INLINE b32 isRenderSubView(RENDER_SUB_VIEW subView) const { return _renderSubView.isFlag(subView); }
    GX_FORCE_INLINE void setRenderSubView(RENDER_SUB_VIEW subView, b32 enable){ _renderSubView.setFlag(subView, enable); }
    GX_FORCE_INLINE b32 isUpdateEnable(UPDATE_TYPE updateType) const { return _updateEnable.isFlag(updateType); }
    GX_FORCE_INLINE void setUpdateEnable(UPDATE_TYPE updateType, b32 enable){ _updateEnable.setFlag(updateType, enable); }
    
    GX_FORCE_INLINE void getPropertyAttributeUpdate(void* const pValue) { *static_cast<b32*>(pValue) = isAttribute(ATTRIBUTE_UPDATE); }
    GX_FORCE_INLINE void setPropertyAttributeUpdate(const void* const pValue) { setAttribute(ATTRIBUTE_UPDATE, *static_cast<b32*>(const_cast<void*>(pValue))); }
 
    template<typename T> T* getModule(void) const
    {
        for (auto* pModule : _modules)
        {
            if (static_cast<GxModUnitBase*>(pModule)->getRtti() == T::GX_RTTI)
            {
                return static_cast<T*>(pModule);
            }
        }
        return nullptr;
    }
 
    constexpr u32 getChildCount(void) const { return _children.getCount(); }
    constexpr GxUnitBase* getChild(u32 index) const { GX_ASSERT(index < _children.getCount(), "index over access!"); return static_cast<GxUnitBase*>(_children[index]); }
    constexpr GxUnitBase* getParent(void) const { return _pParent; }
    void setParent(GxUnitBase* pParent);
 
    constexpr GxResUnitInstance* getResUnitInstance(void) const { return _pResUnitInstance; }
    void setResUnitInstance(GxResUnitInstance* pResUnitInstance);
    constexpr void getPropertyResUnitInstance(void* const pValue) { *static_cast<GxResUnitInstance**>(pValue) = _pResUnitInstance; }
    void setPropertyResUnitInstance(const void* const pValue);
    GX_FORCE_INLINE const GxTypedObject* getDefaultObject(void) override { return _pDefaultUnit ? _pDefaultUnit : Super::getDefaultObject(); }
    constexpr GxUnitBase* getDefaultUnit(void) const { return _pDefaultUnit; }
    void setDefaultUnit(GxUnitBase* pDefaultUnit);
 
#if GX_DEVELOP
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    virtual void addUnitOwnProperty( GxPropertyTable& table );
    GX_FORCE_INLINE virtual void setExpandToolUnitProperty( GxToolUnitProperty* /*pTool*/) {}
    GX_FORCE_INLINE virtual void setFilterProperty(GxPropertyTable* /*pPropertyTable*/) {}
    GX_FORCE_INLINE virtual void setResource(GxResBase* /*pResource*/){}
    GX_FORCE_INLINE virtual b32 isUseTexture(GxRenderTexture* /*pTexture*/) { return false; }
    GX_FORCE_INLINE virtual void reloadBegin(void){}
    GX_FORCE_INLINE virtual void reloadEnd(void){}
 
    GX_FORCE_INLINE void getPropertyVirtualName(void* pValue) { *static_cast<GX_CSTR*>(pValue) = getVirtualName(); }
    constexpr GX_CSTR getVirtualName(void) const { return _virtualName.getLength() > 0 ? _virtualName.getString() : getRtti().getName(); }
    GX_FORCE_INLINE void setVirtualName(GX_CSTR name){ _virtualName = name; }
    constexpr GxToolBase* getParentTool(void) const { return _pParentTool; }
    constexpr void setParentTool(GxToolBase* pParentTool) { _pParentTool = pParentTool; }
    void setParentToolChildren(GxToolBase* pParentTool);
    void addPropertyToTable(GxPropertyTable* pPropertyTable, GX_CSTR name, b32 pageExpand = false);
 
#if GX_USE_UNIT_PROFILE
    void beginProfile(UPDATE_TYPE updateType);
    void endProfile(UPDATE_TYPE updateType);
    void resetProfile(void);
    void outputProfile(UPDATE_TYPE updateType);
    constexpr u32 getUpdateTime(UPDATE_TYPE updateType) const { return _updateTime[static_cast<s32>(updateType)]; }
#endif //GX_USE_UNIT_PROFILE
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index);
 
#endif // GX_DEVELOP
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    f32                             _deltaTimeFactor;           
    f32                             _deltaTime;                 
    f32                             _deltaTimeRatio;            
    STATE                           _state;                     
    u32                             _attribute;                 
    b32                             _isRender;                  
 
    GxFlag32Index<RENDER_VIEW>      _renderView;                
    GxFlag32Index<RENDER_SUB_VIEW>  _renderSubView;             
    GxFlag32Index<UPDATE_TYPE>      _updateEnable;              
 
    GxArrayClassBase                _modules;                   
 
    GxUnitBase*                     _pParent;                   
    GxArray                         _children;                  
    static GxCriticalSection        _criticalSection;           
    GxResUnitInstance*              _pResUnitInstance;          
    GxUnitBase*                     _pDefaultUnit;              
 
#if GX_USE_UNIT_PROFILE
    GxTimer                         _timer[static_cast<s32>(UPDATE_TYPE::MAX)];             
    u32                             _updateTime[static_cast<s32>(UPDATE_TYPE::MAX)];        
    u32                             _updateTimeWorst[static_cast<s32>(UPDATE_TYPE::MAX)];   
#endif // GX_USE_UNIT_PROFILE
    GxString                        _virtualName;               
#if GX_DEVELOP
    GxToolBase*                     _pParentTool;               
#endif //GX_DEVELOP
 
};
 
// ユニットが無効になった場合、ポインタをnullptrにします
#define GX_UPDATE_UNIT_POINTER(__POINTER__) if( (__POINTER__) && (!(__POINTER__)->isEnable()) ) { (__POINTER__) = nullptr; }
 
// 安全なkill
#define GX_SAFE_KILL(__POINTER__) { if(__POINTER__){ __POINTER__->kill(); __POINTER__ = nullptr; } }
 
GX_CORE_NAMESPACE_END()