TerrainLattice.h

#pragma once
#include "IAttributeFields.h"
#include "TerrainLoadListener.h"
#include "TextureSet.h"
#include "TextureFactory.h"
#include "TTerrain.h"
#include "TerrainGeoMipmapIndices.h"

namespace ParaEngine
{
    struct TextureEntity;
    class TTerrain;
    class CShapeAABB;
    class CShapeFrustum;
}
namespace ParaTerrain
{
    class TerrainLatticeLoader
    {
    public:
        virtual Terrain * LoadTerrainAt(Terrain *pTerrain, int latticeX, int latticeY, bool useGeoMipmap = false) = 0;
        virtual void UnloadTerrain(int latticeX, int latticeY, Terrain * pTerrain) = 0;
        virtual float GetTerrainWidth() = 0;
        virtual float GetTerrainHeight() = 0;

        virtual bool UpdateTileConfigFile(int x, int y, const string& sTileConfigFile) = 0;

        virtual bool SaveWorldConfigFile() = 0;
    };


    class TerrainLattice : public IAttributeFields
    {
    public:
        typedef map<int, TerrainTileCacheItem> TerrainTileCacheMap_type;
        TerrainLattice(TerrainLatticeLoader * pLoader, bool useGeoMipmap = false);
        virtual ~TerrainLattice();

        ATTRIBUTE_DEFINE_CLASS(TerrainLattice);

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

        void Load(char *szBaseName, int maxNumTriangles, int maxBlockSize, float commonRepeats);
        void SetTileSize(float fTileSize);
        Terrain *GetTerrain(int positionX, int positionY);
        Terrain *GetTerrainAtPoint(float x, float y);
        void SetCameraPosition(float x, float y, float z);
        void ModelViewMatrixChanged();
        void Render();
        float GetElevation(float x, float y);

        DWORD GetRegionValue(const string& sLayerName, float x, float y);

        void GetNormal(float x, float y, float &normalX, float &normalY, float &normalZ);
        float IntersectRay(float startX, float startY, float startZ, float dirX, float dirY, float dirZ, float &intersectX, float &intersectY, float &intersectZ, float fMaxDistance = INFINITY);

        void  SetLowestVisibleHeight(float fHeight);
        float GetLowestVisibleHeight();

        void Paint(ParaEngine::TextureEntity* detailTexture, float brushRadius, float brushIntensity, float maxIntensity, bool erase, float x, float y);

        void Flatten(float x, float y, float radius, int flatten_op, float elevation, float factor);

        void DigCircleFlat(float x, float y, float radius, float fFlatPercentage = 0.7f, float factor = 0.5f);

        /*
        *  This creates a Gaussian hill at the specified location with the specified parameters.
        *  it actually adds the hill to the original terrain surface.
        *  Here ElevNew(x,y) =
        |(x,y)-(center_x,center_y)| < radius*smooth_factor, ElevOld(x,y)+hscale*exp(-[(x-center_x)^2+(y-center_y)^2]/(2*standard_deviation^2) ),
        |(x,y)-(center_x,center_y)| > radius*smooth_factor, minimize hill effect.
        * @param center_x: the center of the affected circle. value in the range [0,1]
        * @param center_y: the center of the affected circle.value in the range [0,1]
        * @param radius: the radius of the affected circle.value in the range [0,0.5]
        * @param hscale: scale factor. One can think of it as the maximum height of the Gaussian Hill. this value can be negative
        * @param standard_deviation: standard deviation of the unit height value. should be in the range (0,1).
        *  0.1 is common value. larger than that will just make a flat hill with smoothing.
        * @param smooth_factor: value is between [0,1]. 1 means fully transformed; 0 means nothing is changed
        */
        void GaussianHill(float x, float y, float radius, float hscale, float standard_deviation = 0.1f, float smooth_factor = 0.5f);

        void Spherical(float x, float y, float radius, float    offset);

        void RadialScale(float x, float y, float scale_factor, float min_dist, float max_dist, float smooth_factor = 0.5f, int frequency = 1);

        void Roughen_Smooth(float x, float y, float radius, bool roughen = false, bool big_grid = false, float factor = 0.5f);

