OceanManager.h

#pragma once
#include "IAttributeFields.h"
#include "terrain/TTerrain.h"
#include <list>
namespace ParaEngine
{
    using namespace std;

    class TTerrain;
    struct TextureEntity;

    struct RippleItem
    {
        // max radius in meters
        float fMaxRadius;
        // propagation speed
        float fSpeed;
        // position in world coordinate system. 
        Vector3 vPos;

        // current radius, which is automatically updated during frame move 
        float fCurrentRadius;
    };

    class RippleList
    {
    public:
        RippleList();
        ~RippleList();

        
        void FrameMove(float fDeltaTime);
    
        void ClearAll();

    public:
        /* all active ripples */
        list<RippleItem> m_ripples;
    };

    class COceanManager : public IAttributeFields
    {
    public:
        COceanManager(void);
        ~COceanManager(void);
        static COceanManager* GetInstance();

        enum eProcessingStages
        {
            k_animateHeight = 0,
            k_animateNormal,
            k_heightFFTv,
            k_heightFFTh,
            k_normalFFTv,
            k_normalFFTh,
            k_uploadBuffer,
            k_rotateBuffer,
            k_total_process_stages
        };
        enum eWaterMeshes
        {
            k_total_water_meshes = 3,
            k_total_terrain_meshes = 1,
        };

        struct sBaseVertex
        {
            Vector2  vPos;
            //DWORD colour;
            //FLOAT u,v;
            //static const DWORD FVF;
        };

        struct sAnimVertex
        {
            float zPos;
            Vector2 vNormal;
        };
        struct sTerrainVertex
        {
            float fHeight;
        };

        struct sComplex
        {
            float real;
            float imag;

            sComplex& operator = (const sComplex& src)
            {
                real = src.real;
                imag = src.imag;
                return *this;
            }
        };

        
    public:
        // implementation of IAttributeFields

        virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_COceanManager;}
        virtual const char* GetAttributeClassName(){static const char name[] = "COceanManager"; return name;}
        virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        ATTRIBUTE_METHOD1(COceanManager, OceanEnabled_s, bool*) {*p1 = cls->OceanEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, EnableOcean_s, bool)   {cls->EnableOcean(p1); return S_OK;}

        ATTRIBUTE_METHOD1(COceanManager, GetWaterLevel_s, float*)   {*p1 = cls->GetWaterLevel(); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, SetWaterLevel_s, float)    {cls->SetWaterLevel(p1); return S_OK;}

        ATTRIBUTE_METHOD1(COceanManager, IsUnderWater_s, bool*) {*p1 = cls->IsUnderWater(); return S_OK;}

        ATTRIBUTE_METHOD1(COceanManager, GetOceanColor_s, Vector3*)     {*p1 = cls->GetOceanColor().ToVector3(); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, SetGetOceanColor_s, Vector3)       {LinearColor c(p1.x, p1.y,p1.z,1); cls->SetGetOceanColor(c); return S_OK;}

        ATTRIBUTE_METHOD1(COceanManager, GetWindSpeed_s, float*)    {*p1 = cls->GetWindSpeed(); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, SetWindSpeed_s, float) {cls->SetWindSpeed(p1); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, GetWindDirection_s, float*)    {*p1 = cls->GetWindDirection(); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, SetWindDirection_s, float) {cls->SetWindDirection(p1); return S_OK;}

        ATTRIBUTE_METHOD1(COceanManager, GetRenderTechnique_s, int*)    {*p1 = cls->GetRenderTechnique(); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, SetRenderTechnique_s, int) {cls->SetRenderTechnique(p1); return S_OK;}

        ATTRIBUTE_METHOD1(COceanManager, IsTerrainReflectionEnabled_s, bool*)   {*p1 = cls->IsTerrainReflectionEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, EnableTerrainReflection_s, bool)   {cls->EnableTerrainReflection(p1); return S_OK;}

        ATTRIBUTE_METHOD1(COceanManager, IsMeshReflectionEnabled_s, bool*)  {*p1 = cls->IsMeshReflectionEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, EnableMeshReflection_s, bool)  {cls->EnableMeshReflection(p1); return S_OK;}

