ChunkVertexBuilderManager.h

#pragma once
#include <vector>
#include <thread>
#include <mutex>
#include <condition_variable>
#include "BlockReadWriteLock.h"
#include "IAttributeFields.h"

namespace ParaEngine
{
    class CBlockWorld;
    class BlockWorldClient;

    class ChunkVertexBuilderManager : public IAttributeFields
    {
    public:
        ChunkVertexBuilderManager();
        virtual ~ChunkVertexBuilderManager();
        ATTRIBUTE_DEFINE_CLASS(ChunkVertexBuilderManager);
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_METHOD1(ChunkVertexBuilderManager, GetMaxChunksToUploadPerTick_s, int*)       { *p1 = cls->GetMaxChunksToUploadPerTick(); return S_OK; }
        ATTRIBUTE_METHOD1(ChunkVertexBuilderManager, SetMaxChunksToUploadPerTick_s, int)    { cls->SetMaxChunksToUploadPerTick(p1); return S_OK; }

        ATTRIBUTE_METHOD1(ChunkVertexBuilderManager, GetMaxBytesToUploadPerTick_s, int*)        { *p1 = cls->GetMaxBytesToUploadPerTick(); return S_OK; }
        ATTRIBUTE_METHOD1(ChunkVertexBuilderManager, SetMaxBytesToUploadPerTick_s, int) { cls->SetMaxBytesToUploadPerTick(p1); return S_OK; }

        ATTRIBUTE_METHOD1(ChunkVertexBuilderManager, GetPendingChunksCount_s, int*)     { *p1 = cls->GetPendingChunksCount(); return S_OK; }

    public:
        static ChunkVertexBuilderManager& GetInstance();

        bool AddChunk(RenderableChunk* pChunk);

        void RemovePendingChunks(std::set<RenderableChunk*>* pExcludeList);
        
        int ProcessOneChunk(Scoped_ReadLock<BlockReadWriteLock>& ReadWriteLock_);

        void UploadPendingChunksToDevice();

        void Cleanup();

        int GetPendingChunksCount();

        void StartChunkBuildThread(CBlockWorld* pBlockWorld);

        int GetMaxChunksToUploadPerTick() const;
        void SetMaxChunksToUploadPerTick(int val);
        int GetMaxBytesToUploadPerTick() const;
        void SetMaxBytesToUploadPerTick(int val);

    protected:
        void ChunkBuildThreadProc();
    protected:
        // weak references, no need to release them.
        // chunks that need to be rebuild. 
        std::vector<RenderableChunk*> m_pendingChunks;
        // chunks that needing uploading to device
        std::vector<RenderableChunk*> m_pendingUploadChunks;
        std::mutex m_mutex;
        std::mutex m_queueMutex;
        std::thread m_chunk_build_thread;
        std::condition_variable m_chunk_request_signal;
        bool m_bChunkThreadStarted;
        CBlockWorld* m_pBlockWorld;
        int m_nMaxPendingChunks;
        int m_nMaxUploadingChunks;
        int m_nMaxChunksToUploadPerTick;
        int m_nMaxBytesToUploadPerTick;
        
        friend class CBlockWorld;
        friend class BlockWorldClient;
    };
}