Start of the OpenSim library , for now only contains a few textures.

21 files changed, 3328 insertions, 3328 deletions

diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Bitmap/Bitmap.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Bitmap/Bitmap.cs
index 1ef09fc..4093f51 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Bitmap/Bitmap.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Bitmap/Bitmap.cs
@@ -1,74 +1,74 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-using System.Drawing;

-

-namespace libTerrain

-{

-    class Raster

-    {

-        int w;

-        int h;

-        Bitmap bmp;

-

-        public Raster(int width, int height)

-        {

-            w = width;

-            h = height;

-            bmp = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);

-        }

-

-        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;

-        }

-

-        public void DrawText(string txt, string font, double size)

-        {

-            Graphics gd = Graphics.FromImage(bmp);

-            //gd.DrawString(txt,

-

-            

-        }

-    }

-}

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+using System.Drawing;
+
+namespace libTerrain
+{
+    class Raster
+    {
+        int w;
+        int h;
+        Bitmap bmp;
+
+        public Raster(int width, int height)
+        {
+            w = width;
+            h = height;
+            bmp = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
+        }
+
+        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;
+        }
+
+        public void DrawText(string txt, string font, double size)
+        {
+            Graphics gd = Graphics.FromImage(bmp);
+            //gd.DrawString(txt,
+
+            
+        }
+    }
+}
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Channel.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Channel.cs
index 6dfee1f..2e84409 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Channel.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Channel.cs
@@ -1,66 +1,66 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-