        ATTRIBUTE_METHOD1(COceanManager, IsPlayerReflectionEnabled_s, bool*)    {*p1 = cls->IsPlayerReflectionEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, EnablePlayerReflection_s, bool)    {cls->EnablePlayerReflection(p1); return S_OK;}

        ATTRIBUTE_METHOD1(COceanManager, IsCharacterReflectionEnabled_s, bool*) {*p1 = cls->IsCharacterReflectionEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, EnableCharacterReflection_s, bool) {cls->EnableCharacterReflection(p1); return S_OK;}

        ATTRIBUTE_METHOD1(COceanManager, IsAnimateFFT_s, bool*) {*p1 = cls->IsAnimateFFT(); return S_OK;}
        ATTRIBUTE_METHOD1(COceanManager, SetAnimateFFT_s, bool) {cls->SetAnimateFFT(p1); return S_OK;}

        ATTRIBUTE_METHOD(COceanManager, CleanupTerrainCache_s)  {cls->CleanupTerrainCache(); return S_OK;}

        const LinearColor& GetOceanColor(){return m_colorOcean;};
        void SetGetOceanColor(const LinearColor& color){m_colorOcean= color;};


        bool OceanEnabled();
        void EnableOcean(bool Enable);
        
        float GetWaterLevel();
        void SetWaterLevel(float fLevel);

        enum ReflectionItem
        {
            R_SKY_BOX = 0,
            R_GLOBAL_TERRAIN,
            R_MESH_FRONT_TO_BACK,
            R_MESH_BACK_TO_FRONT,
            R_CHARACTERS,
            R_CURRENT_PLAYER,
            R_MESH_TRANSPARENT,
            R_LAST_ITEM,
        };
        void EnableReflectionItem(ReflectionItem item, bool bEnabled);
        bool IsReflectionItemEnabled(ReflectionItem item);

        void EnableTerrainReflection(bool bEnabled){EnableReflectionItem(R_GLOBAL_TERRAIN, bEnabled);};
        bool IsTerrainReflectionEnabled(){return IsReflectionItemEnabled(R_GLOBAL_TERRAIN);};

        void EnableMeshReflection(bool bEnabled){EnableReflectionItem(R_MESH_FRONT_TO_BACK, bEnabled); EnableReflectionItem(R_MESH_BACK_TO_FRONT, bEnabled);};
        bool IsMeshReflectionEnabled(){return IsReflectionItemEnabled(R_MESH_FRONT_TO_BACK);};

        void EnablePlayerReflection(bool bEnabled){EnableReflectionItem(R_CURRENT_PLAYER, bEnabled);};
        bool IsPlayerReflectionEnabled(){return IsReflectionItemEnabled(R_CURRENT_PLAYER);};

        void EnableCharacterReflection(bool bEnabled){EnableReflectionItem(R_CHARACTERS, bEnabled);};
        bool IsCharacterReflectionEnabled(){return IsReflectionItemEnabled(R_CHARACTERS);};


        bool IsRedrawStillReflection();
        
        bool IsUnderWater();

        float GetWindSpeed();
        void SetWindSpeed(float fSpeed);
        float GetWindDirection();
        void SetWindDirection(float fWindDirection);

        void SetGlobalWater(bool bEnable, float fWaterLevel = 0.0f);

        float GetMaxWaterLevel();

        
        void AddRipple(const Vector3& vPos);
    private:
        bool m_bAnimateFFT;
        RippleList m_rippleList;
        int m_nMaxRippleNumber;
        
        float   m_fGlobalWaterLevel;
        bool    m_bDrawGlobalWater;
        LinearColor m_colorOcean;

        // whether to render ocean reflection texture according to occlusion result. 
        bool m_bRenderOceanReflection;

        int m_grid_size;
        int m_half_grid_size;
        int m_log_grid_size;
        void SetFFTGrid(int nSize);
        void DeleteGrid();

        float m_fWindX;    
        float m_fWindY;
        float m_fWindSpeed;
        float m_fWaveHeight;
        float m_fDirectionalDependence;
        float m_fSuppressSmallWavesFactor;
        
        float m_fLargestPossibleWave;   
        float m_fSuppressSmallWaves;

        float m_ocean_tile_size; 
        float m_ocean_tile_height;

