OpenSim
/
OpenSimMirror
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* Removing old libTerrainBSD and associated Plugin & Project. 

* Updated prebuild.xml accordingly.
0.6.0-stable
Adam Frisby 2008-04-23 10:55:04 +00:00
parent 2de6d09d74
commit 7c897043ba
29 changed files with 0 additions and 5188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
OpenSim/Region/Terrain.BasicTerrain/Properties/AssemblyInfo.cs
View File

@ -1,65 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System.Reflection;
using System.Runtime.InteropServices;
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly : AssemblyTitle("OpenSim.Region.Terrain.BasicTerrain")]
[assembly : AssemblyDescription("")]
[assembly : AssemblyConfiguration("")]
[assembly : AssemblyCompany("")]
[assembly : AssemblyProduct("OpenSim.Region.Terrain.BasicTerrain")]
[assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers 2007-2008")]
[assembly : AssemblyTrademark("")]
[assembly : AssemblyCulture("")]
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
[assembly : ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly : Guid("3263f5b5-0a41-4ed5-91a2-9baaaeecc849")]
// Version information for an assembly consists of the following four values:
//
// Major Version
// Minor Version
// Build Number
// Revision
//
// You can specify all the values or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly : AssemblyVersion("1.0.0.0")]
[assembly : AssemblyFileVersion("1.0.0.0")]

1451
OpenSim/Region/Terrain.BasicTerrain/TerrainEngine.cs
View File

File diff suppressed because it is too large Load Diff

125
OpenSim/Region/Terrain.BasicTerrain/TerrainFilter.cs
View File

@ -1,125 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using libTerrain;
using Microsoft.CSharp;
using Microsoft.JScript;
namespace OpenSim.Region.Terrain
{
public interface ITerrainFilter
{
void Filter(Channel heightmap, string[] args);
string Register();
string Help();
}
public class TestFilter : ITerrainFilter
{
public void Filter(Channel heightmap, string[] args)
{
Console.WriteLine("Hello world");
}
public string Register()
{
return "demofilter";
}
public string Help()
{
return "demofilter - Does nothing";
}
}
public class FilterHost
{
public Dictionary<string, ITerrainFilter> filters = new Dictionary<string, ITerrainFilter>();
private void LoadFilter(CodeDomProvider compiler, string filename)
{
CompilerParameters compilerParams = new CompilerParameters();
CompilerResults compilerResults;
compilerParams.GenerateExecutable = false;
compilerParams.GenerateInMemory = true;
compilerParams.IncludeDebugInformation = false;
compilerParams.ReferencedAssemblies.Add("OpenSim.Terrain.BasicTerrain.dll");
compilerParams.ReferencedAssemblies.Add("System.dll");
compilerResults = compiler.CompileAssemblyFromFile(compilerParams, filename);
if (compilerResults.Errors.Count > 0)
{
Console.WriteLine("Compile errors:");
foreach (CompilerError error in compilerResults.Errors)
{
Console.WriteLine(error.Line.ToString() + ": " + error.ErrorText.ToString());
}
}
else
{
foreach (Type pluginType in compilerResults.CompiledAssembly.GetExportedTypes())
{
Type testInterface = pluginType.GetInterface("ITerrainFilter", true);
if (testInterface != null)
{
ITerrainFilter filter =
(ITerrainFilter) compilerResults.CompiledAssembly.CreateInstance(pluginType.ToString());
string filterName = filter.Register();
Console.WriteLine("Plugin: " + filterName + " loaded.");
if (!filters.ContainsKey(filterName))
{
filters.Add(filterName, filter);
}
else
{
filters[filterName] = filter;
}
}
}
}
}
public void LoadFilterCSharp(string filename)
{
CSharpCodeProvider compiler = new CSharpCodeProvider();
LoadFilter(compiler, filename);
}
public void LoadFilterJScript(string filename)
{
JScriptCodeProvider compiler = new JScriptCodeProvider();
LoadFilter(compiler, filename);
}
}
}

85
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Bitmap/Bitmap.cs
View File

@ -1,85 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System.Drawing;
using System.Drawing.Imaging;
namespace libTerrain
{
internal class Raster
{
private Bitmap bmp;
/// <summary>
/// Creates a new Raster channel for use with bitmap or GDI functions
/// </summary>
/// <param name="width">Width in pixels</param>
/// <param name="height">Height in pixels</param>
public Raster(int width, int height)
{
bmp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
}
/// <summary>
/// Converts a raster image to a channel by averaging the RGB values to a single 0..1 heightmap
/// </summary>
/// <returns>A libTerrain Channel</returns>
public Channel ToChannel()
{
Channel chan = new Channel(bmp.Width, bmp.Height);
int x, y;
for (x = 0; x < bmp.Width; x++)
{
for (y = 0; y < bmp.Height; y++)
{
Color val = bmp.GetPixel(x, y);
chan.map[x, y] = (((double) val.R + (double) val.G + (double) val.B)/3.0)/255.0;
}
}
return chan;
}
/// <summary>
/// Draws a piece of text into the specified raster
/// </summary>
/// <param name="txt">The text string to print</param>
/// <param name="font">The font to use to draw the specified image</param>
/// <param name="size">Font size (points) to use</param>
public void DrawText(string txt, string font, double size)
{
Rectangle area = new Rectangle(0, 0, 256, 256);
StringFormat sf = new StringFormat();
sf.Alignment = StringAlignment.Center;
sf.LineAlignment = StringAlignment.Center;
Graphics gd = Graphics.FromImage(bmp);
gd.DrawString(txt, new Font(font, (float) size), new SolidBrush(Color.White), area, sf);
}
}
}

59
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Channel.cs
View File

@ -1,59 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* Channel
* A channel is a single heightmap array
* */
namespace libTerrain
{
partial class Channel
{
public double[,] map;
public int[,] diff;
public int w;
public int h;
public int seed = 1338; // One better than 1337
public Channel()
{
w = 256;
h = 256;
map = new double[w,h];
diff = new int[(int) (w/16),(int) (h/16)];
}
public Channel(int width, int height)
{
w = width;
h = height;
map = new double[w,h];
diff = new int[(int) (w/16),(int) (h/16)];
}
}
}

281
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Common.cs
View File

@ -1,281 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
namespace libTerrain
{
public partial class Channel
{
public int GetWidth()
{
return w;
}
public int GetHeight()
{
return h;
}
public Channel Copy()
{
Channel x = new Channel(w, h);
x.map = (double[,]) map.Clone();
return x;
}
public void SetDiff()
{
SetDiff(1);
}
public void SetDiff(int val)
{
for (int x = 0; x < w/16; x++)
{
for (int y = 0; y < h/16; y++)
{
diff[x, y] = val;
}
}
}
public void SetDiff(int x, int y)
{
diff[x/16, y/16]++;
}
public void Set(int x, int y, double val)
{
if (x >= w)
throw new Exception("Bounds error while setting pixel (width)");
if (y >= h)
throw new Exception("Bounds error while setting pixel (height)");
if (x < 0)
throw new Exception("Bounds error while setting pixel (width)");
if (y < 0)
throw new Exception("Bounds error while setting pixel (height)");
if (map[x, y] != val)
{
SetDiff(x, y);
map[x, y] = val;
}
}
public void SetClip(int x, int y, double val)
{
SetDiff(x, y);
if (x >= w)
throw new Exception("Bounds error while setting pixel (width)");
if (y >= h)
throw new Exception("Bounds error while setting pixel (height)");
if (x < 0)
throw new Exception("Bounds error while setting pixel (width)");
if (y < 0)
throw new Exception("Bounds error while setting pixel (height)");
if (val > 1.0)
val = 1.0;
if (val < 0.0)
val = 0.0;
map[x, y] = val;
}
private double GetBilinearInterpolate(double x, double y)
{
if (x > w - 2.0)
x = w - 2.0;
if (y > h - 2.0)
y = h - 2.0;
if (x < 0.0)
x = 0.0;
if (y < 0.0)
y = 0.0;
int stepSize = 1;
double h00 = Get((int) x, (int) y);
double h10 = Get((int) x + stepSize, (int) y);
double h01 = Get((int) x, (int) y + stepSize);
double h11 = Get((int) x + stepSize, (int) y + stepSize);
double h1 = h00;
double h2 = h10;
double h3 = h01;
double h4 = h11;
double a00 = h1;
double a10 = h2 - h1;
double a01 = h3 - h1;
double a11 = h1 - h2 - h3 + h4;
double partialx = x - (int) x;
double partialz = y - (int) y;
double hi = a00 + (a10*partialx) + (a01*partialz) + (a11*partialx*partialz);
return hi;
}
public double Get(int x, int y)
{
try
{
return map[x, y];
}
catch (IndexOutOfRangeException)
{
if (x >= w)
x = w - 1;
if (y >= h)
y = h - 1;
if (x < 0)
x = 0;
if (y < 0)
y = 0;
return map[x, y];
}
}
public void SetWrap(int x, int y, double val)
{
SetDiff(x, y);
map[x%w, y%h] = val;
}
public void SetWrapClip(int x, int y, double val)
{
SetDiff(x, y);
if (val > 1.0)
val = 1.0;
if (val < 0.0)
val = 0.0;
map[x%w, y%h] = val;
}
public void Fill(double val)
{
SetDiff();
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
map[x, y] = val;
}
}
}
public void Fill(double min, double max, double val)
{
SetDiff();
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
if (map[x, y] >= min && map[x, y] <= max)
map[x, y] = val;
}
}
}
public double FindMax()
{
int x, y;
double max = double.MinValue;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
if (map[x, y] > max)
max = map[x, y];
}
}
return max;
}
public double FindMin()
{
int x, y;
double min = double.MaxValue;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
if (map[x, y] < min)
min = map[x, y];
}
}
return min;
}
public double Sum()
{
int x, y;
double sum = 0.0;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
sum += map[x, y];
}
}
return sum;
}
public double Avg()
{
return Sum()/(w*h);
}
public bool ContainsNaN()
{
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
double elm = map[x, y];
if (Double.IsNaN(elm))
return true;
}
}
return false;
}
}
}

