BlockWorldClient.h

#pragma once
#include "BlockWorld.h"
#include "effect_file.h"

namespace ParaEngine
{
    class BlockRegion;
    class RenderableChunk;
    class BlockRenderTask;
    struct BlockHeightValue;
    class CShadowMap;
    class CMultiFrameBlockWorldRenderer;

    class BlockWorldClient : public CBlockWorld
    {
    public:
        virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_BlockWorldClient;}
        virtual const char* GetAttributeClassName(){static const char name[] = "BlockWorldClient"; return name;}
        virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        virtual IAttributeFields* GetChildAttributeObject(const std::string& sName);
        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);
        virtual int GetChildAttributeColumnCount();
        virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);

        //ATTRIBUTE_METHOD1(BlockWorldClient, GetTimeOfDay_s, float*)   {*p1 = cls->GetTimeOfDay(); return S_OK;}
        //ATTRIBUTE_METHOD1(BlockWorldClient, SetTimeOfDay_s, float)    {cls->SetTimeOfDay(p1); return S_OK;}

        
        ATTRIBUTE_METHOD1(BlockWorldClient, GetBlockLightColor_s, Vector3*) {*p1 = cls->GetBlockLightColor().ToVector3(); return S_OK;}
        ATTRIBUTE_METHOD1(BlockWorldClient, SetBlockLightColor_s, Vector3) {LinearColor c(p1.x, p1.y,p1.z,1); cls->SetBlockLightColor(c); return S_OK;}

        ATTRIBUTE_METHOD1(BlockWorldClient, SetPostProcessingScript_s, const char*) {cls->SetPostProcessingScript(p1); return S_OK;}

        ATTRIBUTE_METHOD1(BlockWorldClient, SetPostProcessingAlphaScript_s, const char*)    { cls->SetPostProcessingAlphaScript(p1); return S_OK; }

        ATTRIBUTE_METHOD1(BlockWorldClient, GetUseSunlightShadowMap_s, bool*)       {*p1 = cls->GetUseSunlightShadowMap(); return S_OK;}
        ATTRIBUTE_METHOD1(BlockWorldClient, SetUseSunlightShadowMap_s, bool)    {cls->SetUseSunlightShadowMap((BlockRenderMethod)p1); return S_OK;}
        
        ATTRIBUTE_METHOD1(BlockWorldClient, HasSunlightShadowMap_s, bool*)      { *p1 = cls->HasSunlightShadowMap(); return S_OK; }


        ATTRIBUTE_METHOD1(BlockWorldClient, GetUseWaterReflection_s, bool*)     {*p1 = cls->GetUseWaterReflection(); return S_OK;}
        ATTRIBUTE_METHOD1(BlockWorldClient, SetUseWaterReflection_s, bool)  {cls->SetUseWaterReflection((BlockRenderMethod)p1); return S_OK;}

        ATTRIBUTE_METHOD1(BlockWorldClient, CanUseAdvancedShading_s, bool*)     {*p1 = cls->CanUseAdvancedShading(); return S_OK;}
        
        ATTRIBUTE_METHOD1(BlockWorldClient, IsMovieOutputMode_s, bool*)     { *p1 = cls->IsMovieOutputMode(); return S_OK; }
        ATTRIBUTE_METHOD1(BlockWorldClient, EnableMovieOutputMode_s, bool)  { cls->EnableMovieOutputMode((BlockRenderMethod)p1); return S_OK; }

        ATTRIBUTE_METHOD1(BlockWorldClient, GetVertexBufferSizeLimit_s, int*)       { *p1 = cls->GetVertexBufferSizeLimit(); return S_OK; }
        ATTRIBUTE_METHOD1(BlockWorldClient, SetVertexBufferSizeLimit_s, int)    { cls->SetVertexBufferSizeLimit(p1); return S_OK; }

        ATTRIBUTE_METHOD1(BlockWorldClient, IsAsyncChunkMode_s, bool*)      { *p1 = cls->IsAsyncChunkMode(); return S_OK; }
        ATTRIBUTE_METHOD1(BlockWorldClient, SetAsyncChunkMode_s, bool)  { cls->SetAsyncChunkMode(p1); return S_OK; }


        ATTRIBUTE_METHOD1(BlockWorldClient, GetAlwaysInVertexBufferChunkRadius_s, int*)     { *p1 = cls->GetAlwaysInVertexBufferChunkRadius(); return S_OK; }
        ATTRIBUTE_METHOD1(BlockWorldClient, SetAlwaysInVertexBufferChunkRadius_s, int)  { cls->SetAlwaysInVertexBufferChunkRadius(p1); return S_OK; }

        ATTRIBUTE_METHOD1(BlockWorldClient, GetMaxVisibleVertexBufferBytes_s, int*)     { *p1 = cls->GetMaxVisibleVertexBufferBytes(); return S_OK; }
        ATTRIBUTE_METHOD1(BlockWorldClient, SetMaxVisibleVertexBufferBytes_s, int)  { cls->SetMaxVisibleVertexBufferBytes(p1); return S_OK; }


        ATTRIBUTE_METHOD1(BlockWorldClient, GetNearCameraChunkDist_s, int*)     { *p1 = cls->GetNearCameraChunkDist(); return S_OK; }
        ATTRIBUTE_METHOD1(BlockWorldClient, SetNearCameraChunkDist_s, int)  { cls->SetNearCameraChunkDist(p1); return S_OK; }

        ATTRIBUTE_METHOD1(BlockWorldClient, GetMaxBufferRebuildPerTick_s, int*)     { *p1 = cls->GetMaxBufferRebuildPerTick(); return S_OK; }
        ATTRIBUTE_METHOD1(BlockWorldClient, SetMaxBufferRebuildPerTick_s, int)  { cls->SetMaxBufferRebuildPerTick(p1); return S_OK; }

        ATTRIBUTE_METHOD1(BlockWorldClient, GetMaxBufferRebuildPerTick_FarChunk_s, int*)        { *p1 = cls->GetMaxBufferRebuildPerTick_FarChunk(); return S_OK; }
        ATTRIBUTE_METHOD1(BlockWorldClient, SetMaxBufferRebuildPerTick_FarChunk_s, int) { cls->SetMaxBufferRebuildPerTick_FarChunk(p1); return S_OK; }

        ATTRIBUTE_METHOD1(BlockWorldClient, GetUsePointTextureFiltering_s, bool*)   { *p1 = cls->GetUsePointTextureFiltering(); return S_OK; }
        ATTRIBUTE_METHOD1(BlockWorldClient, SetUsePointTextureFiltering_s, bool)    { cls->SetUsePointTextureFiltering(p1); return S_OK; }

        //static functions
        static BlockWorldClient* GetInstance();

        //member functions
        BlockWorldClient();
        ~BlockWorldClient();

        //init block world
        virtual void EnterWorld(const string& sWorldDir, float x,float y,float z);

        //call this function when leave the block world
        virtual void LeaveWorld();

        //perform culling and fill up m_visibleChunks
        virtual void UpdateVisibleChunks(bool bIsShadowPass = false);
        
        virtual void ClearBlockRenderCache();

        void DeleteAllBlocks();

        //render related function

        virtual void SetBlockRenderMethod(BlockRenderMethod method);

        //perform culling and prepare render group,this function should be called
        //before Render
        void PreRender(bool bIsShadowPass = false);

        void CheckRebuildVisibleChunks(bool bAsyncMode = true, bool bIsShadowPass = false);

        void Render(BlockRenderPass nRenderPass = BlockRenderPass_Opaque, std::vector<BlockRenderTask*>* pCurRenderQueue = NULL, int nRenderMethod = -1);

        void RenderDeferredLights();

        std::vector<BlockRenderTask*>* GetRenderQueueByPass(BlockRenderPass nRenderPass);

        void RenderShadowMap();

        //add render task to render queueGe
        virtual void AddRenderTask(BlockRenderTask* pRenderTask);

        //this function can be used to render a damaged block
        void SetDamagedBlock(uint16_t wx,uint16_t wy,uint16_t wz);

        void SetDamagedBlockDegree(float degree);

        bool IsPointUnderWater(const Vector3& vPos);

        void SetBlockLightColor(const LinearColor& color);

        LinearColor GetBlockLightColor();

        
        void SetSelectionTexture(const char* textureName);

        std::string GetSelectionTexture();

        void SetDamageTexture(const char* textureName);
        std::string GetDamageTexture();

        
        float GetWaterLevel(float x, float y, float z, int nRayLength=2);

        void InitDeviceObjects();
        void RestoreDeviceObjects();
        void DeleteDeviceObjects();
        void InvalidateDeviceObjects();
        void RendererRecreated();

        void DoPostRenderingProcessing(BlockRenderPass nRenderPass = BlockRenderPass_Opaque);

        void RestoreNormalShader();

        void Cleanup();

        bool PrepareAllRenderTargets(bool bSetRenderTarget = true);

        bool DrawMultiFrameBlockWorld();

        bool DrawMultiFrameBlockWorldOnSky();

        void SetPostProcessingScript(const char* sCallbackScript);
        void SetPostProcessingAlphaScript(const char* sCallbackScript);

        bool CanUseAdvancedShading();

        void SetUseSunlightShadowMap(bool bEnable);
        bool GetUseSunlightShadowMap();


        void SetUseWaterReflection(bool bEnable);
        bool GetUseWaterReflection();

        void PrepareShadowCasters( CShadowMap* pShadowMap );

        void RenderDynamicBlocks();
        
        //get highest y values of current and neighbor blocks above terrain.
        //return terrain height if no block above ground.
        //@param result: int16_t[6] array contains the result height of {center,x,-x,z,-z,mask} 
        // each bit of mask indicate return value is block height or terrain height, 
        virtual void GetMaxBlockHeightWatchingSky(uint16_t blockX_ws, uint16_t blockZ_ws, ChunkMaxHeight* pResult);

        bool IsMovieOutputMode() const;
        void EnableMovieOutputMode(bool val);

        int GetVertexBufferSizeLimit() const;
        void SetVertexBufferSizeLimit(int val);

        int GetAlwaysInVertexBufferChunkRadius() const;
        void SetAlwaysInVertexBufferChunkRadius(int val);

        int GetMaxVisibleVertexBufferBytes() const;
        void SetMaxVisibleVertexBufferBytes(int val);

        bool IsAsyncChunkMode() const;
        void SetAsyncChunkMode(bool val);

        int GetNearCameraChunkDist() const;
        void SetNearCameraChunkDist(int val);

        int GetMaxBufferRebuildPerTick() const;
        void SetMaxBufferRebuildPerTick(int val);
        
        int GetMaxBufferRebuildPerTick_FarChunk() const;
        void SetMaxBufferRebuildPerTick_FarChunk(int val);

        //helper function to compare render order
        static bool CompareRenderOrder(BlockRenderTask* v0, BlockRenderTask* v1);

        bool GetUsePointTextureFiltering();
        void SetUsePointTextureFiltering(bool bUse);
    protected:
        virtual void UpdateActiveChunk();

    private:
        //Get shared index buffer which will be reused for all render task
        IndexBufferDevicePtr_type GetIndexBuffer();
        VertexDeclarationPtr GetVertexLayout();
        VertexDeclarationPtr GetSelectBlockVertexLayout();

        void BuildSelectionBlockBuffer();

        void RenderSelectionBlock(int nSelectionIndex = BLOCK_GROUP_ID_HIGHLIGHT, float fScaledBlockSize = 1.01f, LinearColor* pColor = NULL, BOOL bColorAnimate = TRUE);

        void RenderWireFrameBlock(int nSelectionIndex = BLOCK_GROUP_ID_WIREFRAME, float fScaledBlockSize = 1.01f, LinearColor* pLineColor = NULL);

        void RenderDamagedBlock();

        int FillSelectBlockVertice(std::map<int64_t, Uint16x3>* pSelectedBlockMap, uint16_t x, uint16_t y, uint16_t z, SelectBlockVertex* blockModel, const Vector3& vOffset, const float fBlockSize, float fUV_Y_Offset = 0.f, float fUV_Y_Size = 1.f);

        int FillSelectBlockInvert(std::map<int64_t, Uint16x3>& selectedBlockMap, uint16_t x, uint16_t y, uint16_t z, SelectBlockVertex* blockModel, const Vector3& vOffset, const float fBlockSize, float fUV_Y_Offset = 0.f, float fUV_Y_Size = 1.f);
        
        bool HasSunlightShadowMap();

        void AddToVisibleChunk(RenderableChunk &chunk, int nViewDist, int nRenderFrameCount);
        int ClearActiveChunksToMemLimit(bool bIsShadowPass = false);

        void ClearVisibleChunksToByteLimit(bool bIsShadowPass);

    private:
        static BlockWorldClient* g_pInstance;
        
        static int32_t g_TexPass;
        static int32_t g_twoTexPass;
        static int32_t g_TexNormalMapPass;
        static int32_t g_twoTexNormalMapPass;
        static int32_t g_transparentBlockPass;
        static int32_t g_waterBlockPass;
        static int32_t g_selectBlockPass;
        static int32_t g_bumpyBlockPass;

        
        bool m_isUnderLiquid;
        
        LinearColor m_vBlockLightColor;

        std::vector<BlockRenderTask*> m_solidRenderTasks;
        std::vector<BlockRenderTask*> m_alphaTestRenderTasks;
        std::vector<BlockRenderTask*> m_alphaBlendRenderTasks;
        std::vector<BlockRenderTask*> m_reflectedWaterRenderTasks;


        std::vector<float> m_selectBlockInstData;
        int32_t m_maxSelectBlockPerBatch;

        asset_ptr<TextureEntity> m_highLightTextures[BLOCK_GROUP_ID_MAX];
        std::vector<SelectBlockVertex>  m_select_block_vertices;
        std::vector<uint16_t>  m_select_block_indices;

        ParaIndexBuffer m_sharedIndexBuffer;