        /************************************************************************/
        /* cached terrain tiles for shorelines                                  */
        /************************************************************************/
        bool m_bDrawShoreline;
        map <int, TerrainTileCacheItem> m_pCachedTerrains;
        int m_nMaxCacheSize;

        static int GetTileIDFromXY(int X, int Y);
        static bool GetXYFromTileID(int nTileID, int* X, int* Y);

        TTerrain* GetTerrainHeightField(int nID);

        void FrameMoveCachedTerrainTiles();

        /************************************************************************/
        /* default values                                                       */
        /************************************************************************/
        static const float GRAVITY_CONSTANT;

        static const float m_fDefaultWindDirection;
        static const float m_fDefaultWindSpeed;
        static const float m_fDefaultWaveHeight;

        static const float m_fDefaultDirectionalDependence;

        static const float m_fDefaultSuppressSmallWavesFactor;

        float m_fTime;
        float m_fBumpTime;

        int m_tickCounter;

        float m_fInterpolation;

        Plane                m_refractionClipPlaneAboveWater;
        Plane                m_reflectionClipPlaneAboveWater;
        Plane                m_refractionClipPlaneBelowWater;
        Plane                m_reflectionClipPlaneBelowWater;

        float                    m_refractionMapOverdraw;
        float                    m_reflectionMapOverdraw;

        int                      m_reflectionTextureWidth;
        int                      m_reflectionTextureHeight;
        int                      m_refractionTextureWidth;
        int                      m_refractionTextureHeight;
#ifdef USE_DIRECTX_RENDERER
        LPDIRECT3DSURFACE9       m_pDepthStencilSurface;
        LPDIRECT3DTEXTURE9       m_waveReflectionTexture;
        LPDIRECT3DSURFACE9       m_waveReflectionSurface;
        LPDIRECT3DTEXTURE9       m_waveRefractionTexture;
        LPDIRECT3DSURFACE9       m_waveRefractionSurface;
        LPDIRECT3DTEXTURE9       m_waveReflectionNearTexture;
        LPDIRECT3DSURFACE9       m_waveReflectionNearSurface;
        LPDIRECT3DTEXTURE9       m_waveRefractionNearTexture;
        LPDIRECT3DSURFACE9       m_waveRefractionNearSurface;
#endif
        // procedure ripples on the surface. 
        //LPDIRECT3DVERTEXBUFFER9    m_lpVBRipples; 

        Matrix4               m_projectionMatrix;
        Matrix4               m_reflectionProjectionMatrix;
        Matrix4               m_refractionProjectionMatrix;
        Matrix4               m_worldViewProjectionInverseTransposeMatrix;

        bool                     m_reflectViewMatrix;
        bool                     m_underwater;
        DWORD                    m_dwTechnique;

        float m_fLastReflectionTime;

        void SetMatrices(bool bPostPushMatrices=false, bool bPrePopMatrices=false);
        
    private:
        bool m_ReflectionItems[R_LAST_ITEM];
        
        bool m_bDisableFogInReflection;
        bool m_bIsCreated;
        asset_ptr<TextureEntity> m_pRippleBumpMappingTexture;
        asset_ptr<TextureEntity> m_pShorelineTexture;
        asset_ptr<TextureEntity> m_pRippleTexture;
        bool m_bUseShorelineTexture;
        asset_ptr<TextureEntity> m_pWaterColorTexture;
        asset_ptr<TextureEntity> m_pWaterFadeTexture;
        /* only used in TECH_OCEAN_SIMPLE */
        asset_ptr<TextureEntity> m_pSimpleReflectionTexture;
        /* only used in TECH_OCEAN_SIMPLE */
        asset_ptr<TextureEntity> m_pSimpleBumpTexture;
        /* only used in TECH_OCEAN_CLOUD */
        asset_ptr<TextureEntity> m_pCloudTexture;
        /* only used in FILE_SUNSETGLOW */
        asset_ptr<TextureEntity> m_pSunsetTexture;
#ifdef USE_DIRECTX_RENDERER

        LPDIRECT3DVERTEXBUFFER9 m_pBaseBuffer;
        LPDIRECT3DINDEXBUFFER9 m_pIndexBuffer;
        
        LPDIRECT3DVERTEXBUFFER9 m_pAnimBuffer[k_total_water_meshes];
        LPDIRECT3DVERTEXBUFFER9 m_pTerrainHeightmapBuffer[k_total_terrain_meshes];
#endif

