38 files changed, 1729 insertions, 445 deletions
diff --git a/OpenSim/ApplicationPlugins/LoadRegions/LoadRegionsPlugin.cs b/OpenSim/ApplicationPlugins/LoadRegions/LoadRegionsPlugin.cs
index 1d63d26..74a7a50 100644
--- a/OpenSim/ApplicationPlugins/LoadRegions/LoadRegionsPlugin.cs
+++ b/OpenSim/ApplicationPlugins/LoadRegions/LoadRegionsPlugin.cs
@@ -184,11 +184,11 @@ namespace OpenSim.ApplicationPlugins.LoadRegions
                        return false;
                    }
                    else if (
-                        regions[i].RegionLocX == regions[j].RegionLocX && regions[i].RegionLocY == regions[j].RegionLocY)
+                        regions[i].LegacyRegionLocX == regions[j].LegacyRegionLocX && regions[i].LegacyRegionLocY == regions[j].LegacyRegionLocY)
                    {
                        m_log.ErrorFormat(
                            "[LOAD REGIONS PLUGIN]: Regions {0} and {1} have the same grid location ({2}, {3})",
-                            regions[i].RegionName, regions[j].RegionName, regions[i].RegionLocX, regions[i].RegionLocY);
+                            regions[i].RegionName, regions[j].RegionName, regions[i].LegacyRegionLocX, regions[i].LegacyRegionLocY);
                        return false;
                    }
                    else if (regions[i].InternalEndPoint.Port == regions[j].InternalEndPoint.Port)
diff --git a/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs b/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs
index c78cf3b..7afdd34 100644
--- a/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs
+++ b/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs
@@ -542,7 +542,7 @@ namespace OpenSim.ApplicationPlugins.RemoteController
                        throw new Exception(
                            String.Format("region UUID already in use by region {0}, UUID {1}, <{2},{3}>",
                                          scene.RegionInfo.RegionName, scene.RegionInfo.RegionID,
-                                          scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY));
+                                          scene.RegionInfo.LegacyRegionLocX, scene.RegionInfo.LegacyRegionLocY));
                }
                else
                {
@@ -556,8 +556,8 @@ namespace OpenSim.ApplicationPlugins.RemoteController
                region.RegionID = regionID;
                region.originRegionID = regionID;
                region.RegionName = (string) requestData["region_name"];
-                region.RegionLocX = Convert.ToUInt32(requestData["region_x"]);
+                region.LegacyRegionLocX = Convert.ToUInt32(requestData["region_x"]);
-                region.RegionLocY = Convert.ToUInt32(requestData["region_y"]);
+                region.LegacyRegionLocY = Convert.ToUInt32(requestData["region_y"]);
                // check for collisions: region name, region UUID,
                // region location
@@ -565,14 +565,14 @@ namespace OpenSim.ApplicationPlugins.RemoteController
                    throw new Exception(
                        String.Format("region name already in use by region {0}, UUID {1}, <{2},{3}>",
                                      scene.RegionInfo.RegionName, scene.RegionInfo.RegionID,
-                                      scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY));
+                                      scene.RegionInfo.LegacyRegionLocX, scene.RegionInfo.LegacyRegionLocY));
-                if (m_application.SceneManager.TryGetScene(region.RegionLocX, region.RegionLocY, out scene))
+                if (m_application.SceneManager.TryGetScene(region.LegacyRegionLocX, region.LegacyRegionLocY, out scene))
                    throw new Exception(
                        String.Format("region location <{0},{1}> already in use by region {2}, UUID {3}, <{4},{5}>",
-                                      region.RegionLocX, region.RegionLocY,
+                                      region.LegacyRegionLocX, region.LegacyRegionLocY,
                                      scene.RegionInfo.RegionName, scene.RegionInfo.RegionID,
-                                      scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY));
+                                      scene.RegionInfo.LegacyRegionLocX, scene.RegionInfo.LegacyRegionLocY));
                region.InternalEndPoint =
                    new IPEndPoint(IPAddress.Parse((string) requestData["listen_ip"]), 0);
@@ -586,7 +586,7 @@ namespace OpenSim.ApplicationPlugins.RemoteController
                            region.InternalEndPoint.Address,
                            region.InternalEndPoint.Port,
                            scene.RegionInfo.RegionName, scene.RegionInfo.RegionID,
-                            scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY));
+                            scene.RegionInfo.LegacyRegionLocX, scene.RegionInfo.LegacyRegionLocY));
                region.ExternalHostName = (string) requestData["external_address"];
@@ -625,8 +625,8 @@ namespace OpenSim.ApplicationPlugins.RemoteController
                                                        String.Format(
                                                            m_config.GetString("region_file_template",
                                                                               "{0}x{1}-{2}.ini"),
-                                                            region.RegionLocX.ToString(),
+                                                            region.LegacyRegionLocX.ToString(),
-                                                            region.RegionLocY.ToString(),
+                                                            region.LegacyRegionLocY.ToString(),
                                                            regionID.ToString(),
                                                            region.InternalEndPoint.Port.ToString(),
                                                            region.RegionName.Replace(" ", "_").Replace(":", "_").
diff --git a/OpenSim/Data/MSSQL/MSSQLSimulationData.cs b/OpenSim/Data/MSSQL/MSSQLSimulationData.cs
index f41f60c..dbfd16c 100644
--- a/OpenSim/Data/MSSQL/MSSQLSimulationData.cs
+++ b/OpenSim/Data/MSSQL/MSSQLSimulationData.cs
@@ -49,6 +49,7 @@ namespace OpenSim.Data.MSSQL
        // private static FileSystemDataStore Instance = new FileSystemDataStore();
        private static readonly ILog _Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[REGION DB MSSQL]";
        /// <summary>
        /// The database manager
@@ -569,15 +570,19 @@ ELSE
            return terrain;
        }
+        // Legacy entry point for when terrain was always a 256x256 hieghtmap
+        public void StoreTerrain(double[,] ter, UUID regionID)
+        {
+            StoreTerrain(new HeightmapTerrainData(ter), regionID);
+        }
        /// <summary>
        /// Stores the terrain map to DB.
        /// </summary>
        /// <param name="terrain">terrain map data.</param>
        /// <param name="regionID">regionID.</param>
-        public void StoreTerrain(double[,] terrain, UUID regionID)
+        public void StoreTerrain(TerrainData terrData, UUID regionID)
        {
-            int revision = Util.UnixTimeSinceEpoch();
            //Delete old terrain map
            string sql = "delete from terrain where RegionUUID=@RegionUUID";
            using (SqlConnection conn = new SqlConnection(m_connectionString))
@@ -590,17 +595,21 @@ ELSE
            sql = "insert into terrain(RegionUUID, Revision, Heightfield) values(@RegionUUID, @Revision, @Heightfield)";
+            int terrainDBRevision;
+            Array terrainDBblob;
+            terrData.GetDatabaseBlob(out terrainDBRevision, out terrainDBblob);
            using (SqlConnection conn = new SqlConnection(m_connectionString))
            using (SqlCommand cmd = new SqlCommand(sql, conn))
            {
                cmd.Parameters.Add(_Database.CreateParameter("@RegionUUID", regionID));
-                cmd.Parameters.Add(_Database.CreateParameter("@Revision", revision));
+                cmd.Parameters.Add(_Database.CreateParameter("@Revision", terrainDBRevision));
-                cmd.Parameters.Add(_Database.CreateParameter("@Heightfield", serializeTerrain(terrain)));
+                cmd.Parameters.Add(_Database.CreateParameter("@Heightfield", terrainDBblob));
                conn.Open();
                cmd.ExecuteNonQuery();
            }
-            _Log.Info("[REGION DB]: Stored terrain revision r " + revision);
+            _Log.InfoFormat("{0} Stored terrain revision r={1}", LogHeader, terrainDBRevision);
        }
        /// <summary>
@@ -1345,30 +1354,6 @@ VALUES
        #region Private Methods
        /// <summary>
-        /// Serializes the terrain data for storage in DB.
-        /// </summary>
-        /// <param name="val">terrain data</param>
-        /// <returns></returns>
-        private static Array serializeTerrain(double[,] val)
-        {
-            MemoryStream str = new MemoryStream(((int)Constants.RegionSize * (int)Constants.RegionSize) * sizeof(double));
-            BinaryWriter bw = new BinaryWriter(str);
-            // TODO: COMPATIBILITY - Add byte-order conversions
-            for (int x = 0; x < (int)Constants.RegionSize; x++)
-                for (int y = 0; y < (int)Constants.RegionSize; y++)
-                {
-                    double height = val[x, y];
-                    if (height == 0.0)
-                        height = double.Epsilon;
-                    bw.Write(height);
-                }
-            return str.ToArray();
-        }
-        /// <summary>
        /// Stores new regionsettings.
        /// </summary>
        /// <param name="regionSettings">The region settings.</param>
diff --git a/OpenSim/Data/MySQL/MySQLSimulationData.cs b/OpenSim/Data/MySQL/MySQLSimulationData.cs
index b03a904..4bd8617 100644
--- a/OpenSim/Data/MySQL/MySQLSimulationData.cs
+++ b/OpenSim/Data/MySQL/MySQLSimulationData.cs
@@ -48,6 +48,7 @@ namespace OpenSim.Data.MySQL
    public class MySQLSimulationData : ISimulationDataStore
    {
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[REGION DB MYSQL]";
        private string m_connectionString;
        private object m_dbLock = new object();
@@ -91,7 +92,7 @@ namespace OpenSim.Data.MySQL
            }
            catch (Exception e)
            {
-                m_log.Error("[REGION DB]: MySQL error in ExecuteReader: " + e.Message);
+                m_log.ErrorFormat("{0} MySQL error in ExecuteReader: {1}", LogHeader, e);
                throw;
            }
@@ -572,10 +573,14 @@ namespace OpenSim.Data.MySQL
            }
        }
+        // Legacy entry point for when terrain was always a 256x256 hieghtmap
        public void StoreTerrain(double[,] ter, UUID regionID)
        {
-            m_log.Info("[REGION DB]: Storing terrain");
+            StoreTerrain(new HeightmapTerrainData(ter), regionID);
+        }
+        public void StoreTerrain(TerrainData terrData, UUID regionID)
+        {
            lock (m_dbLock)
            {
                using (MySqlConnection dbcon = new MySqlConnection(m_connectionString))
@@ -589,11 +594,18 @@ namespace OpenSim.Data.MySQL
                        ExecuteNonQuery(cmd);
-                        cmd.CommandText = "insert into terrain (RegionUUID, " +
+                        int terrainDBRevision;
-                            "Revision, Heightfield) values (?RegionUUID, " +
+                        Array terrainDBblob;
-                            "1, ?Heightfield)";
+                        terrData.GetDatabaseBlob(out terrainDBRevision, out terrainDBblob);
- 
-                        cmd.Parameters.AddWithValue("Heightfield", SerializeTerrain(ter));
+                        m_log.InfoFormat("{0} Storing terrain. X={1}, Y={2}, rev={3}",
+                                    LogHeader, terrData.SizeX, terrData.SizeY, terrainDBRevision);
+                        cmd.CommandText = "insert into terrain (RegionUUID, Revision, Heightfield)"
+                        +   "values (?RegionUUID, ?Revision, ?Heightfield)";
+                        cmd.Parameters.AddWithValue("Revision", terrainDBRevision);
+                        cmd.Parameters.AddWithValue("Heightfield", terrainDBblob);
                        ExecuteNonQuery(cmd);
                    }
@@ -1525,30 +1537,6 @@ namespace OpenSim.Data.MySQL
        }
        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="val"></param>
-        /// <returns></returns>
-        private static Array SerializeTerrain(double[,] val)
-        {
-            MemoryStream str = new MemoryStream(((int)Constants.RegionSize * (int)Constants.RegionSize) *sizeof (double));
-            BinaryWriter bw = new BinaryWriter(str);
-            // TODO: COMPATIBILITY - Add byte-order conversions
-            for (int x = 0; x < (int)Constants.RegionSize; x++)
-                for (int y = 0; y < (int)Constants.RegionSize; y++)
-                {
-                    double height = val[x, y];
-                    if (height == 0.0)
-                        height = double.Epsilon;
-                    bw.Write(height);
-                }
-            return str.ToArray();
-        }
-        /// <summary>
        /// Fill the prim command with prim values
        /// </summary>
        /// <param name="row"></param>
diff --git a/OpenSim/Data/SQLite/SQLiteSimulationData.cs b/OpenSim/Data/SQLite/SQLiteSimulationData.cs
index d938b6b..cce59c1 100644
--- a/OpenSim/Data/SQLite/SQLiteSimulationData.cs
+++ b/OpenSim/Data/SQLite/SQLiteSimulationData.cs
@@ -51,6 +51,7 @@ namespace OpenSim.Data.SQLite
    public class SQLiteSimulationData : ISimulationDataStore
    {
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly string LogHeader = "[REGION DB SQLLITE]";
        private const string primSelect = "select * from prims";
        private const string shapeSelect = "select * from primshapes";
@@ -819,45 +820,44 @@ namespace OpenSim.Data.SQLite
            prim.Inventory.RestoreInventoryItems(inventory);
        }
+        // Legacy entry point for when terrain was always a 256x256 hieghtmap
+        public void StoreTerrain(double[,] ter, UUID regionID)
+        {
+            StoreTerrain(new HeightmapTerrainData(ter), regionID);
+        }
        /// <summary>
        /// Store a terrain revision in region storage
        /// </summary>
        /// <param name="ter">terrain heightfield</param>
        /// <param name="regionID">region UUID</param>
-        public void StoreTerrain(double[,] ter, UUID regionID)
+        public void StoreTerrain(TerrainData terrData, UUID regionID)
        {
            lock (ds)
            {
-                int revision = Util.UnixTimeSinceEpoch();
-                // This is added to get rid of the infinitely growing
-                // terrain databases which negatively impact on SQLite
-                // over time.  Before reenabling this feature there
-                // needs to be a limitter put on the number of
-                // revisions in the database, as this old
-                // implementation is a DOS attack waiting to happen.
                using (
-                    SqliteCommand cmd =
+                    SqliteCommand cmd = new SqliteCommand("delete from terrain where RegionUUID=:RegionUUID", m_conn))
-                        new SqliteCommand("delete from terrain where RegionUUID=:RegionUUID and Revision <= :Revision",
-                                          m_conn))
                {
                    cmd.Parameters.Add(new SqliteParameter(":RegionUUID", regionID.ToString()));
-                    cmd.Parameters.Add(new SqliteParameter(":Revision", revision));
                    cmd.ExecuteNonQuery();
                }
                // the following is an work around for .NET.  The perf
                // issues associated with it aren't as bad as you think.
-                m_log.Debug("[SQLITE REGION DB]: Storing terrain revision r" + revision.ToString());
                String sql = "insert into terrain(RegionUUID, Revision, Heightfield)" +
                             " values(:RegionUUID, :Revision, :Heightfield)";
+                int terrainDBRevision;
+                Array terrainDBblob;
+                terrData.GetDatabaseBlob(out terrainDBRevision, out terrainDBblob);
+                m_log.DebugFormat("{0} Storing terrain revision r {1}", LogHeader, terrainDBRevision);
                using (SqliteCommand cmd = new SqliteCommand(sql, m_conn))
                {
                    cmd.Parameters.Add(new SqliteParameter(":RegionUUID", regionID.ToString()));
-                    cmd.Parameters.Add(new SqliteParameter(":Revision", revision));
+                    cmd.Parameters.Add(new SqliteParameter(":Revision", terrainDBRevision));
-                    cmd.Parameters.Add(new SqliteParameter(":Heightfield", serializeTerrain(ter)));
+                    cmd.Parameters.Add(new SqliteParameter(":Heightfield", terrainDBblob));
                    cmd.ExecuteNonQuery();
                }
            }
@@ -2016,24 +2016,6 @@ namespace OpenSim.Data.SQLite
            return entry;
        }
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="val"></param>
-        /// <returns></returns>
-        private static Array serializeTerrain(double[,] val)
-        {
-            MemoryStream str = new MemoryStream(((int)Constants.RegionSize * (int)Constants.RegionSize) * sizeof(double));
-            BinaryWriter bw = new BinaryWriter(str);
-            // TODO: COMPATIBILITY - Add byte-order conversions
-            for (int x = 0; x < (int)Constants.RegionSize; x++)
-                for (int y = 0; y < (int)Constants.RegionSize; y++)
-                    bw.Write(val[x, y]);
-            return str.ToArray();
-        }
        //         private void fillTerrainRow(DataRow row, UUID regionUUID, int rev, double[,] val)
        //         {
        //             row["RegionUUID"] = regionUUID;
diff --git a/OpenSim/Data/Tests/RegionTests.cs b/OpenSim/Data/Tests/RegionTests.cs
index dbed8f6..b4989d1 100644
--- a/OpenSim/Data/Tests/RegionTests.cs
+++ b/OpenSim/Data/Tests/RegionTests.cs
@@ -300,8 +300,8 @@ namespace OpenSim.Data.Tests
            RegionInfo regionInfo = new RegionInfo();
            regionInfo.RegionID = region3;
-            regionInfo.RegionLocX = 0;
+            regionInfo.LegacyRegionLocX = 0;
-            regionInfo.RegionLocY = 0;
+            regionInfo.LegacyRegionLocY = 0;
            SceneObjectPart sop = new SceneObjectPart();
            SceneObjectGroup sog = new SceneObjectGroup(sop);