141
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Editing/Flatten.cs
View File

@ -1,141 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
namespace libTerrain
{
partial class Channel
{
/// <summary>
/// Flattens the area underneath rx,ry by moving it to the average of the area. Uses a spherical mask provided by the raise() function.
/// </summary>
/// <param name="rx">The X coordinate of the terrain mask</param>
/// <param name="ry">The Y coordinate of the terrain mask</param>
/// <param name="size">The size of the terrain mask</param>
/// <param name="amount">The scale of the terrain mask</param>
public void Flatten(double rx, double ry, double size, double amount)
{
FlattenSlow(rx, ry, size, amount);
}
private void FlattenSlow(double rx, double ry, double size, double amount)
{
// Generate the mask
Channel temp = new Channel(w, h);
temp.Fill(0);
temp.Raise(rx, ry, size, amount);
temp.Normalise();
double total_mod = temp.Sum();
// Establish the average height under the area
Channel newmap = new Channel(w, h);
newmap.map = (double[,]) map.Clone();
newmap *= temp;
double total_terrain = newmap.Sum();
double avg_height = total_terrain/total_mod;
// Create a flat terrain using the average height
Channel flat = new Channel(w, h);
flat.Fill(avg_height);
// Blend the current terrain with the average height terrain
// using the "raised" empty terrain as a mask
Blend(flat, temp);
}
// TODO: unused
// private void FlattenFast(double rx, double ry, double size, double amount)
// {
// int x, y;
// double avg = 0;
// double div = 0;
// int minX = Math.Max(0, (int) (rx - (size + 1)));
// int maxX = Math.Min(w, (int) (rx + (size + 1)));
// int minY = Math.Max(0, (int) (ry - (size + 1)));
// int maxY = Math.Min(h, (int) (ry + (size + 1)));
// for (x = minX; x < maxX; x++)
// {
// for (y = minY; y < maxY; y++)
// {
// double z = size;
// z *= z;
// z -= ((x - rx)*(x - rx)) + ((y - ry)*(y - ry));
// if (z < 0)
// z = 0;
// avg += z*amount;
// div += z;
// }
// }
// double height = avg/div;
// for (x = minX; x < maxX; x++)
// {
// for (y = minY; y < maxY; y++)
// {
// double z = size;
// z *= z;
// z -= ((x - rx)*(x - rx)) + ((y - ry)*(y - ry));
// if (z > 0.0)
// Set(x, y, Tools.LinearInterpolate(map[x, y], height, z));
// }
// }
// }
public void Flatten(Channel mask, double amount)
{
// Generate the mask
Channel temp = mask*amount;
temp.Clip(0, 1); // Cut off out-of-bounds values
double total_mod = temp.Sum();
// Establish the average height under the area
Channel map = new Channel(w, h);
map.map = (double[,]) this.map.Clone();
map *= temp;
double total_terrain = map.Sum();
double avg_height = total_terrain/total_mod;
// Create a flat terrain using the average height
Channel flat = new Channel(w, h);
flat.Fill(avg_height);
// Blend the current terrain with the average height terrain
// using the "raised" empty terrain as a mask
Blend(flat, temp);
}
}
}

191
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Editing/Raise.cs
View File

@ -1,191 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
namespace libTerrain
{
partial class Channel
{
/// <summary>
/// Raises land around the selection
/// </summary>
/// <param name="rx">The center the X coordinate of where you wish to raise the land</param>
/// <param name="ry">The center the Y coordinate of where you wish to raise the land</param>
/// <param name="size">The radius of the dimple</param>
/// <param name="amount">How much impact to add to the terrain (0..2 usually)</param>
public void Raise(double rx, double ry, double size, double amount)
{
RaiseSphere(rx, ry, size, amount);
}
/// <summary>
/// Raises land in a sphere around the selection
/// </summary>
/// <param name="rx">The center the X coordinate of where you wish to raise the land</param>
/// <param name="ry">The center the Y coordinate of where you wish to raise the land</param>
/// <param name="size">The radius of the sphere dimple</param>
/// <param name="amount">How much impact to add to the terrain (0..2 usually)</param>
public void RaiseSphere(double rx, double ry, double size, double amount)
{
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
double z = size;
z *= z;
z -= ((x - rx)*(x - rx)) + ((y - ry)*(y - ry));
if (z > 0.0)
Set(x, y, map[x, y] + (z * amount));
}
}
}
/// <summary>
/// Raises land in a cone around the selection
/// </summary>
/// <param name="rx">The center the X coordinate of where you wish to raise the land</param>
/// <param name="ry">The center the Y coordinate of where you wish to raise the land</param>
/// <param name="size">The radius of the cone</param>
/// <param name="amount">How much impact to add to the terrain (0..2 usually)</param>
public void RaiseCone(double rx, double ry, double size, double amount)
{
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
double z = size;
z -= Math.Sqrt(((x - rx)*(x - rx)) + ((y - ry)*(y - ry)));
if (z > 0.0)
Set(x, y, map[x, y] + (z * amount));
}
}
}
/// <summary>
/// Lowers land in a sphere around the selection
/// </summary>
/// <param name="rx">The center the X coordinate of where you wish to lower the land</param>
/// <param name="ry">The center the Y coordinate of where you wish to lower the land</param>
/// <param name="size">The radius of the sphere dimple</param>
/// <param name="amount">How much impact to remove from the terrain (0..2 usually)</param>
public void Lower(double rx, double ry, double size, double amount)
{
LowerSphere(rx, ry, size, amount);
}
/// <summary>
/// Lowers land in a sphere around the selection
/// </summary>
/// <param name="rx">The center the X coordinate of where you wish to lower the land</param>
/// <param name="ry">The center the Y coordinate of where you wish to lower the land</param>
/// <param name="size">The radius of the sphere dimple</param>
/// <param name="amount">How much impact to remove from the terrain (0..2 usually)</param>
public void LowerSphere(double rx, double ry, double size, double amount)
{
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
double z = size;
z *= z;
z -= ((x - rx)*(x - rx)) + ((y - ry)*(y - ry));
if (z > 0.0)
Set(x, y, map[x, y] - (z * amount));
}
}
}
public double SphericalFactor(double x, double y, double rx, double ry, double size)
{
double z = size * size - ((x - rx) * (x - rx) + (y - ry) * (y - ry));
return z;
}
public void SmoothRegion(double rx, double ry, double size, double amount)
{
int x, y;
double[,] tweak = new double[w, h];
double n, l;
double area = size;
double step = size / 4.0;
// compute delta map
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
double z = SphericalFactor(x, y, rx, ry, size);
if (z > 0) // add in non-zero amount
{
double average = 0.0;
int avgsteps = 0;
for (n = 0.0 - area; n < area; n += step)
{
for (l = 0.0 - area; l < area; l += step)
{
avgsteps++;
average += GetBilinearInterpolate(x + n, y + l);
}
}
tweak[x, y] = average / avgsteps;
//if (x == rx && y == ry)
// Console.WriteLine("tweak[ " + x + " , " + y + " ] = " + tweak[x, y]);
}
}
}
// blend in map
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
double z = SphericalFactor(x, y, rx, ry, size);
if (z > 0) // add in non-zero amount
{
double da = z * amount;
double a = (map[x, y] - tweak[x, y]) * da;
double newz = map[x, y] - a;
//if (rx == x || ry == y)
// Console.WriteLine("map[ " + x + " , " + y + " ] = " + map[x, y] + " tweak, a , da, z, size, amount = " + tweak[x, y] + " " + a + " " + da + " " + z + " " + size + " " + amount);
if (newz > 0.0)
Set(x, y, newz);
}
}
}
}
}
}

