1 files changed, 169 insertions, 80 deletions

diff --git a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
index b7030f1..817cc22 100644
--- a/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
+++ b/OpenSim/Region/Physics/OdePlugin/OdePlugin.cs
@@ -227,13 +227,11 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         public int bodyFramesAutoDisable = 20;
 
-        private float[] _heightmap;
+        
 
         private float[] _watermap;
         private bool m_filterCollisions = true;
 
-        private float[] _origheightmap;    // Used for Fly height. Kitto Flora
-
         private d.NearCallback nearCallback;
         public d.TriCallback triCallback;
         public d.TriArrayCallback triArrayCallback;
@@ -257,6 +255,8 @@ namespace OpenSim.Region.Physics.OdePlugin
         private Object externalJointRequestsLock = new Object();
         private readonly Dictionary<String, PhysicsJoint> SOPName_to_activeJoint = new Dictionary<String, PhysicsJoint>();
         private readonly Dictionary<String, PhysicsJoint> SOPName_to_pendingJoint = new Dictionary<String, PhysicsJoint>();
+        private readonly DoubleDictionary<Vector3, IntPtr, IntPtr> RegionTerrain = new DoubleDictionary<Vector3, IntPtr, IntPtr>();
+        private readonly Dictionary<IntPtr,float[]> TerrainHeightFieldHeights = new Dictionary<IntPtr, float[]>();
 
         private d.Contact contact;
         private d.Contact TerrainContact;
@@ -311,6 +311,10 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         private volatile int m_global_contactcount = 0;
 
+        private Vector3 m_worldOffset = Vector3.Zero;
+        public Vector2 WorldExtents = new Vector2((int)Constants.RegionSize, (int)Constants.RegionSize);
+        private PhysicsScene m_parentScene = null;
+
         private ODERayCastRequestManager m_rayCastManager;
 
         /// <summary>
@@ -347,11 +351,7 @@ namespace OpenSim.Region.Physics.OdePlugin
                 #endif
             }
 
-            // zero out a heightmap array float array (single dimension [flattened]))
-            if ((int)Constants.RegionSize == 256)
-                _heightmap = new float[514*514];
-            else
-                _heightmap = new float[(((int)Constants.RegionSize + 2) * ((int)Constants.RegionSize + 2))];
+
             _watermap = new float[258 * 258];
 
             // Zero out the prim spaces array (we split our space into smaller spaces so
@@ -1556,28 +1556,65 @@ namespace OpenSim.Region.Physics.OdePlugin
         }
 
         #endregion
-       
+
+        public override void Combine(PhysicsScene pScene, Vector3 offset, Vector3 extents)
+        {
+            m_worldOffset = offset;
+            WorldExtents = new Vector2(extents.X, extents.Y);
+            m_parentScene = pScene;
+            
+        }
 // Recovered for use by fly height. Kitto Flora
         public float GetTerrainHeightAtXY(float x, float y)
         {
 
-            int index;
+            int offsetX = ((int) (x/256)) * 256;
+            int offsetY = ((int) (y/256)) * 256;
 
-            // Teravus: Kitto, this code causes recurring errors that stall physics permenantly unless 
-            // the values are checked, so checking below.
-            // Is there any reason that we don't do this in ScenePresence?   
-            // The only physics engine that benefits from it in the physics plugin is this one
+            IntPtr heightFieldGeom = IntPtr.Zero;
 
-            if ((int)x > Constants.RegionSize || (int)y > Constants.RegionSize || 
-                (int)x < 0.001f || (int)y < 0.001f)
-                return 0;
+            if (RegionTerrain.TryGetValue(new Vector3(offsetX,offsetY,0), out heightFieldGeom))
+            {
+                if (heightFieldGeom != IntPtr.Zero)
+                {
+                    if (TerrainHeightFieldHeights.ContainsKey(heightFieldGeom))
+                    {
+                        
+                        int index;
+
+
+                        if ((int)x > WorldExtents.X || (int)y > WorldExtents.Y ||
+                            (int)x < 0.001f || (int)y < 0.001f)
+                            return 0;
 
-            index = (int) ((int)y * Constants.RegionSize + (int)x);
+                        x = x - offsetX;
+                        y = y - offsetY;
 
-            if (index < _origheightmap.Length)
-                return (float)_origheightmap[(int)y * Constants.RegionSize + (int)x];
+                        index = (int)((int)y * (int)Constants.RegionSize + (int)x);
+
+                        if (index < TerrainHeightFieldHeights[heightFieldGeom].Length)
+                            return (float)TerrainHeightFieldHeights[heightFieldGeom][(int)y * (int)Constants.RegionSize + (int)x];
+                        else
+                            return 0f;
+                    }
+                    else
+                    {
+                        return 0f;
+                    }
+
+                }
+                else
+                {
+                    return 0f;
+                }
+
+            }
             else
-                return 0;
+            {
+                return 0f;
+            }
+
+
         } 
 // End recovered. Kitto Flora
 