@@ -1066,8 +1066,8 @@ namespace OpenSim.Data.Tests
        {
            RegionInfo regionInfo = new RegionInfo();
            regionInfo.RegionID = regionId;
-            regionInfo.RegionLocX = 0;
+            regionInfo.LegacyRegionLocX = 0;
-            regionInfo.RegionLocY = 0;
+            regionInfo.LegacyRegionLocY = 0;
            SceneObjectPart sop = new SceneObjectPart();
            sop.Name = name;
diff --git a/OpenSim/Framework/Constants.cs b/OpenSim/Framework/Constants.cs
index a2eb5ee..9ddb34b 100644
--- a/OpenSim/Framework/Constants.cs
+++ b/OpenSim/Framework/Constants.cs
@@ -30,9 +30,18 @@ namespace OpenSim.Framework
 {
    public class Constants
    {
+        // 'RegionSize' captures the legacy region size.
+        // DO NOT USE THIS FOR ANY NEW CODE. Use Scene.RegionSize[XYZ] as a region might not
+        //      be the legacy region size.
        public const uint RegionSize = 256;
        public const uint RegionHeight = 4096;
-        public const byte TerrainPatchSize = 16;
+        // Terrain heightmap is kept as shorts that are the float value times this compression factor
+        public const float TerrainCompression = 100.0f;
+        // Since terrain is stored in 16x16 heights, regions must be a multiple of this number and that is the minimum
+        public const int MinRegionSize = 16;
+        public const int TerrainPatchSize = 16;
        public const string DefaultTexture = "89556747-24cb-43ed-920b-47caed15465f";
        public enum EstateAccessCodex : uint
diff --git a/OpenSim/Framework/RegionInfo.cs b/OpenSim/Framework/RegionInfo.cs
index 24b9c89..882fe33 100644
--- a/OpenSim/Framework/RegionInfo.cs
+++ b/OpenSim/Framework/RegionInfo.cs
@@ -137,16 +137,20 @@ namespace OpenSim.Framework
        public bool m_allow_alternate_ports;
        protected string m_externalHostName;
        protected IPEndPoint m_internalEndPoint;
-        protected uint? m_regionLocX;
-        protected uint? m_regionLocY;
        protected uint m_remotingPort;
        public UUID RegionID = UUID.Zero;
        public string RemotingAddress;
        public UUID ScopeID = UUID.Zero;
        private UUID m_maptileStaticUUID = UUID.Zero;
-        private Dictionary<String, String> m_otherSettings = new Dictionary<string, string>();
+        public uint RegionWorldLocX = 0;
+        public uint RegionWorldLocY = 0;
+        public uint RegionWorldLocZ = 0;
+        public uint RegionSizeX = Constants.RegionSize;
+        public uint RegionSizeY = Constants.RegionSize;
+        public uint RegionSizeZ = Constants.RegionHeight;
+        private Dictionary<String, String> m_otherSettings = new Dictionary<string, string>();
        // Apparently, we're applying the same estatesettings regardless of whether it's local or remote.
@@ -229,11 +233,8 @@ namespace OpenSim.Framework
            m_serverURI = string.Empty;
        }
-        public RegionInfo(uint regionLocX, uint regionLocY, IPEndPoint internalEndPoint, string externalUri)
+        public RegionInfo(uint legacyRegionLocX, uint legacyRegionLocY, IPEndPoint internalEndPoint, string externalUri)
        {
-            m_regionLocX = regionLocX;
-            m_regionLocY = regionLocY;
            m_internalEndPoint = internalEndPoint;
            m_externalHostName = externalUri;
            m_serverURI = string.Empty;
@@ -447,25 +448,66 @@ namespace OpenSim.Framework
        /// <summary>
        /// The x co-ordinate of this region in map tiles (e.g. 1000).
+        /// Coordinate is scaled as world coordinates divided by the legacy region size
+        /// and is thus is the number of legacy regions.
+        /// </summary>
+        public uint LegacyRegionLocX
+        {
+            get { return RegionWorldLocX / Constants.RegionSize; }
+            set { RegionWorldLocX = value * Constants.RegionSize; }
+        }
+        /// <summary>
+        /// The y co-ordinate of this region in map tiles (e.g. 1000).
+        /// Coordinate is scaled as world coordinates divided by the legacy region size
+        /// and is thus is the number of legacy regions.
+        /// </summary>
+        public uint LegacyRegionLocY
+        {
+            get { return RegionWorldLocY / Constants.RegionSize; }
+            set { RegionWorldLocY = value * Constants.RegionSize; }
+        }
+        /// <summary>
+        /// The x co-ordinate of this region in map tiles (e.g. 1000).
+        /// Coordinate is scaled as world coordinates divided by the legacy region size
+        /// and is thus is the number of legacy regions.
+        /// DO NOT USE FOR NEW CODE! This entrypoint exists for downward compatability with external modules.
        /// </summary>
        public uint RegionLocX
        {
-            get { return m_regionLocX.Value; }
+            get { return LegacyRegionLocX; }
-            set { m_regionLocX = value; }
+            set { LegacyRegionLocX = value; }
        }
        /// <summary>
        /// The y co-ordinate of this region in map tiles (e.g. 1000).
+        /// Coordinate is scaled as world coordinates divided by the legacy region size
+        /// and is thus is the number of legacy regions.
+        /// DO NOT USE FOR NEW CODE! This entrypoint exists for downward compatability with external modules.
        /// </summary>
        public uint RegionLocY
        {
-            get { return m_regionLocY.Value; }
+            get { return LegacyRegionLocY; }
-            set { m_regionLocY = value; }
+            set { LegacyRegionLocY = value; }
+        }
+        public void SetDefaultRegionSize()
+        {
+            RegionWorldLocX = 0;
+            RegionWorldLocY = 0;
+            RegionWorldLocZ = 0;
+            RegionSizeX = Constants.RegionSize;
+            RegionSizeY = Constants.RegionSize;
+            RegionSizeZ = Constants.RegionHeight;
        }
+        // A unique region handle is created from the region's world coordinates.
+        // This cannot be changed because some code expects to receive the region handle and then
+        //    compute the region coordinates from it.
        public ulong RegionHandle
        {
-            get { return Util.UIntsToLong((RegionLocX * (uint) Constants.RegionSize), (RegionLocY * (uint) Constants.RegionSize)); }
+            get { return Util.UIntsToLong(RegionWorldLocX, RegionWorldLocY); }
        }
        public void SetEndPoint(string ipaddr, int port)
@@ -572,8 +614,23 @@ namespace OpenSim.Framework
            string[] locationElements = location.Split(new char[] {','});
-            m_regionLocX = Convert.ToUInt32(locationElements[0]);
+            LegacyRegionLocX = Convert.ToUInt32(locationElements[0]);
-            m_regionLocY = Convert.ToUInt32(locationElements[1]);
+            LegacyRegionLocY = Convert.ToUInt32(locationElements[1]);
+            // Region size
+            // Default to legacy region size if not specified.
+            allKeys.Remove("SizeX");
+            string configSizeX = config.GetString("SizeX", Constants.RegionSize.ToString());
+            config.Set("SizeX", configSizeX);
+            RegionSizeX = Convert.ToUInt32(configSizeX);
+            allKeys.Remove("SizeY");
+            string configSizeY = config.GetString("SizeY", Constants.RegionSize.ToString());
+            config.Set("SizeY", configSizeX);
+            RegionSizeY = Convert.ToUInt32(configSizeY);
+            allKeys.Remove("SizeZ");
+            string configSizeZ = config.GetString("SizeZ", Constants.RegionHeight.ToString());
+            config.Set("SizeZ", configSizeX);
+            RegionSizeZ = Convert.ToUInt32(configSizeZ);
            // InternalAddress
            //
@@ -704,9 +761,16 @@ namespace OpenSim.Framework
            config.Set("RegionUUID", RegionID.ToString());
-            string location = String.Format("{0},{1}", m_regionLocX, m_regionLocY);
+            string location = String.Format("{0},{1}", LegacyRegionLocX, LegacyRegionLocY);
            config.Set("Location", location);
+            if (RegionSizeX != Constants.RegionSize || RegionSizeY != Constants.RegionSize)
+            {
+                config.Set("SizeX", RegionSizeX);
+                config.Set("SizeY", RegionSizeY);
+                config.Set("SizeZ", RegionSizeZ);
+            }
            config.Set("InternalAddress", m_internalEndPoint.Address.ToString());
            config.Set("InternalPort", m_internalEndPoint.Port);
@@ -789,10 +853,18 @@ namespace OpenSim.Framework
                                                RegionID.ToString(), true);
            configMember.addConfigurationOption("sim_name", ConfigurationOption.ConfigurationTypes.TYPE_STRING_NOT_EMPTY,
                                                "Region Name", RegionName, true);
            configMember.addConfigurationOption("sim_location_x", ConfigurationOption.ConfigurationTypes.TYPE_UINT32,
-                                                "Grid Location (X Axis)", m_regionLocX.ToString(), true);
+                                                "Grid Location (X Axis)", LegacyRegionLocX.ToString(), true);
            configMember.addConfigurationOption("sim_location_y", ConfigurationOption.ConfigurationTypes.TYPE_UINT32,
-                                                "Grid Location (Y Axis)", m_regionLocY.ToString(), true);
+                                                "Grid Location (Y Axis)", LegacyRegionLocY.ToString(), true);
+            configMember.addConfigurationOption("sim_size_x", ConfigurationOption.ConfigurationTypes.TYPE_UINT32,
+                                                "Size of region in X dimension", RegionSizeX.ToString(), true);
+            configMember.addConfigurationOption("sim_size_y", ConfigurationOption.ConfigurationTypes.TYPE_UINT32,
+                                                "Size of region in Y dimension", RegionSizeY.ToString(), true);
+            configMember.addConfigurationOption("sim_size_z", ConfigurationOption.ConfigurationTypes.TYPE_UINT32,
+                                                "Size of region in Z dimension", RegionSizeZ.ToString(), true);
            //m_configMember.addConfigurationOption("datastore", ConfigurationOption.ConfigurationTypes.TYPE_STRING_NOT_EMPTY, "Filename for local storage", "OpenSim.db", false);
            configMember.addConfigurationOption("internal_ip_address",
                                                ConfigurationOption.ConfigurationTypes.TYPE_IP_ADDRESS,
@@ -855,10 +927,18 @@ namespace OpenSim.Framework
                                                UUID.Random().ToString(), true);
            configMember.addConfigurationOption("sim_name", ConfigurationOption.ConfigurationTypes.TYPE_STRING_NOT_EMPTY,
                                                "Region Name", "OpenSim Test", false);
            configMember.addConfigurationOption("sim_location_x", ConfigurationOption.ConfigurationTypes.TYPE_UINT32,
                                                "Grid Location (X Axis)", "1000", false);
            configMember.addConfigurationOption("sim_location_y", ConfigurationOption.ConfigurationTypes.TYPE_UINT32,
                                                "Grid Location (Y Axis)", "1000", false);
+            configMember.addConfigurationOption("sim_size_x", ConfigurationOption.ConfigurationTypes.TYPE_UINT32,
+                                                "Size of region in X dimension", Constants.RegionSize.ToString(), false);
+            configMember.addConfigurationOption("sim_size_y", ConfigurationOption.ConfigurationTypes.TYPE_UINT32,
+                                                "Size of region in Y dimension", Constants.RegionSize.ToString(), false);
+            configMember.addConfigurationOption("sim_size_z", ConfigurationOption.ConfigurationTypes.TYPE_UINT32,
+                                                "Size of region in Z dimension", Constants.RegionHeight.ToString(), false);
            //m_configMember.addConfigurationOption("datastore", ConfigurationOption.ConfigurationTypes.TYPE_STRING_NOT_EMPTY, "Filename for local storage", "OpenSim.db", false);
            configMember.addConfigurationOption("internal_ip_address",
                                                ConfigurationOption.ConfigurationTypes.TYPE_IP_ADDRESS,
@@ -916,10 +996,19 @@ namespace OpenSim.Framework
                    RegionName = (string) configuration_result;
                    break;
                case "sim_location_x":
-                    m_regionLocX = (uint) configuration_result;
+                    LegacyRegionLocX = (uint) configuration_result;
                    break;
                case "sim_location_y":
-                    m_regionLocY = (uint) configuration_result;
+                    LegacyRegionLocY = (uint) configuration_result;
+                    break;
+                case "sim_size_x":
+                    RegionSizeX = (uint) configuration_result;
+                    break;
+                case "sim_size_y":
+                    RegionSizeY = (uint) configuration_result;
+                    break;
+                case "sim_size_z":
+                    RegionSizeZ = (uint) configuration_result;
                    break;
                case "internal_ip_address":
                    IPAddress address = (IPAddress) configuration_result;
@@ -1000,8 +1089,13 @@ namespace OpenSim.Framework
            args["external_host_name"] = OSD.FromString(ExternalHostName);
            args["http_port"] = OSD.FromString(HttpPort.ToString());
            args["server_uri"] = OSD.FromString(ServerURI);
-            args["region_xloc"] = OSD.FromString(RegionLocX.ToString());
-            args["region_yloc"] = OSD.FromString(RegionLocY.ToString());
+            args["region_xloc"] = OSD.FromString(LegacyRegionLocX.ToString());
+            args["region_yloc"] = OSD.FromString(LegacyRegionLocY.ToString());
+            args["region_size_x"] = OSD.FromString(RegionSizeX.ToString());
+            args["region_size_y"] = OSD.FromString(RegionSizeY.ToString());
+            args["region_size_z"] = OSD.FromString(RegionSizeZ.ToString());
            args["internal_ep_address"] = OSD.FromString(InternalEndPoint.Address.ToString());
            args["internal_ep_port"] = OSD.FromString(InternalEndPoint.Port.ToString());
            if ((RemotingAddress != null) && !RemotingAddress.Equals(""))
@@ -1032,14 +1126,21 @@ namespace OpenSim.Framework
            {
                uint locx;
                UInt32.TryParse(args["region_xloc"].AsString(), out locx);
-                RegionLocX = locx;
+                LegacyRegionLocX = locx;
            }
            if (args["region_yloc"] != null)
            {
                uint locy;
                UInt32.TryParse(args["region_yloc"].AsString(), out locy);
-                RegionLocY = locy;
+                LegacyRegionLocY = locy;
            }
+            if (args.ContainsKey("region_size_x"))
+                RegionSizeX = (uint)args["region_size_x"].AsInteger();
+            if (args.ContainsKey("region_size_y"))
+                RegionSizeY = (uint)args["region_size_y"].AsInteger();
+            if (args.ContainsKey("region_size_z"))
+                RegionSizeZ = (uint)args["region_size_z"].AsInteger();
            IPAddress ip_addr = null;
            if (args["internal_ep_address"] != null)
            {
@@ -1076,23 +1177,5 @@ namespace OpenSim.Framework
            regionInfo.ServerURI = serverURI;
            return regionInfo;
        }
-        public Dictionary<string, object> ToKeyValuePairs()
-        {
-            Dictionary<string, object> kvp = new Dictionary<string, object>();
-            kvp["uuid"] = RegionID.ToString();
-            kvp["locX"] = RegionLocX.ToString();
-            kvp["locY"] = RegionLocY.ToString();
-            kvp["external_ip_address"] = ExternalEndPoint.Address.ToString();
-            kvp["external_port"] = ExternalEndPoint.Port.ToString();
-            kvp["external_host_name"] = ExternalHostName;
-            kvp["http_port"] = HttpPort.ToString();
-            kvp["internal_ip_address"] = InternalEndPoint.Address.ToString();
-            kvp["internal_port"] = InternalEndPoint.Port.ToString();
-            kvp["alternate_ports"] = m_allow_alternate_ports.ToString();
-            kvp["server_uri"] = ServerURI;
-            return kvp;
-        }
    }
 }
