379 lines
14 KiB
C#
379 lines
14 KiB
C#
/*
|
|
* 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 OpenSimulator 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.Reflection;
|
|
using log4net;
|
|
|
|
using OpenSim.Region.Framework.Interfaces;
|
|
|
|
namespace OpenSim.Region.CoreModules.World.Terrain
|
|
{
|
|
public abstract class TerrainModifier : ITerrainModifier
|
|
{
|
|
protected ITerrainModule m_module;
|
|
protected static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
protected TerrainModifier(ITerrainModule module)
|
|
{
|
|
m_module = module;
|
|
}
|
|
|
|
public abstract string ModifyTerrain(ITerrainChannel map, string[] args);
|
|
|
|
public abstract string GetUsage();
|
|
|
|
public abstract double operate(double[,] map, TerrainModifierData data, int x, int y);
|
|
|
|
protected String parseParameters(string[] args, out TerrainModifierData data)
|
|
{
|
|
string val;
|
|
string arg;
|
|
string result;
|
|
data = new TerrainModifierData();
|
|
data.shape = String.Empty;
|
|
data.bevel = String.Empty;
|
|
data.dx = 0;
|
|
data.dy = 0;
|
|
if (args.Length < 4)
|
|
{
|
|
result = "Usage: " + GetUsage();
|
|
}
|
|
else
|
|
{
|
|
result = this.parseFloat(args[3], out data.elevation);
|
|
}
|
|
if (result == String.Empty)
|
|
{
|
|
int index = 3;
|
|
while(++index < args.Length && result == String.Empty)
|
|
{
|
|
arg = args[index];
|
|
// check for shape
|
|
if (arg.StartsWith("-rec=") || arg.StartsWith("-ell="))
|
|
{
|
|
if (data.shape != String.Empty)
|
|
{
|
|
result = "Only 1 '-rec' or '-ell' parameter is permitted.";
|
|
}
|
|
else
|
|
{
|
|
data.shape = arg.StartsWith("-ell=") ? "ellipse" : "rectangle";
|
|
val = arg.Substring(arg.IndexOf("=") + 1);
|
|
string[] coords = val.Split(new char[] {','});
|
|
if ((coords.Length < 3) || (coords.Length > 4))
|
|
{
|
|
result = String.Format("Bad format for shape parameter {0}", arg);
|
|
}
|
|
else
|
|
{
|
|
result = this.parseInt(coords[0], out data.x0);
|
|
if (result == String.Empty)
|
|
{
|
|
result = this.parseInt(coords[1], out data.y0);
|
|
}
|
|
if (result == String.Empty)
|
|
{
|
|
result = this.parseInt(coords[2], out data.dx);
|
|
}
|
|
if (result == String.Empty)
|
|
{
|
|
if (coords.Length == 4)
|
|
{
|
|
result = this.parseInt(coords[3], out data.dy);
|
|
}
|
|
else
|
|
{
|
|
data.dy = data.dx;
|
|
}
|
|
}
|
|
if (result == String.Empty)
|
|
{
|
|
if ((data.dx <= 0) || (data.dy <= 0))
|
|
{
|
|
result = "Shape sizes must be positive integers";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = String.Format("Bad value in shape parameters {0}", arg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (arg.StartsWith("-taper="))
|
|
{
|
|
if (data.bevel != String.Empty)
|
|
{
|
|
result = "Only 1 '-taper' parameter is permitted.";
|
|
}
|
|
else
|
|
{
|
|
data.bevel = "taper";
|
|
val = arg.Substring(arg.IndexOf("=") + 1);
|
|
result = this.parseFloat(val, out data.bevelevation);
|
|
if (result != String.Empty)
|
|
{
|
|
result = String.Format("Bad format for taper parameter {0}", arg);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = String.Format("Unrecognized parameter {0}", arg);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
protected string parseFloat(String s, out float f)
|
|
{
|
|
string result;
|
|
double d;
|
|
if (Double.TryParse(s, out d))
|
|
{
|
|
try
|
|
{
|
|
f = (float)d;
|
|
result = String.Empty;
|
|
}
|
|
catch(InvalidCastException)
|
|
{
|
|
result = String.Format("{0} is invalid", s);
|
|
f = -1.0f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
f = -1.0f;
|
|
result = String.Format("{0} is invalid", s);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
protected string parseInt(String s, out int i)
|
|
{
|
|
string result;
|
|
if (Int32.TryParse(s, out i))
|
|
{
|
|
result = String.Empty;
|
|
}
|
|
else
|
|
{
|
|
result = String.Format("{0} is invalid", s);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
protected void applyModification(ITerrainChannel map, TerrainModifierData data)
|
|
{
|
|
bool[,] mask;
|
|
int xMax;
|
|
int yMax;
|
|
int xMid;
|
|
int yMid;
|
|
if (data.shape == "ellipse")
|
|
{
|
|
mask = this.ellipticalMask(data.dx, data.dy);
|
|
xMax = mask.GetLength(0);
|
|
yMax = mask.GetLength(1);
|
|
xMid = xMax / 2 + xMax % 2;
|
|
yMid = yMax / 2 + yMax % 2;
|
|
}
|
|
else
|
|
{
|
|
mask = this.rectangularMask(data.dx, data.dy);
|
|
xMax = mask.GetLength(0);
|
|
yMax = mask.GetLength(1);
|
|
xMid = 0;
|
|
yMid = 0;
|
|
}
|
|
// m_log.DebugFormat("Apply {0} mask {1}x{2} @ {3},{4}", data.shape, xMax, yMax, xMid, yMid);
|
|
double[,] buffer = map.GetDoubles();
|
|
int yDim = yMax;
|
|
while(--yDim >= 0)
|
|
{
|
|
int yPos = data.y0 + yDim - yMid;
|
|
if ((yPos >= 0) && (yPos < map.Height))
|
|
{
|
|
int xDim = xMax;
|
|
while(--xDim >= 0)
|
|
{
|
|
int xPos = data.x0 + xDim - xMid;
|
|
if ((xPos >= 0) && (xPos < map.Width) && (mask[xDim, yDim]))
|
|
{
|
|
double endElevation = this.operate(buffer, data, xPos, yPos);
|
|
map[xPos, yPos] = endElevation;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected double computeBevel(TerrainModifierData data, int x, int y)
|
|
{
|
|
int deltaX;
|
|
int deltaY;
|
|
int xMax;
|
|
int yMax;
|
|
double factor;
|
|
if (data.bevel == "taper")
|
|
{
|
|
if (data.shape == "ellipse")
|
|
{
|
|
deltaX = x - data.x0;
|
|
deltaY = y - data.y0;
|
|
xMax = data.dx;
|
|
yMax = data.dy;
|
|
factor = (double)((deltaX * deltaX) + (deltaY * deltaY));
|
|
factor /= ((xMax * xMax) + (yMax * yMax));
|
|
}
|
|
else
|
|
{
|
|
// pyramid
|
|
xMax = data.dx / 2 + data.dx % 2;
|
|
yMax = data.dy / 2 + data.dy % 2;
|
|
deltaX = Math.Abs(data.x0 + xMax - x);
|
|
deltaY = Math.Abs(data.y0 + yMax - y);
|
|
factor = Math.Max(((double)(deltaY) / yMax), ((double)(deltaX) / xMax));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
factor = 0.0;
|
|
}
|
|
return factor;
|
|
}
|
|
|
|
private bool[,] rectangularMask(int xSize, int ySize)
|
|
{
|
|
bool[,] mask = new bool[xSize, ySize];
|
|
int yPos = ySize;
|
|
while(--yPos >= 0)
|
|
{
|
|
int xPos = xSize;
|
|
while(--xPos >= 0)
|
|
{
|
|
mask[xPos, yPos] = true;
|
|
}
|
|
}
|
|
return mask;
|
|
}
|
|
|
|
/*
|
|
* Fast ellipse-based derivative of Bresenham algorithm.
|
|
* https://web.archive.org/web/20120225095359/http://homepage.smc.edu/kennedy_john/belipse.pdf
|
|
*/
|
|
private bool[,] ellipticalMask(int xRadius, int yRadius)
|
|
{
|
|
long twoASquared = 2L * xRadius * xRadius;
|
|
long twoBSquared = 2L * yRadius * yRadius;
|
|
|
|
bool[,] mask = new bool[2 * xRadius + 1, 2 * yRadius + 1];
|
|
|
|
long ellipseError = 0L;
|
|
long stoppingX = twoBSquared * xRadius;
|
|
long stoppingY = 0L;
|
|
long xChange = yRadius * yRadius * (1L - 2L * xRadius);
|
|
long yChange = xRadius * xRadius;
|
|
|
|
int xPos = xRadius;
|
|
int yPos = 0;
|
|
|
|
// first set of points
|
|
while(stoppingX >= stoppingY)
|
|
{
|
|
int yUpper = yRadius + yPos;
|
|
int yLower = yRadius - yPos;
|
|
// fill in the mask
|
|
int xNow = xPos;
|
|
while(xNow >= 0)
|
|
{
|
|
mask[xRadius + xNow, yUpper] = true;
|
|
mask[xRadius - xNow, yUpper] = true;
|
|
mask[xRadius + xNow, yLower] = true;
|
|
mask[xRadius - xNow, yLower] = true;
|
|
--xNow;
|
|
}
|
|
yPos++;
|
|
stoppingY += twoASquared;
|
|
ellipseError += yChange;
|
|
yChange += twoASquared;
|
|
if ((2L * ellipseError + xChange) > 0L)
|
|
{
|
|
xPos--;
|
|
stoppingX -= twoBSquared;
|
|
ellipseError += xChange;
|
|
xChange += twoBSquared;
|
|
}
|
|
}
|
|
|
|
// second set of points
|
|
xPos = 0;
|
|
yPos = yRadius;
|
|
xChange = yRadius * yRadius;
|
|
yChange = xRadius * xRadius * (1L - 2L * yRadius);
|
|
|
|
ellipseError = 0L;
|
|
stoppingX = 0L;
|
|
stoppingY = twoASquared * yRadius;
|
|
|
|
while(stoppingX <= stoppingY)
|
|
{
|
|
int xUpper = xRadius + xPos;
|
|
int xLower = xRadius - xPos;
|
|
// fill in the mask
|
|
int yNow = yPos;
|
|
while(yNow >= 0)
|
|
{
|
|
mask[xUpper, yRadius + yNow] = true;
|
|
mask[xUpper, yRadius - yNow] = true;
|
|
mask[xLower, yRadius + yNow] = true;
|
|
mask[xLower, yRadius - yNow] = true;
|
|
--yNow;
|
|
}
|
|
xPos++;
|
|
stoppingX += twoBSquared;
|
|
ellipseError += xChange;
|
|
xChange += twoBSquared;
|
|
if ((2L * ellipseError + yChange) > 0L)
|
|
{
|
|
yPos--;
|
|
stoppingY -= twoASquared;
|
|
ellipseError += yChange;
|
|
yChange += twoASquared;
|
|
}
|
|
}
|
|
return mask;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|