@@ -1646,6 +1683,7 @@ namespace OpenSim.Region.Physics.OdePlugin
         private PhysicsActor AddPrim(String name, PhysicsVector position, PhysicsVector size, Quaternion rotation,
                                      IMesh mesh, PrimitiveBaseShape pbs, bool isphysical)
         {
+            
             PhysicsVector pos = new PhysicsVector(position.X, position.Y, position.Z);
             //pos.X = position.X;
             //pos.Y = position.Y;
@@ -2548,6 +2586,9 @@ namespace OpenSim.Region.Physics.OdePlugin
             if (framecount >= int.MaxValue)
                 framecount = 0;
 
+            //if (m_worldOffset != Vector3.Zero)
+            //    return 0;
+
             framecount++;
 
             float fps = 0;
@@ -3006,14 +3047,14 @@ namespace OpenSim.Region.Physics.OdePlugin
         public float[] ResizeTerrain512NearestNeighbour(float[] heightMap)
         {
             float[] returnarr = new float[262144];
-            float[,] resultarr = new float[m_regionWidth, m_regionHeight];
+            float[,] resultarr = new float[(int)WorldExtents.X, (int)WorldExtents.Y];
 
             // Filling out the array into its multi-dimensional components
-            for (int y = 0; y < m_regionHeight; y++)
+            for (int y = 0; y < WorldExtents.Y; y++)
             {
-                for (int x = 0; x < m_regionWidth; x++)
+                for (int x = 0; x < WorldExtents.X; x++)
                 {
-                    resultarr[y, x] = heightMap[y * m_regionWidth + x];
+                    resultarr[y, x] = heightMap[y * (int)WorldExtents.Y + x];
                 }
             }
 
@@ -3077,21 +3118,21 @@ namespace OpenSim.Region.Physics.OdePlugin
             // on single loop.
 
             float[,] resultarr2 = new float[512, 512];
-            for (int y = 0; y < m_regionHeight; y++)
+            for (int y = 0; y < WorldExtents.Y; y++)
             {
-                for (int x = 0; x < m_regionWidth; x++)
+                for (int x = 0; x < WorldExtents.X; x++)
                 {
                     resultarr2[y * 2, x * 2] = resultarr[y, x];
 
-                    if (y < m_regionHeight)
+                    if (y < WorldExtents.Y)
                     {
                         resultarr2[(y * 2) + 1, x * 2] = resultarr[y, x];
                     }
-                    if (x < m_regionWidth)
+                    if (x < WorldExtents.X)
                     {
                         resultarr2[y * 2, (x * 2) + 1] = resultarr[y, x];
                     }
-                    if (x < m_regionWidth && y < m_regionHeight)
+                    if (x < WorldExtents.X && y < WorldExtents.Y)
                     {
                         resultarr2[(y * 2) + 1, (x * 2) + 1] = resultarr[y, x];
                     }
@@ -3119,14 +3160,14 @@ namespace OpenSim.Region.Physics.OdePlugin
         public float[] ResizeTerrain512Interpolation(float[] heightMap)
         {
             float[] returnarr = new float[262144];
-            float[,] resultarr = new float[m_regionWidth,m_regionHeight];
+            float[,] resultarr = new float[512,512];
 
             // Filling out the array into its multi-dimensional components
-            for (int y = 0; y < m_regionHeight; y++)
+            for (int y = 0; y < 256; y++)
             {
-                for (int x = 0; x < m_regionWidth; x++)
+                for (int x = 0; x < 256; x++)
                 {
-                    resultarr[y, x] = heightMap[y*m_regionWidth + x];
+                    resultarr[y, x] = heightMap[y * 256 + x];
                 }
             }
 
@@ -3190,17 +3231,17 @@ namespace OpenSim.Region.Physics.OdePlugin
             // on single loop.
 
             float[,] resultarr2 = new float[512,512];
-            for (int y = 0; y < m_regionHeight; y++)
+            for (int y = 0; y < (int)Constants.RegionSize; y++)
             {
-                for (int x = 0; x < m_regionWidth; x++)
+                for (int x = 0; x < (int)Constants.RegionSize; x++)
                 {
                     resultarr2[y*2, x*2] = resultarr[y, x];
 
-                    if (y < m_regionHeight)
+                    if (y < (int)Constants.RegionSize)
                     {
-                        if (y + 1 < m_regionHeight)
+                        if (y + 1 < (int)Constants.RegionSize)
                         {
-                            if (x + 1 < m_regionWidth)
+                            if (x + 1 < (int)Constants.RegionSize)
                             {
                                 resultarr2[(y*2) + 1, x*2] = ((resultarr[y, x] + resultarr[y + 1, x] +
                                                                resultarr[y, x + 1] + resultarr[y + 1, x + 1])/4);
@@ -3215,11 +3256,11 @@ namespace OpenSim.Region.Physics.OdePlugin
                             resultarr2[(y*2) + 1, x*2] = resultarr[y, x];
                         }
                     }
-                    if (x < m_regionWidth)
+                    if (x < (int)Constants.RegionSize)
                     {
-                        if (x + 1 < m_regionWidth)
+                        if (x + 1 < (int)Constants.RegionSize)
                         {
-                            if (y + 1 < m_regionHeight)
+                            if (y + 1 < (int)Constants.RegionSize)
                             {
                                 resultarr2[y*2, (x*2) + 1] = ((resultarr[y, x] + resultarr[y + 1, x] +
                                                                resultarr[y, x + 1] + resultarr[y + 1, x + 1])/4);
@@ -3234,9 +3275,9 @@ namespace OpenSim.Region.Physics.OdePlugin
                             resultarr2[y*2, (x*2) + 1] = resultarr[y, x];
                         }
                     }
-                    if (x < m_regionWidth && y < m_regionHeight)
+                    if (x < (int)Constants.RegionSize && y < (int)Constants.RegionSize)
                     {
-                        if ((x + 1 < m_regionWidth) && (y + 1 < m_regionHeight))
+                        if ((x + 1 < (int)Constants.RegionSize) && (y + 1 < (int)Constants.RegionSize))
                         {
                             resultarr2[(y*2) + 1, (x*2) + 1] = ((resultarr[y, x] + resultarr[y + 1, x] +
                                                                  resultarr[y, x + 1] + resultarr[y + 1, x + 1])/4);
@@ -3271,41 +3312,68 @@ namespace OpenSim.Region.Physics.OdePlugin
 
         public override void SetTerrain(float[] heightMap)
         {
-            // this._heightmap[i] = (double)heightMap[i];
-            // dbm (danx0r) -- creating a buffer zone of one extra sample all around
-            _origheightmap = heightMap;    // Used for Fly height. Kitto Flora
-            uint heightmapWidth = m_regionWidth + 1;
-            uint heightmapHeight = m_regionHeight + 1;
-
-            uint heightmapWidthSamples; 
-            
-            uint heightmapHeightSamples;
-            if (((int)Constants.RegionSize) == 256)
+            if (m_worldOffset != Vector3.Zero && m_parentScene != null)
             {
-                heightmapWidthSamples = 2*m_regionWidth + 2;
-                heightmapHeightSamples = 2*m_regionHeight + 2;
-                heightmapWidth++;
-                heightmapHeight++;
+                if (m_parentScene is OdeScene)
+                {
+                    ((OdeScene)m_parentScene).SetTerrain(heightMap, m_worldOffset);
+                }
             }
             else
             {
-                heightmapWidthSamples = m_regionWidth + 1;
-                heightmapHeightSamples = m_regionHeight + 1;
+                SetTerrain(heightMap, m_worldOffset);
             }
+        }
+
+        public void SetTerrain(float[] heightMap, Vector3 pOffset)
+        {
+            // this._heightmap[i] = (double)heightMap[i];
+            // dbm (danx0r) -- creating a buffer zone of one extra sample all around
+            //_origheightmap = heightMap;    
+           
+            float[] _heightmap;
+
+            // zero out a heightmap array float array (single dimension [flattened]))
+            //if ((int)Constants.RegionSize == 256)
+            //    _heightmap = new float[514 * 514];
+            //else
+
+            _heightmap = new float[(((int)Constants.RegionSize + 2) * ((int)Constants.RegionSize + 2))];
+
+            uint heightmapWidth = Constants.RegionSize + 1;
+            uint heightmapHeight = Constants.RegionSize + 1;
+
+            uint heightmapWidthSamples;
+
+            uint heightmapHeightSamples;
+
+            //if (((int)Constants.RegionSize) == 256)
+            //{
+            //    heightmapWidthSamples = 2 * (uint)Constants.RegionSize + 2;
+            //    heightmapHeightSamples = 2 * (uint)Constants.RegionSize + 2;
+            //    heightmapWidth++;
+            //    heightmapHeight++;
+            //}
+            //else
+            //{
+
+                heightmapWidthSamples = (uint)Constants.RegionSize + 1;
+                heightmapHeightSamples = (uint)Constants.RegionSize + 1;
+            //}
 
             const float scale = 1.0f;
             const float offset = 0.0f;
             const float thickness = 0.2f;
             const int wrap = 0;
-            
 
+            int regionsize = (int) Constants.RegionSize;
             //Double resolution
-            if (((int)Constants.RegionSize) == 256)
-                heightMap = ResizeTerrain512Interpolation(heightMap);
+            //if (((int)Constants.RegionSize) == 256)
+            //    heightMap = ResizeTerrain512Interpolation(heightMap);
 
-            int regionsize = (int)Constants.RegionSize;
-            if (regionsize == 256)
-                regionsize = 512;
+
+           // if (((int)Constants.RegionSize) == 256 && (int)Constants.RegionSize == 256)
+           //     regionsize = 512;
 
             float hfmin = 2000;
             float hfmax = -2000;
@@ -3316,8 +3384,8 @@ namespace OpenSim.Region.Physics.OdePlugin
                     int xx = Util.Clip(x - 1, 0, regionsize - 1);
                     int yy = Util.Clip(y - 1, 0, regionsize - 1);
 
-                    float val = heightMap[yy*regionsize + xx];
-                    _heightmap[x*heightmapHeightSamples + y] = val;
+                    float val = heightMap[yy * regionsize + xx];
+                    _heightmap[x * heightmapHeightSamples + y] = val;
                     hfmin = (val < hfmin) ? val : hfmin;
                     hfmax = (val > hfmax) ? val : hfmax;
                 }
@@ -3325,23 +3393,34 @@ namespace OpenSim.Region.Physics.OdePlugin
 
             lock (OdeLock)
             {
-                if (LandGeom != IntPtr.Zero)
+                IntPtr GroundGeom = IntPtr.Zero;
+                if (RegionTerrain.TryGetValue(pOffset, out GroundGeom))
                 {
-                    d.SpaceRemove(space, LandGeom);
+                    RegionTerrain.Remove(pOffset);
+                    if (GroundGeom != IntPtr.Zero)
+                    {
+                        if (TerrainHeightFieldHeights.ContainsKey(GroundGeom))
+                        {
+                            TerrainHeightFieldHeights.Remove(GroundGeom);
+                        }
+                        d.SpaceRemove(space, GroundGeom);
+                        d.GeomDestroy(GroundGeom);
+                    }
+
                 }
                 IntPtr HeightmapData = d.GeomHeightfieldDataCreate();
                 d.GeomHeightfieldDataBuildSingle(HeightmapData, _heightmap, 0, heightmapWidth, heightmapHeight,
-                                                 (int) heightmapWidthSamples, (int) heightmapHeightSamples, scale,
+                                                 (int)heightmapWidthSamples, (int)heightmapHeightSamples, scale,
                                                  offset, thickness, wrap);
-                d.GeomHeightfieldDataSetBounds(HeightmapData, hfmin - 1 , hfmax + 1);
-                LandGeom = d.CreateHeightfield(space, HeightmapData, 1);
-                if (LandGeom != IntPtr.Zero)
+                d.GeomHeightfieldDataSetBounds(HeightmapData, hfmin - 1, hfmax + 1);
+                GroundGeom = d.CreateHeightfield(space, HeightmapData, 1);
+                if (GroundGeom != IntPtr.Zero)
                 {
-                    d.GeomSetCategoryBits(LandGeom, (int)(CollisionCategories.Land));
-                    d.GeomSetCollideBits(LandGeom, (int)(CollisionCategories.Space));
+                    d.GeomSetCategoryBits(GroundGeom, (int)(CollisionCategories.Land));
+                    d.GeomSetCollideBits(GroundGeom, (int)(CollisionCategories.Space));
 
                 }
-                geom_name_map[LandGeom] = "Terrain";
+                geom_name_map[GroundGeom] = "Terrain";
 
                 d.Matrix3 R = new d.Matrix3();
 
@@ -3349,15 +3428,23 @@ namespace OpenSim.Region.Physics.OdePlugin
                 Quaternion q2 = Quaternion.CreateFromAxisAngle(new Vector3(0, 1, 0), 1.5707f);
                 //Axiom.Math.Quaternion q3 = Axiom.Math.Quaternion.FromAngleAxis(3.14f, new Axiom.Math.Vector3(0, 0, 1));
 
-                q1 = q1*q2;
+                q1 = q1 * q2;
                 //q1 = q1 * q3;
                 Vector3 v3;
                 float angle;
                 q1.GetAxisAngle(out v3, out angle);
 
                 d.RFromAxisAndAngle(out R, v3.X, v3.Y, v3.Z, angle);
-                d.GeomSetRotation(LandGeom, ref R);
-                d.GeomSetPosition(LandGeom, (int)Constants.RegionSize * 0.5f, (int)Constants.RegionSize * 0.5f, 0);
+                d.GeomSetRotation(GroundGeom, ref R);
+                d.GeomSetPosition(GroundGeom, pOffset.X + ((int)Constants.RegionSize * 0.5f), pOffset.Y + ((int)Constants.RegionSize * 0.5f), 0);
+                IntPtr testGround = IntPtr.Zero;
+                if (RegionTerrain.TryGetValue(pOffset, out testGround))
+                {
+                    RegionTerrain.Remove(pOffset);
+                }
+                RegionTerrain.Add(pOffset, GroundGeom, GroundGeom);
+                TerrainHeightFieldHeights.Add(GroundGeom,_heightmap);
+                
             }
         }
 
@@ -3370,6 +3457,8 @@ namespace OpenSim.Region.Physics.OdePlugin
             return waterlevel;
         }
 
+
+
         public override void SetWaterLevel(float baseheight)
         {
             waterlevel = baseheight;