ParaScriptingTerrain.h

//-----------------------------------------------------------------------------
// Copyright (C) 2004 - 2006 ParaEngine Dev Studio, All Rights Reserved.
// Date:    2005.12
// Description: API for terrain
//-----------------------------------------------------------------------------
#pragma once

#include "ParaScriptingCommon.h"
#include "ParaScriptingGlobal.h"
namespace ParaEngine{
    class CTerrainTile;
}

namespace ParaScripting
{
    using namespace std;
    using namespace ParaEngine;

    class PE_CORE_DECL ParaTerrain
    {
    public:
        ParaTerrain(void);
        ~ParaTerrain(void);
    public:
        static ParaAttributeObject GetAttributeObject();
        static void GetAttributeObject_(ParaAttributeObject& output);
        
        static ParaAttributeObject GetBlockAttributeObject();


        static int GetTextureCount(float x, float y);

        static void GetTexturesInCell(float x, float y, const object& out);

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

        static ParaAssetObject GetTexture(float x, float y, int nIndex);
        static void GetTexture__(ParaAssetObject* pOut, float x, float y, int nIndex);
        static bool ReplaceTexture(float x, float y, int nIndex, ParaAssetObject& TextureAsset);
        static bool ReplaceTexture_(float x, float y, int nIndex,  const object& sTextureAsset);

        static ParaAttributeObject GetAttributeObjectAt(float x, float y);
        static void GetAttributeObjectAt_(ParaAttributeObject& output, float x, float y);
        
        static float GetElevation(float x, float y);

        static DWORD GetRegionValue(const char* sLayerName, float x, float y);

        static DWORD GetRegionValue4(const char* sLayerName, float x, float y, const char* argb);

        static string GetTerrainOnloadScript(float x, float y);
        static const char * GetTerrainOnloadScript__(float x, float y);

        static string GetTerrainElevFile(float x, float y);
        static const char* GetTerrainElevFile__(float x, float y);
        
        
        static void SaveTerrain(bool bHeightMap, bool bTextures);

        static void ReloadTerrain(bool bHeightMap, bool bTextures);
        
        static void UpdateTerrain();
        static void UpdateTerrain1(bool bForceUpdate);

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

        static float GetVertexSpacing();

        // Terrain editor
        
        static void Paint(const char* detailTexture, float brushRadius, float brushIntensity, float maxIntensity, bool erase, float x, float y);
        static void Paint_(int nDetailTextureID, float brushRadius, float brushIntensity, float maxIntensity, bool erase, float x, float y);

        static void DigCircleFlat(float x, float y, float radius, float fFlatPercentage, float factor);

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

        static void RadialScale (float x, float y,  float scale_factor, float min_dist,float max_dist, float smooth_factor);

        /*
        *  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
        */
        static void GaussianHill (float x,float y,float radius,float hscale,float standard_deviation,float smooth_factor);
        
        static void Spherical ( float x,float y,float radius, float    offset);

        static void Roughen_Smooth (float x, float y, float radius,bool roughen, bool big_grid,float factor);

        static void Ramp(float x1, float y1, float x2, float y2, float radius, float borderpercentage, float factor);

        static void AddHeightField(float x, float y, const char* filename, int nSmoothPixels);

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

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

        static bool IsModified();

        static void SetContentModified(float x, float y, bool bIsModified);

        static void SetContentModified4(float x, float y, bool bIsModified, DWORD dwModifiedBits);

        static void SetAllLoadedModified(bool bIsModified, DWORD dwModifiedBits);
        

        //
        // global effect and light settings
        //

        static void EnableLighting(bool bEnable);

        //
        //Edit additional terrin data e.g walkable region,waypoint region
        //
        static void PaintTerrainData (float x,float y,float radius,unsigned int data,unsigned int dataMask,unsigned int bitOffset);

        static uint32 GetTerrainData (float x,float y,uint32 dataMask,byte bitOffset);

        static void SetVisibleDataMask(uint32 mask,byte bitOffset);


        //
        //Block terrain api
        //

        //call this function to start block world
        //params are camera position, if camera is attached to object then it should be attached object position
        static void EnterBlockWorld(float x,float y,float z);

        //call this when leave block world
        //this function will release most resource(buffer,cached data) used by block engine.
        static void LeaveBlockWorld();

        static bool IsInBlockWorld();

        static void SaveBlockWorld(bool saveToTemp);

        static void DeleteAllBlocks();