#ifdef USE_DIRECTX_RENDERER

        asset_ptr<TextureEntity> m_render_target_color;
        asset_ptr<TextureEntity> m_render_target_color_hdr;
        asset_ptr<TextureEntity> m_render_target_block_info;
        LPDIRECT3DSURFACE9       m_render_target_block_info_surface;
        asset_ptr<TextureEntity> m_render_target_depth_tex;
        LPDIRECT3DSURFACE9       m_render_target_depth_tex_surface;
        asset_ptr<TextureEntity> m_render_target_normal;
        LPDIRECT3DSURFACE9       m_render_target_normal_surface;
        LPDIRECT3DSURFACE9 m_pDepthStencilSurface; 
        LPDIRECT3DSURFACE9 m_pOldRenderTarget; 
        LPDIRECT3DSURFACE9 m_pOldZBuffer; 

        asset_ptr<CEffectFile> m_block_effect_fancy;
        asset_ptr<CEffectFile> m_normal_mesh_effect_fancy;
        asset_ptr<CEffectFile> m_bmax_model_effect_fancy;
        asset_ptr<CEffectFile> m_terrain_fancy;

        asset_ptr<CEffectFile> m_lightgeometry_effects[3];
#endif
        CMultiFrameBlockWorldRenderer* m_pMultiFrameRenderer;

        Uint16x3 m_damagedBlockId;
        asset_ptr<TextureEntity> m_damangeTexture;
        float m_damageDegree;

        std::string m_sPostProcessorCallbackScript;
        std::string m_sPostProcessorAlphaCallbackScript;
        
        int m_nMaxBufferRebuildPerTick;
        int m_nNearCameraChunkDist;
        int m_nMaxBufferRebuildPerTick_FarChunk;
        
        int m_nVertexBufferSizeLimit;
        int m_nAlwaysInVertexBufferChunkRadius;
        int m_nMaxVisibleVertexBufferBytes;
        
        int m_nBufferRebuildCountThisTick;

        bool m_bUseSunlightShadowMap;

        bool m_bUseWaterReflection;

        bool m_bMovieOutputMode;

        bool m_bAsyncChunkMode;

        bool m_bUsePointTextureFiltering;
    };
}