diff --git a/OpenSim/Framework/TerrainData.cs b/OpenSim/Framework/TerrainData.cs
new file mode 100644
index 0000000..bee6814
--- /dev/null
+++ b/OpenSim/Framework/TerrainData.cs
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+using System;
+using System.Collections.Generic;
+using System.IO;
+using OpenMetaverse;
+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; }
+        public abstract float this[int x, int y] { get; set; }
+        // Someday terrain will have caves
+        public abstract float this[int x, int y, int z] { get; set; }
+        public bool IsTainted { get; protected set; }
+        public abstract bool IsTaintedAt(int xx, int yy);
+        public abstract void ClearTaint();
+        // 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);
+        // return a special compressed representation of the heightmap in shorts
+        public abstract short[] GetCompressedMap();
+        public abstract void SetCompressedMap(short[] cmap);
+        public abstract TerrainData Clone();
+    }
+    // The terrain is stored as a blob in the database 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
+    //    feature removed, that left some old entries with the time in the revision
+    //    field.
+    // Thus, if revision is greater than 'RevisionHigh' then terrain db entry is
+    //    left over and it is presumed to be 'Legacy256'.
+    // Numbers are arbitrary and are chosen to to reduce possible mis-interpretation.
+    // If a revision does not match any of these, it is assumed to be Legacy256.
+    public enum DBTerrainRevision
+    {
+        // Terrain is 'double[256,256]'
+        Legacy256 = 11,
+        // Terrain is 'int32, int32, float[,]' where the shorts are X and Y dimensions
+        // The dimensions are presumed to be multiples of 16 and, more likely, multiples of 256.
+        Variable2D = 22,
+        // A revision that is not listed above or any revision greater than this value is 'Legacy256'.
+        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 short integers. The integer values are converted to
+    //    and from floats by TerrainCompressionFactor.
+    public class HeightmapTerrainData : TerrainData
+    {
+        // TerrainData.this[x, y]
+        public override float this[int x, int y]
+        {
+            get { return FromCompressedHeight(m_heightmap[x, y]); }
+            set {
+                short newVal = ToCompressedHeight(value);
+                if (m_heightmap[x, y] != newVal)
+                {
+                    m_heightmap[x, y] = newVal;
+                    m_taint[x / Constants.TerrainPatchSize, y / Constants.TerrainPatchSize] = true;
+                }
+            }
+        }
+        // TerrainData.this[x, y, z]
+        public override float this[int x, int y, int z]
+        {
+            get { return this[x, y]; }
+            set { this[x, y] = value; }
+        }
+        // TerrainData.ClearTaint
+        public override void ClearTaint()
+        {
+            IsTainted = false;
+            for (int ii = 0; ii < m_taint.GetLength(0); ii++)
+                for (int jj = 0; jj < m_taint.GetLength(1); jj++)
+                    m_taint[ii, jj] = false;
+        }
+        public override bool IsTaintedAt(int xx, int yy)
+        {
+            return m_taint[xx / Constants.TerrainPatchSize, yy / Constants.TerrainPatchSize];
+        }
+        // TerrainData.GetDatabaseBlob
+        // The user wants something to store in the database.
+        public override bool GetDatabaseBlob(out int DBRevisionCode, out Array blob)
+        {
+            DBRevisionCode = (int)DBTerrainRevision.Legacy256;
+            blob = LegacyTerrainSerialization();
+            return false;
+        }
+        public override short[] GetCompressedMap()
+        {
+            short[] newMap = new short[SizeX * SizeY];
+            int ind = 0;
+            for (int xx = 0; xx < SizeX; xx++)
+                for (int yy = 0; yy < SizeY; yy++)
+                    newMap[ind++] = m_heightmap[xx, yy];
+            return newMap;
+        }
+        public override void SetCompressedMap(short[] cmap)
+        {
+            int ind = 0;
+            for (int xx = 0; xx < SizeX; xx++)
+                for (int yy = 0; yy < SizeY; yy++)
+                    m_heightmap[xx, yy] = cmap[ind++];
+        }
+        // TerrainData.Clone
+        public override TerrainData Clone()
+        {
+            HeightmapTerrainData ret = new HeightmapTerrainData(SizeX, SizeY, SizeZ);
+            ret.m_heightmap = (short[,])this.m_heightmap.Clone();
+            return ret;
+        }
+        // =============================================================
+        private short[,] m_heightmap;
+        // Remember subregions of the heightmap that has changed.
+        private bool[,] m_taint;
+        // To save space (especially for large regions), keep the height as a short integer
+        //    that is coded as the float height times the compression factor (usually '100'
+        //    to make for two decimal points).
+        public static short ToCompressedHeight(double pHeight)
+        {
+            return (short)(pHeight * Constants.TerrainCompression);
+        }
+        public static float FromCompressedHeight(short pHeight)
+        {
+            return ((float)pHeight) / Constants.TerrainCompression;
+        }
+        // To keep with the legacy theme, this can be created with the way terrain
+        //     used to passed around as.
+        public HeightmapTerrainData(double[,] pTerrain)
+        {
+            SizeX = pTerrain.GetLength(0);
+            SizeY = pTerrain.GetLength(1);
+            SizeZ = (int)Constants.RegionHeight;
+            m_heightmap = new short[SizeX, SizeY];
+            for (int ii = 0; ii < SizeX; ii++)
+            {
+                for (int jj = 0; jj < SizeY; jj++)
+                {
+                    m_heightmap[ii, jj] = ToCompressedHeight(pTerrain[ii, jj]);
+                }
+            }
+            m_taint = new bool[SizeX / Constants.TerrainPatchSize, SizeY / Constants.TerrainPatchSize];
+            ClearTaint();
+        }
+        // Create underlying structures but don't initialize the heightmap assuming the caller will immediately do that
+        public HeightmapTerrainData(int pX, int pY, int pZ)
+        {
+            SizeX = pX;
+            SizeY = pY;
+            SizeZ = pZ;
+            m_heightmap = new short[SizeX, SizeY];
+            m_taint = new bool[SizeX / Constants.TerrainPatchSize, SizeY / Constants.TerrainPatchSize];
+            ClearTaint();
+        }
+        public HeightmapTerrainData(short[] cmap, int pX, int pY, int pZ) : this(pX, pY, pZ)
+        {
+            SetCompressedMap(cmap);
+        }
+        // Just create an array of doubles. Presumes the caller implicitly knows the size.
+        public Array LegacyTerrainSerialization()
+        {
+            Array ret = null;
+            using (MemoryStream str = new MemoryStream(SizeX * SizeY * sizeof(double)))
+            {
+                using (BinaryWriter bw = new BinaryWriter(str))
+                {
+                    // TODO: COMPATIBILITY - Add byte-order conversions
+                    for (int ii = 0; ii < SizeX; ii++)
+                        for (int jj = 0; jj < SizeY; jj++)
+                    {
+                        double height = this[ii, jj];
+                        if (height == 0.0)
+                            height = double.Epsilon;
+                        bw.Write(height);
+                    }
+                }
+                ret = str.ToArray();
+            }
+            return ret;
+        }
+    }
+}
diff --git a/OpenSim/Region/Application/OpenSim.cs b/OpenSim/Region/Application/OpenSim.cs
index 12250df..e241274 100644
--- a/OpenSim/Region/Application/OpenSim.cs
+++ b/OpenSim/Region/Application/OpenSim.cs
@@ -781,8 +781,8 @@ namespace OpenSim
                                MainConsole.Instance.Output(String.Format(
                                           "Region Name: {0}, Region XLoc: {1}, Region YLoc: {2}, Region Port: {3}, Estate Name: {4}",
                                           scene.RegionInfo.RegionName,
-                                           scene.RegionInfo.RegionLocX,
+                                           scene.RegionInfo.LegacyRegionLocX,
-                                           scene.RegionInfo.RegionLocY,
+                                           scene.RegionInfo.LegacyRegionLocY,
                                           scene.RegionInfo.InternalEndPoint.Port,
                                           scene.RegionInfo.EstateSettings.EstateName));
                            });
diff --git a/OpenSim/Region/Application/OpenSimBase.cs b/OpenSim/Region/Application/OpenSimBase.cs
index b032e7f..1e34a1e 100644
--- a/OpenSim/Region/Application/OpenSimBase.cs
+++ b/OpenSim/Region/Application/OpenSimBase.cs
@@ -742,7 +742,7 @@ namespace OpenSim
        {
            m_log.InfoFormat(
                "[OPENSIM]: Got restart signal from SceneManager for region {0} ({1},{2})", 
-                whichRegion.RegionName, whichRegion.RegionLocX, whichRegion.RegionLocY);
+                whichRegion.RegionName, whichRegion.LegacyRegionLocX, whichRegion.LegacyRegionLocY);
            ShutdownClientServer(whichRegion);
            IScene scene;
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index 6b58fb7..7984acc 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
@@ -34,11 +34,13 @@ using System.Text;
 using System.Threading;
 using System.Timers;
 using System.Xml;
 using log4net;
 using OpenMetaverse;
 using OpenMetaverse.Packets;
 using OpenMetaverse.Messages.Linden;
 using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using OpenSim.Framework.Client;
 using OpenSim.Framework.Monitoring;
@@ -48,7 +50,6 @@ using OpenSim.Services.Interfaces;
 using Timer = System.Timers.Timer;
 using AssetLandmark = OpenSim.Framework.AssetLandmark;
 using RegionFlags = OpenMetaverse.RegionFlags;
-using Nini.Config;
 using System.IO;
 using PermissionMask = OpenSim.Framework.PermissionMask;
@@ -307,6 +308,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        private const float m_sunPainDaHalfOrbitalCutoff = 4.712388980384689858f;
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[LLCLIENTVIEW]";
        protected static Dictionary<PacketType, PacketMethod> PacketHandlers = new Dictionary<PacketType, PacketMethod>(); //Global/static handlers for all clients
        /// <summary>
@@ -447,7 +449,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 //        ~LLClientView()
 //        {
-//            m_log.DebugFormat("[LLCLIENTVIEW]: Destructor called for {0}, circuit code {1}", Name, CircuitCode);
+//            m_log.DebugFormat("{0} Destructor called for {1}, circuit code {2}", LogHeader, Name, CircuitCode);
 //        }
        /// <summary>
@@ -513,9 +515,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                // there is some unidentified connection problem, not where we have issues due to deadlock
                if (!IsActive && !force)
                {
-                    m_log.DebugFormat(
+                    m_log.DebugFormat( "{0} Not attempting to close inactive client {1} in {2} since force flag is not set", 
-                        "[CLIENT]: Not attempting to close inactive client {0} in {1} since force flag is not set", 
+                        LogHeader, Name, m_scene.Name);
-                        Name, m_scene.Name);
                    return;
                }