75
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/File.cs
View File

@ -1,75 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Drawing;
using System.Drawing.Imaging;
namespace libTerrain
{
partial class Channel
{
public Channel LoadImage(string filename)
{
SetDiff();
Bitmap bit = new Bitmap(filename);
Channel chan = new Channel(bit.Width, bit.Height);
int x, y;
for (x = 0; x < bit.Width; x++)
{
for (y = 0; y < bit.Height; y++)
{
Color val = bit.GetPixel(x, y);
chan.map[x, y] = (((double) val.R + (double) val.G + (double) val.B)/3.0)/255.0;
}
}
return chan;
}
public void SaveImage(string filename)
{
Channel outmap = Copy();
outmap.Normalise();
Bitmap bit = new Bitmap(w, h, PixelFormat.Format24bppRgb);
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
int val = Math.Min(255, (int) (outmap.map[x, y]*255));
Color col = Color.FromArgb(val, val, val);
bit.SetPixel(x, y, col);
}
}
bit.Save(filename);
}
}
}

28
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Cellular.cs
View File

@ -1,28 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* TODO: Needs BSD rewrite */

142
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Fracture.cs
View File

@ -1,142 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
namespace libTerrain
{
partial class Channel
{
/// <summary>
/// Produces a set of coordinates defined by an edge point. Eg - 0 = 0,0. 256 = 0,256. 512 = 256,256
/// Assumes a 256^2 heightmap. This needs fixing for input values of w,h
/// </summary>
/// <param name="val"></param>
/// <param name="w"></param>
/// <param name="h"></param>
/// <returns></returns>
private int[] RadialEdge256(int val)
{
// Four cases:
// 1. 000..255 return 0,val
// 2. 256..511 return val - 256,255
// 3. 512..767 return 255, val - 511
// 4. 768..1023 return val - 768,0
int[] ret = new int[2];
if (val < 256)
{
ret[0] = 0;
ret[1] = val;
return ret;
}
if (val < 512)
{
ret[0] = (val%256);
ret[1] = 255;
return ret;
}
if (val < 768)
{
ret[0] = 255;
ret[1] = 255 - (val%256);
return ret;
}
if (val < 1024)
{
ret[0] = 255 - (val%256);
ret[1] = 255;
return ret;
}
throw new Exception("Out of bounds parameter (val)");
}
public void Fracture(int number, double scalemin, double scalemax)
{
SetDiff();
Random rand = new Random(seed);
for (int i = 0; i < number; i++)
{
int[] a, b;
a = RadialEdge256(rand.Next(1023)); // TODO: Broken
b = RadialEdge256(rand.Next(1023)); // TODO: Broken
double z = rand.NextDouble();
double u = rand.NextDouble();
double v = rand.NextDouble();
for (int x = 0; x < w; x++)
{
for (int y = 0; y < h; y++)
{
double miny = Tools.LinearInterpolate(a[1], b[1], (double) x/(double) w);
if (v >= 0.5)
{
if (u >= 0.5)
{
if (y > miny)
{
map[x, y] += Tools.LinearInterpolate(scalemin, scalemax, z);
}
}
else
{
if (y < miny)
{
map[x, y] += Tools.LinearInterpolate(scalemin, scalemax, z);
}
}
}
else
{
if (u >= 0.5)
{
if (x > miny)
{
map[x, y] += Tools.LinearInterpolate(scalemin, scalemax, z);
}
}
else
{
if (x < miny)
{
map[x, y] += Tools.LinearInterpolate(scalemin, scalemax, z);
}
}
}
}
}
}
Normalise();
}
}
}

60
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Gradient.cs
View File

@ -1,60 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
namespace libTerrain
{
partial class Channel
{
public void GradientCube()
{
SetDiff();
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
map[x, y] = x*y;
}
}
Normalise();
}
public void GradientStripe()
{
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
map[x, y] = x;
}
}
Normalise();
}
}
}

281
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/HillPlanter.cs
View File

@ -1,281 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
namespace libTerrain
{
partial class Channel
{
/// <summary>
/// Generates a series of spheres which are then either max()'d or added together. Inspired by suggestion from jh.
/// </summary>
/// <remarks>3-Clause BSD Licensed</remarks>
/// <param name="number">The number of hills to generate</param>
/// <param name="scale_min">The minimum size of each hill</param>
/// <param name="scale_range">The maximum size of each hill</param>
/// <param name="island">Whether to bias hills towards the center of the map</param>
/// <param name="additive">Whether to add hills together or to pick the largest value</param>
/// <param name="noisy">Generates hill-shaped noise instead of consistent hills</param>
public void HillsSpheres(int number, double scale_min, double scale_range, bool island, bool additive,
bool noisy)
{
SetDiff();
Random random = new Random(seed);
int x, y;
int i;
for (i = 0; i < number; i++)
{
double rx = Math.Min(255.0, random.NextDouble()*w);
double ry = Math.Min(255.0, random.NextDouble()*h);
double rand = random.NextDouble();
if (island)
{
// Move everything towards the center
rx -= w/2;
rx /= 2;
rx += w/2;
ry -= h/2;
ry /= 2;
ry += h/2;
}
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
if (noisy)
rand = random.NextDouble();
double z = (scale_min + (scale_range*rand));
z *= z;
z -= ((x - rx)*(x - rx)) + ((y - ry)*(y - ry));
if (z < 0)
z = 0;
if (additive)
{
map[x, y] += z;
}
else
{
map[x, y] = Math.Max(map[x, y], z);
}
}
}
}
Normalise();
}
/// <summary>
/// Generates a series of cones which are then either max()'d or added together. Inspired by suggestion from jh.
/// </summary>
/// <remarks>3-Clause BSD Licensed</remarks>
/// <param name="number">The number of hills to generate</param>
/// <param name="scale_min">The minimum size of each hill</param>
/// <param name="scale_range">The maximum size of each hill</param>
/// <param name="island">Whether to bias hills towards the center of the map</param>
/// <param name="additive">Whether to add hills together or to pick the largest value</param>
/// <param name="noisy">Generates hill-shaped noise instead of consistent hills</param>
public void HillsCones(int number, double scale_min, double scale_range, bool island, bool additive, bool noisy)
{
SetDiff();
Random random = new Random(seed);
int x, y;
int i;
for (i = 0; i < number; i++)
{
double rx = Math.Min(255.0, random.NextDouble()*w);
double ry = Math.Min(255.0, random.NextDouble()*h);
double rand = random.NextDouble();
if (island)
{
// Move everything towards the center
rx -= w/2;
rx /= 2;
rx += w/2;
ry -= h/2;
ry /= 2;
ry += h/2;
}
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
if (noisy)
rand = random.NextDouble();
double z = (scale_min + (scale_range*rand));
z -= Math.Sqrt(((x - rx)*(x - rx)) + ((y - ry)*(y - ry)));
if (z < 0)
z = 0;
if (additive)
{
map[x, y] += z;
}
else
{
map[x, y] = Math.Max(map[x, y], z);
}
}
}
}
Normalise();
}
public void HillsBlocks(int number, double scale_min, double scale_range, bool island, bool additive, bool noisy)
{
SetDiff();
Random random = new Random(seed);
int x, y;
int i;
for (i = 0; i < number; i++)
{
double rx = Math.Min(255.0, random.NextDouble()*w);
double ry = Math.Min(255.0, random.NextDouble()*h);
double rand = random.NextDouble();
if (island)
{
// Move everything towards the center
rx -= w/2;
rx /= 2;
rx += w/2;
ry -= h/2;
ry /= 2;
ry += h/2;
}
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
if (noisy)
rand = random.NextDouble();
double z = (scale_min + (scale_range*rand));
z -= Math.Abs(x - rx) + Math.Abs(y - ry);
//z -= Math.Sqrt(((x - rx) * (x - rx)) + ((y - ry) * (y - ry)));
if (z < 0)
z = 0;
if (additive)
{
map[x, y] += z;
}
else
{
map[x, y] = Math.Max(map[x, y], z);
}
}
}
}
Normalise();
}
public void HillsSquared(int number, double scale_min, double scale_range, bool island, bool additive,
bool noisy)
{
SetDiff();
Random random = new Random(seed);
int x, y;
int i;
for (i = 0; i < number; i++)
{
double rx = Math.Min(255.0, random.NextDouble()*w);
double ry = Math.Min(255.0, random.NextDouble()*h);
double rand = random.NextDouble();
if (island)
{
// Move everything towards the center
rx -= w/2;
rx /= 2;
rx += w/2;
ry -= h/2;
ry /= 2;
ry += h/2;
}
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
if (noisy)
rand = random.NextDouble();
double z = (scale_min + (scale_range*rand));
z *= z*z*z;
double dx = Math.Abs(x - rx);
double dy = Math.Abs(y - ry);
z -= (dx*dx*dx*dx) + (dy*dy*dy*dy);
if (z < 0)
z = 0;
if (additive)
{
map[x, y] += z;
}
else
{
map[x, y] = Math.Max(map[x, y], z);
}
}
}
}
Normalise();
}
}
}

