BlockLightGridClient.h

#pragma once

#include <stdint.h>
#include <vector>
#include <queue>
#include <mutex>
#include <unordered_set>
#include <map>
#include <utility>
#include <bitset>
#include <boost/circular_buffer.hpp>
#include <boost/thread.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include "util/ParaMemPool.h"
#include "BlockReadWriteLock.h"
#include "BlockLightGridBase.h"

namespace ParaEngine
{
    class CBlockLightGridClient : public CBlockLightGridBase
    {
    public:
        typedef FixedSizedAllocator< std::pair<const uint64_t, Light> > DL_Allocator_BlockLight;
        
        CBlockLightGridClient(int32_t chunkCacheDim, CBlockWorld* pBlockWorld);
        virtual ~CBlockLightGridClient();

    public:
        virtual void OnEnterWorld();
        virtual void OnLeaveWorld();
        virtual void OnWorldMove(uint16_t centerChunkX, uint16_t centerChunkZ);
        virtual void UpdateLighting();

        //get light brightness of current and 26 nearby block
        // @param brightness: pointer to uint8_t blockBrightness[27];
        // @param nSize: if 1, it will only get the center block.
        // @param nLightType: -1 means Max light. 0 means emissive block light, 1 means sun light. 2 means both. where brightness[i] is block light and brightness[i+nSize] is sunlight 
        // @return : true if exist.  false if there is no block at the position. 
        virtual bool GetBrightness(Uint16x3& blockId, uint8_t* brightness, int nSize = 27, int nLightType = -1);

        virtual void SetLightDirty(Uint16x3& blockId_ws, bool isSunLight, int8 nUpdateRange = 0);

        virtual void NotifyBlockHeightChanged(uint16_t blockIdX_ws, uint16_t blockIdZ_ws, ChunkMaxHeight& prevBlockHeight);

        virtual void AddDirtyColumn(uint16_t chunkX_ws, uint16_t chunkZ_ws);
        
        virtual int GetDirtyColumnCount();

        virtual int GetDirtyBlockCount();

        virtual void SetColumnPreloaded(uint16_t chunkX_ws, uint16_t chunkZ_ws);
    
        virtual void SetColumnUnloaded(uint16_t chunkX_ws, uint16_t chunkZ_ws);

        virtual void SetLightGridSize(int nSize);

        virtual int ForceAddChunkColumn(int nChunkWX, int nChunkWZ);

        virtual int GetForcedChunkColumnCount();
    public:
        bool IsAsyncLightCalculation() const;
        void SetAsyncLightCalculation(bool val);

        bool IsChunkColumnLoadedWorldPos(int nWorldX, int nWorldY, int nWorldZ);
        bool IsChunkColumnLoaded(int nChunkX, int nChunkZ);

        /* whether this light block is marked dirty. please note only call this functionin light thread, since there is no lock on this function. */
        bool IsLightDirty(Uint16x3& blockId_ws);
        
    private:
        /*
        * @param nUpdateRange: currently only 0 and 1 are supported. 
        * @return false if block world is exiting. 
        */
        bool RefreshLight(const Uint16x3& blockId, bool isSunLight, int32 nUpdateRange = 0, Scoped_ReadLock<BlockReadWriteLock>* Lock_= NULL, int* pnCpuYieldCount = NULL);

        void AddPointToAABB(const Uint16x3 &curBlockPos, Int32x3 &minDirtyBlockId_ws, Int32x3 &maxDirtyBlockId_ws);

        void SetChunksDirtyInAABB(Int32x3 & minDirtyBlockId_ws, Int32x3 & maxDirtyBlockId_ws);

        void EmitSunLight(uint16_t blockIdX_ws,uint16_t blockIdZ_ws, bool bInitialSet=false);

        void LightThreadProc();

        void SetLightingInChunkColumnInitialized(uint16_t chunkX_ws, uint16_t chunkBlockZ);

        void RemoveDirtyColumn(const ChunkLocation& curChunkId_ws);

        void StartLightThread();

        void DoQuickSunLightValues(int chunkX, int chunkZ);
        void CheckDoQuickSunLightValues(int chunkX, int chunkZ);
        
        /* compute light value according to the nearby 6 blocks. */
        int32 ComputeLightValue(uint16 x, uint16 y, uint16 z, bool isSunLight = false);
        /* Returns whether a block above this one can reach to the sky (by checking the height map) */
        bool CanBlockSeeTheSky(uint16 x, uint16 y, uint16 z);
        int32 GetSavedLightValue(int32 x, int32 y, int32 z, bool isSunLight);
        int32 GetBlockOpacity(int32 x, int32 y, int32 z);
        void SetLightValue(uint16_t x, uint16_t y, uint16_t z, int nLightValue, bool isSunLight);
        
    public:
        int m_max_cells_per_frame;
        int m_max_cells_left_per_frame;
    private:
        //first cached block
        int32_t m_minLightBlockIdX;
        int32_t m_minLightBlockIdZ;
        //last cached block
        int32_t m_maxLightBlockIdX;
        int32_t m_maxLightBlockIdZ;

        //fist cached chunk
        int32_t m_minChunkIdX_ws;
        int32_t m_minChunkIdZ_ws;
        int32_t m_maxChunkIdX_ws;
        int32_t m_maxChunkIdZ_ws;

        int32_t m_centerChunkIdX_ws;
        int32_t m_centerChunkIdZ_ws;
        // dirty blocks since last frame's calculation
        uint32  m_nDirtyBlocksCount;

        // temporary array used by Relight function
        std::vector<LightBlock> m_blocksNeedLightRecalcuation;

        std::map<uint64_t, Light, std::greater<uint64_t>, DL_Allocator_BlockLight> m_dirtyCells;

        typedef std::unordered_set<ChunkLocation, ChunkLocation::ChunkLocationHasher>  ChunkLocationSet_type;
        ChunkLocationSet_type m_dirtyColumns;
        std::vector< std::pair<ChunkLocation, int32_t> > m_closest_chunks;
        std::vector< ChunkLocation > m_forced_chunks;

        std::set<uint32_t> m_loaded_columns;
        ChunkLocationSet_type m_quick_loaded_columns;

        bool m_bIsLightThreadStarted;

        std::thread m_light_thread;

        bool m_bIsAsyncLightCalculation;

        std::recursive_mutex m_mutex;
    };
}