1 files changed, 105 insertions, 127 deletions

diff --git a/OpenSim/Framework/TerrainData.cs b/OpenSim/Framework/TerrainData.cs
index 5cec2b5..0e5e83e 100644
--- a/OpenSim/Framework/TerrainData.cs
+++ b/OpenSim/Framework/TerrainData.cs
@@ -37,52 +37,6 @@ using log4net;
 
 namespace OpenSim.Framework
 {
-    public abstract class TerrainData
-    {
-        // Terrain always is a square
-        public int SizeX { get; protected set; }
-        public int SizeY { get; protected set; }
-        public int SizeZ { get; protected set; }
-
-        // A height used when the user doesn't specify anything
-        public const float DefaultTerrainHeight = 21f;
-
-        public abstract float this[int x, int y] { get; set; }
-        // Someday terrain will have caves
-        // at most holes :p
-        public abstract float this[int x, int y, int z] { get; set; }
-
-        public abstract bool IsTaintedAt(int xx, int yy);
-        public abstract bool IsTaintedAt(int xx, int yy, bool clearOnTest);
-        public abstract void TaintAllTerrain();
-        public abstract void ClearTaint();
-
-        public abstract void ClearLand();
-        public abstract void ClearLand(float height);
-
-        // Return a representation of this terrain for storing as a blob in the database.
-        // Returns 'true' to say blob was stored in the 'out' locations.
-        public abstract bool GetDatabaseBlob(out int DBFormatRevisionCode, out Array blob);
-
-        // Given a revision code and a blob from the database, create and return the right type of TerrainData.
-        // The sizes passed are the expected size of the region. The database info will be used to
-        //     initialize the heightmap of that sized region with as much data is in the blob.
-        // Return created TerrainData or 'null' if unsuccessful.
-        public static TerrainData CreateFromDatabaseBlobFactory(int pSizeX, int pSizeY, int pSizeZ, int pFormatCode, byte[] pBlob)
-        {
-            // For the moment, there is only one implementation class
-            return new HeightmapTerrainData(pSizeX, pSizeY, pSizeZ, pFormatCode, pBlob);
-        }
-
-        // return a special compressed representation of the heightmap in ushort
-        public abstract float[] GetCompressedMap();
-        public abstract float CompressionFactor { get; }
-
-        public abstract float[] GetFloatsSerialized();
-        public abstract double[,] GetDoubles();
-        public abstract TerrainData Clone();
-    }
-
     // The terrain is stored in the database as a blob with a 'revision' field.
     // Some implementations of terrain storage would fill the revision field with
     //    the time the terrain was stored. When real revisions were added and this
@@ -112,18 +66,37 @@ namespace OpenSim.Framework
         RevisionHigh = 1234
     }
 
-    // Version of terrain that is a heightmap.
-    // This should really be 'LLOptimizedHeightmapTerrainData' as it includes knowledge
-    //    of 'patches' which are 16x16 terrain areas which can be sent separately to the viewer.
-    // The heighmap is kept as an array of ushorts. The ushort values are converted to
-    //    and from floats by TerrainCompressionFactor.
-    public class HeightmapTerrainData : TerrainData
+    public class TerrainData
     {
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        private static string LogHeader = "[HEIGHTMAP TERRAIN DATA]";
+        private static string LogHeader = "[TERRAIN DATA]";
+
+        private float[,] m_heightmap;
+        // Remember subregions of the heightmap that has changed.
+        private bool[,] m_taint;
+
+        // legacy CompressionFactor
+        public float CompressionFactor { get; private set; }
+
+        // Terrain always is a square
+        public int SizeX { get; protected set; }
+        public int SizeY { get; protected set; }
+        public int SizeZ { get; protected set; }
+
+        // A height used when the user doesn't specify anything
+        public const float DefaultTerrainHeight = 21f;
+
+        // Given a revision code and a blob from the database, create and return the right type of TerrainData.
+        // The sizes passed are the expected size of the region. The database info will be used to
+        //     initialize the heightmap of that sized region with as much data is in the blob.
+        // Return created TerrainData or 'null' if unsuccessful.
+        public static TerrainData CreateFromDatabaseBlobFactory(int pSizeX, int pSizeY, int pSizeZ, int pFormatCode, byte[] pBlob)
+        {
+            // For the moment, there is only one implementation class
+            return new TerrainData(pSizeX, pSizeY, pSizeZ, pFormatCode, pBlob);
+        }
 
-        // TerrainData.this[x, y]
-        public override float this[int x, int y]
+        public float this[int x, int y]
         {
             get { return m_heightmap[x, y]; }
             set
@@ -136,21 +109,18 @@ namespace OpenSim.Framework
             }
         }
 