28
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Midpoint.cs
View File

@ -1,28 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* TODO: Needs BSD rewrite */

28
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Mountain.cs
View File

@ -1,28 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* TODO: Needs BSD rewrite */

53
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Noise.cs
View File

@ -1,53 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
namespace libTerrain
{
partial class Channel
{
/// <summary>
/// Fills a channel with 0..1 noise
/// </summary>
/// <remarks>3-Clause BSD Licensed</remarks>
public void Noise()
{
SetDiff();
Random rand = new Random(seed);
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
map[x, y] = rand.NextDouble();
}
}
}
}
}

156
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Spiral.cs
View File

@ -1,156 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
namespace libTerrain
{
partial class Channel
{
private double[] CoordinatesToPolar(int x, int y)
{
double theta = Math.Atan2(x - (w/2), y - (h/2));
double rx = (double) x - ((double) w/2);
double ry = (double) y - ((double) h/2);
double r = Math.Sqrt((rx*rx) + (ry*ry));
double[] coords = new double[2];
coords[0] = r;
coords[1] = theta;
return coords;
}
public int[] PolarToCoordinates(double r, double theta)
{
double nx;
double ny;
nx = (double) r*Math.Cos(theta);
ny = (double) r*Math.Sin(theta);
nx += w/2;
ny += h/2;
if (nx >= w)
nx = w - 1;
if (ny >= h)
ny = h - 1;
if (nx < 0)
nx = 0;
if (ny < 0)
ny = 0;
int[] coords = new int[2];
coords[0] = (int) nx;
coords[1] = (int) ny;
return coords;
}
public void Polar()
{
SetDiff();
Channel n = Copy();
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
double[] coords = CoordinatesToPolar(x, y);
coords[0] += w/2.0;
coords[1] += h/2.0;
map[x, y] = n.map[(int) coords[0]%n.w, (int) coords[1]%n.h];
}
}
}
public void SpiralPlanter(int steps, double incAngle, double incRadius, double offsetRadius, double offsetAngle)
{
SetDiff();
int i;
double r = offsetRadius;
double theta = offsetAngle;
for (i = 0; i < steps; i++)
{
r += incRadius;
theta += incAngle;
int[] coords = PolarToCoordinates(r, theta);
Raise(coords[0], coords[1], 20, 1);
}
}
public void SpiralCells(int steps, double incAngle, double incRadius, double offsetRadius, double offsetAngle,
double[] c)
{
SetDiff();
List<Point2D> points = new List<Point2D>();
int i;
double r = offsetRadius;
double theta = offsetAngle;
for (i = 0; i < steps; i++)
{
r += incRadius;
theta += incAngle;
int[] coords = PolarToCoordinates(r, theta);
points.Add(new Point2D(coords[0], coords[1]));
}
VoronoiDiagram(points, c);
}
public void Spiral(double wid, double hig, double offset)
{
SetDiff();
int x, y, z;
z = 0;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
z++;
double dx = Math.Abs((w/2) - x);
double dy = Math.Abs((h/2) - y);
map[x, y] += Math.Sin(dx/wid) + Math.Cos(dy/hig);
}
}
Normalise();
}
}
}

211
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Voronoi.cs
View File

@ -1,211 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.Collections.Generic;
namespace libTerrain
{
partial class Channel
{
/// <summary>
/// Generates a Voronoi diagram (sort of a stained glass effect) which will fill the entire channel
/// </summary>
/// <remarks>3-Clause BSD Licensed</remarks>
/// <param name="pointsPerBlock">The number of generator points in each block</param>
/// <param name="blockSize">A multiple of the channel width and height which will have voronoi points generated in it.
/// <para>This is to ensure a more even distribution of the points than pure random allocation.</para></param>
/// <param name="c">The Voronoi diagram type. Usually an array with values consisting of [-1,1]. Experiment with the chain, you can have as many values as you like.</param>
public void VoronoiDiagram(int pointsPerBlock, int blockSize, double[] c)
{
SetDiff();
List<Point2D> points = new List<Point2D>();
Random generator = new Random(seed);
// Generate the emitter points
int x, y, i;
for (x = -blockSize; x < w + blockSize; x += blockSize)
{
for (y = -blockSize; y < h + blockSize; y += blockSize)
{
for (i = 0; i < pointsPerBlock; i++)
{
double pX = x + (generator.NextDouble()*(double) blockSize);
double pY = y + (generator.NextDouble()*(double) blockSize);
points.Add(new Point2D(pX, pY));
}
}
}
double[] distances = new double[points.Count];
// Calculate the distance each pixel is from an emitter
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
for (i = 0; i < points.Count; i++)
{
double dx, dy;
dx = Math.Abs((double) x - points[i].x);
dy = Math.Abs((double) y - points[i].y);
distances[i] = (dx*dx + dy*dy);
}
Array.Sort(distances);
double f = 0.0;
// Multiply the distances with their 'c' counterpart
// ordering the distances descending
for (i = 0; i < c.Length; i++)
{
if (i >= points.Count)
break;
f += c[i]*distances[i];
}
map[x, y] = f;
}
}
// Normalise the result
Normalise();
}
public void VoronoiDiagram(List<Point2D> points, double[] c)
{
SetDiff();
int x, y, i;
double[] distances = new double[points.Count];
// Calculate the distance each pixel is from an emitter
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
for (i = 0; i < points.Count; i++)
{
double dx, dy;
dx = Math.Abs((double) x - points[i].x);
dy = Math.Abs((double) y - points[i].y);
distances[i] = (dx*dx + dy*dy);
}
Array.Sort(distances);
double f = 0.0;
// Multiply the distances with their 'c' counterpart
// ordering the distances descending
for (i = 0; i < c.Length; i++)
{
if (i >= points.Count)
break;
f += c[i]*distances[i];
}
map[x, y] = f;
}
}
// Normalise the result
Normalise();
}
public void VoroflatDiagram(int pointsPerBlock, int blockSize)
{
SetDiff();
List<Point2D> points = new List<Point2D>();
Random generator = new Random(seed);
// Generate the emitter points
int x, y, i;
for (x = -blockSize; x < w + blockSize; x += blockSize)
{
for (y = -blockSize; y < h + blockSize; y += blockSize)
{
for (i = 0; i < pointsPerBlock; i++)
{
double pX = x + (generator.NextDouble()*(double) blockSize);
double pY = y + (generator.NextDouble()*(double) blockSize);
points.Add(new Point2D(pX, pY));
}
}
}
double[] distances = new double[points.Count];
// Calculate the distance each pixel is from an emitter
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
for (i = 0; i < points.Count; i++)
{
double dx, dy;
dx = Math.Abs((double) x - points[i].x);
dy = Math.Abs((double) y - points[i].y);
distances[i] = (dx*dx + dy*dy);
}
//Array.Sort(distances);
double f = 0.0;
double min = double.MaxValue;
for (int j = 0; j < distances.Length; j++)
{
if (distances[j] < min)
{
min = distances[j];
f = j;
}
}
// Multiply the distances with their 'c' counterpart
// ordering the distances descending
map[x, y] = f;
}
}
// Normalise the result
Normalise();
}
}
}

71
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Worms.cs
View File

@ -1,71 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
namespace libTerrain
{
partial class Channel
{
/// <summary>
/// Generates 'number' of worms which navigate randomly around the landscape creating terrain as they go.
/// </summary>
/// <param name="number">The number of worms which will traverse the map</param>
/// <param name="rounds">The number of steps each worm will traverse</param>
/// <param name="movement">The maximum distance each worm will move each step</param>
/// <param name="size">The size of the area around the worm modified</param>
/// <param name="centerspawn">Do worms start in the middle, or randomly?</param>
public void Worms(int number, int rounds, double movement, double size, bool centerspawn)
{
SetDiff();
Random random = new Random(seed);
int i, j;
for (i = 0; i < number; i++)
{
double rx, ry;
if (centerspawn)
{
rx = w/2.0;
ry = h/2.0;
}
else
{
rx = random.NextDouble()*(w - 1);
ry = random.NextDouble()*(h - 1);
}
for (j = 0; j < rounds; j++)
{
rx += (random.NextDouble()*movement) - (movement/2.0);
ry += (random.NextDouble()*movement) - (movement/2.0);
Raise(rx, ry, size, 1.0);
}
}
}
}
}

376
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Grid.cs
View File

