RenderableChunk.h

#pragma once
#include "BlockRenderTask.h"
#include "BlockCommon.h"
#include "ShapeAABB.h"
#include "BlockReadWriteLock.h"

namespace ParaEngine
{
    class BlockRegion;
    class BlockRenderTask;
    class Block;
    class BlockChunk;
    class CBlockWorld;
    class ParaVertexBufferPool;
    class BlockGeneralTessellator;

    class RenderableChunk
    {
    public:
        enum ChunkBuildState
        {
            // chunk vertex buffer is ready on device
            ChunkBuild_Ready,
            // main thread is requesting to rebuild vertex buffer
            ChunkBuild_RequestRebuild,
            // chunk data is rebuilding in (possibly in another thread). 
            ChunkBuild_Rebuilding,
            // building thread has finished, and request the main thread to upload the buffer
            ChunkBuild_RequestBufferUpload,
            // initial state: chunk has never been built before. 
            ChunkBuild_empty,
        };


        RenderableChunk();
        ~RenderableChunk();

        void ReuseChunk(BlockRegion* m_ownerBlockRegion,int16_t chunkIndex);

        void ClearChunkData();

        void ReleaseVertexBuffers();

        void Reset();

        bool ShouldRebuildRenderBuffer(CBlockWorld* pWorld, bool bNewBuffer = true, bool bUpdatedBuffer = true);

        bool RebuildRenderBuffer(CBlockWorld* pWorld, bool bAsyncMode);


        void FillRenderQueue(CBlockWorld* pWorld);

        void OnLeaveWorld();

        void DeleteDeviceObjects();

        void ClearRenderTasks();

        void RendererRecreated();
        bool IsEmptyChunk();

        inline uint16_t GetChunkIndex(){return m_packedChunkID;}

        Int16x3 GetChunkPosWs();

        BlockChunk* GetChunk();

        void FillRenderQueue(CBlockWorld* pWorld,Vector3& renderOfs,float verticalOffset);

        void SetChunkDirty(bool isDirty)
        {
            m_isDirty = isDirty;
        }

        bool IsDirty() const { 
            return m_isDirty; 
        }

        bool IsDirtyByNeighbor();
        bool GetIsDirtyByBlockChange();

        bool IsIntersect(CShapeSphere& sphere);

        bool IsNearbyChunksLoaded();

        RenderableChunk::ChunkBuildState GetChunkBuildState() const;
        bool IsBuildingBuffer() const;
        bool IsReadyOrEmpty() const;
        void SetChunkBuildState(RenderableChunk::ChunkBuildState val);

        static void StaticInit();
        static void StaticRelease();
        static ParaVertexBufferPool* GetVertexBufferPool();
        
        void WaitUntilChunkReady();

        void RebuildRenderBufferToMemory(Scoped_ReadLock<BlockReadWriteLock>* Lock_, int* pnCpuYieldCount);
        void ClearBuilderBuffer();
        void UploadFromMemoryToDeviceBuffer();

        /* total number of faces. */
        int32 GetTotalFaceCount() const;

        int32 GetDelayedRebuildTick() const;
        void SetDelayedRebuildTick(int32 val);

        int16 GetChunkViewDistance() const;
        void SetChunkViewDistance(int16 val);

        int16 GetViewIndex() const;
        void SetViewIndex(int16 val);

        int GetRenderFrameCount() const;
        void SetRenderFrameCount(int val);

        int GetVertexBufferBytes();
        int GetLastBufferBytes();

        static int GetTotalRenderableChunks();

        std::vector<BlockRenderTask*> GetRenderTasks();
    
        const CShapeBox& GetShapeAABB() const;
        
        int GetShaderID() const;
        void SetShaderID(int val);

        bool IsMainRenderer() const;
        void SetIsMainRenderer(bool val);

        bool IsDirtyByBlockChange() const;
        void IsDirtyByBlockChange(bool val);
    public:
        struct InstanceGroup
        {
            BlockTemplate* m_pTemplate;
            uint32_t m_blockData;
            uint32_t m_nFaceCount;

            //packedBlockId
            std::vector<uint16_t> instances;
            InstanceGroup() :m_pTemplate(NULL), m_blockData(0), m_nFaceCount(0){}
            inline void reset(){
                m_pTemplate = 0;
                m_nFaceCount = 0;
                instances.clear();
            }
            inline bool isEmpty() const {
                return !(m_pTemplate || instances.size() > 0);
            }
            inline void AddFace(uint32_t nCount){
                m_nFaceCount += nCount;
            }
            inline void AddInstance(uint16_t nIndex, uint32_t nFaceCount = 0){
                instances.push_back(nIndex);
                AddFace(nFaceCount);
            }
            inline uint32_t GetFaceCount() const { return m_nFaceCount; }
            void operator+=(InstanceGroup& right){
                AddFace(right.GetFaceCount());
                instances.insert(instances.end(), right.instances.begin(), right.instances.end());
            }
            bool CanShareRenderBufferWith(InstanceGroup* pOther = NULL);
        };
        std::vector<InstanceGroup* >& GetInstanceGroups();

        std::map<int32_t, int>& GetInstanceMap();
        
        static void StaticReleaseInstGroup(std::vector<RenderableChunk::InstanceGroup* >* pInstances);

        BlockGeneralTessellator& GetBlockTessellator();

    protected:
        void BuildRenderGroup();

        void ResetInstanceGroups();

        int32 BuildInstanceGroupsByIdAndData(BlockChunk* pChunk);
        void SortAndMergeInstanceGroupsByTexture();

        ParaVertexBuffer* RequestVertexBuffer(int32 nFaceCountInVertexBuffer);
        ParaMemoryBuffer RequestMemoryBuffer(int32 nFaceCountInVertexBuffer, int32* pBufferIndex);

    protected:
        std::vector<BlockRenderTask*> m_builder_tasks;
        std::vector<ParaMemoryBuffer> m_memoryBuffers; 
        
    private:
        static int s_nTotalRenderableChunks;
        CBlockWorld* m_pWorld;
        int16_t m_regionX, m_regionZ;
        int16_t m_packedChunkID;
        bool m_isDirty;
        int32 m_nRenderFrameCount;
        int32 m_nLastVertexBufferBytes;
        int32 m_nDelayedRebuildTick;
        int16 m_nChunkViewDistance;
        int16 m_nViewIndex;
        
        ChunkBuildState m_chunkBuildState;
        
        int m_dwShaderID;

        std::vector<BlockRenderTask*> m_renderTasks;
        std::vector<ParaVertexBuffer*> m_vertexBuffers;
        CShapeBox m_pShapeAABB;

        int32 m_totalFaceCount;

        bool m_bIsMainRenderer : 1;
        bool m_bIsDirtyByBlockChange : 1;
    };
}