BlockLightGridBase.h

#pragma once

#include "BlockCommon.h"
#include "BlockConfig.h"
#include "IAttributeFields.h"

namespace ParaEngine
{
    class CBlockWorld;
    class BlockChunk;
    class LightData;

    class LightBlock
    {
    public:
        Uint16x3 blockId;
        int8_t brightness;
        
        LightBlock()
            :blockId(0,0,0),brightness(0)
        {
        }

        LightBlock(uint16_t x,uint16_t y,uint16_t z,uint8_t lightValue)
            :blockId(x,y,z),brightness(lightValue)
        {
        }

        LightBlock(const Uint16x3& pos,uint8_t lightValue)
            :blockId(pos),brightness(lightValue)
        {
        }
    };

    class CBlockLightGridBase : public IAttributeFields
    {
    public:
        struct Light
        {
            Uint16x3 blockId;
            // 0 means normal refresh, 1 means force update neighbor within 1 blocks. - 1 to disable
            int8_t sunlightUpdateRange;
            int8_t pointLightUpdateRange;

            Light(Uint16x3& blockId_ws, uint8_t sunValue, uint8_t pointValue)
                :blockId(blockId_ws), sunlightUpdateRange(sunValue), pointLightUpdateRange(pointValue)
            {
            }
        };

        enum CellType
        {
            cp_empty,
            cp_light,
            cp_obstructure,
        };

    public:
        CBlockLightGridBase(CBlockWorld* pBlockWorld);
        virtual ~CBlockLightGridBase();
        ATTRIBUTE_DEFINE_CLASS(CBlockLightGridBase);
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

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

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

    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 void SetColumnPreloaded(uint16_t chunkX_ws, uint16_t chunkZ_ws);
        virtual void SetColumnUnloaded(uint16_t chunkX_ws, uint16_t chunkZ_ws);

        virtual int GetDirtyColumnCount();
        virtual int GetDirtyBlockCount();

        virtual int GetLightGridSize();

        virtual void SetLightGridSize(int nSize);

        virtual void SetLightCalculationStep(uint32 nTicks);
        virtual uint32 GetLightCalculationStep() const;
        
        virtual int ForceAddChunkColumn(int nChunkWX, int nChunkWZ);
        virtual int GetForcedChunkColumnCount();

    public:
        //ignore all SetLightDirty calls
        void SuspendLightUpdate();

        void ResumeLightUpdate();

        bool IsLightUpdateSuspended();
    protected:
        BlockIndex  CalcLightDataIndex(const Uint16x3& blockId, bool bCreateIfNotExist = true);
        LightData* GetLightData(const BlockIndex& index);
        LightData* GetLightData(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);

    protected:
        bool m_suspendLightUpdate;
        CBlockWorld* m_pBlockWorld;
        int32 m_nLightGridChunkSize;
        uint32 m_nLightCalculationStep;
    };
}