@ -1,376 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
namespace libTerrain
{
partial class Channel
{
public Channel Normalise()
{
SetDiff();
double max = FindMax();
double min = FindMin();
int x, y;
if (max != min)
{
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
map[x, y] = (map[x, y] - min)*(1.0/(max - min));
}
}
}
else
{
Fill(0.5);
}
return this;
}
public Channel Normalise(double minv, double maxv)
{
SetDiff();
if (minv == maxv)
{
Fill(minv);
return this;
}
double max = FindMax();
double min = FindMin();
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
if (min != max)
{
double val = (map[x, y] - min)*(1.0/(max - min));
val *= maxv - minv;
val += minv;
map[x, y] = val;
}
else
{
map[x, y] = 0.5;
}
}
}
return this;
}
public Channel Elevate(double meters)
{
SetDiff();
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
map[x, y] += meters;
}
}
return this;
}
public Channel Clip()
{
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
SetClip(x, y, map[x, y]);
}
}
return this;
}
public Channel Clip(double min, double max)
{
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
double val = map[x, y];
if (val > max) val = max;
if (val < min) val = min;
Set(x, y, val);
}
}
return this;
}
public Channel Crop(int x1, int y1, int x2, int y2)
{
int width = x1 - x2 + 1;
int height = y1 - y2 + 1;
Channel chan = new Channel(width, height);
int x, y;
int nx, ny;
nx = 0;
for (x = x1; x < x2; x++)
{
ny = 0;
for (y = y1; y < y2; y++)
{
chan.map[nx, ny] = map[x, y];
ny++;
}
nx++;
}
return this;
}
public Channel AddClip(Channel other)
{
SetDiff();
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
map[x, y] = other.map[x, y];
if (map[x, y] > 1)
map[x, y] = 1;
if (map[x, y] < 0)
map[x, y] = 0;
}
}
return this;
}
public void Smooth(double amount)
{
SetDiff();
double area = amount;
double step = amount/4.0;
double[,] manipulate = new double[w,h];
int x, y;
double n, l;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
double average = 0.0;
int avgsteps = 0;
for (n = 0.0 - area; n < area; n += step)
{
for (l = 0.0 - area; l < area; l += step)
{
avgsteps++;
average += GetBilinearInterpolate(x + n, y + l);
}
}
manipulate[x, y] = average/avgsteps;
}
}
map = manipulate;
}
public void Pertubation(double amount)
{
SetDiff();
// Simple pertubation filter
double[,] manipulated = new double[w,h];
Random generator = new Random(seed); // Seeds FTW!
//double amount = 8.0;
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
double offset_x = (double) x + (generator.NextDouble()*amount) - (amount/2.0);
double offset_y = (double) y + (generator.NextDouble()*amount) - (amount/2.0);
double p = GetBilinearInterpolate(offset_x, offset_y);
manipulated[x, y] = p;
}
}
map = manipulated;
}
public void PertubationMask(Channel mask)
{
// Simple pertubation filter
double[,] manipulated = new double[w,h];
Random generator = new Random(seed); // Seeds FTW!
//double amount = 8.0;
double amount;
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
amount = mask.map[x, y];
double offset_x = (double) x + (generator.NextDouble()*amount) - (amount/2.0);
double offset_y = (double) y + (generator.NextDouble()*amount) - (amount/2.0);
if (offset_x > w)
offset_x = w - 1;
if (offset_y > h)
offset_y = h - 1;
if (offset_y < 0)
offset_y = 0;
if (offset_x < 0)
offset_x = 0;
double p = GetBilinearInterpolate(offset_x, offset_y);
manipulated[x, y] = p;
SetDiff(x, y);
}
}
map = manipulated;
}
public void Distort(Channel mask, double str)
{
// Simple pertubation filter
double[,] manipulated = new double[w,h];
double amount;
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
amount = mask.map[x, y];
double offset_x = (double) x + (amount*str) - (0.5*str);
double offset_y = (double) y + (amount*str) - (0.5*str);
if (offset_x > w)
offset_x = w - 1;
if (offset_y > h)
offset_y = h - 1;
if (offset_y < 0)
offset_y = 0;
if (offset_x < 0)
offset_x = 0;
double p = GetBilinearInterpolate(offset_x, offset_y);
manipulated[x, y] = p;
SetDiff(x, y);
}
}
map = manipulated;
}
public void Distort(Channel mask, Channel mask2, double str)
{
// Simple pertubation filter
double[,] manipulated = new double[w,h];
double amountX;
double amountY;
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
amountX = mask.map[x, y];
amountY = mask2.map[x, y];
double offset_x = (double) x + (amountX*str) - (0.5*str);
double offset_y = (double) y + (amountY*str) - (0.5*str);
if (offset_x > w)
offset_x = w - 1;
if (offset_y > h)
offset_y = h - 1;
if (offset_y < 0)
offset_y = 0;
if (offset_x < 0)
offset_x = 0;
double p = GetBilinearInterpolate(offset_x, offset_y);
manipulated[x, y] = p;
SetDiff(x, y);
}
}
map = manipulated;
}
public Channel Blend(Channel other, double amount)
{
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
Set(x, y, Tools.LinearInterpolate(map[x, y], other.map[x, y], amount));
}
}
return this;
}
public Channel Blend(Channel other, Channel amount)
{
int x, y;
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
Set(x, y, Tools.LinearInterpolate(map[x, y], other.map[x, y], amount.map[x, y]));
}
}
return this;
}
}
}

211
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/AerobicErosion.cs
View File

@ -1,211 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
namespace libTerrain
{
partial class Channel
{
// Ideas for Aerobic erosion
//
// Unlike thermal (gravity) and hydraulic (water suspension)
// aerobic erosion should displace mass by moving sediment
// in "hops". The length of the hop being dictated by the
// presence of sharp cliffs and wind speed.
// The ability to pickup sediment is defined by the total
// surface area, such that:
// 0 0 0
// 0 1 0
// 0 0 0
// Would be the best possible value for sediment to be
// picked up (total difference = 8) and flatter land
// will erode less quickly.
// Suspended particles assist the erosion process by hitting
// the surface and chiselling additional particles off faster
// than alone.
// Particles are deposited when one of two conditions is met
// First:
// When particles hit a wall - such that the
// wind direction points at a difference >= the
// deposition mininum talus.
// Second:
// When wind speed is lowered to below the minimum
// required for transit. An idea for this is to
// use the navier-stokes algorithms for simulating
// pressure across the terrain.
/// <summary>
/// An experimental erosion algorithm developed by Adam. Moves sediment by factoring the surface area of each height point.
/// </summary>
/// <param name="windspeed">0..1 The speed of the wind</param>
/// <param name="pickup_talus_minimum">The minimum angle at which rock is eroded 0..1 (recommended: <= 0.30)</param>
/// <param name="drop_talus_minimum">The minimum angle at which rock is dropped 0..1 (recommended: >= 0.00)</param>
/// <param name="carry">The percentage of rock which can be picked up to pickup 0..1</param>
/// <param name="rounds">The number of erosion rounds (recommended: 25+)</param>
/// <param name="lowest">Drop sediment at the lowest point?</param>
public void AerobicErosion(double windspeed, double pickupTalusMinimum, double dropTalusMinimum, double carry,
int rounds, bool lowest, bool usingFluidDynamics)
{
bool debugImages = false;
Channel wind = new Channel(w, h);
Channel sediment = new Channel(w, h);
int x, y, i, j;
Normalise();
wind = Copy();
wind.Noise();
if (debugImages)
wind.SaveImage("testimg/wind_start.png");
if (usingFluidDynamics)
{
wind.navierStokes(20, 0.1, 0.0, 0.0);
}
else
{
wind.Pertubation(30);
}
if (debugImages)
wind.SaveImage("testimg/wind_begin.png");
for (i = 0; i < rounds; i++)
{
// Convert some rocks to sand
for (x = 1; x < w - 1; x++)
{
for (y = 1; y < h - 1; y++)
{
double me = Get(x, y);
double surfacearea = 0.3; // Everything will erode even if it's flat. Just slower.
for (j = 0; j < 9; j++)
{
int[] coords = Neighbours(NeighbourSystem.Moore, j);
double target = Get(x + coords[0], y + coords[1]);
surfacearea += Math.Abs(target - me);
}
double amount = surfacearea*wind.map[x, y]*carry;
if (amount < 0)
amount = 0;
if (surfacearea > pickupTalusMinimum)
{
Set(x, y, map[x, y] - amount);
sediment.map[x, y] += amount;
}
}
}
if (usingFluidDynamics)
{
sediment.navierStokes(7, 0.1, 0.0, 0.1);
Channel noiseChan = new Channel(w, h);
noiseChan.Noise();
wind.Blend(noiseChan, 0.01);
wind.navierStokes(10, 0.1, 0.01, 0.01);
sediment.Distort(wind, windspeed);
}
else
{
wind.Pertubation(15); // Can do better later
wind.seed++;
sediment.Pertubation(10); // Sediment is blown around a bit
sediment.seed++;
}
if (debugImages)
wind.SaveImage("testimg/wind_" + i.ToString() + ".png");
// Convert some sand to rock
for (x = 1; x < w - 1; x++)
{
for (y = 1; y < h - 1; y++)
{
double me = Get(x, y);
double surfacearea = 0.01; // Flat land does not get deposition
double min = double.MaxValue;
int[] minside = new int[2];
for (j = 0; j < 9; j++)
{
int[] coords = Neighbours(NeighbourSystem.Moore, j);
double target = Get(x + coords[0], y + coords[1]);
surfacearea += Math.Abs(target - me);
if (target < min && lowest)
{
minside = (int[]) coords.Clone();
min = target;
}
}
double amount = surfacearea*(1.0 - wind.map[x, y])*carry;
if (amount < 0)
amount = 0;
if (surfacearea > dropTalusMinimum)
{
Set(x + minside[0], y + minside[1], map[x + minside[0], y + minside[1]] + amount);
sediment.map[x, y] -= amount;
}
}
}
if (debugImages)
sediment.SaveImage("testimg/sediment_" + i.ToString() + ".png");
wind.Normalise();
wind *= windspeed;
Normalise();
}
Channel myself = this;
myself += sediment;
myself.Normalise();
if (debugImages)
SaveImage("testimg/output.png");
}
}
}

