GxSysUnit.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CORE_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxUnitInitialInformation : public GxClassBase
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS(GxUnitInitialInformation, GxClassBase)
    // GxClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxUnitInitialInformation)
 
    
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxUnitInitialInformation(void)
        : _listProcessMax(8)
    {}
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void loadJson(const GxJson::GxJsonNode& jsonNode);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    u32 _listProcessMax;    
 
};
 
//===========================================================================
//===========================================================================
class GxSysUnit : public GxSysBase, public SingletonBase<GxSysUnit>
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_ABSTRACT_CLASS(GxSysUnit, GxSysBase)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxSysUnit)
 
    friend class GxUnitBase;
    class GxListUnit;
    class GxAddList;
    class GxAddNode;
 
    static constexpr u32 LIST_KIND_MAX      = GxMath::VALUE_32;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxSysUnit(void);
    ~GxSysUnit(void) override {}
    b32 initialize(const GxClassBase* pInitializeInformation) override;
 
#if (GX_OCTREE_TYPE == GX_OCTREE_POOL)
    void    initializeSpaceGraph(u32 level, GxVector3& min, GxVector3& max, u32 levelNonShared = 0, u32 numCsecShared = 10);
#else //GX_OCTREE_TYPE == GX_OCTREE_POOL
    void    initializeSpaceGraph(u32 level, GxVector3& min, GxVector3& max);
#endif // GX_OCTREE_TYPE != GX_OCTREE_POOL
 
    void terminate(void) override;
    void    terminateSpaceGraph( void );
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    virtual void preAsyncUpdate(void);
    virtual void asyncUpdate(void);
    virtual void postAsyncUpdate(void);
    virtual void sequentialUpdate(void);
    virtual void forceAsyncUpdate(void);
 
    virtual void render(void);
    void drawSpaceGraph(void);
 
    GxUnitBase* createAndAddTop(u32 listProcessNumber, u32 listKindNumber, const GxRtti& rtti);
    GxUnitBase* createAndAddBottom(u32 listProcessNumber, u32 listKindNumber, const GxRtti& rtti);
    GX_FORCE_INLINE GxUnitBase* createAndAddBottom(const GxRtti& rtti) { return createAndAddBottom(getProcessListNumber(rtti), getKindListNumber(rtti), rtti); }
    void addBottom(GxUnitBase* pUnit, u32 listProcessNumber, u32 listKindNumber);
 
    virtual void onAddUnit(GxUnitBase* pUnit, u32 listProcessNumber, u32 listKindNumber, const GxRtti& rtti);
    void killAll(void);
    void setAttributeAll(GxUnitBase::ATTRIBUTE attribute, b32 enable);
    void setViewportAll(RENDER_VIEW view, b32 enable);
    void killByIncludeRtti( const GxRtti& rtti );
 
    GX_FORCE_INLINE void pushCmdBuildSpaceGraph( void ){ _stopBuildSpaceGraph = false; }
 
    void storeUnit(GxArrayClassBase& storeList, GxArrayClassBase& parentList, const GxArrayClassBase& unitArray, u32 attributeCondition = GxUnitBase::ATTRIBUTE_NOSERIALIZE, b32 enableCondition = true);
    void restoreUnit(GxArrayClassBase& storeList, GxArrayClassBase& parentList);
 
#if GX_DEVELOP
    void copyUnit(GxUnitBase* pUnit);
    GxUnitBase* pasteUnit(void);
#endif //GX_DEVELOP
 
private:
    void beginBuildSpaceGraph( void );
    void finishBuildSpaceGraph( void );
 
    void buildSpaceGraph( void );
 
    void resetCullingFlags(void);
    void hierarchCalCullingOctree(void);
    void cullingObjects(void);
    void cullingMeshes(void);
    void cullingInstances(void);
 
    void preAsyncUpdate(u32 listProcessNumber);
    void asyncUpdate(u32 listProcessNumber);
    void postAsyncUpdate(u32 listProcessNumber);
    void sequentialUpdate(u32 listProcessNumber);
    void forceAsyncUpdate(u32 listProcessNumber);
 
    void render(u32 listProcessNumber);
 
    void updateAddList(void);
    void updateRootUnitList(void);
    virtual void removeUnit(GxUnitBase* pUnit);
 
    void storeUnitSub(GxArrayClassBase& storeList, GxArrayClassBase& parentList, GxUnitBase* pUnit, u32 attributeCondition, b32 enableCondition);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    template<typename T> T* getUnit(void) { return static_cast<T*>(getUnit(T::GX_RTTI)); }
    template<typename T> void getUnitList(GxArrayClassBase& unitList) { getUnitList(T::GX_RTTI, unitList); }
    template<typename T> void getDerivedUnitList(GxArrayClassBase& unitList) { getDerivedUnitList(T::GX_RTTI, unitList); }
