MultiFrameBlockWorldRenderer.h

#pragma once
#include "IAttributeFields.h"
#include "math/ShapeSphere.h"
#include "BaseCamera.h"

namespace ParaEngine
{
    class BlockWorldClient;
    class CRenderTarget;
    class RenderableChunk;
    class BlockRenderTask;

    class CMultiFrameBlockWorldRenderer : public IAttributeFields
    {
    public:
        CMultiFrameBlockWorldRenderer(BlockWorldClient* pWorld);
        ~CMultiFrameBlockWorldRenderer();
        ATTRIBUTE_DEFINE_CLASS(CMultiFrameBlockWorldRenderer);

        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, IsEnabled_s, bool*)    { *p1 = cls->IsEnabled(); return S_OK; }
        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, SetEnabled_s, bool)    { cls->SetEnabled(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, IsDirty_s, bool*)  { *p1 = cls->IsDirty(); return S_OK; }
        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, SetDirty_s, bool)  { cls->SetDirty(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, IsUseMyCamera_s, bool*)    { *p1 = cls->IsUseMyCamera(); return S_OK; }
        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, SetUseMyCamera_s, bool)    { cls->SetUseMyCamera(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, IsDebugImage_s, bool*) { *p1 = cls->IsDebugImage(); return S_OK; }
        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, SetDebugImage_s, bool) { cls->SetDebugImage(p1); return S_OK; }


        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, IsFinished_s, bool*)   { *p1 = cls->IsFinished(); return S_OK; }
        

        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, GetMaxChunksToDrawPerTick_s, int*) { *p1 = cls->GetMaxChunksToDrawPerTick(); return S_OK; }
        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, SetMaxChunksToDrawPerTick_s, int)  { cls->SetMaxChunksToDrawPerTick(p1); return S_OK; }
        
        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, GetRenderDistance_s, int*) { *p1 = cls->GetRenderDistance(); return S_OK; }
        ATTRIBUTE_METHOD1(CMultiFrameBlockWorldRenderer, SetRenderDistance_s, int)  { cls->SetRenderDistance(p1); return S_OK; }
        
    public:
        bool Draw(int nMaxChunks = -1);

        bool DrawToSkybox();

        bool IsDebugImage() const;
        void SetDebugImage(bool val);

        bool IsEnabled() const;
        void SetEnabled(bool val);

        bool IsUseMyCamera() const;
        void SetUseMyCamera(bool val);

        int GetMaxChunksToDrawPerTick() const;
        void SetMaxChunksToDrawPerTick(int val);

        void CheckCreateActiveChunks();

        bool IsDrawToSkybox() const;
        void SetDrawToSkybox(bool val);

        bool IsDirty() const;
        void SetDirty(bool val);

        bool IsFinished() const;
        void SetFinished(bool val);

        int GetRenderDistance() const;
        void SetRenderDistance(int val);

        void DeleteDeviceObjects();
        void RendererRecreated();

        CBaseCamera* GetCamera();

    protected:
        virtual CRenderTarget* CreateGetRenderTarget(bool bCreateIfNotExist = true);

        bool DrawInternal(int nMaxChunks);

        void DrawRenderTasks(BlockRenderPass nCurRenderPass);

        RenderableChunk* GetRenderableChunkByPosition(const Int16x3& chunkPos, int nBufferIndex, bool* pbFromMainBuffer);

        bool GetChunkByProgress(int nProgress, Int16x3& outChunkPos, bool bIsResuming = false);

        void ResetProgress();

        void UpdateViewParams();


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

        const Uint16x3& GetEyeChunkId();
    protected:
        BlockWorldClient* m_pWorld;

        WeakPtr m_renderTarget;

        int m_nRenderDistance;

        int m_nMaxChunksToDrawPerTick;

        bool m_bIsDirty;

        bool m_bIsFinished;

        bool m_bEnabled;

        bool m_bDrawToSkybox;

        int m_nProgress;
        int m_nCurRenderPass;
                
        std::vector<RenderableChunk*> m_activeChunks;

        std::vector<BlockRenderTask*> m_tempRenderTasks;

        std::vector<Int16x3> m_alphaTestTasks;
        std::vector<Int16x3> m_alphaBlendTasks;
        std::vector<Int16x3> m_reflectedWaterTasks;

        //
        // camera related parameters
        //
        CBaseCamera* m_pCamera;
        Uint16x3 m_curCamChunkId;
        Uint16x3 m_curCamBlockId;
        CShapeSphere m_sEyeSphere;
        int32 m_chunkViewSize;
        CCameraFrustum m_frustum;
        Uint16x3 m_startIdx, m_endIdx;
        Vector3 m_renderOrig;
        bool m_bUseMyCamera;

        bool m_bDebugImage;

    private:
        int32 m_nIndex;
        int32 m_dx;
        int32 m_dz;
        int32 m_length;
        int32 m_k;
        int32 m_i;
        int m_nProgressIndex;
        bool m_bCanResumeProgress;
    };
}