-/*  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)];

-        }

-

-    }

-}

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+
+/*  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)];
+        }
+
+    }
+}
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Common.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Common.cs
index 1750418..b0182dc 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Common.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Common.cs
@@ -1,277 +1,277 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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[,])this.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)

-        {

-            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;

-        }

-    }

-}

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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[,])this.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)
+        {
+            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;
+        }
+    }
+}
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Editing/Flatten.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Editing/Flatten.cs
index 48f02e8..713ae23 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Editing/Flatten.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Editing/Flatten.cs
@@ -1,149 +1,149 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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);

-

-        }

-

-        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)

-                        z = 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);

-        }

-    }

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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);
+
+        }
+
+        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)
+                        z = 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);
+        }
+    }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Editing/Raise.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Editing/Raise.cs
index 1d04a4f..64d175c 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Editing/Raise.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Editing/Raise.cs
@@ -1,139 +1,139 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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)

-                        z = 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)

-                        z = 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)

-                        z = 0;

-

-                    Set(x, y, map[x, y] - (z * amount));

-                }

-            }

-        }

-    }

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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)
+                        z = 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)
+                        z = 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)
+                        z = 0;
+
+                    Set(x, y, map[x, y] - (z * amount));
+                }
+            }
+        }
+    }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/File.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/File.cs
index c0173c0..cfefb6b 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/File.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/File.cs
@@ -1,77 +1,77 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-using System.Drawing;

-

-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 = this.Copy();

-            outmap.Normalise();

-

-            Bitmap bit = new Bitmap(w, h, System.Drawing.Imaging.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);

-        }

-    }

-}

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+using System.Drawing;
+
+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 = this.Copy();
+            outmap.Normalise();
+
+            Bitmap bit = new Bitmap(w, h, System.Drawing.Imaging.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);
+        }
+    }
+}
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Fracture.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Fracture.cs
index 13dd1bc..2d42759 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Fracture.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Fracture.cs
@@ -1,145 +1,145 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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();

-        }

-    }

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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();
+        }
+    }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Gradient.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Gradient.cs
index 47b7a66..141fe04 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Gradient.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Gradient.cs
@@ -1,66 +1,66 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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();

-        }

-    }

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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();
+        }
+    }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/HillPlanter.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/HillPlanter.cs
index 5a697b1..aa18e40 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/HillPlanter.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/HillPlanter.cs
@@ -1,283 +1,283 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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();

-        }

-

-    }

-}

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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();
+        }
+
+    }
+}
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Noise.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Noise.cs
index 3cefcfe..d40302c 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Noise.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Noise.cs
@@ -1,56 +1,56 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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();

-                }

-            }

-        }

-    }

-}

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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();
+                }
+            }
+        }
+    }
+}
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Spiral.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Spiral.cs
index 80abfe5..59d877a 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Spiral.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Spiral.cs
@@ -1,156 +1,156 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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 = this.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();

-        }

-    }

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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 = this.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();
+        }
+    }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Voronoi.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Voronoi.cs
index eb8f7ba..3411ccf 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Voronoi.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Voronoi.cs
@@ -1,214 +1,214 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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();

-

-            Random generator = new Random(seed);

-            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();

-        }

-    }

-}

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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();
+
+            Random generator = new Random(seed);
+            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();
+        }
+    }
+}
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Worms.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Worms.cs
index ce36daf..ba2fad6 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Worms.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Generators/Worms.cs
@@ -1,74 +1,74 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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);

-                }

-            }

-        }

-    }

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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);
+                }
+            }
+        }
+    }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Grid.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Grid.cs
index e6b18f4..18e40b5 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Grid.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Grid.cs
@@ -1,350 +1,350 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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

-            {

-                this.Fill(0.5);

-            }

-

-            return this;

-        }

-

-        public Channel Normalise(double minv, double maxv)

-        {

-            SetDiff();

-

-            double max = FindMax();

-            double min = FindMin();

-

-            int x, y;

-

-            for (x = 0; x < w; x++)

-            {

-                for (y = 0; y < h; y++)

-                {

-                    double val = (map[x, y] - min) * (1.0 / max - min);

-                    val *= maxv - minv;

-                    val += minv;

-

-                    map[x, y] = val;

-                }

-            }

-

-            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;

-        }

-    }

-}

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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
+            {
+                this.Fill(0.5);
+            }
+
+            return this;
+        }
+
+        public Channel Normalise(double minv, double maxv)
+        {
+            SetDiff();
+
+            double max = FindMax();
+            double min = FindMin();
+
+            int x, y;
+
+            for (x = 0; x < w; x++)
+            {
+                for (y = 0; y < h; y++)
+                {
+                    double val = (map[x, y] - min) * (1.0 / max - min);
+                    val *= maxv - minv;
+                    val += minv;
+
+                    map[x, y] = val;
+                }
+            }
+
+            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;
+        }
+    }
+}
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/AerobicErosion.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/AerobicErosion.cs
index 589d360..5d2b4d4 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/AerobicErosion.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/AerobicErosion.cs
@@ -1,213 +1,213 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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;

-

-            this.Normalise();

-

-            wind = this.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;

-

-                this.Normalise();

-            }

-

-            Channel myself = this;

-            myself += sediment;

-            myself.Normalise();

-

-            if (debugImages)

-                this.SaveImage("testimg/output.png");

-        }

-    }

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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;
+
+            this.Normalise();
+
+            wind = this.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;
+
+                this.Normalise();
+            }
+
+            Channel myself = this;
+            myself += sediment;
+            myself.Normalise();
+
+            if (debugImages)
+                this.SaveImage("testimg/output.png");
+        }
+    }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/HydraulicErosion.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/HydraulicErosion.cs
index 36da77c..fb9e21e 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/HydraulicErosion.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/HydraulicErosion.cs
@@ -1,146 +1,146 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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;

-                        }

-                    }

-                }

-

-            }

-        }

-    }

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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;
+                        }
+                    }
+                }
+
+            }
+        }
+    }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/NavierStokes.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/NavierStokes.cs
index 8a111ed..1cd213b 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/NavierStokes.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/NavierStokes.cs
@@ -1,307 +1,307 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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));

-        }

-

-        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(this.map, N, ref dens);

-            nsDoublesToBuffer(this.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 this.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(this.h, rounds, dt, diff, visc);

-        }

-

-        public void navierStokes(int rounds, double dt, double diff, double visc, ref double[,] uret, ref double[,] vret)

-        {

-            int N = this.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(this.map, N, ref dens);

-            nsDoublesToBuffer(this.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 this.map);

-        }

-    }

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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));
+        }
+
+        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(this.map, N, ref dens);
+            nsDoublesToBuffer(this.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 this.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(this.h, rounds, dt, diff, visc);
+        }
+
+        public void navierStokes(int rounds, double dt, double diff, double visc, ref double[,] uret, ref double[,] vret)
+        {
+            int N = this.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(this.map, N, ref dens);
+            nsDoublesToBuffer(this.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 this.map);
+        }
+    }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/ThermalWeathering.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/ThermalWeathering.cs
index 07c7d66..695d501 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/ThermalWeathering.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Manipulators/ThermalWeathering.cs
@@ -1,112 +1,112 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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;

-        }

-    }

-}

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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;
+        }
+    }
+}
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Neighbours.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Neighbours.cs
index 6dc2e30..da03871 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Neighbours.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Neighbours.cs
@@ -1,141 +1,141 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-namespace libTerrain

-{

-    partial class Channel

-    {

-        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;

-        }

-    }

-}

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+namespace libTerrain
+{
+    partial class Channel
+    {
+        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;
+        }
+    }
+}
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Operators.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Operators.cs
index 3199ddc..8184f06 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Operators.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Channel/Operators.cs
@@ -1,243 +1,243 @@
-/*

-* Copyright (c) Contributors, http://www.openmetaverse.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;

-using System.Text;

-

-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;

-        }

-

-    }

-}

+/*
+* Copyright (c) Contributors, http://www.openmetaverse.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;
+using System.Text;
+
+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;
+        }
+
+    }
+}
diff --git a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Tools/Point2D.cs b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Tools/Point2D.cs
index 69c1148..785ba0d 100644
--- a/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Tools/Point2D.cs
+++ b/OpenSim/Region/Terrain.BasicTerrain/libTerrainBSD/Tools/Point2D.cs
@@ -1,49 +1,49 @@
-/*

-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 libTerrain 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 COPYRIGHT HOLDERS AND CONTRIBUTORS

-"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 COPYRIGHT

-OWNER OR 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;

-using System.Text;

-

-namespace libTerrain

-{

-    public class Point2D

-    {

-        public double x;

-        public double y;

-

-        public Point2D(double X, double Y)

-        {

-            x = X;

-            y = Y;

-        }

-    }

-}

+/*
+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 libTerrain 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 COPYRIGHT HOLDERS AND CONTRIBUTORS
+"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 COPYRIGHT
+OWNER OR 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;
+using System.Text;
+
+namespace libTerrain
+{
+    public class Point2D
+    {
+        public double x;
+        public double y;
+
+        public Point2D(double X, double Y)
+        {
+            x = X;
+            y = Y;
+        }
+    }
+}