private:
    GxUnitBase* getUnit(const GxRtti& rtti);
    void getUnitList(const GxRtti& rtti, GxArrayClassBase& unitList);
    void getDerivedUnitList(const GxRtti& rtti, GxArrayClassBase& unitList);
public:
    GX_FORCE_INLINE virtual u32 getProcessListNumber(const GxRtti& /*rtti*/) { return 0; }
    GX_FORCE_INLINE virtual u32 getKindListNumber(const GxRtti& /*rtti*/) { return 0; }
    void addToListOctreeBuildReserve(GxUnitLocate* pUnitLocate);
    void deleteFromListOctreeBuildReserve(GxUnitLocate* pUnitLocate);
 
    constexpr u32 getListProcessMax(void) const { return _listProcessMax; }
    GxListUnit* getListProcess(u32 listProcessNumber) const;
    GxListUnit* getListProcess(GxUnitBase* pUnit) const;
#if GX_DEVELOP
    void changeListProcess(GxUnitBase* pUnit, u32 listNumber);
#endif //GX_DEVELOP
    GxListUnit* getListKind(u32 listKindNumber) const;
    GxListUnit* getListKind(GxUnitBase* pUnit) const;
    void changeListKind(GxUnitBase* pUnit, u32 listNumber);
    GX_FORCE_INLINE const GxArrayClassBase& getRootUnitList(void) const { return _rootUnitList; }
    u32 getUnitCount(void) const;
#if GX_DEVELOP
    GxUnitBase* getSelectedUnit(void);
    GxUnitBase* getSelectedUnitFromTail(void);
 
    GX_FORCE_INLINE void setGlobalFrustum( GxShapeFrustum& frustum ){ _testFrustum = frustum; _setFrustum = false; }
#endif //GX_DEVELOP
    GX_FORCE_INLINE b32 isSlow(void){ return _slowTimeRatio < 1.0f ? true : false; }
    GX_FORCE_INLINE void setSlow(f32 timeRatio = 1.0f){ _slowTimeRatio = GxMath::getClamp(timeRatio, 0.0f, 1.0f); }
 
    constexpr s32 getSpaceGraphLebel(void) const { return _sceneGraphLevel; }
    constexpr s32 getSpaceGraphLebel(void) { return _sceneGraphLevel; }
    constexpr void  setSpaceGraphLebel( s32 value ) { _sceneGraphLevel = value; }
 
    constexpr GxOctree* getSpaceGraphPointer(void) const { return _pSpaceGraph; }
    constexpr GxOctree* getSpaceGraphPointer(void) { return _pSpaceGraph; }
 
 
    GX_FORCE_INLINE const   b32     isCullingSkip(void) const   { return _cullingSkip; }
    GX_FORCE_INLINE         b32     isCullingSkip(void)         { return _cullingSkip; }
    GX_FORCE_INLINE void    startSkipCulling(void) { _cullingSkip = true; }
    GX_FORCE_INLINE void    stopSkipCulling(void) { _cullingSkip = false; }
 
#if GX_DEVELOP
    GX_FORCE_INLINE const   b32     isDebugDrawCulling(void) const      { return _CullingDebugDraw; }
    GX_FORCE_INLINE         b32     isDebugDrawCulling(void)            { return _CullingDebugDraw; }
    GX_FORCE_INLINE         void    setDebugDrawCulling( b32 value )    { _CullingDebugDraw = value; }
#endif //GX_DEVELOP
 
    virtual GxUnitCameraBase* getMainCamera(void) { return nullptr; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    GxListUnit* _pListOctreeBuildReserve;                                   
    GxListUnit** _ppListProcess;                                            
    GxListUnit* _pListKind[LIST_KIND_MAX];                                  
    GxAddList* _pListAddTop[GxThread::HARDWARE_THREAD_MAX];                 
    GxAddList* _pListAddBottom[GxThread::HARDWARE_THREAD_MAX];              
    GxArrayClassBase _rootUnitList;                                         
    f32 _slowTimeRatio;                                                     
    s32 _sceneGraphLevel;                                                   
    u32 _listProcessMax;                                                    
 
    GxOtFrustumCulling* _pSpaceGraph;                                       
    b32*                _pOctreeCullingState;                               
    GxOtFrustumCulling::GxCullingMeshParam  _unitCullParam[GxThread::THREAD_MAX];   
    GxOtFrustumCulling::GxCullingMeshParam  _meshCullParam[GxThread::THREAD_MAX];   
    GxOtFrustumCulling::GxCullingMeshParam  _instanceCullParam[GxThread::THREAD_MAX];   
    b32                 _stopBuildSpaceGraph;                               
    b32                 _cullingSkip;                                       
    GxShapeFrustum      _cullfrustum;                                       
    GxArray             _hitArray;                                          
#if GX_DEVELOP
    b32                 _setFrustum;                                        
    GxShapeFrustum      _testFrustum;                                       
    b32                 _CullingDebugDraw;                                  
#endif //GX_DEVELOP
 
};
 