144
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/HydraulicErosion.cs
View File

@ -1,144 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
namespace libTerrain
{
partial class Channel
{
public void HydraulicErosion(Channel rain, double evaporation, double solubility, int frequency, int rounds)
{
SetDiff();
Channel water = new Channel(w, h);
Channel sediment = new Channel(w, h);
Channel terrain = this;
Channel waterFlow = new Channel(w, h);
NeighbourSystem type = NeighbourSystem.Moore;
int NEIGHBOUR_ME = 4;
int NEIGHBOUR_MAX = type == NeighbourSystem.Moore ? 9 : 5;
for (int i = 0; i < rounds; i++)
{
water += rain;
sediment = terrain*water;
terrain -= sediment;
for (int x = 1; x < w - 1; x++)
{
for (int y = 1; y < h - 1; y++)
{
double[] heights = new double[NEIGHBOUR_MAX];
double[] diffs = new double[NEIGHBOUR_MAX];
double heightCenter = map[x, y];
for (int j = 0; j < NEIGHBOUR_MAX; j++)
{
if (j != NEIGHBOUR_ME)
{
int[] coords = Neighbours(type, j);
coords[0] += x;
coords[1] += y;
heights[j] = map[coords[0], coords[1]] + water.map[coords[0], coords[1]] +
sediment.map[coords[0], coords[1]];
diffs[j] = heightCenter - heights[j];
}
}
double totalHeight = 0;
double totalHeightDiff = 0;
int totalCellsCounted = 1;
for (int j = 0; j < NEIGHBOUR_MAX; j++)
{
if (j != NEIGHBOUR_ME)
{
if (diffs[j] > 0)
{
totalHeight += heights[j];
totalHeightDiff += diffs[j];
totalCellsCounted++;
}
}
}
if (totalCellsCounted == 1)
continue;
double averageHeight = totalHeight/totalCellsCounted;
double waterAmount = Math.Min(water.map[x, y], heightCenter - averageHeight);
// TODO: Check this.
waterFlow.map[x, y] += waterFlow.map[x, y] - waterAmount;
double totalInverseDiff = waterAmount/totalHeightDiff;
for (int j = 0; j < NEIGHBOUR_MAX; j++)
{
if (j != NEIGHBOUR_ME)
{
int[] coords = Neighbours(type, j);
coords[0] += x;
coords[1] += y;
if (diffs[j] > 0)
{
waterFlow.SetWrap(coords[0], coords[1],
waterFlow.map[coords[0], coords[1]] + diffs[j]*totalInverseDiff);
}
}
}
}
}
water += waterFlow;
waterFlow.Fill(0);
water *= evaporation;
for (int x = 0; x < w; x++)
{
for (int y = 0; y < h; y++)
{
double deposition = sediment.map[x, y] - water.map[x, y]*solubility;
if (deposition > 0)
{
sediment.map[x, y] -= deposition;
terrain.map[x, y] += deposition;
}
}
}
}
}
}
}

307
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/NavierStokes.cs
View File