-        // TerrainData.this[x, y, z]
-        public override float this[int x, int y, int z]
+        public float this[int x, int y, int z]
         {
             get { return this[x, y]; }
             set { this[x, y] = value; }
         }
 
-        // TerrainData.ClearTaint
-        public override void ClearTaint()
+        public void ClearTaint()
         {
             SetAllTaint(false);
         }
 
-        // TerrainData.TaintAllTerrain
-        public override void TaintAllTerrain()
+        public void TaintAllTerrain()
         {
             SetAllTaint(true);
         }
@@ -162,13 +132,12 @@ namespace OpenSim.Framework
                     m_taint[ii, jj] = setting;
         }
 
-        // TerrainData.ClearLand
-        public override void ClearLand()
+        public void ClearLand()
         {
             ClearLand(DefaultTerrainHeight);
         }
-        // TerrainData.ClearLand(float)
-        public override void ClearLand(float pHeight)
+
+        public void ClearLand(float pHeight)
         {
             for (int xx = 0; xx < SizeX; xx++)
                 for (int yy = 0; yy < SizeY; yy++)
@@ -178,7 +147,7 @@ namespace OpenSim.Framework
         // Return 'true' of the patch that contains these region coordinates has been modified.
         // Note that checking the taint clears it.
         // There is existing code that relies on this feature.
-        public override bool IsTaintedAt(int xx, int yy, bool clearOnTest)
+        public bool IsTaintedAt(int xx, int yy, bool clearOnTest)
         {
             int tx = xx / Constants.TerrainPatchSize;
             int ty = yy / Constants.TerrainPatchSize;
@@ -191,41 +160,22 @@ namespace OpenSim.Framework
         // Old form that clears the taint flag when we check it.
         // ubit: this dangerus naming should be only check without clear
         // keeping for old modules outthere
-        public override bool IsTaintedAt(int xx, int yy)
+        public bool IsTaintedAt(int xx, int yy)
         {
             return IsTaintedAt(xx, yy, true /* clearOnTest */);
         }
 
         // TerrainData.GetDatabaseBlob
         // The user wants something to store in the database.
-        public override bool GetDatabaseBlob(out int DBRevisionCode, out Array blob)
+        public bool GetDatabaseBlob(out int DBRevisionCode, out Array blob)
         {
-            bool ret = false;
-/* save all as Variable2DGzip
-            if (SizeX == Constants.RegionSize && SizeY == Constants.RegionSize)
-            {
-                DBRevisionCode = (int)DBTerrainRevision.Legacy256;
-                blob = ToLegacyTerrainSerialization();
-                ret = true;
-            }
-            else
-            {
-*/
-                DBRevisionCode = (int)DBTerrainRevision.Variable2DGzip;
-//                DBRevisionCode = (int)DBTerrainRevision.Variable2D;
-                blob = ToCompressedTerrainSerializationV2DGzip();
-//                blob = ToCompressedTerrainSerializationV2D();
-                ret = true;
-//            }
-            return ret;
+            DBRevisionCode = (int)DBTerrainRevision.Variable2DGzip;
+            blob = ToCompressedTerrainSerializationV2DGzip();
+            return true;
         }
 
-        // TerrainData.CompressionFactor
-        private float m_compressionFactor = 100.0f;
-        public override float CompressionFactor { get { return m_compressionFactor; } }
-
         // TerrainData.GetCompressedMap
-        public override float[] GetCompressedMap()
+        public float[] GetCompressedMap()
         {
             float[] newMap = new float[SizeX * SizeY];
 
@@ -235,21 +185,16 @@ namespace OpenSim.Framework
                     newMap[ind++] = m_heightmap[xx, yy];
 
             return newMap;
-
         }
-        // TerrainData.Clone
-        public override TerrainData Clone()
+
+        public TerrainData Clone()
         {
-            HeightmapTerrainData ret = new HeightmapTerrainData(SizeX, SizeY, SizeZ);
+            TerrainData ret = new TerrainData(SizeX, SizeY, SizeZ);
             ret.m_heightmap = (float[,])this.m_heightmap.Clone();
             return ret;
         }
 
-        // TerrainData.GetFloatsSerialized
-        // This one dimensional version is ordered so height = map[y*sizeX+x];
-        // DEPRECATED: don't use this function as it does not retain the dimensions of the terrain
-        //     and the caller will probably do the wrong thing if the terrain is not the legacy 256x256.
-        public override float[] GetFloatsSerialized()
+        public float[] GetFloatsSerialized()
         {
             int points = SizeX * SizeY;
             float[] heights = new float[points];
@@ -264,8 +209,7 @@ namespace OpenSim.Framework
             return heights;
         }
 
-        // TerrainData.GetDoubles
-        public override double[,] GetDoubles()
+        public double[,] GetDoubles()
         {
             double[,] ret = new double[SizeX, SizeY];
             for (int xx = 0; xx < SizeX; xx++)
@@ -275,14 +219,53 @@ namespace OpenSim.Framework
             return ret;
         }
 
+        public unsafe void GetPatchMinMax(int px, int py, out float zmin, out float zmax)
+        {
+            zmax = float.MinValue;
+            zmin = float.MaxValue;
 
-        // =============================================================
+            int stride = m_heightmap.GetLength(1);
 
-        private float[,] m_heightmap;
-        // Remember subregions of the heightmap that has changed.
-        private bool[,] m_taint;
+            int startx = px * 16 * stride;
+            int endx = (px + 1) * 16 * stride;
+            int starty = py * 16;
+            fixed (float* map = m_heightmap)
+            {
+                for (int i = startx; i < endx; i += stride)
+                {
+                    float* p = &map[i];
+                    for (int j = starty; j < starty + 16; j++)
+                    {
+                        float val = p[j];
+                        if (val > zmax) zmax = val;
+                        if (val < zmin) zmin = val;
+                    }
+                }
+            }
+        }
+
+        public unsafe void GetPatchBlock(float[] _block, int px, int py, float sub, float premult)
+        {
+            int k = 0;
+            int stride = m_heightmap.GetLength(1);
 
-        //    that is coded as the float height times the compression factor (usually '100'
+            int startX = px * 16 * stride;
+            int endX = (px + 1) * 16 * stride;
+            int startY = py * 16;
+            fixed(float* block = _block, map = m_heightmap)
+            {
+                for (int y = startY; y < startY + 16; y++)
+                {
+                    for (int x = startX; x < endX; x += stride)
+                    {
+                        block[k++] = (map[x + y] - sub) * premult;
+                    }
+                }
+            }
+        }
+
+/*
+ //    that is coded as the float height times the compression factor (usually '100'
         //    to make for two decimal points).
         public short ToCompressedHeightshort(float pHeight)
         {
@@ -305,6 +288,7 @@ namespace OpenSim.Framework
                 return ushort.MaxValue;
             return (ushort)pHeight;
         }
+*/
 
         public float FromCompressedHeight(short pHeight)
         {
@@ -318,12 +302,12 @@ namespace OpenSim.Framework
 
         // To keep with the legacy theme, create an instance of this class based on the
         //     way terrain used to be passed around.
-        public HeightmapTerrainData(double[,] pTerrain)
+        public TerrainData(double[,] pTerrain)
         {
             SizeX = pTerrain.GetLength(0);
             SizeY = pTerrain.GetLength(1);
             SizeZ = (int)Constants.RegionHeight;
-            m_compressionFactor = 100.0f;
+            CompressionFactor = 100.0f;
 
             m_heightmap = new float[SizeX, SizeY];
             for (int ii = 0; ii < SizeX; ii++)
@@ -341,12 +325,12 @@ namespace OpenSim.Framework
         }
 
         // Create underlying structures but don't initialize the heightmap assuming the caller will immediately do that
-        public HeightmapTerrainData(int pX, int pY, int pZ)
+        public TerrainData(int pX, int pY, int pZ)
         {
             SizeX = pX;
             SizeY = pY;
             SizeZ = pZ;
-            m_compressionFactor = 100.0f;
+            CompressionFactor = 100.0f;
             m_heightmap = new float[SizeX, SizeY];
             m_taint = new bool[SizeX / Constants.TerrainPatchSize, SizeY / Constants.TerrainPatchSize];
             // m_log.DebugFormat("{0} new by dimensions. sizeX={1}, sizeY={2}, sizeZ={3}", LogHeader, SizeX, SizeY, SizeZ);
@@ -354,10 +338,10 @@ namespace OpenSim.Framework
             ClearLand(0f);
         }
 
-        public HeightmapTerrainData(float[] cmap, float pCompressionFactor, int pX, int pY, int pZ)
+        public TerrainData(float[] cmap, float pCompressionFactor, int pX, int pY, int pZ)
             : this(pX, pY, pZ)
         {
-            m_compressionFactor = pCompressionFactor;
+            CompressionFactor = pCompressionFactor;
             int ind = 0;
             for (int xx = 0; xx < SizeX; xx++)
                 for (int yy = 0; yy < SizeY; yy++)
@@ -366,7 +350,7 @@ namespace OpenSim.Framework
         }
 
         // Create a heighmap from a database blob
-        public HeightmapTerrainData(int pSizeX, int pSizeY, int pSizeZ, int pFormatCode, byte[] pBlob)
+        public TerrainData(int pSizeX, int pSizeY, int pSizeZ, int pFormatCode, byte[] pBlob)
             : this(pSizeX, pSizeY, pSizeZ)
         {
             switch ((DBTerrainRevision)pFormatCode)
@@ -476,13 +460,9 @@ namespace OpenSim.Framework
                     ret = str.ToArray();
                 }
             }
-            catch
-            {
-
-            }
+            catch {}
 
-            m_log.DebugFormat("{0} V2D {1} bytes",
-                     LogHeader, ret.Length);
+            m_log.DebugFormat("{0} V2D {1} bytes", LogHeader, ret.Length);
 
             return ret;
         }
@@ -502,7 +482,8 @@ namespace OpenSim.Framework
                         for (int yy = 0; yy < SizeY; yy++)
                             for (int xx = 0; xx < SizeX; xx++)
                             {
-                                bw.Write((float)m_heightmap[xx, yy]);
+                                //bw.Write((float)m_heightmap[xx, yy]);
+                                bw.Write((float)Math.Round(m_heightmap[xx, yy], 3, MidpointRounding.AwayFromZero));
                             }
 
                         bw.Flush();
@@ -520,12 +501,9 @@ namespace OpenSim.Framework
                     }
                 }
             }
-            catch
-            {
+            catch {}
 
-            }
-            m_log.DebugFormat("{0} V2DGzip {1} bytes",
-                 LogHeader, ret.Length);
+            m_log.DebugFormat("{0} V2DGzip {1} bytes", LogHeader, ret.Length);
             return ret;
         }
 
@@ -548,7 +526,7 @@ namespace OpenSim.Framework
                     hmSizeY = br.ReadInt32();
                     hmCompressionFactor = br.ReadInt32();
 
-                    m_compressionFactor = hmCompressionFactor;
+                    CompressionFactor = hmCompressionFactor;
 
                     // In case database info doesn't match real terrain size, initialize the whole terrain.
                     ClearLand();