        void AddHeightField(float x, float y, const char* filename, int nSmoothPixels = 7);
        void MergeHeightField(float x, float y, const char* filename, int mergeOperation = 0, float weight1 = 1.0, float weight2 = 1.0, int nSmoothPixels = 7);

        void Ramp(float x1, float y1, float x2, float y2, float radius, float borderpercentage = 0.5f, float factor = 1.0f);

        void UpdateHoles(float x, float y);
        bool IsHole(float x, float y);
        void SetHole(float x, float y, bool bIsHold);

        void InitDeviceObjects();
        void DeleteDeviceObjects();
        void InvalidateDeviceObjects();

        float GetVertexElevation(float x, float y);
        void SetVertexElevation(float x, float y, float newElevation, bool recalculate_geometry = true);

        float GetVertexSpacing() const;
        bool SnapPointToVertexGrid(float& x, float& y);

        int GetMaxTileCacheSize();

        void SetMaxTileCacheSize(int nNum);

        void ResizeTextureMaskWidth(int nWidth);

        void SetGlobalConfigModified(bool bEnable = true);
    private:
        bool  Copy_Rect_to_HeightField(ParaEngine::TTerrain* pHeightField, float x, float y, float fRadius, bool bNormalize = true);
        bool  Apply_HeightField_to_Rect(ParaEngine::TTerrain* pHeightField, float x, float y, bool bRecalculateGeometry, bool bRecoverHeightData = true);
        void  RecalculateTerrainGeometry(float x, float y, float fRadius);

        void Tessellate();
        Terrain * CreateTerrainTile(int positionX, int positionY);
        ParaTerrain::DIRECTION GetOppositeDirection(ParaTerrain::DIRECTION direction);
        Terrain *GetTerrainRelative(Terrain * pTerrain, int positionX, int positionY);
        Terrain *GetTerrainRelative(Terrain * pTerrain, ParaTerrain::DIRECTION direction);
        Terrain *LoadTerrain(int index);
        TerrainLatticeLoader *m_pLoader;
        //int m_WidthTerrains, m_HeightTerrains;
        int m_WidthActiveTerrains, m_HeightActiveTerrains;
        float m_TerrainWidth, m_TerrainHeight;
        float m_fLowestVisibleHeight;

        TerrainTileCacheMap_type m_pCachedTerrains;
        int m_nMaxCacheSize;

        int m_CurrentTerrainIndex[9];

        CShapeBox       m_BoundingBox;
        bool m_bIsGlobalConfigModified;
    public:
        const CShapeBox& GetBoundingBox() const;
        void GetBoundingBoxes(vector<ParaEngine::CShapeAABB>& boxes, const Matrix4* modelView, const ParaEngine::CShapeFrustum& frustum, int nMaxBoxesNum = 1024, int nSmallestBoxStride = 4);

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

        void SetAllLoadedModified(bool bIsModified = true, DWORD dwModifiedBits = 16);

        void SaveTerrain(bool bHeightMap, bool bTextures);
        bool IsModified();

    public:
        bool m_useGeoMipmap;
        void SwitchLodStyle(bool useGeoMipmap);
        bool IsWalkable(float x, float y, Vector3& oNormal);
        void SetTerrainInfo(float x, float y, float radius, uint32 data, uint32 bitMask, uint32 bitOffset);
        uint32 GetTerrainInfo(float x, float y, uint32 bitMask, uint32 bitOffset);
        void SetEditorMode(bool enable);
        void SetVisibleDataMask(uint32 mask, uint8 bitOffset);
    private:
        ParaIndexBuffer m_pIndices;
        
        GeoMipmapIndicesGroup m_geoMipmapIndices;
        int m_terrainBlockXCount;
        float m_camPosX;
        float m_camPosY;
        int m_Level0ChunkCount;;
        int m_Level1ChunkCount;

        void CreateGeoMipmapIndexBuffer();
        void GetIndexInfo(int level, GeoMipmapChunkType type);
        void CalcGeoMipmapLod(float camX, float camY);
        int CalcBlockLod(int* lodBounds, int blockIndexX, int blockIndexY, int maxLod);

        void SetVertexInfo(float x, float y, uint32 data, uint32 bitMask, uint32 bitOffset);
    };
}