@ -1,307 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
namespace libTerrain
{
partial class Channel
{
// Navier Stokes Algorithms ported from
// "Real-Time Fluid Dynamics for Games" by Jos Stam.
// presented at GDC 2003.
// Poorly ported from C++. (I gave up making it properly native somewhere after nsSetBnd)
private static int nsIX(int i, int j, int N)
{
return ((i) + (N + 2)*(j));
}
// TODO: unused
// private static void nsSwap(ref double x0, ref double x)
// {
// double tmp = x0;
// x0 = x;
// x = tmp;
// }
private static void nsSwap(ref double[] x0, ref double[] x)
{
double[] tmp = x0;
x0 = x;
x = tmp;
}
private void nsAddSource(int N, ref double[] x, ref double[] s, double dt)
{
int i;
int size = (N + 2)*(N + 2);
for (i = 0; i < size; i++)
{
x[i] += dt*s[i];
}
}
private void nsSetBnd(int N, int b, ref double[] x)
{
int i;
for (i = 0; i <= N; i++)
{
x[nsIX(0, i, N)] = b == 1 ? -x[nsIX(1, i, N)] : x[nsIX(1, i, N)];
x[nsIX(0, N + 1, N)] = b == 1 ? -x[nsIX(N, i, N)] : x[nsIX(N, i, N)];
x[nsIX(i, 0, N)] = b == 2 ? -x[nsIX(i, 1, N)] : x[nsIX(i, 1, N)];
x[nsIX(i, N + 1, N)] = b == 2 ? -x[nsIX(i, N, N)] : x[nsIX(i, N, N)];
}
x[nsIX(0, 0, N)] = 0.5f*(x[nsIX(1, 0, N)] + x[nsIX(0, 1, N)]);
x[nsIX(0, N + 1, N)] = 0.5f*(x[nsIX(1, N + 1, N)] + x[nsIX(0, N, N)]);
x[nsIX(N + 1, 0, N)] = 0.5f*(x[nsIX(N, 0, N)] + x[nsIX(N + 1, 1, N)]);
x[nsIX(N + 1, N + 1, N)] = 0.5f*(x[nsIX(N, N + 1, N)] + x[nsIX(N + 1, N, N)]);
}
private void nsLinSolve(int N, int b, ref double[] x, ref double[] x0, double a, double c)
{
int i, j;
for (i = 1; i <= N; i++)
{
for (j = 1; j <= N; j++)
{
x[nsIX(i, j, N)] = (x0[nsIX(i, j, N)] + a*
(x[nsIX(i - 1, j, N)] +
x[nsIX(i + 1, j, N)] +
x[nsIX(i, j - 1, N)] + x[nsIX(i, j + 1, N)])
)/c;
}
}
nsSetBnd(N, b, ref x);
}
private void nsDiffuse(int N, int b, ref double[] x, ref double[] x0, double diff, double dt)
{
double a = dt*diff*N*N;
nsLinSolve(N, b, ref x, ref x0, a, 1 + 4*a);
}
private void nsAdvect(int N, int b, ref double[] d, ref double[] d0, ref double[] u, ref double[] v, double dt)
{
int i, j, i0, j0, i1, j1;
double x, y, s0, t0, s1, t1, dt0;
dt0 = dt*N;
for (i = 1; i <= N; i++)
{
for (j = 1; j <= N; j++)
{
x = i - dt0*u[nsIX(i, j, N)];
y = j - dt0*v[nsIX(i, j, N)];
if (x < 0.5)
x = 0.5;
if (x > N + 0.5)
x = N + 0.5;
i0 = (int) x;
i1 = i0 + 1;
if (y < 0.5)
y = 0.5;
if (y > N + 0.5)
y = N + 0.5;
j0 = (int) y;
j1 = j0 + 1;
s1 = x - i0;
s0 = 1 - s1;
t1 = y - j0;
t0 = 1 - t1;
d[nsIX(i, j, N)] = s0*(t0*d0[nsIX(i0, j0, N)] + t1*d0[nsIX(i0, j1, N)]) +
s1*(t0*d0[nsIX(i1, j0, N)] + t1*d0[nsIX(i1, j1, N)]);
}
}
nsSetBnd(N, b, ref d);
}
public void nsProject(int N, ref double[] u, ref double[] v, ref double[] p, ref double[] div)
{
int i, j;
for (i = 1; i <= N; i++)
{
for (j = 1; j <= N; j++)
{
div[nsIX(i, j, N)] = -0.5*
(u[nsIX(i + 1, j, N)] - u[nsIX(i - 1, j, N)] + v[nsIX(i, j + 1, N)] -
v[nsIX(i, j - 1, N)])/N;
p[nsIX(i, j, N)] = 0;
}
}
nsSetBnd(N, 0, ref div);
nsSetBnd(N, 0, ref p);
nsLinSolve(N, 0, ref p, ref div, 1, 4);
for (i = 1; i <= N; i++)
{
for (j = 1; j <= N; j++)
{
u[nsIX(i, j, N)] -= 0.5*N*(p[nsIX(i + 1, j, N)] - p[nsIX(i - 1, j, N)]);
v[nsIX(i, j, N)] -= 0.5*N*(p[nsIX(i, j + 1, N)] - p[nsIX(i, j - 1, N)]);
}
}
nsSetBnd(N, 1, ref u);
nsSetBnd(N, 2, ref v);
}
private void nsDensStep(int N, ref double[] x, ref double[] x0, ref double[] u, ref double[] v, double diff,
double dt)
{
nsAddSource(N, ref x, ref x0, dt);
nsSwap(ref x0, ref x);
nsDiffuse(N, 0, ref x, ref x0, diff, dt);
nsSwap(ref x0, ref x);
nsAdvect(N, 0, ref x, ref x0, ref u, ref v, dt);
}
private void nsVelStep(int N, ref double[] u, ref double[] v, ref double[] u0, ref double[] v0, double visc,
double dt)
{
nsAddSource(N, ref u, ref u0, dt);
nsAddSource(N, ref v, ref v0, dt);
nsSwap(ref u0, ref u);
nsDiffuse(N, 1, ref u, ref u0, visc, dt);
nsSwap(ref v0, ref v);
nsDiffuse(N, 2, ref v, ref v0, visc, dt);
nsProject(N, ref u, ref v, ref u0, ref v0);
nsSwap(ref u0, ref u);
nsSwap(ref v0, ref v);
nsAdvect(N, 1, ref u, ref u0, ref u0, ref v0, dt);
nsAdvect(N, 2, ref v, ref v0, ref u0, ref v0, dt);
nsProject(N, ref u, ref v, ref u0, ref v0);
}
private void nsBufferToDoubles(ref double[] dens, int N, ref double[,] doubles)
{
int i;
int j;
for (i = 1; i <= N; i++)
{
for (j = 1; j <= N; j++)
{
doubles[i - 1, j - 1] = dens[nsIX(i, j, N)];
}
}
}
private void nsDoublesToBuffer(double[,] doubles, int N, ref double[] dens)
{
int i;
int j;
for (i = 1; i <= N; i++)
{
for (j = 1; j <= N; j++)
{
dens[nsIX(i, j, N)] = doubles[i - 1, j - 1];
}
}
}
private void nsSimulate(int N, int rounds, double dt, double diff, double visc)
{
int size = (N*2)*(N*2);
double[] u = new double[size]; // Force, X axis
double[] v = new double[size]; // Force, Y axis
double[] u_prev = new double[size];
double[] v_prev = new double[size];
double[] dens = new double[size];
double[] dens_prev = new double[size];
nsDoublesToBuffer(map, N, ref dens);
nsDoublesToBuffer(map, N, ref dens_prev);
for (int i = 0; i < rounds; i++)
{
u_prev = u;
v_prev = v;
dens_prev = dens;
nsVelStep(N, ref u, ref v, ref u_prev, ref v_prev, visc, dt);
nsDensStep(N, ref dens, ref dens_prev, ref u, ref v, diff, dt);
}
nsBufferToDoubles(ref dens, N, ref map);
}
/// <summary>
/// Performs computational fluid dynamics on a channel
/// </summary>
/// <param name="rounds">The number of steps to perform (Recommended: 20)</param>
/// <param name="dt">Delta Time - The time between steps (Recommended: 0.1)</param>
/// <param name="diff">Fluid diffusion rate (Recommended: 0.0)</param>
/// <param name="visc">Fluid viscosity (Recommended: 0.0)</param>
public void navierStokes(int rounds, double dt, double diff, double visc)
{
nsSimulate(h, rounds, dt, diff, visc);
}
public void navierStokes(int rounds, double dt, double diff, double visc, ref double[,] uret, ref double[,] vret)
{
int N = h;
int size = (N*2)*(N*2);
double[] u = new double[size]; // Force, X axis
double[] v = new double[size]; // Force, Y axis
double[] u_prev = new double[size];
double[] v_prev = new double[size];
double[] dens = new double[size];
double[] dens_prev = new double[size];
nsDoublesToBuffer(map, N, ref dens);
nsDoublesToBuffer(map, N, ref dens_prev);
for (int i = 0; i < rounds; i++)
{
u_prev = u;
v_prev = v;
dens_prev = dens;
nsVelStep(N, ref u, ref v, ref u_prev, ref v_prev, visc, dt);
nsDensStep(N, ref dens, ref dens_prev, ref u, ref v, diff, dt);
}
nsBufferToDoubles(ref u, N, ref uret);
nsBufferToDoubles(ref v, N, ref vret);
nsBufferToDoubles(ref dens, N, ref map);
}
}
}

107
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/ThermalWeathering.cs
View File

@ -1,107 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
namespace libTerrain
{
partial class Channel
{
/// <summary>
/// A thermal weathering implementation based on Musgrave's original 1989 algorithm. This is Adam's custom implementation which may differ slightly from the original.
/// </summary>
/// <param name="talus">The rock angle (represented as a dy/dx ratio) at which point it will be succeptible to breakage</param>
/// <param name="rounds">The number of erosion rounds</param>
/// <param name="c">The amount of rock to carry each round</param>
public Channel ThermalWeathering(double talus, int rounds, double c)
{
SetDiff();
double[,] lastFrame;
double[,] thisFrame;
lastFrame = (double[,]) map.Clone();
thisFrame = (double[,]) map.Clone();
NeighbourSystem type = NeighbourSystem.Moore;
// Using moore neighbourhood (twice as computationally expensive)
int NEIGHBOUR_ME = 4; // I am always 4 in both systems.
int NEIGHBOUR_MAX = type == NeighbourSystem.Moore ? 9 : 5;
int frames = rounds; // Number of thermal erosion iterations to run
int i, j;
int x, y;
for (i = 0; i < frames; i++)
{
for (x = 0; x < w; x++)
{
for (y = 0; y < h; y++)
{
for (j = 0; j < NEIGHBOUR_MAX; j++)
{
if (j != NEIGHBOUR_ME)
{
int[] coords = Neighbours(type, j);
coords[0] += x;
coords[1] += y;
if (coords[0] > w - 1)
coords[0] = w - 1;
if (coords[1] > h - 1)
coords[1] = h - 1;
if (coords[0] < 0)
coords[0] = 0;
if (coords[1] < 0)
coords[1] = 0;
double heightF = thisFrame[x, y];
double target = thisFrame[coords[0], coords[1]];
if (target > heightF + talus)
{
double calc = c*((target - heightF) - talus);
heightF += calc;
target -= calc;
}
thisFrame[x, y] = heightF;
thisFrame[coords[0], coords[1]] = target;
}
}
}
}
lastFrame = (double[,]) thisFrame.Clone();
}
map = thisFrame;
Normalise(); // Just to guaruntee a smooth 0..1 value
return this;
}
}
}

136
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Neighbours.cs
View File

@ -1,136 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
namespace libTerrain
{
partial class Channel
{
private enum NeighbourSystem
{
Moore,
VonNeumann
} ;
private int[] Neighbours(NeighbourSystem type, int index)
{
int[] coord = new int[2];
index++;
switch (type)
{
case NeighbourSystem.Moore:
switch (index)
{
case 1:
coord[0] = -1;
coord[1] = -1;
break;
case 2:
coord[0] = -0;
coord[1] = -1;
break;
case 3:
coord[0] = +1;
coord[1] = -1;
break;
case 4:
coord[0] = -1;
coord[1] = -0;
break;
case 5:
coord[0] = -0;
coord[1] = -0;
break;
case 6:
coord[0] = +1;
coord[1] = -0;
break;
case 7:
coord[0] = -1;
coord[1] = +1;
break;
case 8:
coord[0] = -0;
coord[1] = +1;
break;
case 9:
coord[0] = +1;
coord[1] = +1;
break;
default:
break;
}
break;
case NeighbourSystem.VonNeumann:
switch (index)
{
case 1:
coord[0] = 0;
coord[1] = -1;
break;
case 2:
coord[0] = -1;
coord[1] = 0;
break;
case 3:
coord[0] = +1;
coord[1] = 0;
break;
case 4:
coord[0] = 0;
coord[1] = +1;
break;
case 5:
coord[0] = -0;
coord[1] = -0;
break;
default:
break;
}
break;
}
return coord;
}
}
}