//===========================================================================
//===========================================================================
class GxSysUnit::GxListUnit : public GxArrayClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_CLASS(GxSysUnit::GxListUnit, GxArrayClassBase)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxListUnit)
    using __type = GxUnitBase*;
 
    static constexpr u32 LIST_DISCONNECT = GxMath::VALUE_64 - 1;
    static constexpr u32 NAME_LENGTH = GxMath::VALUE_32;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxListUnit(void);
    ~GxListUnit(void) override {}
    b32 initialize(u32 number);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GX_INLINE const __type& operator[](u32 i) const { GX_ASSERT(i < _count, "count error."); return reinterpret_cast<__type*>(_ppObject)[i]; }
    GX_INLINE __type& operator[](u32 i) { GX_ASSERT(i < _count, "count error."); return reinterpret_cast<__type*>(_ppObject)[i]; }
    GX_FORCE_INLINE GxArray::Iterator<__type> begin(void) const { return { &reinterpret_cast<__type*>(_ppObject)[0] }; }
    GX_FORCE_INLINE GxArray::Iterator<__type> end(void) const { return { &reinterpret_cast<__type*>(_ppObject)[_count] }; }
 
    constexpr u32 getNumber(void) const { return _number; }
    GX_FORCE_INLINE void setUpdate(b32 enable) { _updateFlag = enable; }
    GX_FORCE_INLINE b32 isUpdate(void) const { return _updateFlag; }
    GX_FORCE_INLINE b32 isRender(void) const { return _renderFlag; }
    constexpr void setDeltaTimeFactor(f32 deltaTimeFactor){ _deltaTimeFactor = deltaTimeFactor; }
    constexpr f32 getDeltaTimeFactor(void) const { return _deltaTimeFactor; }
    constexpr void setDeltaTime(f32 deltaTime){ _deltaTime = deltaTime; }
    constexpr f32 getDeltaTime(void) const { return _deltaTime; }
    constexpr void setDeltaTimeRatio(f32 deltaTimeRatio){ _deltaTimeRatio = deltaTimeRatio; }
    constexpr f32 getDeltaTimeRatio(void) const { return _deltaTimeRatio; }
    GX_FORCE_INLINE b32 isCheckToUpdateForceAsync(void) const { return _isCheckToUpdateForceAsync; }
    GX_FORCE_INLINE void setCheckToUpdateForceAsync(b32 flag) { _isCheckToUpdateForceAsync = flag; }
#if GX_DEVELOP
    constexpr GX_CSTR getListName(void) const { return _name; }
#endif //GX_DEVELOP
    //GX_FORCE_INLINE GxIterator begin(void){ return GxIterator(this); }
    //GX_FORCE_INLINE GxIterator end(void){ GxIterator iterator(this); iterator.getBottom(); iterator.getNext();    return iterator; }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    void killAll(void);
    void setAttributeAll(GxUnitBase::ATTRIBUTE attribute, b32 enable);
    void setRenderAll(b32 enable);
    void setViewportAll(RENDER_VIEW view, b32 enable);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    u32 _number;                    
    b32 _updateFlag;                
    b32 _renderFlag;                
    f32 _deltaTimeFactor;           
    f32 _deltaTime;                 
    f32 _deltaTimeRatio;            
    b32 _isCheckToUpdateForceAsync; 
#if GX_DEVELOP
    GX_CHAR _name[NAME_LENGTH];     
#endif //GX_DEVELOP
 
};
 
//===========================================================================
//===========================================================================
class GxSysUnit::GxAddList : public GxListClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxSysUnit::GxAddList, GxListClassBase)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxAddList)
 
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxAddList(void) : GxListClassBase(GxAllocatorList::ALLOCATOR_TYPE::UNIT){}
    ~GxAddList(void) override {}
protected:
    GxNodeClassBase* allocNode(void) override;
 
};
 
//===========================================================================
//===========================================================================
class GxSysUnit::GxAddNode : public GxListClassBase::GxNodeClassBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GX_RTTI_CLASS(GxSysUnit::GxAddNode, GxListClassBase::GxNodeClassBase)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxAddNode)
    // new, delete定義
    GX_OPERATOR_NEW_DELETE(GxAllocatorList::ALLOCATOR_TYPE::UNIT)
 
    
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    GxAddNode(void) : _listProcessNumber(0), _listKindNumber(0){}
    ~GxAddNode(void) override {}
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
 
    constexpr u32 getListProcessNumber(void) const { return _listProcessNumber; }
    constexpr void setListProcessNumber(u32 number){ _listProcessNumber = number; }
    constexpr u32 getListKindNumber(void) const { return _listKindNumber; }
    constexpr void setListKindNumber(u32 number){ _listKindNumber = number; }
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
private:
    u32 _listProcessNumber; 
    u32 _listKindNumber;    
 
};
 
// アクセスインターフェース
GX_FORCE_INLINE GxSysUnit* getGxSysUnit(void){ return GxSysUnit::getSingletonPointer(); }
 
GX_CORE_NAMESPACE_END()