@@ -1162,10 +1163,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        /// <param name="o"></param>
        private void DoSendLayerData(object o)
        {
-            float[] map = LLHeightFieldMoronize((float[])o);
+            float[] map = (float[])o;
            try
            {
+                // Send LayerData in typerwriter pattern
                //for (int y = 0; y < 16; y++)
                //{
                //    for (int x = 0; x < 16; x++)
@@ -1230,7 +1232,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        // }
        /// <summary>
-        /// Sends a specified patch to a client
+        /// Sends a terrain packet for the point specified.
+        /// This is a legacy call that has refarbed the terrain into a flat map of floats.
+        /// We just use the terrain from the region we know about.
        /// </summary>
        /// <param name="px">Patch coordinate (x) 0..15</param>
        /// <param name="py">Patch coordinate (y) 0..15</param>
@@ -1239,12 +1243,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        {
            try
            {
-                int[] patches = new int[] { py * 16 + px };
+                // For unknown reasons, after this point, patch numbers are swapped X for y.
-                float[] heightmap = (map.Length == 65536) ?
+                //    That means, that for <patchNumX, patchNumY, the array location is computed as map[patchNumY * 16 + patchNumX].
-                    map :
+                //    TODO: someday straighten the below implementation to keep the X row order for patch numbers.
-                    LLHeightFieldMoronize(map);
+                // Since this is passing only one patch, we just swap the patch numbers.
+                LayerDataPacket layerpack = OpenSimTerrainCompressor.CreateLandPacket(m_scene.Heightmap.GetTerrainData(), px, py);
-                LayerDataPacket layerpack = TerrainCompressor.CreateLandPacket(heightmap, patches);
                
                // When a user edits the terrain, so much data is sent, the data queues up fast and presents a sub optimal editing experience.  
                // To alleviate this issue, when the user edits the terrain, we start skipping the queues until they're done editing the terrain.
@@ -1262,14 +1265,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                if (m_justEditedTerrain)
                {
                    layerpack.Header.Reliable = false;
-                    OutPacket(layerpack,
+                    OutPacket(layerpack, ThrottleOutPacketType.Unknown );
-                               ThrottleOutPacketType.Unknown );
                }
                else
                {
                    layerpack.Header.Reliable = true;
-                    OutPacket(layerpack,
+                    OutPacket(layerpack, ThrottleOutPacketType.Land);
-                               ThrottleOutPacketType.Land);
                }
            }
            catch (Exception e)
@@ -1279,38 +1280,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        }
        /// <summary>
-        /// Munges heightfield into the LLUDP backed in restricted heightfield.
-        /// </summary>
-        /// <param name="map">float array in the base; Constants.RegionSize</param>
-        /// <returns>float array in the base 256</returns>
-        internal float[] LLHeightFieldMoronize(float[] map)
-        {
-            if (map.Length == 65536)
-                return map;
-            else
-            {
-                float[] returnmap = new float[65536];
-                if (map.Length < 65535)
-                {
-                    // rebase the vector stride to 256
-                    for (int i = 0; i < Constants.RegionSize; i++)
-                        Array.Copy(map, i * (int)Constants.RegionSize, returnmap, i * 256, (int)Constants.RegionSize);
-                }
-                else
-                {
-                    for (int i = 0; i < 256; i++)
-                        Array.Copy(map, i * (int)Constants.RegionSize, returnmap, i * 256, 256);
-                }
-                //Array.Copy(map,0,returnmap,0,(map.Length < 65536)? map.Length : 65536);
-                return returnmap;
-            }
-        }
-        /// <summary>
        ///  Send the wind matrix to the client
        /// </summary>
        /// <param name="windSpeeds">16x16 array of wind speeds</param>
@@ -2782,8 +2751,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        {
            if (req.AssetInf.Data == null)
            {
-                m_log.ErrorFormat("Cannot send asset {0} ({1}), asset data is null",
+                m_log.ErrorFormat("{0} Cannot send asset {1} ({2}), asset data is null",
-                    req.AssetInf.ID, req.AssetInf.Metadata.ContentType);
+                                LogHeader, req.AssetInf.ID, req.AssetInf.Metadata.ContentType);
                return;
            }
@@ -2910,8 +2879,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            {
                pos = (land.AABBMax + land.AABBMin) * 0.5f;
            }
-            reply.Data.GlobalX = info.RegionLocX + x;
+            reply.Data.GlobalX = info.LegacyRegionLocX + x;
-            reply.Data.GlobalY = info.RegionLocY + y;
+            reply.Data.GlobalY = info.LegacyRegionLocY + y;
            reply.Data.GlobalZ = pos.Z;
            reply.Data.SimName = Utils.StringToBytes(info.RegionName);
            reply.Data.SnapshotID = land.SnapshotID;
diff --git a/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs b/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
index 27ace68..db62b31 100644
--- a/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
@@ -189,8 +189,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
            string message = c.Message;
            Scene scene = (Scene)c.Scene;
            Vector3 fromPos = c.Position;
-            Vector3 regionPos = new Vector3(scene.RegionInfo.RegionLocX * Constants.RegionSize,
+            Vector3 regionPos = new Vector3(scene.RegionInfo.RegionWorldLocX, scene.RegionInfo.RegionWorldLocY, 0);
-                                            scene.RegionInfo.RegionLocY * Constants.RegionSize, 0);
            if (c.Channel == DEBUG_CHANNEL) c.Type = ChatTypeEnum.DebugChannel;
@@ -342,8 +341,7 @@ namespace OpenSim.Region.CoreModules.Avatar.Chat
            {
                Vector3 fromRegionPos = fromPos + regionPos;
                Vector3 toRegionPos = presence.AbsolutePosition +
-                    new Vector3(presence.Scene.RegionInfo.RegionLocX * Constants.RegionSize,
+                    new Vector3(presence.Scene.RegionInfo.RegionWorldLocX, presence.Scene.RegionInfo.RegionWorldLocY, 0);
-                                presence.Scene.RegionInfo.RegionLocY * Constants.RegionSize, 0);
                int dis = (int)Util.GetDistanceTo(toRegionPos, fromRegionPos);
diff --git a/OpenSim/Region/CoreModules/Avatar/UserProfiles/UserProfileModule.cs b/OpenSim/Region/CoreModules/Avatar/UserProfiles/UserProfileModule.cs
index 56ff2bd..a982466 100644
--- a/OpenSim/Region/CoreModules/Avatar/UserProfiles/UserProfileModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/UserProfiles/UserProfileModule.cs
@@ -663,8 +663,8 @@ namespace OpenSim.Region.OptionalModules.Avatar.UserProfiles
            Vector3 avaPos = p.AbsolutePosition;
            // Getting the global position for the Avatar
-            Vector3 posGlobal = new Vector3(remoteClient.Scene.RegionInfo.RegionLocX*Constants.RegionSize + avaPos.X,
+            Vector3 posGlobal = new Vector3(remoteClient.Scene.RegionInfo.RegionWorldLocX + avaPos.X,
-                                            remoteClient.Scene.RegionInfo.RegionLocY*Constants.RegionSize + avaPos.Y,
+                                            remoteClient.Scene.RegionInfo.RegionWorldLocY + avaPos.Y,
                                            avaPos.Z);
            string landOwnerName = string.Empty;
diff --git a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
index aa8a4db..eb1b271 100644
--- a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
@@ -494,8 +494,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                }
                // Check that these are not the same coordinates
-                if (finalDestination.RegionLocX == sp.Scene.RegionInfo.RegionLocX &&
+                if (finalDestination.RegionLocX == sp.Scene.RegionInfo.LegacyRegionLocX &&
-                    finalDestination.RegionLocY == sp.Scene.RegionInfo.RegionLocY)
+                    finalDestination.RegionLocY == sp.Scene.RegionInfo.LegacyRegionLocY)
                {
                    // Can't do. Viewer crashes
                    sp.ControllingClient.SendTeleportFailed("Space warp! You would crash. Move to a different region and try again.");
@@ -567,8 +567,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 //                            destRegionX, destRegionY, finalDestination.RegionID, finalDestination.ServerURI);
            // Insanely, RegionLoc on RegionInfo is the 256m map co-ord whilst GridRegion.RegionLoc is the raw meters position.
-            return Math.Abs(sourceRegion.RegionLocX - destRegion.RegionCoordX) <= MaxTransferDistance
+            return Math.Abs(sourceRegion.LegacyRegionLocX - destRegion.RegionCoordX) <= MaxTransferDistance
-                && Math.Abs(sourceRegion.RegionLocY - destRegion.RegionCoordY) <= MaxTransferDistance;
+                && Math.Abs(sourceRegion.LegacyRegionLocY - destRegion.RegionCoordY) <= MaxTransferDistance;
        }
        /// <summary>
@@ -635,7 +635,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                    string.Format(
                      "Can't teleport to {0} ({1},{2}) from {3} ({4},{5}), destination is more than {6} regions way",
                      finalDestination.RegionName, finalDestination.RegionCoordX, finalDestination.RegionCoordY,
-                      sourceRegion.RegionName, sourceRegion.RegionLocX, sourceRegion.RegionLocY,
+                      sourceRegion.RegionName, sourceRegion.LegacyRegionLocX, sourceRegion.LegacyRegionLocY,
                      MaxTransferDistance));
                return;
@@ -1374,8 +1374,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 //                "[ENTITY TRANSFER MODULE]: Crossing agent {0} at pos {1} in {2}", agent.Name, pos, scene.Name);
            Vector3 newpos = new Vector3(pos.X, pos.Y, pos.Z);
-            uint neighbourx = scene.RegionInfo.RegionLocX;
+            uint neighbourx = scene.RegionInfo.LegacyRegionLocX;
-            uint neighboury = scene.RegionInfo.RegionLocY;
+            uint neighboury = scene.RegionInfo.LegacyRegionLocY;
            const float boundaryDistance = 1.7f;
            Vector3 northCross = new Vector3(0, boundaryDistance, 0);
            Vector3 southCross = new Vector3(0, -1 * boundaryDistance, 0);
@@ -1408,8 +1408,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                        neighbourx = b.TriggerRegionX;
                        Vector3 newposition = pos;
-                        newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
+                        newposition.X += (scene.RegionInfo.LegacyRegionLocX - neighbourx) * Constants.RegionSize;
-                        newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
+                        newposition.Y += (scene.RegionInfo.LegacyRegionLocY - neighboury) * Constants.RegionSize;
                        agent.ControllingClient.SendAgentAlertMessage(
                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
                        InformClientToInitiateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
@@ -1431,8 +1431,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                    neighbourx = ba.TriggerRegionX;
                    Vector3 newposition = pos;
-                    newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
+                    newposition.X += (scene.RegionInfo.LegacyRegionLocX - neighbourx) * Constants.RegionSize;
-                    newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
+                    newposition.Y += (scene.RegionInfo.LegacyRegionLocY - neighboury) * Constants.RegionSize;
                    agent.ControllingClient.SendAgentAlertMessage(
                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
                    InformClientToInitiateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
@@ -1462,8 +1462,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                        neighboury = ba.TriggerRegionY;
                        neighbourx = ba.TriggerRegionX;
                        Vector3 newposition = pos;
-                        newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
+                        newposition.X += (scene.RegionInfo.LegacyRegionLocX - neighbourx) * Constants.RegionSize;
-                        newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
+                        newposition.Y += (scene.RegionInfo.LegacyRegionLocY - neighboury) * Constants.RegionSize;
                        agent.ControllingClient.SendAgentAlertMessage(
                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
                        InformClientToInitiateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
@@ -1492,8 +1492,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                    neighboury = b.TriggerRegionY;
                    neighbourx = b.TriggerRegionX;
                    Vector3 newposition = pos;
-                    newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
+                    newposition.X += (scene.RegionInfo.LegacyRegionLocX - neighbourx) * Constants.RegionSize;
-                    newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
+                    newposition.Y += (scene.RegionInfo.LegacyRegionLocY - neighboury) * Constants.RegionSize;
                    agent.ControllingClient.SendAgentAlertMessage(
                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
                    InformClientToInitiateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
@@ -1901,7 +1901,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
            if (m_regionInfo != null)
            {
-                neighbours = RequestNeighbours(sp, m_regionInfo.RegionLocX, m_regionInfo.RegionLocY);
+                neighbours = RequestNeighbours(sp, m_regionInfo.LegacyRegionLocX, m_regionInfo.LegacyRegionLocY);
            }
            else
            {
@@ -2057,8 +2057,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
        Vector3 CalculateOffset(ScenePresence sp, GridRegion neighbour)
        {
-            int rRegionX = (int)sp.Scene.RegionInfo.RegionLocX;
+            int rRegionX = (int)sp.Scene.RegionInfo.LegacyRegionLocX;
-            int rRegionY = (int)sp.Scene.RegionInfo.RegionLocY;
+            int rRegionY = (int)sp.Scene.RegionInfo.LegacyRegionLocY;
            int tRegionX = neighbour.RegionLocX / (int)Constants.RegionSize;
            int tRegionY = neighbour.RegionLocY / (int)Constants.RegionSize;
            int shiftx = (rRegionX - tRegionX) * (int)Constants.RegionSize;
@@ -2161,10 +2161,10 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
            extent.X = ((int)extent.X / (int)Constants.RegionSize);
            extent.Y = ((int)extent.Y / (int)Constants.RegionSize);
-            swCorner.X = Scene.RegionInfo.RegionLocX - 1;
+            swCorner.X = Scene.RegionInfo.LegacyRegionLocX - 1;
-            swCorner.Y = Scene.RegionInfo.RegionLocY - 1;
+            swCorner.Y = Scene.RegionInfo.LegacyRegionLocY - 1;
-            neCorner.X = Scene.RegionInfo.RegionLocX + extent.X;
+            neCorner.X = Scene.RegionInfo.LegacyRegionLocX + extent.X;
-            neCorner.Y = Scene.RegionInfo.RegionLocY + extent.Y;
+            neCorner.Y = Scene.RegionInfo.LegacyRegionLocY + extent.Y;
        }
        /// <summary>
@@ -2301,8 +2301,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                return;
            }
-            int thisx = (int)scene.RegionInfo.RegionLocX;
+            int thisx = (int)scene.RegionInfo.LegacyRegionLocX;
-            int thisy = (int)scene.RegionInfo.RegionLocY;
+            int thisy = (int)scene.RegionInfo.LegacyRegionLocY;
            Vector3 EastCross = new Vector3(0.1f, 0, 0);
            Vector3 WestCross = new Vector3(-0.1f, 0, 0);
            Vector3 NorthCross = new Vector3(0, 0.1f, 0);
diff --git a/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs b/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs
index d943b20..bf87392 100644
--- a/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs
+++ b/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs
@@ -213,8 +213,8 @@ namespace OpenSim.Region.CoreModules.Scripting.EmailModules
                    if (part != null)
                    {
                        ObjectRegionName = s.RegionInfo.RegionName;
-                        uint localX = (s.RegionInfo.RegionLocX * (int)Constants.RegionSize);
+                        uint localX = s.RegionInfo.RegionWorldLocX;
-                        uint localY = (s.RegionInfo.RegionLocY * (int)Constants.RegionSize);
+                        uint localY = s.RegionInfo.RegionWorldLocY;
                        ObjectRegionName = ObjectRegionName + " (" + localX + ", " + localY + ")";
                        return part;
                    }
diff --git a/OpenSim/Region/CoreModules/ServiceConnectorsOut/MapImage/MapImageServiceModule.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/MapImage/MapImageServiceModule.cs
index 26d22b8..c1f2f04 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/MapImage/MapImageServiceModule.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/MapImage/MapImageServiceModule.cs
@@ -224,10 +224,10 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.MapImage
            }
            string reason = string.Empty;
-            if (!m_MapService.AddMapTile((int)scene.RegionInfo.RegionLocX, (int)scene.RegionInfo.RegionLocY, jpgData, out reason))
+            if (!m_MapService.AddMapTile((int)scene.RegionInfo.LegacyRegionLocX, (int)scene.RegionInfo.LegacyRegionLocY, jpgData, out reason))
            {
                m_log.DebugFormat("[MAP IMAGE SERVICE MODULE]: Unable to upload tile image for {0} at {1}-{2}: {3}",
-                    scene.RegionInfo.RegionName, scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY, reason);
+                    scene.RegionInfo.RegionName, scene.RegionInfo.LegacyRegionLocX, scene.RegionInfo.LegacyRegionLocY, reason);
            }
        }
    }
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveScenesGroup.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveScenesGroup.cs
index d8dace2..9aa4243 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveScenesGroup.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveScenesGroup.cs
@@ -71,8 +71,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver
        public void AddScene(Scene scene)
        {
-            uint x = scene.RegionInfo.RegionLocX;
+            uint x = scene.RegionInfo.LegacyRegionLocX;
-            uint y = scene.RegionInfo.RegionLocY;
+            uint y = scene.RegionInfo.LegacyRegionLocY;
            SortedDictionary<uint, Scene> row;
            if (!Regions.TryGetValue(y, out row))
@@ -120,8 +120,8 @@ namespace OpenSim.Region.CoreModules.World.Archiver
            {
                // We add the region's coordinates to ensure uniqueness even if multiple regions have the same name
                string path = string.Format("{0}_{1}_{2}",
-                    scene.RegionInfo.RegionLocX - Rect.X + 1,
+                    scene.RegionInfo.LegacyRegionLocX - Rect.X + 1,
-                    scene.RegionInfo.RegionLocY - Rect.Y + 1,
+                    scene.RegionInfo.LegacyRegionLocY - Rect.Y + 1,
                    scene.RegionInfo.RegionName.Replace(' ', '_'));
                m_regionDirs[scene.RegionInfo.RegionID] = path;
            });
diff --git a/OpenSim/Region/CoreModules/World/Archiver/DearchiveScenesGroup.cs b/OpenSim/Region/CoreModules/World/Archiver/DearchiveScenesGroup.cs
index 3dcc020..25f1e5c 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/DearchiveScenesGroup.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/DearchiveScenesGroup.cs
@@ -145,7 +145,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
        {
            foreach (RegionInfo archivedRegion in m_directory2region.Values)
            {
-                Point location = new Point((int)rootScene.RegionInfo.RegionLocX, (int)rootScene.RegionInfo.RegionLocY);
+                Point location = new Point((int)rootScene.RegionInfo.LegacyRegionLocX, (int)rootScene.RegionInfo.LegacyRegionLocY);
                location.Offset(archivedRegion.Location);
                Scene scene;
diff --git a/OpenSim/Region/CoreModules/World/Estate/EstateManagementCommands.cs b/OpenSim/Region/CoreModules/World/Estate/EstateManagementCommands.cs
index 173b603..bc172a4 100644
--- a/OpenSim/Region/CoreModules/World/Estate/EstateManagementCommands.cs
+++ b/OpenSim/Region/CoreModules/World/Estate/EstateManagementCommands.cs
@@ -96,9 +96,9 @@ namespace OpenSim.Region.CoreModules.World.Estate
            int x = (args.Length > 5 ? int.Parse(args[5]) : -1);
            int y = (args.Length > 6 ? int.Parse(args[6]) : -1);
-            if (x == -1 || m_module.Scene.RegionInfo.RegionLocX == x)
+            if (x == -1 || m_module.Scene.RegionInfo.LegacyRegionLocX == x)
            {
-                if (y == -1 || m_module.Scene.RegionInfo.RegionLocY == y)
+                if (y == -1 || m_module.Scene.RegionInfo.LegacyRegionLocY == y)
                {
                    int corner = int.Parse(num);
                    UUID texture = UUID.Parse(uuid);
@@ -135,9 +135,9 @@ namespace OpenSim.Region.CoreModules.World.Estate
            int x = (args.Length > 4 ? int.Parse(args[4]) : -1);
            int y = (args.Length > 5 ? int.Parse(args[5]) : -1);
-            if (x == -1 || m_module.Scene.RegionInfo.RegionLocX == x)
+            if (x == -1 || m_module.Scene.RegionInfo.LegacyRegionLocX == x)
            {
-                if (y == -1 || m_module.Scene.RegionInfo.RegionLocY == y)
+                if (y == -1 || m_module.Scene.RegionInfo.LegacyRegionLocY == y)
                {
                    double selectedheight = double.Parse(heightstring);
@@ -159,9 +159,9 @@ namespace OpenSim.Region.CoreModules.World.Estate
            int x = (args.Length > 6 ? int.Parse(args[6]) : -1);
            int y = (args.Length > 7 ? int.Parse(args[7]) : -1);
-            if (x == -1 || m_module.Scene.RegionInfo.RegionLocX == x)
+            if (x == -1 || m_module.Scene.RegionInfo.LegacyRegionLocX == x)
            {
-                if (y == -1 || m_module.Scene.RegionInfo.RegionLocY == y)
+                if (y == -1 || m_module.Scene.RegionInfo.LegacyRegionLocY == y)
                {
                    int corner = int.Parse(num);
                    float lowValue = float.Parse(min, Culture.NumberFormatInfo);
diff --git a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
index 1789d6d..51ed83f 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
@@ -1717,8 +1717,8 @@ namespace OpenSim.Region.CoreModules.World.Land
                // HACK for now
                RegionInfo r = new RegionInfo();
                r.RegionName = info.RegionName;
-                r.RegionLocX = (uint)info.RegionLocX;
+                r.LegacyRegionLocX = (uint)info.RegionLocX;
-                r.RegionLocY = (uint)info.RegionLocY;
+                r.LegacyRegionLocY = (uint)info.RegionLocY;
                r.RegionSettings.Maturity = (int)Util.ConvertAccessLevelToMaturity(data.RegionAccess);
                remoteClient.SendParcelInfo(r, data.LandData, parcelID, data.X, data.Y);
            }
diff --git a/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/GenericSystemDrawing.cs b/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/GenericSystemDrawing.cs
index d78ade5..d5c77ec 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/GenericSystemDrawing.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/FileLoaders/GenericSystemDrawing.cs
@@ -67,7 +67,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain.FileLoaders
        {
            using (Bitmap bitmap = new Bitmap(filename))
            {
-                ITerrainChannel retval = new TerrainChannel(true);
+                ITerrainChannel retval = new TerrainChannel(w, h);
                for (int x = 0; x < retval.Width; x++)
                {
diff --git a/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs b/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
index fd30c46..eb6187b 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
@@ -30,10 +30,14 @@ using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
 using System.Net;
 using log4net;
 using Nini.Config;
 using OpenMetaverse;
 using Mono.Addins;
+using OpenSim.Data;
 using OpenSim.Framework;
 using OpenSim.Region.CoreModules.Framework.InterfaceCommander;
 using OpenSim.Region.CoreModules.World.Terrain.FileLoaders;
@@ -130,15 +134,15 @@ namespace OpenSim.Region.CoreModules.World.Terrain
            {
                if (m_scene.Heightmap == null)
                {
-                    m_channel = new TerrainChannel(m_InitialTerrain);
+                    m_channel = new TerrainChannel(m_InitialTerrain, (int)m_scene.RegionInfo.RegionSizeX,
+                                                                     (int)m_scene.RegionInfo.RegionSizeY,
+                                                                     (int)m_scene.RegionInfo.RegionSizeZ);
                    m_scene.Heightmap = m_channel;
-                    m_revert = new TerrainChannel();
                    UpdateRevertMap();
                }
                else
                {
                    m_channel = m_scene.Heightmap;
-                    m_revert = new TerrainChannel();
                    UpdateRevertMap();
                }
@@ -532,6 +536,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
        /// </summary>
        public void UpdateRevertMap()
        {
+            /*
            int x;
            for (x = 0; x < m_channel.Width; x++)
            {
@@ -541,6 +546,8 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                    m_revert[x, y] = m_channel[x, y];
                }
            }
+             */
+            m_revert = m_channel.MakeCopy();
        }
        /// <summary>
@@ -553,8 +560,8 @@ namespace OpenSim.Region.CoreModules.World.Terrain
        /// <param name="fileStartY">Where to begin our slice</param>
        public void LoadFromFile(string filename, int fileWidth, int fileHeight, int fileStartX, int fileStartY)
        {
-            int offsetX = (int) m_scene.RegionInfo.RegionLocX - fileStartX;
+            int offsetX = (int) m_scene.RegionInfo.LegacyRegionLocX - fileStartX;
-            int offsetY = (int) m_scene.RegionInfo.RegionLocY - fileStartY;
+            int offsetY = (int) m_scene.RegionInfo.LegacyRegionLocY - fileStartY;
            if (offsetX >= 0 && offsetX < fileWidth && offsetY >= 0 && offsetY < fileHeight)
            {
@@ -594,14 +601,14 @@ namespace OpenSim.Region.CoreModules.World.Terrain
        /// <param name="fileStartY">The may y co-ordinate at which to begin the save.</param>
        public void SaveToFile(string filename, int fileWidth, int fileHeight, int fileStartX, int fileStartY)
        {
-            int offsetX = (int)m_scene.RegionInfo.RegionLocX - fileStartX;
+            int offsetX = (int)m_scene.RegionInfo.LegacyRegionLocX - fileStartX;
-            int offsetY = (int)m_scene.RegionInfo.RegionLocY - fileStartY;
+            int offsetY = (int)m_scene.RegionInfo.LegacyRegionLocY - fileStartY;
            if (offsetX < 0 || offsetX >= fileWidth || offsetY < 0 || offsetY >= fileHeight)
            {
                MainConsole.Instance.OutputFormat(
                    "ERROR: file width + minimum X tile and file height + minimum Y tile must incorporate the current region at ({0},{1}).  File width {2} from {3} and file height {4} from {5} does not.",
-                    m_scene.RegionInfo.RegionLocX, m_scene.RegionInfo.RegionLocY, fileWidth, fileStartX, fileHeight, fileStartY);
+                    m_scene.RegionInfo.LegacyRegionLocX, m_scene.RegionInfo.LegacyRegionLocY, fileWidth, fileStartX, fileHeight, fileStartY);
                return;
            }
@@ -705,7 +712,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
        private void CheckForTerrainUpdates(bool respectEstateSettings)
        {
            bool shouldTaint = false;
-            float[] serialised = m_channel.GetFloatsSerialised();
+            float[] terrData = m_channel.GetFloatsSerialised();
            int x;
            for (x = 0; x < m_channel.Width; x += Constants.TerrainPatchSize)
            {
@@ -714,16 +721,16 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                {
                    if (m_channel.Tainted(x, y))
                    {
-                        // if we should respect the estate settings then
+                        // If we should respect the estate settings then
-                        // fixup and height deltas that don't respect them
+                        //     fixup and height deltas that don't respect them.
+                        // Note that LimitChannelChanges() modifies the TerrainChannel with the limited height values.
                        if (respectEstateSettings && LimitChannelChanges(x, y))
                        {
-                            // this has been vetoed, so update
+                            // Terrain heights were modified. Refetch the terrain info.
-                            // what we are going to send to the client
+                            terrData = m_channel.GetFloatsSerialised();
-                            serialised = m_channel.GetFloatsSerialised();
                        }
-                        SendToClients(serialised, x, y);
+                        SendToClients(terrData, x, y);
                        shouldTaint = true;
                    }
                }
@@ -792,13 +799,11 @@ namespace OpenSim.Region.CoreModules.World.Terrain
        /// <param name="serialised">A copy of the terrain as a 1D float array of size w*h</param>
        /// <param name="x">The patch corner to send</param>
        /// <param name="y">The patch corner to send</param>
-        private void SendToClients(float[] serialised, int x, int y)
+        private void SendToClients(float[] heightMap, int x, int y)
        {
            m_scene.ForEachClient(
                delegate(IClientAPI controller)
-                    { controller.SendLayerData(
+                    { controller.SendLayerData( x / Constants.TerrainPatchSize, y / Constants.TerrainPatchSize, heightMap); }
-                        x / Constants.TerrainPatchSize, y / Constants.TerrainPatchSize, serialised);
-                    }
            );
        }
diff --git a/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs b/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
index a26a5f0..c985ca2 100644
--- a/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
+++ b/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
@@ -240,7 +240,7 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
            // 6/8/2011 -- I'm adding an explicit 2048 check, so that we never forget that there is
            // a hack here, and so that regions below 4096 don't get spammed with unnecessary map blocks.
-            if (m_scene.RegionInfo.RegionLocX >= 2048 || m_scene.RegionInfo.RegionLocY >= 2048)
+            if (m_scene.RegionInfo.LegacyRegionLocX >= 2048 || m_scene.RegionInfo.LegacyRegionLocY >= 2048)
            {
                ScenePresence avatarPresence = null;
@@ -269,10 +269,10 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
                        List<MapBlockData> mapBlocks = new List<MapBlockData>(); ;
                        List<GridRegion> regions = m_scene.GridService.GetRegionRange(m_scene.RegionInfo.ScopeID,
-                            (int)(m_scene.RegionInfo.RegionLocX - 8) * (int)Constants.RegionSize,
+                            (int)(m_scene.RegionInfo.LegacyRegionLocX - 8) * (int)Constants.RegionSize,
-                            (int)(m_scene.RegionInfo.RegionLocX + 8) * (int)Constants.RegionSize,
+                            (int)(m_scene.RegionInfo.LegacyRegionLocX + 8) * (int)Constants.RegionSize,
-                            (int)(m_scene.RegionInfo.RegionLocY - 8) * (int)Constants.RegionSize,
+                            (int)(m_scene.RegionInfo.LegacyRegionLocY - 8) * (int)Constants.RegionSize,
-                            (int)(m_scene.RegionInfo.RegionLocY + 8) * (int)Constants.RegionSize);
+                            (int)(m_scene.RegionInfo.LegacyRegionLocY + 8) * (int)Constants.RegionSize);
                        foreach (GridRegion r in regions)
                        {
                            MapBlockData block = new MapBlockData();
@@ -1199,10 +1199,10 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
            List<MapBlockData> mapBlocks = new List<MapBlockData>();
            List<GridRegion> regions = m_scene.GridService.GetRegionRange(m_scene.RegionInfo.ScopeID,
-                    (int)(m_scene.RegionInfo.RegionLocX - 9) * (int)Constants.RegionSize,
+                    (int)(m_scene.RegionInfo.LegacyRegionLocX - 9) * (int)Constants.RegionSize,
-                    (int)(m_scene.RegionInfo.RegionLocX + 9) * (int)Constants.RegionSize,
+                    (int)(m_scene.RegionInfo.LegacyRegionLocX + 9) * (int)Constants.RegionSize,
-                    (int)(m_scene.RegionInfo.RegionLocY - 9) * (int)Constants.RegionSize,
+                    (int)(m_scene.RegionInfo.LegacyRegionLocY - 9) * (int)Constants.RegionSize,
-                    (int)(m_scene.RegionInfo.RegionLocY + 9) * (int)Constants.RegionSize);
+                    (int)(m_scene.RegionInfo.LegacyRegionLocY + 9) * (int)Constants.RegionSize);
            List<AssetBase> textures = new List<AssetBase>();
            List<Image> bitImages = new List<Image>();
@@ -1243,8 +1243,8 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
            for (int i = 0; i < mapBlocks.Count; i++)
            {
-                ushort x = (ushort)((mapBlocks[i].X - m_scene.RegionInfo.RegionLocX) + 10);
+                ushort x = (ushort)((mapBlocks[i].X - m_scene.RegionInfo.LegacyRegionLocX) + 10);
-                ushort y = (ushort)((mapBlocks[i].Y - m_scene.RegionInfo.RegionLocY) + 10);
+                ushort y = (ushort)((mapBlocks[i].Y - m_scene.RegionInfo.LegacyRegionLocY) + 10);
                g.DrawImage(bitImages[i], (x * 128), 2560 - (y * 128), 128, 128); // y origin is top
            }
diff --git a/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs b/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs
index 3787ca0..5ba5b31 100644
--- a/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs
+++ b/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs
@@ -135,4 +135,5 @@ namespace OpenSim.Region.Framework.Interfaces
        void Shutdown();
    }
 }
diff --git a/OpenSim/Region/Framework/Interfaces/ITerrainChannel.cs b/OpenSim/Region/Framework/Interfaces/ITerrainChannel.cs
index e467701..cc8a236 100644
--- a/OpenSim/Region/Framework/Interfaces/ITerrainChannel.cs
+++ b/OpenSim/Region/Framework/Interfaces/ITerrainChannel.cs
@@ -25,13 +25,20 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
+using OpenSim.Framework;
 namespace OpenSim.Region.Framework.Interfaces
 {
    public interface ITerrainChannel
    {
-        int Height { get; }
+        int Width { get;}       // X dimension
+        int Height { get;}      // Y dimension
+        int Altitude { get;}    // Z dimension
        double this[int x, int y] { get; set; }
-        int Width { get; }
+        // Return the packaged terrain data for passing into lower levels of communication
+        TerrainData GetTerrainData();
        /// <summary>
        /// Squash the entire heightmap into a single dimensioned array
@@ -40,7 +47,10 @@ namespace OpenSim.Region.Framework.Interfaces
        float[] GetFloatsSerialised();
        double[,] GetDoubles();
+        // Check if a location has been updated. Clears the taint flag as a side effect.
        bool Tainted(int x, int y);
        ITerrainChannel MakeCopy();
        string SaveToXmlString();
        void LoadFromXmlString(string data);
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 7772f94..e2880e3 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -1107,8 +1107,8 @@ namespace OpenSim.Region.Framework.Scenes
            if (RegionInfo.RegionHandle != otherRegion.RegionHandle)
            {
                // If these are cast to INT because long + negative values + abs returns invalid data
-                int resultX = Math.Abs((int)xcell - (int)RegionInfo.RegionLocX);
+                int resultX = Math.Abs((int)xcell - (int)RegionInfo.LegacyRegionLocX);
-                int resultY = Math.Abs((int)ycell - (int)RegionInfo.RegionLocY);
+                int resultY = Math.Abs((int)ycell - (int)RegionInfo.LegacyRegionLocY);
                if (resultX <= 1 && resultY <= 1)
                {
                    // Let the grid service module know, so this can be cached
@@ -1183,8 +1183,8 @@ namespace OpenSim.Region.Framework.Scenes
        /// </returns>
        public int HaveNeighbor(Cardinals car, ref int[] fix)
        {
-            uint neighbourx = RegionInfo.RegionLocX;
+            uint neighbourx = RegionInfo.LegacyRegionLocX;
-            uint neighboury = RegionInfo.RegionLocY;
+            uint neighboury = RegionInfo.LegacyRegionLocY;
            int dir = (int)car;
@@ -1204,8 +1204,8 @@ namespace OpenSim.Region.Framework.Scenes
            if (neighbourRegion == null)
            {
-                fix[0] = (int)(RegionInfo.RegionLocX - neighbourx);
+                fix[0] = (int)(RegionInfo.LegacyRegionLocX - neighbourx);
-                fix[1] = (int)(RegionInfo.RegionLocY - neighboury);
+                fix[1] = (int)(RegionInfo.LegacyRegionLocY - neighboury);
                return dir * (-1);
            }
            else
@@ -1905,13 +1905,13 @@ namespace OpenSim.Region.Framework.Scenes
                        m_InitialTerrain = terrainConfig.GetString("InitialTerrain", m_InitialTerrain);
                    m_log.InfoFormat("[TERRAIN]: No default terrain. Generating a new terrain {0}.", m_InitialTerrain);
-                    Heightmap = new TerrainChannel(m_InitialTerrain);
+                    Heightmap = new TerrainChannel(m_InitialTerrain, (int)RegionInfo.RegionSizeX, (int)RegionInfo.RegionSizeY, (int)RegionInfo.RegionSizeZ);
                    SimulationDataService.StoreTerrain(Heightmap.GetDoubles(), RegionInfo.RegionID);
                }
                else
                {
-                    Heightmap = new TerrainChannel(map);
+                    Heightmap = new TerrainChannel(map, RegionInfo.RegionSizeZ);
                }
            }
            catch (IOException e)
@@ -4371,8 +4371,8 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    uint rRegionX = (uint)(cAgentData.RegionHandle >> 40);
                    uint rRegionY = (((uint)(cAgentData.RegionHandle)) >> 8);
-                    uint tRegionX = RegionInfo.RegionLocX;
+                    uint tRegionX = RegionInfo.LegacyRegionLocX;
-                    uint tRegionY = RegionInfo.RegionLocY;
+                    uint tRegionY = RegionInfo.LegacyRegionLocY;
                    //Send Data to ScenePresence
                    childAgentUpdate.UpdateChildAgent(cAgentData, tRegionX, tRegionY, rRegionX, rRegionY);
                    // Not Implemented:
@@ -4600,13 +4600,13 @@ namespace OpenSim.Region.Framework.Scenes
            ScenePresence sp = GetScenePresence(remoteClient.AgentId);
            if (sp != null)
            {
-                uint regionX = RegionInfo.RegionLocX;
+                uint regionX = RegionInfo.LegacyRegionLocX;
-                uint regionY = RegionInfo.RegionLocY;
+                uint regionY = RegionInfo.LegacyRegionLocY;
                Utils.LongToUInts(regionHandle, out regionX, out regionY);
-                int shiftx = (int) regionX - (int) RegionInfo.RegionLocX * (int)Constants.RegionSize;
+                int shiftx = (int) regionX - (int) RegionInfo.LegacyRegionLocX * (int)Constants.RegionSize;
-                int shifty = (int) regionY - (int) RegionInfo.RegionLocY * (int)Constants.RegionSize;
+                int shifty = (int) regionY - (int) RegionInfo.LegacyRegionLocY * (int)Constants.RegionSize;
                position.X += shiftx;
                position.Y += shifty;
diff --git a/OpenSim/Region/Framework/Scenes/SceneManager.cs b/OpenSim/Region/Framework/Scenes/SceneManager.cs
index 28f7896..2677989 100644
--- a/OpenSim/Region/Framework/Scenes/SceneManager.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneManager.cs
@@ -445,8 +445,8 @@ namespace OpenSim.Region.Framework.Scenes
            {
                foreach (Scene mscene in m_localScenes)
                {
-                    if (mscene.RegionInfo.RegionLocX == locX &&
+                    if (mscene.RegionInfo.LegacyRegionLocX == locX &&
-                        mscene.RegionInfo.RegionLocY == locY)
+                        mscene.RegionInfo.LegacyRegionLocY == locY)
                    {
                        scene = mscene;
                        return true;
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 7243db1..297ee5f 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -710,7 +710,7 @@ namespace OpenSim.Region.Framework.Scenes
                Utils.LongToUInts(handle, out x, out y);
                x = x / Constants.RegionSize;
                y = y / Constants.RegionSize;
-                if (Util.IsOutsideView(DrawDistance, x, Scene.RegionInfo.RegionLocX, y, Scene.RegionInfo.RegionLocY))
+                if (Util.IsOutsideView(DrawDistance, x, Scene.RegionInfo.LegacyRegionLocX, y, Scene.RegionInfo.LegacyRegionLocY))
                {
                    old.Add(handle);
                }
@@ -2094,8 +2094,8 @@ namespace OpenSim.Region.Framework.Scenes
 //            }
            // Get terrain height for sub-region in a megaregion if necessary
-            int X = (int)((m_scene.RegionInfo.RegionLocX * Constants.RegionSize) + pos.X);
+            int X = (int)((m_scene.RegionInfo.RegionWorldLocX) + pos.X);
-            int Y = (int)((m_scene.RegionInfo.RegionLocY * Constants.RegionSize) + pos.Y);
+            int Y = (int)((m_scene.RegionInfo.RegionWorldLocY) + pos.Y);
            GridRegion target_region = m_scene.GridService.GetRegionByPosition(m_scene.RegionInfo.ScopeID, X, Y);
            // If X and Y is NaN, target_region will be null
            if (target_region == null)
diff --git a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
index 95f9caf..67998a0 100644
--- a/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
+++ b/OpenSim/Region/Framework/Scenes/SimStatsReporter.cs
@@ -437,7 +437,7 @@ namespace OpenSim.Region.Framework.Scenes
              
                SimStats simStats 
                    = new SimStats(
-                        ReportingRegion.RegionLocX, ReportingRegion.RegionLocY, regionFlags, (uint)m_objectCapacity,
+                        ReportingRegion.LegacyRegionLocX, ReportingRegion.LegacyRegionLocY, regionFlags, (uint)m_objectCapacity,
                        rb, sb, m_scene.RegionInfo.originRegionID);
                handlerSendStatResult = OnSendStatsResult;
diff --git a/OpenSim/Region/Framework/Scenes/TerrainChannel.cs b/OpenSim/Region/Framework/Scenes/TerrainChannel.cs
index c0ca48e..65e890f 100644
--- a/OpenSim/Region/Framework/Scenes/TerrainChannel.cs
+++ b/OpenSim/Region/Framework/Scenes/TerrainChannel.cs
@@ -25,14 +25,19 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-using OpenSim.Framework;
-using OpenSim.Region.Framework.Interfaces;
 using System;
+using System.IO;
 using System.Text;
+using System.Reflection;
 using System.Xml;
-using System.IO;
 using System.Xml.Serialization;
+using OpenSim.Data;
+using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
+using log4net;
 namespace OpenSim.Region.Framework.Scenes
 {
    /// <summary>
@@ -40,132 +45,115 @@ namespace OpenSim.Region.Framework.Scenes
    /// </summary>
    public class TerrainChannel : ITerrainChannel
    {
-        private readonly bool[,] taint;
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        private double[,] map;
+        private static string LogHeader = "[TERRAIN CHANNEL]";
+        protected TerrainData m_terrainData;
+        public int Width { get { return m_terrainData.SizeX; } }  // X dimension
+        // Unfortunately, for historical reasons, in this module 'Width' is X and 'Height' is Y
+        public int Height { get { return m_terrainData.SizeY; } } // Y dimension
+        public int Altitude { get { return m_terrainData.SizeZ; } } // Y dimension
+        // Default, not-often-used builder
        public TerrainChannel()
        {
-            map = new double[Constants.RegionSize, Constants.RegionSize];
+            m_terrainData = new HeightmapTerrainData((int)Constants.RegionSize, (int)Constants.RegionSize, (int)Constants.RegionHeight);
-            taint = new bool[Constants.RegionSize / 16, Constants.RegionSize / 16];
+            FlatLand();
+            // PinHeadIsland();
-            PinHeadIsland();
        }
-        public TerrainChannel(String type)
+        // Create terrain of given size
+        public TerrainChannel(int pX, int pY)
        {
-            map = new double[Constants.RegionSize, Constants.RegionSize];
+            m_terrainData = new HeightmapTerrainData(pX, pY, (int)Constants.RegionHeight);
-            taint = new bool[Constants.RegionSize / 16, Constants.RegionSize / 16];
+        }
+        // Create terrain of specified size and initialize with specified terrain.
+        // TODO: join this with the terrain initializers.
+        public TerrainChannel(String type, int pX, int pY, int pZ)
+        {
+            m_terrainData = new HeightmapTerrainData(pX, pY, pZ);
            if (type.Equals("flat"))
                FlatLand();
            else
                PinHeadIsland();
        }
-        public TerrainChannel(double[,] import)
+        public TerrainChannel(double[,] pM, uint pAltitude)
-        {
-            map = import;
-            taint = new bool[import.GetLength(0),import.GetLength(1)];
-        }
-        public TerrainChannel(bool createMap)
        {
-            if (createMap)
+            m_terrainData = new HeightmapTerrainData(pM);
-            {
-                map = new double[Constants.RegionSize,Constants.RegionSize];
-                taint = new bool[Constants.RegionSize / 16,Constants.RegionSize / 16];
-            }
-        }
-        public TerrainChannel(int w, int h)
-        {
-            map = new double[w,h];
-            taint = new bool[w / 16,h / 16];
        }
        #region ITerrainChannel Members
-        public int Width
+        // ITerrainChannel.MakeCopy()
+        public ITerrainChannel MakeCopy()
        {
-            get { return map.GetLength(0); }
+            return this.Copy();
        }
-        public int Height
+        // ITerrainChannel.GetTerrainData()
+        public TerrainData GetTerrainData()
        {
-            get { return map.GetLength(1); }
+            return m_terrainData;
        }
-        public ITerrainChannel MakeCopy()
+        // ITerrainChannel.GetFloatsSerialized()
+        // NOTICE that the one dimensional form is ordered by Y!!
+        public float[] GetFloatsSerialised()
        {
-            TerrainChannel copy = new TerrainChannel(false);
+            int points = Width * Height;
-            copy.map = (double[,]) map.Clone();
+            float[] heights = new float[points];
-            return copy;
+            int idx = 0;
+            for (int ii = 0; ii < Height; ii++)
+                for (int jj = 0; jj < Width; jj++)
+                    heights[idx++] = m_terrainData[jj, ii];
+            return heights;
        }
-        public float[] GetFloatsSerialised()
+        // ITerrainChannel.GetDoubles()
+        public double[,] GetDoubles()
        {
-            // Move the member variables into local variables, calling
-            // member variables 256*256 times gets expensive
            int w = Width;
-            int h = Height;
+            int l = Height;
-            float[] heights = new float[w * h];
+            double[,] heights = new double[w, l];
-            int i, j; // map coordinates
            int idx = 0; // index into serialized array
-            for (i = 0; i < h; i++)
+            for (int ii = 0; ii < w; ii++)
            {
-                for (j = 0; j < w; j++)
+                for (int jj = 0; jj < l; jj++)
                {
-                    heights[idx++] = (float)map[j, i];
+                    heights[ii, jj] = (double)m_terrainData[ii, jj];
+                    idx++;
                }
            }
            return heights;
        }
-        public double[,] GetDoubles()
+        // ITerrainChannel.this[x,y]
-        {
-            return map;
-        }
        public double this[int x, int y]
        {
-            get { return map[x, y]; }
+            get { return (double)m_terrainData[x, y]; }
            set
            {
-                // Will "fix" terrain hole problems. Although not fantastically.
                if (Double.IsNaN(value) || Double.IsInfinity(value))
                    return;
-                if (map[x, y] != value)
+                m_terrainData[x, y] = (float)value;
-                {
-                    taint[x / 16, y / 16] = true;
-                    map[x, y] = value;
-                }
            }
        }
+        // ITerrainChannel.Tainted()
        public bool Tainted(int x, int y)
        {
-            if (taint[x / 16, y / 16])
+            return m_terrainData.IsTaintedAt(x, y);
-            {
-                taint[x / 16, y / 16] = false;
-                return true;
-            }
-            return false;
-        }
-        #endregion
-        public TerrainChannel Copy()
-        {
-            TerrainChannel copy = new TerrainChannel(false);
-            copy.map = (double[,]) map.Clone();
-            return copy;
        }
+        // ITerrainChannel.SaveToXmlString()
        public string SaveToXmlString()
        {
            XmlWriterSettings settings = new XmlWriterSettings();
@@ -181,13 +169,7 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
-        private void WriteXml(XmlWriter writer)
+        // ITerrainChannel.LoadFromXmlString()
-        {
-            writer.WriteStartElement(String.Empty, "TerrainMap", String.Empty);
-            ToXml(writer);
-            writer.WriteEndElement();
-        }
        public void LoadFromXmlString(string data)
        {
            StringReader sr = new StringReader(data);
@@ -199,12 +181,65 @@ namespace OpenSim.Region.Framework.Scenes
            sr.Close();
        }
+        #endregion
+        /*
+        // To save space (especially for large regions), keep the height as a short integer
+        //    that is coded as the float height times the compression factor (usually '100'
+        //    to make for two decimal points).
+        public static short ToCompressedHeight(double pHeight)
+        {
+            return (short)(pHeight * Constants.TerrainCompression);
+        }
+        public static float FromCompressedHeight(short pHeight)
+        {
+            return ((float)pHeight) / Constants.TerrainCompression;
+        }
+         */
+        public TerrainChannel Copy()
+        {
+            TerrainChannel copy = new TerrainChannel();
+            copy.m_terrainData = m_terrainData.Clone();
+            return copy;
+        }
+        private void WriteXml(XmlWriter writer)
+        {
+            if (Width == Constants.RegionSize && Height == Constants.RegionSize)
+            {
+                // Downward compatibility for legacy region terrain maps.
+                // If region is exactly legacy size, return the old format XML.
+                writer.WriteStartElement(String.Empty, "TerrainMap", String.Empty);
+                ToXml(writer);
+                writer.WriteEndElement();
+            }
+            else
+            {
+                // New format XML that includes width and length.
+                writer.WriteStartElement(String.Empty, "TerrainMap2", String.Empty);
+                ToXml2(writer);
+                writer.WriteEndElement();
+            }
+        }
        private void ReadXml(XmlReader reader)
        {
-            reader.ReadStartElement("TerrainMap");
+            // Check the first element. If legacy element, use the legacy reader.
-            FromXml(reader);
+            if (reader.IsStartElement("TerrainMap"))
+            {
+                reader.ReadStartElement("TerrainMap");
+                FromXml(reader);
+            }
+            else
+            {
+                reader.ReadStartElement("TerrainMap2");
+                FromXml2(reader);
+            }
        }
+        // Write legacy terrain map. Presumed to be 256x256 of data encoded as floats in a byte array.
        private void ToXml(XmlWriter xmlWriter)
        {
            float[] mapData = GetFloatsSerialised();
@@ -218,12 +253,15 @@ namespace OpenSim.Region.Framework.Scenes
            serializer.Serialize(xmlWriter, buffer);
        }
+        // Read legacy terrain map. Presumed to be 256x256 of data encoded as floats in a byte array.
        private void FromXml(XmlReader xmlReader)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(byte[]));
            byte[] dataArray = (byte[])serializer.Deserialize(xmlReader);
            int index = 0;
+            m_terrainData = new HeightmapTerrainData(Width, Height, Altitude);
+            
            for (int y = 0; y < Height; y++)
            {
                for (int x = 0; x < Width; x++)
@@ -236,35 +274,62 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
+        private class TerrainChannelXMLPackage
+        {
+            public int Version;
+            public int SizeX;
+            public int SizeY;
+            public int SizeZ;
+            public short[] Map;
+            public TerrainChannelXMLPackage(int pX, int pY, int pZ, short[] pMap)
+            {
+                Version = 1;
+                SizeX = pX;
+                SizeY = pY;
+                SizeZ = pZ;
+                Map = pMap;
+            }
+        }
+        // New terrain serialization format that includes the width and length.
+        private void ToXml2(XmlWriter xmlWriter)
+        {
+            TerrainChannelXMLPackage package = new TerrainChannelXMLPackage(Width, Height, Altitude, m_terrainData.GetCompressedMap());
+            XmlSerializer serializer = new XmlSerializer(typeof(TerrainChannelXMLPackage));
+            serializer.Serialize(xmlWriter, package);
+        }
+        // New terrain serialization format that includes the width and length.
+        private void FromXml2(XmlReader xmlReader)
+        {
+            XmlSerializer serializer = new XmlSerializer(typeof(TerrainChannelXMLPackage));
+            TerrainChannelXMLPackage package = (TerrainChannelXMLPackage)serializer.Deserialize(xmlReader);
+            m_terrainData = new HeightmapTerrainData(package.Map, package.SizeX, package.SizeY, package.SizeZ);
+        }
+        // Fill the heightmap with the center bump terrain
        private void PinHeadIsland()
        {
-            int x;
+            for (int x = 0; x < Width; x++)
-            for (x = 0; x < Constants.RegionSize; x++)
            {
-                int y;
+                for (int y = 0; y < Height; y++)
-                for (y = 0; y < Constants.RegionSize; y++)
                {
-                    map[x, y] = TerrainUtil.PerlinNoise2D(x, y, 2, 0.125) * 10;
+                    m_terrainData[x, y] = (float)TerrainUtil.PerlinNoise2D(x, y, 2, 0.125) * 10;
-                    double spherFacA = TerrainUtil.SphericalFactor(x, y, Constants.RegionSize / 2.0, Constants.RegionSize / 2.0, 50) * 0.01;
+                    float spherFacA = (float)(TerrainUtil.SphericalFactor(x, y, m_terrainData.SizeX / 2.0, m_terrainData.SizeY / 2.0, 50) * 0.01d);
-                    double spherFacB = TerrainUtil.SphericalFactor(x, y, Constants.RegionSize / 2.0, Constants.RegionSize / 2.0, 100) * 0.001;
+                    float spherFacB = (float)(TerrainUtil.SphericalFactor(x, y, m_terrainData.SizeX / 2.0, m_terrainData.SizeY / 2.0, 100) * 0.001d);
-                    if (map[x, y] < spherFacA)
+                    if (m_terrainData[x, y]< spherFacA)
-                        map[x, y] = spherFacA;
+                        m_terrainData[x, y]= spherFacA;
-                    if (map[x, y] < spherFacB)
+                    if (m_terrainData[x, y]< spherFacB)
-                        map[x, y] = spherFacB;
+                        m_terrainData[x, y] = spherFacB;
                }
            }
        }
        private void FlatLand()
        {
-            int x;
+            for (int xx = 0; xx < Width; xx++)
-            for (x = 0; x < Constants.RegionSize; x++)
+                for (int yy = 0; yy < Height; yy++)
-            {
+                    m_terrainData[xx, yy] = 21;
-                int y;
-                for (y = 0; y < Constants.RegionSize; y++)
-                    map[x, y] = 21;
-            }
        }
    }
 }
diff --git a/OpenSim/Region/Framework/Scenes/TerrainCompressor.cs b/OpenSim/Region/Framework/Scenes/TerrainCompressor.cs
new file mode 100644
index 0000000..511745d
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/TerrainCompressor.cs
@@ -0,0 +1,949 @@
+/*
+ * Copyright (c) Contributors, http://opensimulator.org/
+ * See CONTRIBUTORS.TXT for a full list of copyright holders.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of the OpenSimulator Project nor the
+ *       names of its contributors may be used to endorse or promote products
+ *       derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+/* Freely adapted from the Aurora version of the terrain compressor.
+ * Copyright (c) Contributors, http://aurora-sim.org/, http://opensimulator.org/
+ */
+using System;
+using System.Reflection;
+using log4net;
+using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Scenes;
+using OpenMetaverse;
+using OpenMetaverse.Packets;
+namespace OpenSim.Region.ClientStack.LindenUDP
+{
+    public static class OpenSimTerrainCompressor
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[TERRAIN COMPRESSOR]";
+        public const int END_OF_PATCHES = 97;
+        private const float OO_SQRT2 = 0.7071067811865475244008443621049f;
+        private const int STRIDE = 264;
+        private const int ZERO_CODE = 0x0;
+        private const int ZERO_EOB = 0x2;
+        private const int POSITIVE_VALUE = 0x6;
+        private const int NEGATIVE_VALUE = 0x7;
+        private static readonly float[] DequantizeTable16 =
+            new float[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+        private static readonly float[] DequantizeTable32 =
+            new float[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+        private static readonly float[] CosineTable16 = new float[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+        //private static readonly float[] CosineTable32 = new float[Constants.TerrainPatchSize * Constants.TerrainPatchSize];
+        private static readonly int[] CopyMatrix16 = new int[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+        private static readonly int[] CopyMatrix32 = new int[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+        private static readonly float[] QuantizeTable16 =
+            new float[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+        static OpenSimTerrainCompressor()
+        {
+            // Initialize the decompression tables
+            BuildDequantizeTable16();
+            SetupCosines16();
+            BuildCopyMatrix16();
+            BuildQuantizeTable16();
+        }
+        // Unused: left for historical reference.
+        public static LayerDataPacket CreateLayerDataPacket(TerrainPatch[] patches, byte type, int pRegionSizeX,
+                                                            int pRegionSizeY)
+        {
+            LayerDataPacket layer = new LayerDataPacket {LayerID = {Type = type}};
+            TerrainPatch.GroupHeader header = new TerrainPatch.GroupHeader
+                                                  {Stride = STRIDE, PatchSize = Constants.TerrainPatchSize};
+            // Should be enough to fit even the most poorly packed data
+            byte[] data = new byte[patches.Length*Constants.TerrainPatchSize*Constants.TerrainPatchSize*2];
+            BitPack bitpack = new BitPack(data, 0);
+            bitpack.PackBits(header.Stride, 16);
+            bitpack.PackBits(header.PatchSize, 8);
+            bitpack.PackBits(type, 8);
+            foreach (TerrainPatch t in patches)
+                CreatePatch(bitpack, t.Data, t.X, t.Y, pRegionSizeX, pRegionSizeY);
+            bitpack.PackBits(END_OF_PATCHES, 8);
+            layer.LayerData.Data = new byte[bitpack.BytePos + 1];
+            Buffer.BlockCopy(bitpack.Data, 0, layer.LayerData.Data, 0, bitpack.BytePos + 1);
+            return layer;
+        }
+        // Legacy land packet generation gluing old land representation (heights) to compressed representation.
+        // This is an intermediate step in converting terrain into a variable sized heightmap. Some of the
+        //     routines (like IClientAPI) only pass the float array of heights around. This entry
+        //     converts that legacy representation into the more compact represenation used in
+        //     TerrainChannel. Someday fix the plumbing between here and the scene.
+        public static LayerDataPacket CreateLandPacket(TerrainData terrData, int patchX, int patchY)
+        {
+            int[] xPieces = new int[1];
+            int[] yPieces = new int[1];
+            xPieces[0] = patchX;  // patch X dimension
+            yPieces[0] = patchY;
+            m_log.DebugFormat("{0} CreateLandPacket. patchX={1}, patchY={2}, sizeX={3}, sizeY={4}",
+                                    LogHeader, patchX, patchY, terrData.SizeX, terrData.SizeY);
+            return CreateLandPacket(terrData, xPieces, yPieces, (int)TerrainPatch.LayerType.Land);
+        }
+        /// <summary>
+        ///     Creates a LayerData packet for compressed land data given a full
+        ///     simulator heightmap and an array of indices of patches to compress
+        /// </summary>
+        /// <param name="heightmap">
+        ///     A 256 * 256 array of floating point values
+        ///     specifying the height at each meter in the simulator
+        /// </param>
+        /// <param name="x">
+        ///     Array of indexes in the 16x16 grid of patches
+        ///     for this simulator. For example if 1 and 17 are specified, patches
+        ///     x=1,y=0 and x=1,y=1 are sent
+        /// </param>
+        /// <param name="y">
+        ///     Array of indexes in the 16x16 grid of patches
+        ///     for this simulator. For example if 1 and 17 are specified, patches
+        ///     x=1,y=0 and x=1,y=1 are sent
+        /// </param>
+        /// <param name="type"></param>
+        /// <param name="pRegionSizeX"></param>
+        /// <param name="pRegionSizeY"></param>
+        /// <returns></returns>
+        public static LayerDataPacket CreateLandPacket(TerrainData terrData, int[] x, int[] y, byte type)
+        {
+            LayerDataPacket layer = new LayerDataPacket {LayerID = {Type = type}};
+            TerrainPatch.GroupHeader header = new TerrainPatch.GroupHeader
+                                                  {Stride = STRIDE, PatchSize = Constants.TerrainPatchSize};
+            byte[] data = new byte[x.Length * Constants.TerrainPatchSize * Constants.TerrainPatchSize * 2];
+            BitPack bitpack = new BitPack(data, 0);
+            bitpack.PackBits(header.Stride, 16);
+            bitpack.PackBits(header.PatchSize, 8);
+            bitpack.PackBits(type, 8);
+            for (int i = 0; i < x.Length; i++)
+                CreatePatchFromHeightmap(bitpack, terrData, x[i], y[i]);
+            bitpack.PackBits(END_OF_PATCHES, 8);
+            layer.LayerData.Data = new byte[bitpack.BytePos + 1];
+            Buffer.BlockCopy(bitpack.Data, 0, layer.LayerData.Data, 0, bitpack.BytePos + 1);
+            return layer;
+        }
+        // Unused: left for historical reference.
+        public static void CreatePatch(BitPack output, float[] patchData, int x, int y, int pRegionSizeX, int pRegionSizeY)
+        {
+            TerrainPatch.Header header = PrescanPatch(patchData);
+            header.QuantWBits = 136;
+            if (pRegionSizeX > Constants.RegionSize || pRegionSizeY > Constants.RegionSize)
+            {
+                header.PatchIDs = (y & 0xFFFF);
+                header.PatchIDs += (x << 16);
+            }
+            else
+            {
+                header.PatchIDs = (y & 0x1F);
+                header.PatchIDs += (x << 5);
+            }
+            // NOTE: No idea what prequant and postquant should be or what they do
+            int wbits;
+            int[] patch = CompressPatch(patchData, header, 10, out wbits);
+            wbits = EncodePatchHeader(output, header, patch, Constants.RegionSize, Constants.RegionSize, wbits);
+            EncodePatch(output, patch, 0, wbits);
+        }
+        /// <summary>
+        ///     Add a patch of terrain to a BitPacker
+        /// </summary>
+        /// <param name="output">BitPacker to write the patch to</param>
+        /// <param name="heightmap">
+        ///     Heightmap of the simulator. Presumed to be an sizeX*sizeY array.
+        /// </param>
+        /// <param name="patchX">
+        ///     X offset of the patch to create.
+        /// </param>
+        /// <param name="patchY">
+        ///     Y offset of the patch to create.
+        /// </param>
+        /// <param name="pRegionSizeX"></param>
+        /// <param name="pRegionSizeY"></param>
+        public static void CreatePatchFromHeightmap(BitPack output, TerrainData terrData, int patchX, int patchY)
+        {
+            TerrainPatch.Header header = PrescanPatch(terrData, patchX, patchY);
+            header.QuantWBits = 136;
+            // If larger than legacy region size, pack patch X and Y info differently.
+            if (terrData.SizeX > Constants.RegionSize || terrData.SizeY > Constants.RegionSize)
+            {
+                header.PatchIDs = (patchY & 0xFFFF);
+                header.PatchIDs += (patchX << 16);
+            }
+            else
+            {
+                header.PatchIDs = (patchY & 0x1F);
+                header.PatchIDs += (patchX << 5);
+            }
+            // NOTE: No idea what prequant and postquant should be or what they do
+            int wbits;
+            int[] patch = CompressPatch(terrData, patchX, patchY, header, 10, out wbits);
+            wbits = EncodePatchHeader(output, header, patch, (uint)terrData.SizeX, (uint)terrData.SizeY, wbits);
+            EncodePatch(output, patch, 0, wbits);
+        }
+        private static TerrainPatch.Header PrescanPatch(float[] patch)
+        {
+            TerrainPatch.Header header = new TerrainPatch.Header();
+            float zmax = -99999999.0f;
+            float zmin = 99999999.0f;
+            for (int i = 0; i < Constants.TerrainPatchSize*Constants.TerrainPatchSize; i++)
+            {
+                float val = patch[i];
+                if (val > zmax) zmax = val;
+                if (val < zmin) zmin = val;
+            }
+            header.DCOffset = zmin;
+            header.Range = (int) ((zmax - zmin) + 1.0f);
+            return header;
+        }
+        // Scan the height info we're returning and return a patch packet header for this patch.
+        private static TerrainPatch.Header PrescanPatch(TerrainData terrData, int patchX, int patchY)
+        {
+            TerrainPatch.Header header = new TerrainPatch.Header();
+            float zmax = -99999999.0f;
+            float zmin = 99999999.0f;
+            for (int j = patchY*16; j < (patchY + 1)*16; j++)
+            {
+                for (int i = patchX*16; i < (patchX + 1)*16; i++)
+                {
+                    // short val = heightmap[j*pRegionSizeX + i];
+                    float val = terrData[j, i];
+                    if (val > zmax) zmax = val;
+                    if (val < zmin) zmin = val;
+                }
+            }
+            // Since the the min and max values are the shorts, rescale to be real values.
+            // TODO: all this logic should go into the class wrapping the short values.
+            header.DCOffset = zmin;
+            header.Range = (int)(zmax - zmin + 1.0f);
+            return header;
+        }
+        public static TerrainPatch.Header DecodePatchHeader(BitPack bitpack)
+        {
+            TerrainPatch.Header header = new TerrainPatch.Header {QuantWBits = bitpack.UnpackBits(8)};
+            // Quantized word bits
+            if (header.QuantWBits == END_OF_PATCHES)
+                return header;
+            // DC offset
+            header.DCOffset = bitpack.UnpackFloat();
+            // Range
+            header.Range = bitpack.UnpackBits(16);
+            // Patch IDs (10 bits)
+            header.PatchIDs = bitpack.UnpackBits(10);
+            // Word bits
+            header.WordBits = (uint) ((header.QuantWBits & 0x0f) + 2);
+            return header;
+        }
+        private static int EncodePatchHeader(BitPack output, TerrainPatch.Header header, int[] patch, uint pRegionSizeX,
+                                             uint pRegionSizeY, int wbits)
+        {
+            /*
+                    int temp;
+                    int wbits = (header.QuantWBits & 0x0f) + 2;
+                    uint maxWbits = (uint)wbits + 5;
+                    uint minWbits = ((uint)wbits >> 1);
+                    int wbitsMaxValue;
+        */
+            // goal is to determ minimum number of bits to use so all data fits
+            /*
+                    wbits = (int)minWbits;
+                    wbitsMaxValue = (1 << wbits);
+                    for (int i = 0; i < patch.Length; i++)
+                    {
+                        temp = patch[i];
+                        if (temp != 0)
+                        {
+                            // Get the absolute value
+                            if (temp < 0) temp *= -1;
+         no coments..
+                            for (int j = (int)maxWbits; j > (int)minWbits; j--)
+                            {
+                                if ((temp & (1 << j)) != 0)
+                                {
+                                    if (j > wbits) wbits = j;
+                                    break;
+                                }
+                            }
+ 
+                            while (temp > wbitsMaxValue)
+                                {
+                                wbits++;
+                                if (wbits == maxWbits)
+                                    goto Done;
+                                wbitsMaxValue = 1 << wbits;
+                                }
+                        }
+                    }
+                Done:
+                    //            wbits += 1;
+         */
+            // better check
+            if (wbits > 17)
+                wbits = 16;
+            else if (wbits < 3)
+                wbits = 3;
+            header.QuantWBits &= 0xf0;
+            header.QuantWBits |= (wbits - 2);
+            output.PackBits(header.QuantWBits, 8);
+            output.PackFloat(header.DCOffset);
+            output.PackBits(header.Range, 16);
+            if (pRegionSizeX > Constants.RegionSize || pRegionSizeY > Constants.RegionSize)
+                output.PackBits(header.PatchIDs, 32);
+            else
+                output.PackBits(header.PatchIDs, 10);
+            return wbits;
+        }
+        private static void IDCTColumn16(float[] linein, float[] lineout, int column)
+        {
+            for (int n = 0; n < Constants.TerrainPatchSize; n++)
+            {
+                float total = OO_SQRT2*linein[column];
+                for (int u = 1; u < Constants.TerrainPatchSize; u++)
+                {
+                    int usize = u*Constants.TerrainPatchSize;
+                    total += linein[usize + column]*CosineTable16[usize + n];
+                }
+                lineout[Constants.TerrainPatchSize*n + column] = total;
+            }
+        }
+        private static void IDCTLine16(float[] linein, float[] lineout, int line)
+        {
+            const float oosob = 2.0f/Constants.TerrainPatchSize;
+            int lineSize = line*Constants.TerrainPatchSize;
+            for (int n = 0; n < Constants.TerrainPatchSize; n++)
+            {
+                float total = OO_SQRT2*linein[lineSize];
+                for (int u = 1; u < Constants.TerrainPatchSize; u++)
+                {
+                    total += linein[lineSize + u]*CosineTable16[u*Constants.TerrainPatchSize + n];
+                }
+                lineout[lineSize + n] = total*oosob;
+            }
+        }
+/*
+        private static void DCTLine16(float[] linein, float[] lineout, int line)
+        {
+            float total = 0.0f;
+            int lineSize = line * Constants.TerrainPatchSize;
+            for (int n = 0; n < Constants.TerrainPatchSize; n++)
+            {
+                total += linein[lineSize + n];
+            }
+            lineout[lineSize] = OO_SQRT2 * total;
+            int uptr = 0;
+            for (int u = 1; u < Constants.TerrainPatchSize; u++)
+            {
+                total = 0.0f;
+                uptr += Constants.TerrainPatchSize;
+                for (int n = 0; n < Constants.TerrainPatchSize; n++)
+                {
+                    total += linein[lineSize + n] * CosineTable16[uptr + n];
+                }
+                lineout[lineSize + u] = total;
+            }
+        }
+*/
+        private static void DCTLine16(float[] linein, float[] lineout, int line)
+        {
+            // outputs transpose data (lines exchanged with coluns )
+            // so to save a bit of cpu when doing coluns
+            float total = 0.0f;
+            int lineSize = line*Constants.TerrainPatchSize;
+            for (int n = 0; n < Constants.TerrainPatchSize; n++)
+            {
+                total += linein[lineSize + n];
+            }
+            lineout[line] = OO_SQRT2*total;
+            for (int u = Constants.TerrainPatchSize;
+                 u < Constants.TerrainPatchSize*Constants.TerrainPatchSize;
+                 u += Constants.TerrainPatchSize)
+            {
+                total = 0.0f;
+                for (int ptrn = lineSize, ptru = u; ptrn < lineSize + Constants.TerrainPatchSize; ptrn++,ptru++)
+                {
+                    total += linein[ptrn]*CosineTable16[ptru];
+                }
+                lineout[line + u] = total;
+            }
+        }
+        /*
+                private static void DCTColumn16(float[] linein, int[] lineout, int column)
+                {
+                    float total = 0.0f;
+        //            const float oosob = 2.0f / Constants.TerrainPatchSize;
+                    for (int n = 0; n < Constants.TerrainPatchSize; n++)
+                    {
+                        total += linein[Constants.TerrainPatchSize * n + column];
+                    }
+        //            lineout[CopyMatrix16[column]] = (int)(OO_SQRT2 * total * oosob * QuantizeTable16[column]);
+                    lineout[CopyMatrix16[column]] = (int)(OO_SQRT2 * total * QuantizeTable16[column]);
+                    for (int uptr = Constants.TerrainPatchSize; uptr < Constants.TerrainPatchSize * Constants.TerrainPatchSize; uptr += Constants.TerrainPatchSize)
+                    {
+                        total = 0.0f;
+                        for (int n = 0; n < Constants.TerrainPatchSize; n++)
+                        {
+                            total += linein[Constants.TerrainPatchSize * n + column] * CosineTable16[uptr + n];
+                        }
+        //                lineout[CopyMatrix16[Constants.TerrainPatchSize * u + column]] = (int)(total * oosob * QuantizeTable16[Constants.TerrainPatchSize * u + column]);
+                        lineout[CopyMatrix16[uptr + column]] = (int)(total * QuantizeTable16[uptr + column]);
+                        }
+                }
+        */
+        private static void DCTColumn16(float[] linein, int[] lineout, int column)
+        {
+            // input columns are in fact stored in lines now
+            float total = 0.0f;
+//            const float oosob = 2.0f / Constants.TerrainPatchSize;
+            int inlinesptr = Constants.TerrainPatchSize*column;
+            for (int n = 0; n < Constants.TerrainPatchSize; n++)
+            {
+                total += linein[inlinesptr + n];
+            }
+            //            lineout[CopyMatrix16[column]] = (int)(OO_SQRT2 * total * oosob * QuantizeTable16[column]);
+            lineout[CopyMatrix16[column]] = (int) (OO_SQRT2*total*QuantizeTable16[column]);
+            for (int uptr = Constants.TerrainPatchSize;
+                 uptr < Constants.TerrainPatchSize*Constants.TerrainPatchSize;
+                 uptr += Constants.TerrainPatchSize)
+            {
+                total = 0.0f;
+                for (int n = inlinesptr, ptru = uptr; n < inlinesptr + Constants.TerrainPatchSize; n++, ptru++)
+                {
+                    total += linein[n]*CosineTable16[ptru];
+                }
+//                lineout[CopyMatrix16[Constants.TerrainPatchSize * u + column]] = (int)(total * oosob * QuantizeTable16[Constants.TerrainPatchSize * u + column]);
+                lineout[CopyMatrix16[uptr + column]] = (int) (total*QuantizeTable16[uptr + column]);
+            }
+        }
+        private static int DCTColumn16Wbits(float[] linein, int[] lineout, int column, int wbits, int maxwbits)
+        {
+            // input columns are in fact stored in lines now
+            bool dowbits = wbits != maxwbits;
+            int wbitsMaxValue = 1 << wbits;
+            float total = 0.0f;
+            //            const float oosob = 2.0f / Constants.TerrainPatchSize;
+            int inlinesptr = Constants.TerrainPatchSize*column;
+            for (int n = 0; n < Constants.TerrainPatchSize; n++)
+            {
+                total += linein[inlinesptr + n];
+            }
+            //            lineout[CopyMatrix16[column]] = (int)(OO_SQRT2 * total * oosob * QuantizeTable16[column]);
+            int tmp = (int) (OO_SQRT2*total*QuantizeTable16[column]);
+            lineout[CopyMatrix16[column]] = tmp;
+            if (dowbits)
+            {
+                if (tmp < 0) tmp *= -1;
+                while (tmp > wbitsMaxValue)
+                {
+                    wbits++;
+                    wbitsMaxValue = 1 << wbits;
+                    if (wbits == maxwbits)
+                    {
+                        dowbits = false;
+                        break;
+                    }
+                }
+            }
+            for (int uptr = Constants.TerrainPatchSize;
+                 uptr < Constants.TerrainPatchSize*Constants.TerrainPatchSize;
+                 uptr += Constants.TerrainPatchSize)
+            {
+                total = 0.0f;
+                for (int n = inlinesptr, ptru = uptr; n < inlinesptr + Constants.TerrainPatchSize; n++, ptru++)
+                {
+                    total += linein[n]*CosineTable16[ptru];
+                }
+                tmp = (int) (total*QuantizeTable16[uptr + column]);
+                lineout[CopyMatrix16[uptr + column]] = tmp;
+                if (dowbits)
+                {
+                    if (tmp < 0) tmp *= -1;
+                    while (tmp > wbitsMaxValue)
+                    {
+                        wbits++;
+                        wbitsMaxValue = 1 << wbits;
+                        if (wbits == maxwbits)
+                        {
+                            dowbits = false;
+                            break;
+                        }
+                    }
+                }
+            }
+            return wbits;
+        }
+        public static void DecodePatch(int[] patches, BitPack bitpack, TerrainPatch.Header header, int size)
+        {
+            for (int n = 0; n < size*size; n++)
+            {
+                // ?
+                int temp = bitpack.UnpackBits(1);
+                if (temp != 0)
+                {
+                    // Value or EOB
+                    temp = bitpack.UnpackBits(1);
+                    if (temp != 0)
+                    {
+                        // Value
+                        temp = bitpack.UnpackBits(1);
+                        if (temp != 0)
+                        {
+                            // Negative
+                            temp = bitpack.UnpackBits((int) header.WordBits);
+                            patches[n] = temp*-1;
+                        }
+                        else
+                        {
+                            // Positive
+                            temp = bitpack.UnpackBits((int) header.WordBits);
+                            patches[n] = temp;
+                        }
+                    }
+                    else
+                    {
+                        // Set the rest to zero
+                        // TODO: This might not be necessary
+                        for (int o = n; o < size*size; o++)
+                        {
+                            patches[o] = 0;
+                        }
+                        break;
+                    }
+                }
+                else
+                {
+                    patches[n] = 0;
+                }
+            }
+        }
+        private static void EncodePatch(BitPack output, int[] patch, int postquant, int wbits)
+        {
+            int maxwbitssize = (1 << wbits) - 1;
+            if (postquant > Constants.TerrainPatchSize*Constants.TerrainPatchSize || postquant < 0)
+            {
+                Logger.Log("Postquant is outside the range of allowed values in EncodePatch()", Helpers.LogLevel.Error);
+                return;
+            }
+            if (postquant != 0) patch[Constants.TerrainPatchSize*Constants.TerrainPatchSize - postquant] = 0;
+            for (int i = 0; i < Constants.TerrainPatchSize*Constants.TerrainPatchSize; i++)
+            {
+                int temp = patch[i];
+                if (temp == 0)
+                {
+                    bool eob = true;
+                    for (int j = i; j < Constants.TerrainPatchSize*Constants.TerrainPatchSize - postquant; j++)
+                    {
+                        if (patch[j] != 0)
+                        {
+                            eob = false;
+                            break;
+                        }
+                    }
+                    if (eob)
+                    {
+                        output.PackBits(ZERO_EOB, 2);
+                        return;
+                    }
+                    output.PackBits(ZERO_CODE, 1);
+                }
+                else
+                {
+                    if (temp < 0)
+                    {
+                        temp *= -1;
+                        if (temp > maxwbitssize) temp = maxwbitssize;
+                        output.PackBits(NEGATIVE_VALUE, 3);
+                        output.PackBits(temp, wbits);
+                    }
+                    else
+                    {
+                        if (temp > maxwbitssize) temp = maxwbitssize;
+                        output.PackBits(POSITIVE_VALUE, 3);
+                        output.PackBits(temp, wbits);
+                    }
+                }
+            }
+        }
+        public static float[] DecompressPatch(int[] patches, TerrainPatch.Header header, TerrainPatch.GroupHeader group)
+        {
+            float[] block = new float[group.PatchSize*group.PatchSize];
+            float[] output = new float[group.PatchSize*group.PatchSize];
+            int prequant = (header.QuantWBits >> 4) + 2;
+            int quantize = 1 << prequant;
+            float ooq = 1.0f/quantize;
+            float mult = ooq*header.Range;
+            float addval = mult*(1 << (prequant - 1)) + header.DCOffset;
+            if (group.PatchSize == Constants.TerrainPatchSize)
+            {
+                for (int n = 0; n < Constants.TerrainPatchSize*Constants.TerrainPatchSize; n++)
+                {
+                    block[n] = patches[CopyMatrix16[n]]*DequantizeTable16[n];
+                }
+                float[] ftemp = new float[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+                for (int o = 0; o < Constants.TerrainPatchSize; o++)
+                    IDCTColumn16(block, ftemp, o);
+                for (int o = 0; o < Constants.TerrainPatchSize; o++)
+                    IDCTLine16(ftemp, block, o);
+            }
+            else
+            {
+                for (int n = 0; n < Constants.TerrainPatchSize*2*Constants.TerrainPatchSize*2; n++)
+                {
+                    block[n] = patches[CopyMatrix32[n]]*DequantizeTable32[n];
+                }
+                Logger.Log("Implement IDCTPatchLarge", Helpers.LogLevel.Error);
+            }
+            for (int j = 0; j < block.Length; j++)
+            {
+                output[j] = block[j]*mult + addval;
+            }
+            return output;
+        }
+        private static int[] CompressPatch(float[] patchData, TerrainPatch.Header header, int prequant, out int wbits)
+        {
+            float[] block = new float[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+            int wordsize = (prequant - 2) & 0x0f;
+            float oozrange = 1.0f/header.Range;
+            float range = (1 << prequant);
+            float premult = oozrange*range;
+            float sub = (1 << (prequant - 1)) + header.DCOffset*premult;
+            header.QuantWBits = wordsize;
+            header.QuantWBits |= wordsize << 4;
+            int k = 0;
+            for (int j = 0; j < Constants.TerrainPatchSize; j++)
+            {
+                for (int i = 0; i < Constants.TerrainPatchSize; i++)
+                    block[k++] = patchData[j*Constants.TerrainPatchSize + i]*premult - sub;
+            }
+            float[] ftemp = new float[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+            int[] itemp = new int[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+            int maxWbits = prequant + 5;
+            wbits = (prequant >> 1);
+            for (int o = 0; o < Constants.TerrainPatchSize; o++)
+                DCTLine16(block, ftemp, o);
+            for (int o = 0; o < Constants.TerrainPatchSize; o++)
+                wbits = DCTColumn16Wbits(ftemp, itemp, o, wbits, maxWbits);
+            return itemp;
+        }
+        private static int[] CompressPatch(float[,] patchData, TerrainPatch.Header header, int prequant, out int wbits)
+        {
+            float[] block = new float[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+            float oozrange = 1.0f/header.Range;
+            float range = (1 << prequant);
+            float premult = oozrange*range;
+            float sub = (1 << (prequant - 1)) + header.DCOffset*premult;
+            int wordsize = (prequant - 2) & 0x0f;
+            header.QuantWBits = wordsize;
+            header.QuantWBits |= wordsize << 4;
+            int k = 0;
+            for (int j = 0; j < Constants.TerrainPatchSize; j++)
+            {
+                for (int i = 0; i < Constants.TerrainPatchSize; i++)
+                    block[k++] = patchData[j, i]*premult - sub;
+            }
+            float[] ftemp = new float[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+            int[] itemp = new int[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+            int maxWbits = prequant + 5;
+            wbits = (prequant >> 1);
+            for (int o = 0; o < Constants.TerrainPatchSize; o++)
+                DCTLine16(block, ftemp, o);
+            for (int o = 0; o < Constants.TerrainPatchSize; o++)
+                wbits = DCTColumn16Wbits(ftemp, itemp, o, wbits, maxWbits);
+            return itemp;
+        }
+        private static int[] CompressPatch(TerrainData terrData, int patchX, int patchY, TerrainPatch.Header header,
+                                                               int prequant, out int wbits)
+        {
+            float[] block = new float[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+            int wordsize = prequant;
+            float oozrange = 1.0f/header.Range;
+            float range = (1 << prequant);
+            float premult = oozrange*range;
+            float sub = (1 << (prequant - 1)) + header.DCOffset*premult;
+            header.QuantWBits = wordsize - 2;
+            header.QuantWBits |= (prequant - 2) << 4;
+            int k = 0;
+            int jPatchLimit = patchY;
+            if (patchY >= (terrData.SizeY / Constants.TerrainPatchSize))
+            {
+                jPatchLimit = (int)(terrData.SizeY - Constants.TerrainPatchSize) / Constants.TerrainPatchSize;
+            }
+            jPatchLimit = (jPatchLimit + 1) * Constants.TerrainPatchSize;
+            int iPatchLimit = patchX;
+            if (patchX >= (terrData.SizeX / Constants.TerrainPatchSize))
+            {
+                iPatchLimit = (int)(terrData.SizeX - Constants.TerrainPatchSize) / Constants.TerrainPatchSize;
+            }
+            iPatchLimit = (iPatchLimit + 1) * Constants.TerrainPatchSize;
+            for (int j = patchY * Constants.TerrainPatchSize; j < jPatchLimit; j++)
+            {
+                for (int i = patchX * Constants.TerrainPatchSize; i < iPatchLimit; i++)
+                {
+                    // block[k++] = (heightmap[j*pRegionSizeX + i])*premult - sub;
+                    block[k++] = terrData[j, i] - sub;
+                }
+            }
+            float[] ftemp = new float[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+            int[] itemp = new int[Constants.TerrainPatchSize*Constants.TerrainPatchSize];
+            int maxWbits = prequant + 5;
+            wbits = (prequant >> 1);
+            for (int o = 0; o < Constants.TerrainPatchSize; o++)
+                DCTLine16(block, ftemp, o);
+            for (int o = 0; o < Constants.TerrainPatchSize; o++)
+                wbits = DCTColumn16Wbits(ftemp, itemp, o, wbits, maxWbits);
+            return itemp;
+        }
+        #region Initialization
+        private static void BuildDequantizeTable16()
+        {
+            for (int j = 0; j < Constants.TerrainPatchSize; j++)
+            {
+                for (int i = 0; i < Constants.TerrainPatchSize; i++)
+                {
+                    DequantizeTable16[j*Constants.TerrainPatchSize + i] = 1.0f + 2.0f*(i + j);
+                }
+            }
+        }
+        private static void BuildQuantizeTable16()
+        {
+            const float oosob = 2.0f/Constants.TerrainPatchSize;
+            for (int j = 0; j < Constants.TerrainPatchSize; j++)
+            {
+                for (int i = 0; i < Constants.TerrainPatchSize; i++)
+                {
+//                    QuantizeTable16[j * Constants.TerrainPatchSize + i] = 1.0f / (1.0f + 2.0f * ((float)i + (float)j));
+                    QuantizeTable16[j*Constants.TerrainPatchSize + i] = oosob/(1.0f + 2.0f*(i + (float) j));
+                }
+            }
+        }
+        private static void SetupCosines16()
+        {
+            const float hposz = (float) Math.PI*0.5f/Constants.TerrainPatchSize;
+            for (int u = 0; u < Constants.TerrainPatchSize; u++)
+            {
+                for (int n = 0; n < Constants.TerrainPatchSize; n++)
+                {
+                    CosineTable16[u*Constants.TerrainPatchSize + n] = (float) Math.Cos((2.0f*n + 1.0f)*u*hposz);
+                }
+            }
+        }
+        private static void BuildCopyMatrix16()
+        {
+            bool diag = false;
+            bool right = true;
+            int i = 0;
+            int j = 0;
+            int count = 0;
+            while (i < Constants.TerrainPatchSize && j < Constants.TerrainPatchSize)
+            {
+                CopyMatrix16[j*Constants.TerrainPatchSize + i] = count++;
+                if (!diag)
+                {
+                    if (right)
+                    {
+                        if (i < Constants.TerrainPatchSize - 1) i++;
+                        else j++;
+                        right = false;
+                        diag = true;
+                    }
+                    else
+                    {
+                        if (j < Constants.TerrainPatchSize - 1) j++;
+                        else i++;
+                        right = true;
+                        diag = true;
+                    }
+                }
+                else
+                {
+                    if (right)
+                    {
+                        i++;
+                        j--;
+                        if (i == Constants.TerrainPatchSize - 1 || j == 0) diag = false;
+                    }
+                    else
+                    {
+                        i--;
+                        j++;
+                        if (j == Constants.TerrainPatchSize - 1 || i == 0) diag = false;
+                    }
+                }
+            }
+        }
+        #endregion Initialization
+    }
+}
+\ No newline at end of file
diff --git a/OpenSim/Region/OptionalModules/Avatar/Chat/RegionState.cs b/OpenSim/Region/OptionalModules/Avatar/Chat/RegionState.cs
index d4fe5e0..cbc538e 100644
--- a/OpenSim/Region/OptionalModules/Avatar/Chat/RegionState.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/Chat/RegionState.cs
@@ -84,8 +84,8 @@ namespace OpenSim.Region.OptionalModules.Avatar.Chat
            Region = scene.RegionInfo.RegionName;
            Host = scene.RegionInfo.ExternalHostName;
-            LocX = Convert.ToString(scene.RegionInfo.RegionLocX);
+            LocX = Convert.ToString(scene.RegionInfo.LegacyRegionLocX);
-            LocY = Convert.ToString(scene.RegionInfo.RegionLocY);
+            LocY = Convert.ToString(scene.RegionInfo.LegacyRegionLocY);
            IDK = Convert.ToString(_idk_++);
            showAlert = config.GetBoolean("alert_show", false);
diff --git a/OpenSim/Region/RegionCombinerModule/RegionCombinerIndividualEventForwarder.cs b/OpenSim/Region/RegionCombinerModule/RegionCombinerIndividualEventForwarder.cs
index 83732e2..7f616bb 100644
--- a/OpenSim/Region/RegionCombinerModule/RegionCombinerIndividualEventForwarder.cs
+++ b/OpenSim/Region/RegionCombinerModule/RegionCombinerIndividualEventForwarder.cs
@@ -100,8 +100,8 @@ namespace OpenSim.Region.RegionCombinerModule
            UUID raytargetid, byte bypassraycast, bool rayendisintersection, bool rezselected, bool removeitem, 
            UUID fromtaskid)
        {
-            int differenceX = (int)m_virtScene.RegionInfo.RegionLocX - (int)m_rootScene.RegionInfo.RegionLocX;
+            int differenceX = (int)m_virtScene.RegionInfo.LegacyRegionLocX - (int)m_rootScene.RegionInfo.LegacyRegionLocX;
-            int differenceY = (int)m_virtScene.RegionInfo.RegionLocY - (int)m_rootScene.RegionInfo.RegionLocY;
+            int differenceY = (int)m_virtScene.RegionInfo.LegacyRegionLocY - (int)m_rootScene.RegionInfo.LegacyRegionLocY;
            rayend.X += differenceX * (int)Constants.RegionSize;
            rayend.Y += differenceY * (int)Constants.RegionSize;
            raystart.X += differenceX * (int)Constants.RegionSize;
@@ -126,8 +126,8 @@ namespace OpenSim.Region.RegionCombinerModule
            PrimitiveBaseShape shape, byte bypassraycast, Vector3 raystart, UUID raytargetid, 
            byte rayendisintersection)
        {
-            int differenceX = (int)m_virtScene.RegionInfo.RegionLocX - (int)m_rootScene.RegionInfo.RegionLocX;
+            int differenceX = (int)m_virtScene.RegionInfo.LegacyRegionLocX - (int)m_rootScene.RegionInfo.LegacyRegionLocX;
-            int differenceY = (int)m_virtScene.RegionInfo.RegionLocY - (int)m_rootScene.RegionInfo.RegionLocY;
+            int differenceY = (int)m_virtScene.RegionInfo.LegacyRegionLocY - (int)m_rootScene.RegionInfo.LegacyRegionLocY;
            rayend.X += differenceX * (int)Constants.RegionSize;
            rayend.Y += differenceY * (int)Constants.RegionSize;
            raystart.X += differenceX * (int)Constants.RegionSize;
diff --git a/OpenSim/Region/RegionCombinerModule/RegionCombinerModule.cs b/OpenSim/Region/RegionCombinerModule/RegionCombinerModule.cs
index 7127c73..3f835a4 100644
--- a/OpenSim/Region/RegionCombinerModule/RegionCombinerModule.cs
+++ b/OpenSim/Region/RegionCombinerModule/RegionCombinerModule.cs
@@ -246,8 +246,8 @@ namespace OpenSim.Region.RegionCombinerModule
            newConn.RegionScene = scene;
            newConn.RegionLandChannel = scene.LandChannel;
            newConn.RegionId = scene.RegionInfo.originRegionID;
-            newConn.X = scene.RegionInfo.RegionLocX;
+            newConn.X = scene.RegionInfo.LegacyRegionLocX;
-            newConn.Y = scene.RegionInfo.RegionLocY;
+            newConn.Y = scene.RegionInfo.LegacyRegionLocY;
            newConn.XEnd = (int)Constants.RegionSize;
            newConn.YEnd = (int)Constants.RegionSize;
@@ -502,11 +502,11 @@ namespace OpenSim.Region.RegionCombinerModule
            lock (scene.WestBorders)
            {
-                scene.WestBorders[0].BorderLine.Z = (int)((scene.RegionInfo.RegionLocX - rootConn.RegionScene.RegionInfo.RegionLocX) * (int)Constants.RegionSize); //auto teleport West
+                scene.WestBorders[0].BorderLine.Z = (int)((scene.RegionInfo.LegacyRegionLocX - rootConn.RegionScene.RegionInfo.LegacyRegionLocX) * (int)Constants.RegionSize); //auto teleport West
                // Trigger auto teleport to root region
-                scene.WestBorders[0].TriggerRegionX = rootConn.RegionScene.RegionInfo.RegionLocX;
+                scene.WestBorders[0].TriggerRegionX = rootConn.RegionScene.RegionInfo.LegacyRegionLocX;
-                scene.WestBorders[0].TriggerRegionY = rootConn.RegionScene.RegionInfo.RegionLocY;
+                scene.WestBorders[0].TriggerRegionY = rootConn.RegionScene.RegionInfo.LegacyRegionLocY;
            }
            // Reset Terrain..  since terrain loads before we get here, we need to load 
@@ -564,9 +564,9 @@ namespace OpenSim.Region.RegionCombinerModule
            lock (scene.SouthBorders)
            {
-                scene.SouthBorders[0].BorderLine.Z = (int)((scene.RegionInfo.RegionLocY - rootConn.RegionScene.RegionInfo.RegionLocY) * (int)Constants.RegionSize); //auto teleport south
+                scene.SouthBorders[0].BorderLine.Z = (int)((scene.RegionInfo.LegacyRegionLocY - rootConn.RegionScene.RegionInfo.LegacyRegionLocY) * (int)Constants.RegionSize); //auto teleport south
-                scene.SouthBorders[0].TriggerRegionX = rootConn.RegionScene.RegionInfo.RegionLocX;
+                scene.SouthBorders[0].TriggerRegionX = rootConn.RegionScene.RegionInfo.LegacyRegionLocX;
-                scene.SouthBorders[0].TriggerRegionY = rootConn.RegionScene.RegionInfo.RegionLocY;
+                scene.SouthBorders[0].TriggerRegionY = rootConn.RegionScene.RegionInfo.LegacyRegionLocY;
            }
            // Reset Terrain..  since terrain normally loads first.
@@ -636,9 +636,9 @@ namespace OpenSim.Region.RegionCombinerModule
            lock (scene.SouthBorders)
            {
-                scene.SouthBorders[0].BorderLine.Z = (int)((scene.RegionInfo.RegionLocY - rootConn.RegionScene.RegionInfo.RegionLocY) * (int)Constants.RegionSize); //auto teleport south
+                scene.SouthBorders[0].BorderLine.Z = (int)((scene.RegionInfo.LegacyRegionLocY - rootConn.RegionScene.RegionInfo.LegacyRegionLocY) * (int)Constants.RegionSize); //auto teleport south
-                scene.SouthBorders[0].TriggerRegionX = rootConn.RegionScene.RegionInfo.RegionLocX;
+                scene.SouthBorders[0].TriggerRegionX = rootConn.RegionScene.RegionInfo.LegacyRegionLocX;
-                scene.SouthBorders[0].TriggerRegionY = rootConn.RegionScene.RegionInfo.RegionLocY;
+                scene.SouthBorders[0].TriggerRegionY = rootConn.RegionScene.RegionInfo.LegacyRegionLocY;
            }
            lock (rootConn.RegionScene.EastBorders)
@@ -657,9 +657,9 @@ namespace OpenSim.Region.RegionCombinerModule
            lock (scene.WestBorders)
            {
-                scene.WestBorders[0].BorderLine.Z = (int)((scene.RegionInfo.RegionLocX - rootConn.RegionScene.RegionInfo.RegionLocX) * (int)Constants.RegionSize); //auto teleport West
+                scene.WestBorders[0].BorderLine.Z = (int)((scene.RegionInfo.LegacyRegionLocX - rootConn.RegionScene.RegionInfo.LegacyRegionLocX) * (int)Constants.RegionSize); //auto teleport West
-                scene.WestBorders[0].TriggerRegionX = rootConn.RegionScene.RegionInfo.RegionLocX;
+                scene.WestBorders[0].TriggerRegionX = rootConn.RegionScene.RegionInfo.LegacyRegionLocX;
-                scene.WestBorders[0].TriggerRegionY = rootConn.RegionScene.RegionInfo.RegionLocY;
+                scene.WestBorders[0].TriggerRegionY = rootConn.RegionScene.RegionInfo.LegacyRegionLocY;
            }
            /*
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
index 975bf2d..2ac0805 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -4241,10 +4241,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                        DataserverPlugin.RegisterRequest(m_host.LocalId,
                                                     m_item.ItemID, item.AssetID.ToString());
-                    Vector3 region = new Vector3(
+                    Vector3 region = new Vector3(World.RegionInfo.RegionWorldLocX, World.RegionInfo.RegionWorldLocY, 0);
-                        World.RegionInfo.RegionLocX * Constants.RegionSize,
-                        World.RegionInfo.RegionLocY * Constants.RegionSize,
-                        0);
                    World.AssetService.Get(item.AssetID.ToString(), this,
                        delegate(string i, object sender, AssetBase a)
@@ -5478,7 +5475,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
        public LSL_Vector llGetRegionCorner()
        {
            m_host.AddScriptLPS(1);
-            return new LSL_Vector(World.RegionInfo.RegionLocX * Constants.RegionSize, World.RegionInfo.RegionLocY * Constants.RegionSize, 0);
+            return new LSL_Vector(World.RegionInfo.RegionWorldLocX, World.RegionInfo.RegionWorldLocY, 0);
        }
        /// <summary>
@@ -5651,8 +5648,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
            List<GridRegion> neighbors = World.GridService.GetNeighbours(World.RegionInfo.ScopeID, World.RegionInfo.RegionID);
-            uint neighborX = World.RegionInfo.RegionLocX + (uint)dir.x;
+            uint neighborX = World.RegionInfo.LegacyRegionLocX + (uint)dir.x;
-            uint neighborY = World.RegionInfo.RegionLocY + (uint)dir.y;
+            uint neighborY = World.RegionInfo.LegacyRegionLocY + (uint)dir.y;
            foreach (GridRegion sri in neighbors)
            {
@@ -10737,7 +10734,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
            httpHeaders["X-SecondLife-Shard"] = shard;
            httpHeaders["X-SecondLife-Object-Name"] = m_host.Name;
            httpHeaders["X-SecondLife-Object-Key"] = m_host.UUID.ToString();
-            httpHeaders["X-SecondLife-Region"] = string.Format("{0} ({1}, {2})", regionInfo.RegionName, regionInfo.RegionLocX, regionInfo.RegionLocY);
+            httpHeaders["X-SecondLife-Region"] = string.Format("{0} ({1}, {2})", regionInfo.RegionName, regionInfo.LegacyRegionLocX, regionInfo.LegacyRegionLocY);
            httpHeaders["X-SecondLife-Local-Position"] = string.Format("({0:0.000000}, {1:0.000000}, {2:0.000000})", position.X, position.Y, position.Z);
            httpHeaders["X-SecondLife-Local-Velocity"] = string.Format("({0:0.000000}, {1:0.000000}, {2:0.000000})", velocity.X, velocity.Y, velocity.Z);
            httpHeaders["X-SecondLife-Local-Rotation"] = string.Format("({0:0.000000}, {1:0.000000}, {2:0.000000}, {3:0.000000})", rotation.X, rotation.Y, rotation.Z, rotation.W);
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianGridMaptileModule.cs b/OpenSim/Services/Connectors/SimianGrid/SimianGridMaptileModule.cs
index b999509..71334ee 100644
--- a/OpenSim/Services/Connectors/SimianGrid/SimianGridMaptileModule.cs
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianGridMaptileModule.cs
@@ -201,8 +201,8 @@ namespace OpenSim.Services.Connectors.SimianGrid
            NameValueCollection requestArgs = new NameValueCollection
                {
                        { "RequestMethod", "xAddMapTile" },
-                        { "X", scene.RegionInfo.RegionLocX.ToString() },
+                        { "X", scene.RegionInfo.LegacyRegionLocX.ToString() },
-                        { "Y", scene.RegionInfo.RegionLocY.ToString() },
+                        { "Y", scene.RegionInfo.LegacyRegionLocY.ToString() },
                        { "ContentType", "image/png" },
                        { "EncodedData", System.Convert.ToBase64String(pngData) }
                };
diff --git a/OpenSim/Services/Interfaces/IGridService.cs b/OpenSim/Services/Interfaces/IGridService.cs
index 88ac5b3..56171b1 100644
--- a/OpenSim/Services/Interfaces/IGridService.cs
+++ b/OpenSim/Services/Interfaces/IGridService.cs
@@ -246,8 +246,8 @@ namespace OpenSim.Services.Interfaces
        public GridRegion(RegionInfo ConvertFrom)
        {
            m_regionName = ConvertFrom.RegionName;
-            m_regionLocX = (int)(ConvertFrom.RegionLocX * Constants.RegionSize);
+            m_regionLocX = (int)(ConvertFrom.RegionWorldLocX);
-            m_regionLocY = (int)(ConvertFrom.RegionLocY * Constants.RegionSize);
+            m_regionLocY = (int)(ConvertFrom.RegionWorldLocY);
            m_internalEndPoint = ConvertFrom.InternalEndPoint;
            m_externalHostName = ConvertFrom.ExternalHostName;
            m_httpPort = ConvertFrom.HttpPort;