239
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Operators.cs
View File

@ -1,239 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
namespace libTerrain
{
partial class Channel
{
/* Operator combination of channel datatypes */
public static Channel operator +(Channel A, Channel B)
{
if (A.h != B.h)
throw new Exception("Cannot add heightmaps, of different height.");
if (A.w != B.w)
throw new Exception("Cannot add heightmaps, of different width.");
int x, y;
for (x = 0; x < A.w; x++)
{
for (y = 0; y < A.h; y++)
{
if (B.map[x, y] != 0)
A.SetDiff(x, y);
A.map[x, y] += B.map[x, y];
}
}
return A;
}
public static Channel operator *(Channel A, Channel B)
{
if (A.h != B.h)
throw new Exception("Cannot multiply heightmaps, of different height.");
if (A.w != B.w)
throw new Exception("Cannot multiply heightmaps, of different width.");
int x, y;
for (x = 0; x < A.w; x++)
{
for (y = 0; y < A.h; y++)
{
A.map[x, y] *= B.map[x, y];
}
}
A.SetDiff();
return A;
}
public static Channel operator -(Channel A, Channel B)
{
if (A.h != B.h)
throw new Exception("Cannot subtract heightmaps, of different height.");
if (A.w != B.w)
throw new Exception("Cannot subtract heightmaps, of different width.");
int x, y;
for (x = 0; x < A.w; x++)
{
for (y = 0; y < A.h; y++)
{
if (B.map[x, y] != 0)
A.SetDiff(x, y);
A.map[x, y] -= B.map[x, y];
}
}
return A;
}
public static Channel operator /(Channel A, Channel B)
{
if (A.h != B.h)
throw new Exception("Cannot divide heightmaps, of different height.");
if (A.w != B.w)
throw new Exception("Cannot divide heightmaps, of different width.");
int x, y;
for (x = 0; x < A.w; x++)
{
for (y = 0; y < A.h; y++)
{
A.map[x, y] /= B.map[x, y];
}
}
A.SetDiff();
return A;
}
public static Channel operator ^(Channel A, Channel B)
{
if (A.h != B.h)
throw new Exception("Cannot divide heightmaps, of different height.");
if (A.w != B.w)
throw new Exception("Cannot divide heightmaps, of different width.");
int x, y;
for (x = 0; x < A.w; x++)
{
for (y = 0; y < A.h; y++)
{
A.map[x, y] = Math.Pow(A.map[x, y], B.map[x, y]);
}
}
A.SetDiff();
return A;
}
/* Operator combination of channel and double datatypes */
public static Channel operator +(Channel A, double B)
{
int x, y;
for (x = 0; x < A.w; x++)
{
for (y = 0; y < A.h; y++)
{
A.map[x, y] += B;
}
}
if (B != 0)
A.SetDiff();
return A;
}
public static Channel operator -(Channel A, double B)
{
int x, y;
for (x = 0; x < A.w; x++)
{
for (y = 0; y < A.h; y++)
{
A.map[x, y] -= B;
}
}
if (B != 0)
A.SetDiff();
return A;
}
public static Channel operator *(Channel A, double B)
{
int x, y;
for (x = 0; x < A.w; x++)
{
for (y = 0; y < A.h; y++)
{
A.map[x, y] *= B;
}
}
if (B != 1)
A.SetDiff();
return A;
}
public static Channel operator /(Channel A, double B)
{
int x, y;
for (x = 0; x < A.w; x++)
{
for (y = 0; y < A.h; y++)
{
A.map[x, y] /= B;
}
}
if (B != 1)
A.SetDiff();
return A;
}
public static Channel operator ^(Channel A, double B)
{
int x, y;
for (x = 0; x < A.w; x++)
{
for (y = 0; y < A.h; y++)
{
A.map[x, y] = Math.Pow(A.map[x, y], B);
}
}
A.SetDiff();
return A;
}
}
}

41
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Tools/Point2D.cs
View File

@ -1,41 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
namespace libTerrain
{
public class Point2D
{
public double x;
public double y;
public Point2D(double X, double Y)
{
x = X;
y = Y;
}
}
}

59
OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Tools/Tools.cs
View File

@ -1,59 +0,0 @@
/*
* Copyright (c) Contributors, http://opensimulator.org/
* See CONTRIBUTORS.TXT for a full list of copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenSim Project nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
using System;
namespace libTerrain
{
internal class Tools
{
public static double LinearInterpolate(double a, double b, double amount)
{
return a + ((b - a)*amount);
}
public static double ExponentialInterpolate(double a, double b, double amount)
{
a = Math.Pow(a, amount);
b = Math.Pow(b - a, 1.0 - amount);
return a + b;
}
public static int PowerOf2Log2(int n)
{
for (int i = 0; i < 31; i++)
{
if ((n & 1) == 1)
{
return i;
}
n >>= 1;
}
return 0;
}
}
}

37
prebuild.xml
View File

@ -646,35 +646,6 @@
</Files>
</Project>
<!-- Terrain engine -->
<Project name="OpenSim.Region.Terrain.BasicTerrain" path="OpenSim/Region/Terrain.BasicTerrain" type="Library">
<Configuration name="Debug">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<Configuration name="Release">
<Options>
<OutputPath>../../../bin/</OutputPath>
</Options>
</Configuration>
<ReferencePath>../../../bin/</ReferencePath>
<Reference name="System"/>
<Reference name="System.Drawing"/>
<Reference name="System.Data"/>
<Reference name="System.Xml"/>
<Reference name="Microsoft.JScript"/>
<Reference name="libsecondlife.dll" />
<Reference name="OpenSim.Framework"/>
<Files>
<Match pattern="*.cs" recurse="true"/>
</Files>
</Project>
<Project name="OpenSim.Data.DB4o" path="OpenSim/Data/DB4o" type="Library">
<Configuration name="Debug">
<Options>
@ -816,7 +787,6 @@
<Reference name="System.Drawing"/>
<Reference name="libsecondlife.dll"/>
<Reference name="Axiom.MathLib.dll"/>
<Reference name="OpenSim.Region.Terrain.BasicTerrain"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Data" />
<Reference name="OpenSim.Framework.Console"/>
@ -852,7 +822,6 @@
<Reference name="libsecondlife.dll"/>
<Reference name="Axiom.MathLib.dll"/>
<Reference name="Db4objects.Db4o.dll"/>
<Reference name="OpenSim.Region.Terrain.BasicTerrain"/>
<Reference name="OpenSim.Region.Environment"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Data"/>
@ -1057,7 +1026,6 @@
<Reference name="libsecondlife.dll"/>
<Reference name="Axiom.MathLib.dll"/>
<Reference name="Db4objects.Db4o.dll"/>
<Reference name="OpenSim.Region.Terrain.BasicTerrain"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Data"/>
<Reference name="OpenSim.Framework.Console"/>
@ -1506,7 +1474,6 @@
<Reference name="Nini.dll" />
<Reference name="RAIL.dll"/>
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Region.Terrain.BasicTerrain"/>
<Reference name="Nini.dll" />
<Reference name="log4net"/>
@ -1539,7 +1506,6 @@
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Region.Environment" />
<Reference name="OpenSim.Region.ScriptEngine.Common"/>
<Reference name="OpenSim.Region.Terrain.BasicTerrain"/>
<Reference name="Microsoft.JScript"/>
<Reference name="Axiom.MathLib.dll" localCopy="false"/>
<Reference name="Nini.dll" />
@ -1574,7 +1540,6 @@
<Reference name="OpenSim.Framework.Console"/>
<Reference name="OpenSim.Region.Environment" />
<Reference name="OpenSim.Region.ScriptEngine.Common"/>
<Reference name="OpenSim.Region.Terrain.BasicTerrain"/>
<Reference name="Axiom.MathLib.dll" localCopy="false"/>
<Reference name="Nini.dll" />
<Reference name="log4net"/>
@ -1611,7 +1576,6 @@
<Reference name="OpenSim.Data"/>
<Reference name="OpenSim.Region.Environment" />
<Reference name="OpenSim.Region.ScriptEngine.Common"/>
<Reference name="OpenSim.Region.Terrain.BasicTerrain"/>
<Reference name="libsecondlife.dll"/>
<Reference name="Axiom.MathLib.dll" localCopy="false"/>
<Reference name="XMLRPC.dll"/>
@ -1698,7 +1662,6 @@
<Reference name="libsecondlife.dll"/>
<Reference name="Axiom.MathLib.dll"/>
<Reference name="Db4objects.Db4o.dll"/>
<Reference name="OpenSim.Region.Terrain.BasicTerrain"/>
<Reference name="OpenSim"/>
<Reference name="OpenSim.Framework"/>
<Reference name="OpenSim.Data"/>