        int m_num_triangle;

        /*LPDIRECT3DVERTEXBUFFER9 m_quad_vb;
        LPDIRECT3DINDEXBUFFER9 m_quad_ib;*/

        int m_activeBuffer;

        sComplex* m_colH;

        sComplex* m_colN;

        sComplex* m_colH0;

        float* m_colAngularFreq;

        float getOceanHeight(int x, int y);
        float getOceanNormalX(int x, int y);
        float getOceanNormalY(int x, int y);

        float getKx(int x);
        float getKy(int y);
        float getAngularFrequency(float fKLength);

        int getIndexH0(int x, int y);
        int getIndex(int x, int y);
        int getIndexFFT(int x, int y);
        int getOffset(int x, int y);
        int getOffsetWrap(int x, int y);

        void FFT(sComplex* pCmpTable);
        void setOceanParameters( 
            unsigned long ulSeed, 
            float fWindDirection, 
            float fWindSpeed,
            float fWaveHeight, 
            float fDirectionalDependence, 
            float fSuppressSmallWavesFactor );
        float phillipsSpectrum( float fKx, float fKy );
#ifdef USE_DIRECTX_RENDERER

        void fillVertexBuffer(LPDIRECT3DVERTEXBUFFER9 pVertexBuffer);
#endif

        bool CreateStripGridIndexBuffer(
            int xVerts, // width of grid
            int yVerts, // height of grid
            int xStep,  // horz vertex count per cell
            int yStep,  // vert vertex count per cell
            int stride  // horz vertex count in vbuffer
            );

        /************************************************************************/
        /* The FFT computational stages                                         */
        /************************************************************************/
        void animateHeightTable();
        void animateNormalTable();
        void horizontalFFT(sComplex* pCmpTable );    
        void verticalFFT(sComplex* pCmpTable );

        // rendering techniques
        void RenderTechnique_Quad();
        int RenderTechnique_Simple(SceneState* pSceneState, float x0, float y0, float x1, float y1);
        int RenderTechnique_FFT_HIGH(SceneState* pSceneState, float x0, float y0, float x1, float y1);
        int RenderTechnique_Cloud(SceneState* pSceneState, float x0, float y0, float x1, float y1);
        
        int RenderTechnique_OccusionTest(SceneState* pSceneState, float x0, float y0, float x1, float y1);
        void RenderRipples(float fTimeDelta);

        void RenderUnderwaterEffect(SceneState* pSceneState);

        void CalculateTileToRender(SceneState* pSceneState, float& x0, float& y0, float& x1, float& y1);
    public:
        bool create();

        void CheckLoadOceanTextures(int nTechnique=0);

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

        void update(float fTimeDelta);

        bool UpdateReflectionTexture(SceneState & sceneState);

        void ForceUpdateOcean();

        void Render(SceneState* pSceneState);
        bool RenderReflectionTexture();
        
        enum OCEAN_RENDER_TECHNIQUE{
            OCEAN_TECH_QUAD=0,      // requires just software processing
            OCEAN_TECH_FFT,         // requires just vertex shader 1.1 and no pixel shader
            OCEAN_TECH_REFLECTION,  // requires shader and pixel shader version 3.0
            OCEAN_TECH_FULL,        // requires shader and pixel shader version 3.0
            OCEAN_TECH_SIMPLE,      // requires just vertex and pixel shader 2
            OCEAN_TECH_CLOUD,       // cloud rendering using layered texture. 
        };
        void SetRenderTechnique(DWORD dwTechnique);
        DWORD GetRenderTechnique();

        bool IsPointUnderWater(const Vector3& vPos);

        bool IsDrawShoreLine();
        void DrawShoreLine(bool bDraw);
        void CleanupTerrainCache();

        bool IsOceanVisible();
        
        bool IsAnimateFFT();
        void SetAnimateFFT(bool bEnable);

    friend class CSceneObject;

    private:
        bool m_useScreenSpaceFog;

        LinearColor m_CustomUnderWaterColor;
    public:
        void EnableScreenSpaceFog(bool value){
            m_useScreenSpaceFog = value;
        }
        bool IsScreenSpaceFog(){return m_useScreenSpaceFog;}
    };
}