GlobalTerrain.h

#pragma once
#include <vector>
#include <stdint.h>
#include "IAttributeFields.h"
#include "IObjectScriptingInterface.h"

namespace ParaEngine
{
    struct TextureEntity;
    class CShapeBox;
    class TTerrain;
    class CShapeAABB;
    class CShapeFrustum;
}
namespace ParaTerrain
{
    using namespace ParaEngine;
    class Terrain;
    class TerrainLattice;
    class CDynamicTerrainLoader;
    class Settings;

    class CGlobalTerrain : public IAttributeFields, IObjectScriptingInterface
    {
    public:
        CGlobalTerrain(void);
        virtual ~CGlobalTerrain(void);
    public:
        // implementation of IAttributeFields

        virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_CGlobalTerrain;}
        virtual const char* GetAttributeClassName(){static const char name[] = "CGlobalTerrain"; 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(CGlobalTerrain, IsModified_s, bool*)  {*p1 = cls->IsModified(); return S_OK;}

        ATTRIBUTE_METHOD1(CGlobalTerrain, TerrainRenderingEnabled_s, bool*) {*p1 = cls->TerrainRenderingEnabled(); return S_OK;}
        ATTRIBUTE_METHOD1(CGlobalTerrain, EnableTerrainRendering_s, bool)   {cls->EnableTerrainRendering(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CGlobalTerrain, IsTerrainEngineEnabled_s, bool*)  { *p1 = cls->IsTerrainEngineEnabled(); return S_OK; }
        ATTRIBUTE_METHOD1(CGlobalTerrain, EnableTerrainEngine_s, bool)  { cls->EnableTerrainEngine(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CGlobalTerrain, IsVerbose_s, bool*)   {*p1 = cls->IsVerbose(); return S_OK;}
        ATTRIBUTE_METHOD1(CGlobalTerrain, SetVerbose_s, bool)   {cls->SetVerbose(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CGlobalTerrain, IsEditor_s, bool*)    {*p1 = cls->IsEditor(); return S_OK;}
        ATTRIBUTE_METHOD1(CGlobalTerrain, SetEditor_s, bool)    {cls->SetEditor(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CGlobalTerrain, GetTessellateMethod_s, int*)  {*p1 = cls->GetTessellateMethod(); return S_OK;}
        ATTRIBUTE_METHOD1(CGlobalTerrain, SetTessellateMethod_s, int)   {cls->SetTessellateMethod(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CGlobalTerrain, UseNormals_s, bool*)  {*p1 = cls->UseNormals(); return S_OK;}
        ATTRIBUTE_METHOD1(CGlobalTerrain, SetUseNormals_s, bool)    {cls->SetUseNormals(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CGlobalTerrain, GetTextureMaskWidth_s, int*)  {*p1 = cls->GetTextureMaskWidth(); return S_OK;}
        ATTRIBUTE_METHOD1(CGlobalTerrain, SetTextureMaskWidth_s, int)   {cls->SetTextureMaskWidth(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CGlobalTerrain, GetDefaultHeight_s, float*)   { *p1 = cls->GetDefaultHeight(); return S_OK; }
        ATTRIBUTE_METHOD1(CGlobalTerrain, SetDefaultHeight_s, float)    { cls->SetDefaultHeight(p1); return S_OK; }

        ATTRIBUTE_METHOD1(CGlobalTerrain, IsGeoMipmapTerrain_s, bool*)  {*p1 =cls->IsGeoMipmapTerrain(); return S_OK;}
        ATTRIBUTE_METHOD1(CGlobalTerrain, SetGeoMipmapTerrain_s, bool)  {cls->SetGeoMipmapTerrain(p1); return S_OK;}
         
        ATTRIBUTE_METHOD1(CGlobalTerrain, IsEditorMode_s, bool*)    {*p1 =cls->IsEditorMode(); return S_OK;}
        ATTRIBUTE_METHOD1(CGlobalTerrain, SetEditorMode_s, bool)    {cls->SetEditorMode(p1); return S_OK;}
               
        ATTRIBUTE_METHOD1(CGlobalTerrain, IsSlopeCollision_s, bool*)    {*p1 =cls->IsSlopeCollision(); return S_OK;}
        ATTRIBUTE_METHOD1(CGlobalTerrain, SetSlopeCollision_s, bool)    {cls->SetSlopeCollision(p1); return S_OK;}

        ATTRIBUTE_METHOD1(CGlobalTerrain, SetBlockSelectionTexture_s, const char*)  {cls->SetBlockSelectionTexture(p1); return S_OK;}
        ATTRIBUTE_METHOD1(CGlobalTerrain, SetBlockDamageTexture_s, const char*) {cls->SetBlockDamageTexture(p1); return S_OK;}
    public:
        IAttributeFields* GetAttributeObjectAt(float x, float y);

        bool IsVerbose();
        void SetVerbose(bool bEnable);

        void SetEditor(bool isEditor);
        bool IsEditor();

        void SetTessellateMethod(int method);
        int GetTessellateMethod();

        void SetUseNormals(bool bUseNormals);
        bool UseNormals();
         
        
        void SetBlockDamageTexture(const char* textureName);
        void SetBlockSelectionTexture(const char* textureName);

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

        Settings* GetSettings();

        void GetBoundingBox(ParaEngine::CShapeBox * BBox);

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

        void SetCameraPosition(float x, float y);

        void Update(bool bForceUpdate=false);
        void Render();
        //void RenderAuto();

        float GetElevation(float x, float y);

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

        void SetVertexElevation(float x, float y,float fHeight);
        float GetVertexElevation(float x, float y);
        
        float GetLowestVisibleHeight();

        float IntersectRay(float startX, float startY, float startZ, float dirX, float dirY, float dirZ, float &intersectX, float &intersectY, float &intersectZ, float fMaxDistance = 999999999.0f);

        void GetNormal(float x, float y, float &normalX, float &normalY, float &normalZ);

        void CreateSingleTerrain(const char* sHeightmapfile, 
            float fTerrainSize, float fElevscale, int bSwapvertical, 
            const char*  sMainTextureFile, const char* sCommonTextureFile, 
            int nMaxBlockSize, float fDetailThreshold);
        void CreateTerrain(const char * sConfigFileName);

        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 Ramp(float x1, float y1, float x2, float y2, float radius, float borderpercentage=0.5f, float factor=1.0f);

        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 UpdateHoles(float x, float y);
        bool IsHole(float x, float y);
        void SetHole(float x, float y, bool bIsHold);

        string GetOnloadScript(float x, float y);

        void SetContentModified(float x, float y, bool bIsModified = true, DWORD dwModifiedBits=16);

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

        string GetTerrainElevFile(float x, float y);
        void SaveTerrain(bool bHeightMap, bool bTextures);

        bool IsModified();

        void EnableLighting(bool bEnable);

        bool IsTerrainEngineEnabled() const;
        void EnableTerrainEngine(bool val);

        bool TerrainRenderingEnabled();

        void EnableTerrainRendering(bool bEnable);

        bool GetHeightmapOf(float fCenterX, float fCenterY, float fSize, TTerrain* pOut);

        bool SetHeightmapOf(float fCenterX, float fCenterY, float fSize, TTerrain* pIn);

        void SnapPointToVertexGrid(float x, float y, float* vertex_x, float* vertex_y);

        float GetVertexSpacing() const;

        int GetTextureCount(float x, float y);

        void GetTexturesInCell(float x, float y, std::vector<int>& indices);

        bool RemoveTextureInCell(float x, float y, int nIndex);

        TextureEntity* GetTexture(float x, float y, int nIndex);
        bool ReplaceTexture(float x, float y, int nIndex, TextureEntity* TextureAsset);

        Terrain * GetTerrainAtPoint(float x,float y);

        int GetMaxTileCacheSize();

        void SetMaxTileCacheSize(int nNum);

        void SetEnablePathEncoding(bool bEnable){ m_bEnablePathEncoding = bEnable;}

        bool GetEnablePathEncoding(){ return  m_bEnablePathEncoding;}

        void SetTextureMaskWidth(int nWidth);
        int GetTextureMaskWidth();

        void SwitheTerrainLodStyle(bool useGeoMipmap);
        
        float GetDefaultHeight() const;
        void SetDefaultHeight(float val);

    private:
        void ModelViewMatrixChanged();
    private:
        float           m_fDefaultHeight;
        Terrain*        m_pTerrainSingle;
        TerrainLattice* m_pTerrainLattice;
        CDynamicTerrainLoader* m_pTerrainLoader;
        enum Terrain_type{
            SINGLE_TERRAIN,
            LATTICED_TERRAIN
        } m_nTerrainType;
        
        bool    m_bRenderTerrain;
        bool    m_bEnableTerrainEngine;
        
        bool    m_bEnablePathEncoding;

        //GeoMipmapCode 
        bool m_useGeoMipmap;
        bool m_enableSlopeCollision;
        bool m_isEditorMode;
        bool m_isSlopeMeshVisible;
        bool m_isWaypointRegionVisible;
        
        Vector3     m_matTerrainEye;
        Vector3     m_vTerrainRenderOffset;
        
    public:
        static const float g_fTerrainInvisibleHeight;

        const Vector3& GetMatTerrainEye() const;
        const Vector3& GetTerrainRenderOffset() const;

        //this function must be called before CreateTerrain,we don't support change
        //terrain rendering style at runtime -.-    --clayman 2012.2.21

        void SetGeoMipmapTerrain(bool enable);

        bool IsGeoMipmapTerrain()
        {
            return m_useGeoMipmap;
        }

        void SetEditorMode(bool enable);

        bool IsEditorMode()
        {
            return m_isEditorMode;
        }

        void SetSlopeCollision(bool enable)
        {
            m_enableSlopeCollision = enable;
        }

        bool IsSlopeCollision()
        {
            return m_enableSlopeCollision;
        }

        void SetSlopeMeshVisible(bool);

        bool IsSlopeMeshVisible()
        {
            return m_isSlopeMeshVisible;
        }

        void SetWaypointRegionVisible(bool enable);

        bool IsWaypointRegionVisible()
        {
            return m_isWaypointRegionVisible;
        }
            
        void PaintTerrainData(float x,float y,float radius,unsigned int data,unsigned int dataMask,unsigned int bitOffset);

        uint32 GetTerrainData(float x,float y,uint32 dataMask,uint8 bitOffset);

        void SetVisibleDataMask(uint32 mask,uint8 bitOffset);

        bool IsWalkable(float x,float y, Vector3& oNormal) const;

    };

}