BlockWorld.h

#pragma once
#include <vector>
#include <array>
#include <map>
#include <unordered_set>
#ifdef WIN32
#include "stdint.h"
#else
#include <stdint.h>
#endif
#include <bitset>
#include "IObjectScriptingInterface.h"
#include "IAttributeFields.h"

#include "util/mutex.h"
#include "BlockTemplate.h"
#include "BlockCommon.h"
#include "BlockChunk.h"
#include "RenderableChunk.h"
#include "BlockRenderTask.h"
#include "WorldInfo.h"
#include "BlockReadWriteLock.h"

namespace ParaEngine
{
    class BlockRegion;
    class RenderableChunk;
    class CBlockLightGridBase;
    class BlockRenderTask;
    struct BlockHeightValue;
    struct ChunkMaxHeight;


    class CBlockWorld : public IAttributeFields, IObjectScriptingInterface
    {
    public:
        CBlockWorld();
        virtual ~CBlockWorld();
    
        virtual int GetAttributeClassID(){ return ATTRIBUTE_CLASSID_BlockWorld; }
        virtual const char* GetAttributeClassName(){ static const char name[] = "BlockWorld"; return name; }
        virtual const char* GetAttributeClassDescription(){ static const char desc[] = ""; return desc; }
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        virtual IAttributeFields* GetChildAttributeObject(const std::string& sName);;
        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);;
        virtual int GetChildAttributeColumnCount() { return 1; };
        virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);

        ATTRIBUTE_METHOD1(CBlockWorld, GetBlockRenderMethod_s, int*)        { *p1 = cls->GetBlockRenderMethod(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetBlockRenderMethod_s, int) { cls->SetBlockRenderMethod((BlockRenderMethod)p1); return S_OK; }

        ATTRIBUTE_METHOD(CBlockWorld, ResumeLightUpdate_s)  { cls->ResumeLightUpdate(); return S_OK; }
        ATTRIBUTE_METHOD(CBlockWorld, SuspendLightUpdate_s) { cls->SuspendLightUpdate(); return S_OK; }

        ATTRIBUTE_METHOD(CBlockWorld, ResetAllLight_s) { cls->ResetAllLight(); return S_OK; }

        ATTRIBUTE_METHOD(CBlockWorld, LockWorld_s)  { cls->LockWorld(); return S_OK; }
        ATTRIBUTE_METHOD(CBlockWorld, UnlockWorld_s)    { cls->UnlockWorld(); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, IsLightUpdateSuspended_s, bool*)     { *p1 = cls->IsLightUpdateSuspended(); return S_OK; }

        ATTRIBUTE_METHOD3(CBlockWorld, SetChunkColumnTimeStamp_s, float) { cls->SetChunkColumnTimeStamp((uint16_t)p1, (uint16_t)p2, (uint16_t)p3); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, GetRenderDist_s, int*)       { *p1 = cls->GetRenderDist(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetRenderDist_s, int)    { cls->SetRenderDist(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, GetDirtyColumnCount_s, int*)     { *p1 = cls->GetDirtyColumnCount(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, GetDirtyBlockCount_s, int*)      { *p1 = cls->GetDirtyBlockCount(); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, IsReadOnly_s, bool*)     { *p1 = cls->IsReadOnly(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetReadOnly_s, bool) { cls->SetReadOnly(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, IsRemote_s, bool*)       { *p1 = cls->IsRemote(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetIsRemote_s, bool) { cls->SetIsRemote(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, IsServerWorld_s, bool*)      { *p1 = cls->IsServerWorld(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetIsServerWorld_s, bool)    { cls->SetIsServerWorld(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, IsSaveLightMap_s, bool*)     { *p1 = cls->IsSaveLightMap(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetSaveLightMap_s, bool) { cls->SaveLightMap(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, IsUseAsyncLoadWorld_s, bool*)        { *p1 = cls->IsUseAsyncLoadWorld(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetUseAsyncLoadWorld_s, bool)    { cls->SetUseAsyncLoadWorld(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, GetLightCalculationStep_s, int*)     { *p1 = cls->GetLightCalculationStep(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetLightCalculationStep_s, int)  { cls->SetLightCalculationStep(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, GetMaxCacheRegionCount_s, int*)      { *p1 = cls->GetMaxCacheRegionCount(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetMaxCacheRegionCount_s, int)   { cls->SetMaxCacheRegionCount(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, GetNumOfLockedBlockRegion_s, int*)       { *p1 = cls->GetNumOfLockedBlockRegion(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, GetNumOfBlockRegion_s, int*)     { *p1 = cls->GetNumOfBlockRegion(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, GetTotalNumOfLoadedChunksInLockedBlockRegion_s, int*)        { *p1 = cls->GetTotalNumOfLoadedChunksInLockedBlockRegion(); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, IsRenderBlocks_s, bool*)     { *p1 = cls->IsRenderBlocks(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetRenderBlocks_s, bool) { cls->SetRenderBlocks(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, GetSunIntensity_s, float*)       { *p1 = cls->GetSunIntensity(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetSunIntensity_s, float)    { cls->SetSunIntensity(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, GetMinWorldPos_s, Vector3*)      { *p1 = Vector3((float)(cls->GetMinWorldPos().x), (float)(cls->GetMinWorldPos().y), (float)(cls->GetMinWorldPos().z)); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetMinWorldPos_s, Vector3)   { Int32x3 v((int32)p1.x, (int32)p1.y, (int32)p1.z); cls->SetMinWorldPos(v); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, GetMaxWorldPos_s, Vector3*)  { *p1 = Vector3((float)(cls->GetMaxWorldPos().x), (float)(cls->GetMaxWorldPos().y), (float)(cls->GetMaxWorldPos().z)); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, SetMaxWorldPos_s, Vector3)   { Int32x3 v((int32)p1.x, (int32)p1.y, (int32)p1.z); cls->SetMaxWorldPos(v); return S_OK; }


        ATTRIBUTE_METHOD1(CBlockWorld, GetTotalChunksInMemory_s, int*)      { *p1 = BlockChunk::GetTotalChunksInMemory(); return S_OK; }
        ATTRIBUTE_METHOD1(CBlockWorld, GetTotalRenderableChunksInMemory_s, int*)        { *p1 = RenderableChunk::GetTotalRenderableChunks(); return S_OK; }

        ATTRIBUTE_METHOD1(CBlockWorld, UseLinearTorchBrightness_s, bool)    { cls->GenerateLightBrightnessTable(p1); return S_OK; }

        
    public:
        enum CallBackType{
            Type_LoadBlockRegion = 0,
            Type_UnLoadBlockRegion,
            Type_GeneratorScript,
            Type_SaveRegionCallbackScript,
            Type_BeforeLoadBlockRegion,
        };
        DEFINE_SCRIPT_EVENT(CBlockWorld, BeforeLoadBlockRegion);
        DEFINE_SCRIPT_EVENT(CBlockWorld, LoadBlockRegion);
        DEFINE_SCRIPT_EVENT(CBlockWorld, UnLoadBlockRegion);
        DEFINE_SCRIPT_EVENT(CBlockWorld, SaveRegionCallbackScript);

        // when there is no block terrain to load from , this function will be used to generate new terrains. 
        DEFINE_SCRIPT_EVENT(CBlockWorld, GeneratorScript);

        int OnBeforeLoadBlockRegion(int x, int y);
        int OnLoadBlockRegion(int x, int y);
        int OnUnLoadBlockRegion(int x, int y);
        int OnSaveBlockRegion(int x, int y);
    public:
        CBlockLightGridBase& GetLightGrid();

        virtual const std::string& GetIdentifier();
        virtual void SetIdentifier(const std::string& sID);

        //init block world
        virtual void EnterWorld(const string& sWorldDir, float x, float y, float z);

        //call this function when leave the block world
        virtual void LeaveWorld();

        void ClearAllBlockTemplates();

        void SetActiveChunkRadius(int nActiveChunkRadius = 12);

        void UpdateAllActiveChunks();

        const ParaEngine::Int32x3& GetMinWorldPos() const;
        void SetMinWorldPos(const ParaEngine::Int32x3& val);
        const ParaEngine::Int32x3& GetMaxWorldPos() const;
        void SetMaxWorldPos(const ParaEngine::Int32x3& val);

        uint16_t GetMaxCacheRegionCount() const;
        void SetMaxCacheRegionCount(uint16_t val);

        virtual void SetLightCalculationStep(uint32 nTicks);
        virtual uint32 GetLightCalculationStep();

        BlockRegion* GetRegion(uint16_t x, uint16_t y, uint16_t z, uint16_t& rs_x, uint16_t& rs_y, uint16_t& rs_z);
        BlockRegion* GetRegion(uint16_t region_x, uint16_t region_z);

        static float GetVerticalOffset();

        static void SetVerticalOffset(float offset);

        int32_t GetActiveChunkDim();

        int32_t GetActiveChunkDimY();

        bool IsInBlockWorld();

        void SetRenderBlocks(bool bValue);

        bool IsRenderBlocks();

        bool IsUseAsyncLoadWorld() const;
        void SetUseAsyncLoadWorld(bool val);

        void SetReadOnly(bool bValue);

        bool IsReadOnly();

        bool IsVisibleChunkDirty() const;
        void SetVisibleChunkDirty(bool val);

        void SetIsRemote(bool bValue);

        bool IsRemote();

        void SetIsServerWorld(bool bValue);

        bool IsServerWorld();

        bool IsGroupByChunkBeforeTexture() const;
        void SetGroupByChunkBeforeTexture(bool val);

        ParaEngine::mutex& GetBlockWorldMutex();

        void LockWorld();
        void UnlockWorld();
        BlockReadWriteLock& GetReadWriteLock();

        bool IsSaveLightMap() const;
        void SaveLightMap(bool val);

        void SaveBlockTemplateData();

        void LoadBlockTemplateData();

        void SaveToFile(bool saveToTemp);

        CWorldInfo& GetWorldInfo();

        //template related function
        BlockTemplate* RegisterTemplate(uint16_t id, uint32_t attFlag, uint16_t category_id);

        bool SetBlockVisible(uint16_t templateId, bool value, bool bRefreshWorld = true);
        void RefreshBlockTemplate(uint16_t templateId);

        //set/get block id/data
        uint32_t SetBlockId(uint16_t x, uint16_t y, uint16_t z, uint32_t nBlockID);
        uint32_t GetBlockId(uint16_t x, uint16_t y, uint16_t z);
        uint32_t SetBlockData(uint16_t x, uint16_t y, uint16_t z, uint32_t nBlockData);
        uint32_t GetBlockData(uint16_t x, uint16_t y, uint16_t z);

        //do *not* hold a permanent reference of return value,underlying memory address may change
        //@param id: template id;
        BlockTemplate* GetBlockTemplate(uint16_t id);

        //do *not* hold a permanent reference of return value,underlying memory address may change
        //@param x,y,z: world space block id
        BlockTemplate* GetBlockTemplate(uint16_t x, uint16_t y, uint16_t z);

        //do *not* hold a permanent reference of return value,underlying memory address may change
        BlockTemplate* GetBlockTemplate(Uint16x3& blockId_ws);

        //@param flag: can be one or more BlockAttrubiteFlag value.
        bool MatchTemplateAttribute(uint16_t templateId, BlockTemplate::BlockAttrubiteFlag flag);

        void SetTemplateTexture(uint16_t id, const char* textureName);

        //get highest block, null if block not exist;
        //@return:first is highest soiled block, second is highest transparent block,second>= first
        ChunkMaxHeight* GetHighestBlock(uint16_t blockX_ws, uint16_t blockZ_ws);

        //get highest y values of current and neighbor blocks above terrain.
        //return terrain height if no block above ground.
        //@param result: int16_t[6] array contains the result height of {center,x,-x,z,-z,mask} 
        // each bit of mask indicate return value is block height or terrain height, 
        virtual void GetMaxBlockHeightWatchingSky(uint16_t blockX_ws, uint16_t blockZ_ws, ChunkMaxHeight* pResult);

        //refresh all lights in chunk column,this function will recalc all point lights in a column
        void RefreshAllLightsInColumn(uint16_t chunkX_ws, uint16_t chunkZ_ws);

        //called when block height map changed.This function will recalc sun light of block column
        void NotifyBlockHeightMapChanged(uint16_t blockIdX_ws, uint16_t blockIdZ_ws, ChunkMaxHeight& prevBlockHeight);

        BlockIndex GetBlockIndex(uint16_t x, uint16_t y, uint16_t z, bool bCreateIfNotExist = true);

        BlockChunk* GetChunk(uint16_t x, uint16_t y, uint16_t z, bool bCreateIfNotExist = true);

        //block manipulation function
        void SetBlockTemplateId(float x, float y, float z, uint16_t templateId);

        void SetBlockTemplateIdByIdx(uint16_t x, uint16_t y, uint16_t z, uint16_t templateId);

        uint16_t GetBlockTemplateId(float x, float y, float z);

        uint16_t GetBlockTemplateIdByIdx(uint16_t x, uint16_t y, uint16_t z);

        void SetBlockUserData(float x, float y, float z, uint32_t data);

        void SetBlockUserDataByIdx(uint16_t x, uint16_t y, uint16_t z, uint32_t data);

        uint32_t GetBlockUserData(float x, float y, float z);

        uint32_t GetBlockUserDataByIdx(uint16_t x, uint16_t y, uint16_t z);

        bool IsObstructionBlock(uint16_t x, uint16_t y, uint16_t z);


        //return null if block not exist
        //note:do *not* hold a permanent reference of the return value,underlying
        //block address may change after SetBlockTemplate()!
        Block* GetBlock(uint16_t x, uint16_t y, uint16_t z);
        Block* GetUnlockBlock(uint16_t x, uint16_t y, uint16_t z);

        //set chunk dirty will rebuild vertex buffer of the chunk
        void SetChunkDirty(Uint16x3& chunkId_ws, bool isDirty);
        void SetChunkLightDirty(Uint16x3& chunkId_ws);

        void SetChunkColumnTimeStamp(uint16_t x, uint16_t z, uint16_t nTimeStamp);
        int32_t GetChunkColumnTimeStamp(uint16_t x, uint16_t z);

        bool DoChunksNearChunkExist(uint16_t x, uint16_t y, uint16_t z, uint16_t radius);

        bool CheckChunkColumnsExist(int minX, int minY, int minZ, int maxX, int maxY, int maxZ);

        bool ChunkColumnExists(uint16_t chunkX, uint16_t chunkZ);

        bool IsChunkLocked(uint32 worldX, uint32 worldZ);

        int32_t GetBlocksInRegion(Uint16x3& startChunk_ws, Uint16x3& endChunk_ws, uint32_t matchType, const luabind::adl::object& result, uint32_t verticalSectionFilter = 0);

        int GetDirtyColumnCount();

        int GetDirtyBlockCount();

        bool IsCubeModePicking();
        void SetCubeModePicking(bool bIsCubeModePicking);

        bool Pick(const Vector3& rayOrig, const Vector3& dir, float length, PickResult& result, uint32_t filter = 0xffffffff);

        int FindFirstBlock(uint16_t x, uint16_t y, uint16_t z, uint16_t nSide = 4, uint32_t max_dist = 32, uint32_t attrFilter = 0xffffffff, int nCategoryID = -1);

        int GetFirstBlock(uint16_t x, uint16_t y, uint16_t z, int nBlockId, uint16_t nSide = 5, uint32_t max_dist = 32);

        bool RefreshChunkColumn(int16_t curChunkWX, int16_t curChunkWZ);
        bool IsChunkColumnInActiveRange(int16_t curChunkWX, int16_t curChunkWZ);

        bool GetBlockBrightness(Uint16x3& blockId_ws, uint8_t* brightness, int nSize = 27, int nLightType = -1);

        bool GetBlockMeshBrightness(Uint16x3& blockId_ws, uint8_t* brightness, int nLightType = 2);

        float GetBlockBrightnessReal(const Vector3& vPos, float* pBrightness = NULL);
        float GetBlockBrightnessReal(Uint16x3& blockId_ws, float* pBrightness = NULL);


        //set global sun light intensity
        //@param intensity: [0,1]
        void SetSunIntensity(float intensity);

        float GetSunIntensity();

        //set light block dirty,called when add/remove any type of block
        //@lightValue: >0 if block is light
        void SetLightBlockDirty(Uint16x3& blockId_ws, bool isSunLight);

        LightData* GetLightData(uint16_t x, uint16_t y, uint16_t z, bool bCreateIfNotExist = true);

        //call this function when loading blocks from file
        void SuspendLightUpdate();

        int GetNumOfLockedBlockRegion();
        int GetTotalNumOfLoadedChunksInLockedBlockRegion();
        int GetNumOfBlockRegion();

        //called when blocks loaded from file;
        void ResumeLightUpdate();

        bool IsLightUpdateSuspended();

        float GetLightBrightnessFloat(uint8_t brightness);

        uint8_t GetLightBrightnessInt(uint8_t brightness);

        float GetLightBrightnessLinearFloat(uint8_t brightness);

        void GenerateLightBrightnessTable(bool bUseLinearBrightness = false);

        //this function should be called every time when view center or camera position changed
        void OnViewCenterMove(float viewCenterX, float viewCenterY, float viewCenterZ);

        void SetRenderDist(int nValue);
        int GetRenderDist();

        BlockRenderMethod GetBlockRenderMethod();
        virtual void SetBlockRenderMethod(BlockRenderMethod method);

        void GetCurrentCenterChunkId(Int16x3& oResult);

        const Uint16x3& GetEyeBlockId();
        void SetEyeBlockId(const Uint16x3& eyePos);

        const Uint16x3& GetEyeChunkId();

        const Int16x3 GetMinActiveChunkId();

        void OnGenerateTerrain(int nRegionX, int nRegionY, int nChunkX = -1, int nChunkZ = -1);

        void SelectBlock(uint16_t x, uint16_t y, uint16_t z, int nGroupID = 0);

        void DeselectBlock(uint16_t x, uint16_t y, uint16_t z, int nGroupID = 0);

        //add render task to render queueGe
        virtual void AddRenderTask(BlockRenderTask* pRenderTask);

        void DeselectAllBlock(int nGroupID = -1);

        BlockRegion* CreateGetRegion(uint16_t block_x, uint16_t block_y, uint16_t block_z);
        BlockRegion* CreateGetRegion(uint16_t region_x, uint16_t region_z);

        virtual void ClearBlockRenderCache();

        // called each frame
        virtual void OnFrameMove();

        /* it will only return a valid chunk if input chunkPos is within current active chunk range usually around the current view center. 
        * only call this function from the main rendering thread. 
        * @return NULL is chunkPos does not exist in the current active range. or the chunk is currently dirty and can not be used. 
        */
        RenderableChunk* GetRenderableChunk(const Int16x3& chunkPos);
        
        bool UnloadRegion(uint16_t block_x, uint16_t block_y, uint16_t block_z, bool bAutoSave = true);



        void ResetAllLight();
    protected:
        void UnloadRegion(BlockRegion* pRegion, bool bAutoSave = true);

        RenderableChunk& GetActiveChunk(uint16_t curChunkWX, uint16_t curChunkWY, uint16_t curChunkWZ);

        bool ReuseActiveChunk(int16_t curChunkWX, int16_t curChunkWY, int16_t curChunkWZ, BlockRegion* pRegion);

        //perform culling and fill up m_visibleChunks
        virtual void UpdateVisibleChunks(bool bIsShadowPass = false);

        //load/unload region on center view position
        virtual void UpdateRegionCache();

        //load/unload chunk on center view position
        virtual void UpdateActiveChunk();

        virtual void ClearOutOfRangeActiveChunkData();
    protected:
        std::string m_sName;
        int32_t m_activeChunkDim;
        int32_t m_activeChunkDimY;
        static float g_verticalOffset;

        bool m_isInWorld;

        bool m_bReadOnlyWorld;

        bool m_bIsRemote;

        bool m_bIsServerWorld;

        bool m_bSaveLightMap;

        bool m_bCubeModePicking;

        bool m_isVisibleChunkDirty;

        bool m_bRenderBlocks;
        bool m_bUseAsyncLoadWorld;

        bool m_group_by_chunk_before_texture;

        bool m_is_linear_torch_brightness;


        //active chunk is a toroidal 3D grid array hold render data for n chunks around eye position.
        //we will wrap the active chunk index when eye position change.
        //say active chunk range from [x,y,z] to [nx,nz,ny] at first when move to 
        //[x+1,y+1,z+1]~[nx+1,ny+1,nz+1] we keep all data from [x+1,y+1,z+1]~[nx,nz,ny]
        //and fill new data in the obsolete grids to avoid full refresh
        std::vector<RenderableChunk*> m_activeChunks;

        Int16x3 m_minActiveChunkId_ws;


        ParaEngine::mutex  m_blockworld_mutex;

        //current region position in world space
        int16_t m_curRegionIdX;
        int16_t m_curRegionIdZ;

        //current chunk position in world space
        Int16x3 m_curChunkIdW;
        Int16x3 m_lastChunkIdW;
        // for checking inside UpdateRegionCache(), 
        Int16x3 m_lastChunkIdW_RegionCache;
        Uint16x3 m_lastViewCheckIdW;

        //
        Uint16x3 m_curCenterBlockId;
        Uint16x3 m_curCamBlockId;
        Uint16x3 m_curCamChunkId;
        Uint16x3 m_selectBlockIdW;

        Int32x3 m_minWorldPos;
        Int32x3 m_maxWorldPos;

        int m_minRegionX, m_minRegionZ;
        int m_maxRegionX, m_maxRegionZ;

        int m_nRenderDistance;

        BlockRenderMethod m_dwBlockRenderMethod;

        float m_sunIntensity;

        //hold all lighting info of current active region
        CBlockLightGridBase* m_pLightGrid;

        //hold all visible chunks of current frame, weak references
        std::vector<RenderableChunk*> m_visibleChunks;
        std::vector<RenderableChunk*> m_tempDirtyChunks;

        // cache 4 regions at least.
        uint16_t m_maxCacheRegionCount;
        typedef BlockRegion* BlockRegionPtr;
        BlockRegionPtr* m_pRegions;
        std::map<int, BlockRegion*> m_regionCache;

        //Block templates
        std::map<uint16_t, BlockTemplate*> m_blockTemplates;
        std::vector<BlockTemplate*> m_blockTemplatesArray;

        //save old data to revert
        struct BlockTemplateVisibleData
        {
            uint8_t torchLight;
            int32_t lightOpyValue;
            bool isTransparent;
        };
        std::map<uint16_t, BlockTemplateVisibleData> m_blockTemplateVisibleDatas;

        /* directory information about the world. */
        CWorldInfo m_worldInfo;

        float m_lightBrightnessTableFloat[17];
        uint8_t m_lightBrightnessTableInt[17];
        float m_lightBrightnessLinearTableFloat[17];

        std::vector<CBlockSelectGroup> m_selectedBlockMap;

        BlockReadWriteLock m_readWriteLock;

        friend class CMultiFrameBlockWorldRenderer;
    };
}