        //set block template
        //x,y,z should be positive value
        //templateId may contain two template values packed as template0 + (template1<<16)
        //use 0 to delete a block.
        static void SetBlockTemplateId(float x,float y,float z,uint16_t templateId);

        static void SetBlockTemplateIdByIdx(uint16_t x,uint16_t y,uint16_t z,uint32_t templateId);

        static uint32_t GetBlockTemplateId(float x,float y,float z);

        static uint32_t GetBlockTemplateIdByIdx(uint16_t x,uint16_t y,uint16_t z);

        //user data is used to store per instance data e.g
        //for two template block it means the blend factor of two template
        //for model object it means the facing and scale value
        //one can pack one or more value into a single uint32 value
        //and unpack them according to pre-defined rules according to block type
        static void SetBlockUserData(float x,float y,float z,uint32_t data);

        static void SetBlockUserDataByIdx(uint16_t x,uint16_t y,uint16_t z,uint32_t data);

        static uint32_t GetBlockUserData(float x,float y,float z);

        static uint32_t GetBlockUserDataByIdx(uint16_t x,uint16_t y,uint16_t z);
        
        //ray orignial should be positive value
        //ray direction should be normalized value
        //@return:
        //result["x"] = pickResult.X;
        //result["y"] = pickResult.Y;
        //result["z"] = pickResult.Z;
        //result["blockX"] = pickResult.BlockX;
        //result["blockY"] = pickResult.BlockY;
        //result["blockZ"] = pickResult.BlockZ;
        //result["side"] = pickResult.Side;
        //result["length"] = pickResult.Distance;
        //side value : 0 negativeX,1 positiveX,2 NZ,3 PZ,4 NY, 5PY
        //length > fMaxDistance when no collision detected
        static object Pick(float rayX,float rayY,float rayZ,float dirX,float dirY,float dirZ,float fMaxDistance,const object& result,uint32_t filter=0xffffffff);
        static object MousePick(float fMaxDistance,const object& result,uint32_t filter=0xffffffff);

        static bool RegisterBlockTemplate(uint16_t templateId,const object& params);

        static void SetTemplateTexture(uint16_t templateId,const char* fileName);

        static void SetBlockWorldYOffset(float offset);

        static object GetBlocksInRegion(int32_t startChunkX,int32_t startChunkY,int32_t startChunkZ,int32_t endChunkX,int32_t endChunkY,int32_t endChunkZ,
            uint32_t matchType,const object& result);

        //get visible chunk region
        //@return : world space chunk id {minX,minY,minZ,maxX,maxY,maxZ}
        static object GetVisibleChunkRegion(const object& result);

        static void SetBlockWorldSunIntensity(float value);

        static void SelectBlock(uint16_t x,uint16_t y,uint16_t z,bool isSelect);
        static void SelectBlock1(uint16_t x,uint16_t y,uint16_t z,bool isSelect, int nGroupID);

        static void DeselectAllBlock1(int nGroupID);

        static void DeselectAllBlock();
        

        //set damage block id
        //@param x,y,z :world space block id;
        static void SetDamagedBlock(uint16_t x,uint16_t y,uint16_t z);

        //set damage block degree
        //@param damageDegree: [0,1] 0 means undamaged block,1 full damaged block
        static void SetDamageDegree(float damagedDegree);

        static int FindFirstBlock(uint16_t x,uint16_t y,uint16_t z, uint16_t nSide = 4, uint32_t max_dist = 32, uint32_t attrFilter = 0xffffffff, int nCategoryID = -1);

        static int GetFirstBlock(uint16_t x,uint16_t y,uint16_t z, int nBlockId, uint16_t nSide = 4, uint32_t max_dist = 32);

        static int32_t GetChunkColumnTimeStamp(uint32_t chunkX, uint32_t chunkZ);

        static void SetChunkColumnTimeStamp(uint32_t chunkX, uint32_t chunkZ, uint32_t nTimeStamp);

        static const std::string& GetMapChunkData(uint32_t chunkX, uint32_t chunkZ, bool bIncludeInit, uint32_t verticalSectionFilter);

        static object ApplyMapChunkData(uint32_t chunkX, uint32_t chunkZ, uint32_t verticalSectionFilter, const std::string& chunkData, const object& out);

        static void GetBlockFullData(uint16_t x, uint16_t y, uint16_t z, uint16_t* pId, uint32_t* pUserData);

    };

}