2007-04-06 18:48:23 +00:00
using System ;
using System.Collections.Generic ;
using System.Text ;
2007-05-24 05:44:53 +00:00
using System.Drawing ;
2007-04-11 05:19:27 +00:00
using libTerrain ;
2007-04-06 18:48:23 +00:00
namespace OpenSim.Terrain
{
public class TerrainEngine
{
2007-04-07 17:30:11 +00:00
/// <summary>
/// A [normally] 256x256 heightmap
/// </summary>
2007-04-11 05:19:27 +00:00
public Channel heightmap ;
2007-04-21 07:46:33 +00:00
/// <summary>
/// Whether or not the terrain has been modified since it was last saved and sent to the Physics engine.
/// Counts the number of modifications since the last save. (0 = Untainted)
/// </summary>
2007-04-21 05:57:53 +00:00
public int tainted ;
2007-04-11 05:19:27 +00:00
2007-04-06 18:48:23 +00:00
int w , h ;
2007-04-07 17:30:11 +00:00
/// <summary>
/// Generate a new TerrainEngine instance and creates a new heightmap
/// </summary>
2007-04-06 18:48:23 +00:00
public TerrainEngine ( )
{
w = 256 ;
h = 256 ;
2007-04-11 05:19:27 +00:00
heightmap = new Channel ( w , h ) ;
2007-04-06 18:48:23 +00:00
2007-04-21 05:57:53 +00:00
tainted + + ;
2007-04-06 18:48:23 +00:00
}
2007-04-07 16:48:38 +00:00
/// <summary>
/// Converts the heightmap to a 65536 value 1D floating point array
/// </summary>
/// <returns>A float[65536] array containing the heightmap</returns>
2007-04-06 18:53:18 +00:00
public float [ ] getHeights1D ( )
{
2007-04-11 09:45:48 +00:00
float [ ] heights = new float [ w * h ] ;
2007-04-06 18:53:18 +00:00
int i ;
2007-04-11 09:45:48 +00:00
for ( i = 0 ; i < w * h ; i + + )
{
2007-04-11 05:19:27 +00:00
heights [ i ] = ( float ) heightmap . map [ i / w , i % w ] ;
}
2007-04-11 09:45:48 +00:00
2007-04-11 05:19:27 +00:00
return heights ;
}
2007-04-21 07:46:33 +00:00
/// <summary>
/// Converts the heightmap to a 256x256 value 2D floating point array.
/// </summary>
/// <returns>An array of 256,256 values containing the heightmap</returns>
2007-04-11 05:19:27 +00:00
public float [ , ] getHeights2D ( )
{
float [ , ] heights = new float [ w , h ] ;
int x , y ;
for ( x = 0 ; x < w ; x + + )
{
for ( y = 0 ; y < h ; y + + )
{
heights [ x , y ] = ( float ) heightmap . map [ x , y ] ;
}
2007-04-06 18:53:18 +00:00
}
return heights ;
}
2007-04-07 16:48:38 +00:00
/// <summary>
/// Imports a 1D floating point array into the 2D heightmap array
/// </summary>
/// <param name="heights">The array to import (must have 65536 members)</param>
2007-04-07 16:30:16 +00:00
public void setHeights1D ( float [ ] heights )
{
int i ;
for ( i = 0 ; i < w * h ; i + + )
{
2007-04-11 05:19:27 +00:00
heightmap . map [ i / w , i % w ] = heights [ i ] ;
}
2007-04-21 05:57:53 +00:00
tainted + + ;
2007-04-11 05:19:27 +00:00
}
2007-04-21 07:46:33 +00:00
/// <summary>
/// Loads a 2D array of values into the heightmap
/// </summary>
/// <param name="heights">An array of 256,256 float values</param>
2007-04-21 05:57:53 +00:00
public void setHeights2D ( float [ , ] heights )
2007-04-11 05:19:27 +00:00
{
int x , y ;
for ( x = 0 ; x < w ; x + + )
{
for ( y = 0 ; y < h ; y + + )
{
heightmap . set ( x , y , ( double ) heights [ x , y ] ) ;
}
2007-04-07 16:30:16 +00:00
}
2007-04-21 05:57:53 +00:00
tainted + + ;
2007-04-07 16:30:16 +00:00
}
2007-04-20 14:49:24 +00:00
2007-04-24 18:01:37 +00:00
/// <summary>
/// Processes a terrain-specific command
/// </summary>
2007-04-24 18:18:18 +00:00
/// <param name="args">Commandline arguments (space seperated)</param>
/// <param name="resultText">Reference that returns error or help text if returning false</param>
/// <returns>If the operation was successful (if not, the error is placed into resultText)</returns>
2007-04-24 18:01:37 +00:00
public bool RunTerrainCmd ( string [ ] args , ref string resultText )
{
string command = args [ 0 ] ;
2007-04-24 18:18:18 +00:00
try
{
switch ( command )
{
case "help" :
resultText + = "terrain regenerate - rebuilds the sims terrain using a default algorithm\n" ;
resultText + = "terrain seed <seed> - sets the random seed value to <seed>\n" ;
resultText + = "terrain load <type> <filename> - loads a terrain from disk, type can be 'F32', 'F64' or 'IMG'\n" ;
resultText + = "terrain save <type> <filename> - saves a terrain to disk, type can be 'F32' or 'F64'\n" ;
resultText + = "terrain rescale <min> <max> - rescales a terrain to be between <min> and <max> meters high\n" ;
resultText + = "terrain erode aerobic <windspeed> <pickupmin> <dropmin> <carry> <rounds> <lowest>\n" ;
resultText + = "terrain erode thermal <talus> <rounds> <carry>\n" ;
resultText + = "terrain multiply <val> - multiplies a terrain by <val>\n" ;
return false ;
case "seed" :
setSeed ( Convert . ToInt32 ( args [ 1 ] ) ) ;
break ;
case "erode" :
switch ( args [ 1 ] . ToLower ( ) )
{
case "aerobic" :
// WindSpeed, PickupMinimum,DropMinimum,Carry,Rounds,Lowest
heightmap . AerobicErosion ( Convert . ToDouble ( args [ 2 ] ) , Convert . ToDouble ( args [ 3 ] ) , Convert . ToDouble ( args [ 4 ] ) , Convert . ToDouble ( args [ 5 ] ) , Convert . ToInt32 ( args [ 6 ] ) , Convert . ToBoolean ( args [ 7 ] ) ) ;
break ;
case "thermal" :
heightmap . thermalWeathering ( Convert . ToDouble ( args [ 2 ] ) , Convert . ToInt32 ( args [ 3 ] ) , Convert . ToDouble ( args [ 4 ] ) ) ;
break ;
default :
resultText = "Unknown erosion type" ;
return false ;
}
break ;
case "regenerate" :
hills ( ) ;
break ;
case "rescale" :
setRange ( Convert . ToSingle ( args [ 1 ] ) , Convert . ToSingle ( args [ 2 ] ) ) ;
break ;
case "multiply" :
heightmap * = Convert . ToDouble ( args [ 1 ] ) ;
break ;
case "load" :
switch ( args [ 1 ] . ToLower ( ) )
{
case "f32" :
loadFromFileF32 ( args [ 2 ] ) ;
break ;
case "f64" :
loadFromFileF64 ( args [ 2 ] ) ;
break ;
case "img" :
resultText = "Error - IMG mode is presently unsupported." ;
return false ;
default :
resultText = "Unknown image or data format" ;
return false ;
}
break ;
case "save" :
switch ( args [ 1 ] . ToLower ( ) )
{
case "f32" :
writeToFileF32 ( args [ 2 ] ) ;
break ;
case "f64" :
writeToFileF64 ( args [ 2 ] ) ;
break ;
default :
resultText = "Unknown image or data format" ;
return false ;
}
break ;
default :
resultText = "Unknown terrain command" ;
return false ;
}
return true ;
}
catch ( Exception e )
2007-04-24 18:01:37 +00:00
{
2007-04-24 18:18:18 +00:00
resultText = "Error running terrain command: " + e . ToString ( ) ;
return false ;
2007-04-24 18:01:37 +00:00
}
}
2007-04-21 07:46:33 +00:00
/// <summary>
/// Renormalises the array between min and max
/// </summary>
/// <param name="min">Minimum value of the new array</param>
/// <param name="max">Maximum value of the new array</param>
2007-04-20 14:49:24 +00:00
public void setRange ( float min , float max )
{
heightmap . normalise ( ( double ) min , ( double ) max ) ;
2007-04-21 05:57:53 +00:00
tainted + + ;
2007-04-20 14:49:24 +00:00
}
2007-04-07 16:30:16 +00:00
2007-04-07 16:48:38 +00:00
/// <summary>
/// Loads a file consisting of 256x256 doubles and imports it as an array into the map.
/// </summary>
2007-04-11 05:19:27 +00:00
/// <remarks>TODO: Move this to libTerrain itself</remarks>
2007-04-07 16:48:38 +00:00
/// <param name="filename">The filename of the double array to import</param>
public void loadFromFileF64 ( string filename )
{
System . IO . FileInfo file = new System . IO . FileInfo ( filename ) ;
System . IO . FileStream s = file . Open ( System . IO . FileMode . Open , System . IO . FileAccess . Read ) ;
System . IO . BinaryReader bs = new System . IO . BinaryReader ( s ) ;
int x , y ;
for ( x = 0 ; x < w ; x + + )
{
for ( y = 0 ; y < h ; y + + )
{
2007-04-11 05:19:27 +00:00
heightmap . map [ x , y ] = bs . ReadDouble ( ) ;
2007-04-07 16:48:38 +00:00
}
}
2007-04-20 05:50:50 +00:00
bs . Close ( ) ;
s . Close ( ) ;
2007-04-21 05:57:53 +00:00
tainted + + ;
2007-04-07 16:48:38 +00:00
}
2007-04-20 05:39:01 +00:00
/// <summary>
/// Loads a file consisting of 256x256 floats and imports it as an array into the map.
/// </summary>
/// <remarks>TODO: Move this to libTerrain itself</remarks>
/// <param name="filename">The filename of the float array to import</param>
public void loadFromFileF32 ( string filename )
{
System . IO . FileInfo file = new System . IO . FileInfo ( filename ) ;
System . IO . FileStream s = file . Open ( System . IO . FileMode . Open , System . IO . FileAccess . Read ) ;
System . IO . BinaryReader bs = new System . IO . BinaryReader ( s ) ;
int x , y ;
for ( x = 0 ; x < w ; x + + )
{
for ( y = 0 ; y < h ; y + + )
{
heightmap . map [ x , y ] = ( double ) bs . ReadSingle ( ) ;
}
}
2007-04-20 05:50:50 +00:00
bs . Close ( ) ;
s . Close ( ) ;
2007-04-21 05:57:53 +00:00
tainted + + ;
2007-04-20 05:39:01 +00:00
}
2007-04-22 02:58:39 +00:00
/// <summary>
/// Writes the current terrain heightmap to disk, in the format of a 65536 entry double[] array.
/// </summary>
/// <param name="filename">The desired output filename</param>
2007-04-20 05:39:01 +00:00
public void writeToFileF64 ( string filename )
{
System . IO . FileInfo file = new System . IO . FileInfo ( filename ) ;
System . IO . FileStream s = file . Open ( System . IO . FileMode . CreateNew , System . IO . FileAccess . Write ) ;
System . IO . BinaryWriter bs = new System . IO . BinaryWriter ( s ) ;
int x , y ;
for ( x = 0 ; x < w ; x + + )
{
for ( y = 0 ; y < h ; y + + )
{
bs . Write ( heightmap . get ( x , y ) ) ;
}
}
2007-04-20 05:50:50 +00:00
bs . Close ( ) ;
s . Close ( ) ;
2007-04-20 05:39:01 +00:00
}
2007-04-22 02:58:39 +00:00
/// <summary>
/// Writes the current terrain heightmap to disk, in the format of a 65536 entry float[] array
/// </summary>
/// <param name="filename">The desired output filename</param>
2007-04-20 05:39:01 +00:00
public void writeToFileF32 ( string filename )
{
System . IO . FileInfo file = new System . IO . FileInfo ( filename ) ;
System . IO . FileStream s = file . Open ( System . IO . FileMode . CreateNew , System . IO . FileAccess . Write ) ;
System . IO . BinaryWriter bs = new System . IO . BinaryWriter ( s ) ;
int x , y ;
for ( x = 0 ; x < w ; x + + )
{
for ( y = 0 ; y < h ; y + + )
{
bs . Write ( ( float ) heightmap . get ( x , y ) ) ;
}
}
2007-04-20 05:50:50 +00:00
bs . Close ( ) ;
s . Close ( ) ;
2007-04-20 05:39:01 +00:00
}
2007-04-22 02:58:39 +00:00
/// <summary>
/// Sets the random seed to be used by procedural functions which involve random numbers.
/// </summary>
/// <param name="val">The desired seed</param>
2007-04-20 05:39:01 +00:00
public void setSeed ( int val )
{
heightmap . seed = val ;
}
2007-04-06 18:48:23 +00:00
/// <summary>
/// Raises land in a sphere around the specified coordinates
/// </summary>
/// <param name="rx">Center of the sphere on the X axis</param>
/// <param name="ry">Center of the sphere on the Y axis</param>
/// <param name="size">The radius of the sphere</param>
/// <param name="amount">Scale the height of the sphere by this amount (recommended 0..2)</param>
public void raise ( double rx , double ry , double size , double amount )
{
2007-04-11 05:19:27 +00:00
lock ( heightmap )
2007-04-06 18:48:23 +00:00
{
2007-04-11 05:19:27 +00:00
heightmap . raise ( rx , ry , size , amount ) ;
2007-04-06 18:48:23 +00:00
}
2007-04-21 05:57:53 +00:00
tainted + + ;
2007-04-06 18:48:23 +00:00
}
2007-04-07 17:30:11 +00:00
/// <summary>
/// Lowers the land in a sphere around the specified coordinates
/// </summary>
/// <param name="rx">The center of the sphere at the X axis</param>
/// <param name="ry">The center of the sphere at the Y axis</param>
/// <param name="size">The radius of the sphere in meters</param>
/// <param name="amount">Scale the height of the sphere by this amount (recommended 0..2)</param>
2007-04-06 18:48:23 +00:00
public void lower ( double rx , double ry , double size , double amount )
{
2007-04-11 05:19:27 +00:00
lock ( heightmap )
2007-04-06 18:48:23 +00:00
{
2007-04-11 05:19:27 +00:00
heightmap . lower ( rx , ry , size , amount ) ;
2007-04-06 18:48:23 +00:00
}
2007-04-21 05:57:53 +00:00
tainted + + ;
2007-04-06 18:48:23 +00:00
}
2007-04-07 17:30:11 +00:00
/// <summary>
/// Generates a simple set of hills in the shape of an island
/// </summary>
2007-04-06 18:48:23 +00:00
public void hills ( )
{
2007-04-11 05:19:27 +00:00
lock ( heightmap )
2007-04-06 18:48:23 +00:00
{
2007-04-11 05:19:27 +00:00
heightmap . hillsSpheres ( 200 , 20 , 40 , true , true , false ) ;
heightmap . normalise ( ) ;
heightmap * = 60.0 ; // Raise to 60m
2007-04-06 18:48:23 +00:00
}
2007-04-21 05:57:53 +00:00
tainted + + ;
2007-04-06 18:48:23 +00:00
}
2007-04-22 02:58:39 +00:00
/// <summary>
/// Multiplies the heightfield by val
/// </summary>
/// <param name="meep">The heightfield</param>
/// <param name="val">The multiplier</param>
/// <returns></returns>
2007-04-20 14:53:38 +00:00
public static TerrainEngine operator * ( TerrainEngine meep , Double val ) {
meep . heightmap * = val ;
2007-04-21 05:57:53 +00:00
meep . tainted + + ;
2007-04-20 14:53:38 +00:00
return meep ;
}
2007-04-22 02:58:39 +00:00
/// <summary>
/// Returns the height at the coordinates x,y
/// </summary>
/// <param name="x">X Coordinate</param>
/// <param name="y">Y Coordinate</param>
/// <returns></returns>
2007-04-11 05:19:27 +00:00
public float this [ int x , int y ]
{
get
{
return ( float ) heightmap . get ( x , y ) ;
}
set
{
2007-04-21 05:57:53 +00:00
tainted + + ;
2007-04-11 05:19:27 +00:00
heightmap . set ( x , y , ( double ) value ) ;
}
}
2007-05-24 05:44:53 +00:00
/// <summary>
/// Exports the current heightmap to a PNG file
/// </summary>
/// <param name="filename">The destination filename for the image</param>
/// <param name="gradientmap">A 1x*height* image which contains the colour gradient to export with. Must be at least 1x2 pixels, 1x256 or more is ideal.</param>
public void exportImage ( string filename , string gradientmap )
{
try
{
Bitmap gradientmapLd = new Bitmap ( gradientmap ) ;
int pallete = gradientmapLd . Width ;
Bitmap bmp = new Bitmap ( heightmap . w , heightmap . h ) ;
Color [ ] colours = new Color [ pallete ] ;
for ( int i = 0 ; i < pallete ; i + + )
{
colours [ i ] = gradientmapLd . GetPixel ( 1 , i ) ;
}
Channel copy = heightmap . copy ( ) ;
for ( int x = 0 ; x < copy . w ; x + + )
{
for ( int y = 0 ; y < copy . h ; y + + )
{
// 512 is the largest possible height before colours clamp
int colorindex = ( int ) ( Math . Max ( Math . Min ( 1.0 , copy . get ( x , y ) / 512.0 ) , 0.0 ) * pallete ) ;
bmp . SetPixel ( x , y , colours [ colorindex ] ) ;
}
}
bmp . Save ( filename , System . Drawing . Imaging . ImageFormat . Png ) ;
}
catch ( Exception e )
{
Console . WriteLine ( "Failed generating terrain map: " + e . ToString ( ) ) ;
}
}
2007-04-06 18:48:23 +00:00
}
}