72 files changed, 2714 insertions, 916 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 8b66ee1..d2f74de 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/IRegionData.cs b/OpenSim/Data/IRegionData.cs
index 463c621..50433ba 100644
--- a/OpenSim/Data/IRegionData.cs
+++ b/OpenSim/Data/IRegionData.cs
@@ -54,12 +54,12 @@ namespace OpenSim.Data
        /// <summary>
        /// Return the x-coordinate of this region.
        /// </summary>
-        public int coordX { get { return posX / (int)Constants.RegionSize; } }
+        public int coordX { get { return (int)Util.WorldToRegionLoc((uint)posX); } }
        /// <summary>
        /// Return the y-coordinate of this region.
        /// </summary>
-        public int coordY { get { return posY / (int)Constants.RegionSize; } }
+        public int coordY { get { return (int)Util.WorldToRegionLoc((uint)posY); } }
        public Dictionary<string, object> Data;
    }
diff --git a/OpenSim/Data/MSSQL/MSSQLSimulationData.cs b/OpenSim/Data/MSSQL/MSSQLSimulationData.cs
index f41f60c..9f5991b 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
@@ -530,43 +531,49 @@ ELSE
        /// <returns></returns>
        public double[,] LoadTerrain(UUID regionID)
        {
-            double[,] terrain = new double[(int)Constants.RegionSize, (int)Constants.RegionSize];
+            TerrainData terrData = LoadTerrain(regionID, (int)Constants.RegionSize, (int)Constants.RegionSize, (int)Constants.RegionHeight);
-            terrain.Initialize();
+            return terrData.GetDoubles();
+        }
+        public TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ)
+        {
+            TerrainData terrData = null;
            string sql = "select top 1 RegionUUID, Revision, Heightfield from terrain where RegionUUID = @RegionUUID order by Revision desc";
            using (SqlConnection conn = new SqlConnection(m_connectionString))
-            using (SqlCommand cmd = new SqlCommand(sql, conn))
            {
-                // MySqlParameter param = new MySqlParameter();
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
-                cmd.Parameters.Add(_Database.CreateParameter("@RegionUUID", regionID));
-                conn.Open();
-                using (SqlDataReader reader = cmd.ExecuteReader())
                {
-                    int rev;
+                    // MySqlParameter param = new MySqlParameter();
-                    if (reader.Read())
+                    cmd.Parameters.Add(_Database.CreateParameter("@RegionUUID", regionID));
+                    conn.Open();
+                    using (SqlDataReader reader = cmd.ExecuteReader())
                    {
-                        MemoryStream str = new MemoryStream((byte[])reader["Heightfield"]);
+                        int rev;
-                        BinaryReader br = new BinaryReader(str);
+                        if (reader.Read())
-                        for (int x = 0; x < (int)Constants.RegionSize; x++)
                        {
-                            for (int y = 0; y < (int)Constants.RegionSize; y++)
+                            rev = (int)reader["Revision"];
-                            {
+                            byte[] blob = (byte[])reader["Heightfield"];
-                                terrain[x, y] = br.ReadDouble();
+                            terrData = TerrainData.CreateFromDatabaseBlobFactory(pSizeX, pSizeY, pSizeZ, rev, blob);
-                            }
                        }
-                        rev = (int)reader["Revision"];
+                        else
-                    }
+                        {
-                    else
+                            _Log.Info("[REGION DB]: No terrain found for region");
-                    {
+                            return null;
-                        _Log.Info("[REGION DB]: No terrain found for region");
+                        }
-                        return null;
+                        _Log.Info("[REGION DB]: Loaded terrain revision r" + rev);
                    }
-                    _Log.Info("[REGION DB]: Loaded terrain revision r" + rev);
                }
            }
-            return terrain;
+            return terrData;
+        }
+        // Legacy entry point for when terrain was always a 256x256 hieghtmap
+        public void StoreTerrain(double[,] ter, UUID regionID)
+        {
+            StoreTerrain(new HeightmapTerrainData(ter), regionID);
        }
        /// <summary>
@@ -574,10 +581,8 @@ ELSE
        /// </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,23 @@ 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));
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
-                cmd.Parameters.Add(_Database.CreateParameter("@Revision", revision));
+                {
-                cmd.Parameters.Add(_Database.CreateParameter("@Heightfield", serializeTerrain(terrain)));
+                    cmd.Parameters.Add(_Database.CreateParameter("@RegionUUID", regionID));
-                conn.Open();
+                    cmd.Parameters.Add(_Database.CreateParameter("@Revision", terrainDBRevision));
-                cmd.ExecuteNonQuery();
+                    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 +1356,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..42f2ebb 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);
                    }
@@ -601,9 +613,16 @@ namespace OpenSim.Data.MySQL
            }
        }
+        // Legacy region loading
        public double[,] LoadTerrain(UUID regionID)
        {
-            double[,] terrain = null;
+            TerrainData terrData = LoadTerrain(regionID, (int)Constants.RegionSize, (int)Constants.RegionSize, (int)Constants.RegionHeight);
+            return terrData.GetDoubles();
+        }
+        public TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ)
+        {
+            TerrainData terrData = null;
            lock (m_dbLock)
            {
@@ -623,32 +642,15 @@ namespace OpenSim.Data.MySQL
                            while (reader.Read())
                            {
                                int rev = Convert.ToInt32(reader["Revision"]);
+                                byte[] blob = (byte[])reader["Heightfield"];
-                                terrain = new double[(int)Constants.RegionSize, (int)Constants.RegionSize];
+                                terrData = TerrainData.CreateFromDatabaseBlobFactory(pSizeX, pSizeY, pSizeZ, rev, blob);
-                                terrain.Initialize();
-                                using (MemoryStream mstr = new MemoryStream((byte[])reader["Heightfield"]))
-                                {
-                                    using (BinaryReader br = new BinaryReader(mstr))
-                                    {
-                                        for (int x = 0; x < (int)Constants.RegionSize; x++)
-                                        {
-                                            for (int y = 0; y < (int)Constants.RegionSize; y++)
-                                            {
-                                                terrain[x, y] = br.ReadDouble();
-                                            }
-                                        }
-                                    }
-                                    m_log.InfoFormat("[REGION DB]: Loaded terrain revision r{0}", rev);
-                                }
                            }
                        }
                    }
                }
            }
-            return terrain;
+            return terrData;
        }
        public void RemoveLandObject(UUID globalID)
@@ -1525,30 +1527,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/Null/NullSimulationData.cs b/OpenSim/Data/Null/NullSimulationData.cs
index d11ad72..acde1a1 100644
--- a/OpenSim/Data/Null/NullSimulationData.cs
+++ b/OpenSim/Data/Null/NullSimulationData.cs
@@ -132,18 +132,35 @@ namespace OpenSim.Data.Null
            return new List<SceneObjectGroup>();
        }
-        Dictionary<UUID, double[,]> m_terrains = new Dictionary<UUID, double[,]>();
+        Dictionary<UUID, TerrainData> m_terrains = new Dictionary<UUID, TerrainData>();
-        public void StoreTerrain(double[,] ter, UUID regionID)
+        public void StoreTerrain(TerrainData ter, UUID regionID)
        {
            if (m_terrains.ContainsKey(regionID))
                m_terrains.Remove(regionID);
            m_terrains.Add(regionID, ter);
        }
+        // Legacy. Just don't do this.
+        public void StoreTerrain(double[,] ter, UUID regionID)
+        {
+            TerrainData terrData = new HeightmapTerrainData(ter);
+            StoreTerrain(terrData, regionID);
+        }
+        // Legacy. Just don't do this.
        public double[,] LoadTerrain(UUID regionID)
        {
            if (m_terrains.ContainsKey(regionID))
            {
+                return m_terrains[regionID].GetDoubles();
+            }
+            return null;
+        }
+        public TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ)
+        {
+            if (m_terrains.ContainsKey(regionID))
+            {
                return m_terrains[regionID];
            }
            return null;
diff --git a/OpenSim/Data/PGSQL/PGSQLSimulationData.cs b/OpenSim/Data/PGSQL/PGSQLSimulationData.cs
index 69b0beb..b063607 100644
--- a/OpenSim/Data/PGSQL/PGSQLSimulationData.cs
+++ b/OpenSim/Data/PGSQL/PGSQLSimulationData.cs
@@ -46,6 +46,7 @@ namespace OpenSim.Data.PGSQL
    public class PGSQLSimulationData : ISimulationDataStore
    {
        private const string _migrationStore = "RegionStore";
+        private const string LogHeader = "[REGION DB PGSQL]";
        // private static FileSystemDataStore Instance = new FileSystemDataStore();
        private static readonly ILog _Log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
@@ -523,44 +524,50 @@ namespace OpenSim.Data.PGSQL
        /// <returns></returns>
        public double[,] LoadTerrain(UUID regionID)
        {
-            double[,] terrain = new double[(int)Constants.RegionSize, (int)Constants.RegionSize];
+            TerrainData terrData = LoadTerrain(regionID, (int)Constants.RegionSize, (int)Constants.RegionSize, (int)Constants.RegionHeight);
-            terrain.Initialize();
+            return terrData.GetDoubles();
+        }
+        public TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ)
+        {
+            TerrainData terrData = null;
            string sql = @"select ""RegionUUID"", ""Revision"", ""Heightfield"" from terrain 
                            where ""RegionUUID"" = :RegionUUID order by ""Revision"" desc limit 1; ";
            using (NpgsqlConnection conn = new NpgsqlConnection(m_connectionString))
-            using (NpgsqlCommand cmd = new NpgsqlCommand(sql, conn))
            {
-                // PGSqlParameter param = new PGSqlParameter();
+                using (NpgsqlCommand cmd = new NpgsqlCommand(sql, conn))
-                cmd.Parameters.Add(_Database.CreateParameter("RegionUUID", regionID));
-                conn.Open();
-                using (NpgsqlDataReader reader = cmd.ExecuteReader())
                {
-                    int rev;
+                    // PGSqlParameter param = new PGSqlParameter();
-                    if (reader.Read())
+                    cmd.Parameters.Add(_Database.CreateParameter("RegionUUID", regionID));
+                    conn.Open();
+                    using (NpgsqlDataReader reader = cmd.ExecuteReader())
                    {
-                        MemoryStream str = new MemoryStream((byte[])reader["Heightfield"]);
+                        int rev;
-                        BinaryReader br = new BinaryReader(str);
+                        if (reader.Read())
-                        for (int x = 0; x < (int)Constants.RegionSize; x++)
                        {
-                            for (int y = 0; y < (int)Constants.RegionSize; y++)
+                            rev = Convert.ToInt32(reader["Revision"]);
-                            {
+                            byte[] blob = (byte[])reader["Heightfield"];
-                                terrain[x, y] = br.ReadDouble();
+                            terrData = TerrainData.CreateFromDatabaseBlobFactory(pSizeX, pSizeY, pSizeZ, rev, blob);
-                            }
                        }
-                        rev = (int)reader["Revision"];
+                        else
-                    }
+                        {
-                    else
+                            _Log.Info("[REGION DB]: No terrain found for region");
-                    {
+                            return null;
-                        _Log.Info("[REGION DB]: No terrain found for region");
+                        }
-                        return null;
+                        _Log.Info("[REGION DB]: Loaded terrain revision r" + rev);
                    }
-                    _Log.Info("[REGION DB]: Loaded terrain revision r" + rev);
                }
            }
-            return terrain;
+            return terrData;
+        }
+        // Legacy entry point for when terrain was always a 256x256 heightmap
+        public void StoreTerrain(double[,] terrain, UUID regionID)
+        {
+            StoreTerrain(new HeightmapTerrainData(terrain), regionID);
        }
        /// <summary>
@@ -568,35 +575,43 @@ namespace OpenSim.Data.PGSQL
        /// </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 (NpgsqlConnection conn = new NpgsqlConnection(m_connectionString))
-            using (NpgsqlCommand cmd = new NpgsqlCommand(sql, conn))
            {
-                cmd.Parameters.Add(_Database.CreateParameter("RegionUUID", regionID));
+                using (NpgsqlCommand cmd = new NpgsqlCommand(sql, conn))
-                conn.Open();
+                {
-                cmd.ExecuteNonQuery();
+                    cmd.Parameters.Add(_Database.CreateParameter("RegionUUID", regionID));
+                    conn.Open();
+                    cmd.ExecuteNonQuery();
+                    _Log.InfoFormat("{0} Deleted terrain revision id = {1}", LogHeader, regionID);
+                }
            }
-            _Log.Info("[REGION DB]: Deleted terrain revision r " + revision);
+            int terrainDBRevision;
+            Array terrainDBblob;
+            terrData.GetDatabaseBlob(out terrainDBRevision, out terrainDBblob);
            sql = @"insert into terrain(""RegionUUID"", ""Revision"", ""Heightfield"") values(:RegionUUID, :Revision, :Heightfield)";
            using (NpgsqlConnection conn = new NpgsqlConnection(m_connectionString))
-            using (NpgsqlCommand cmd = new NpgsqlCommand(sql, conn))
            {
-                cmd.Parameters.Add(_Database.CreateParameter("RegionUUID", regionID));
+                using (NpgsqlCommand cmd = new NpgsqlCommand(sql, conn))
-                cmd.Parameters.Add(_Database.CreateParameter("Revision", revision));
+                {
-                cmd.Parameters.Add(_Database.CreateParameter("Heightfield", serializeTerrain(terrain)));
+                    cmd.Parameters.Add(_Database.CreateParameter("RegionUUID", regionID));
-                conn.Open();
+                    cmd.Parameters.Add(_Database.CreateParameter("Revision", terrainDBRevision));
-                cmd.ExecuteNonQuery();
+                    cmd.Parameters.Add(_Database.CreateParameter("Heightfield", terrainDBblob));
+                    conn.Open();
+                    cmd.ExecuteNonQuery();
+                    _Log.InfoFormat("{0} Stored terrain id = {1}, terrainSize = <{2},{3}>",
+                                    LogHeader, regionID, terrData.SizeX, terrData.SizeY);
+                }
            }
-            _Log.Info("[REGION DB]: Stored terrain revision r " + revision);
        }
        /// <summary>
@@ -1349,30 +1364,6 @@ namespace OpenSim.Data.PGSQL
        #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/SQLite/SQLiteSimulationData.cs b/OpenSim/Data/SQLite/SQLiteSimulationData.cs
index d938b6b..5a34f09 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();
                }
            }
@@ -870,11 +870,16 @@ namespace OpenSim.Data.SQLite
        /// <returns>Heightfield data</returns>
        public double[,] LoadTerrain(UUID regionID)
        {
+            TerrainData terrData = LoadTerrain(regionID, (int)Constants.RegionSize, (int)Constants.RegionSize, (int)Constants.RegionHeight);
+            return terrData.GetDoubles();
+        }
+        public TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ)
+        {
+            TerrainData terrData = null;
            lock (ds)
            {
-                double[,] terret = new double[(int)Constants.RegionSize, (int)Constants.RegionSize];
-                terret.Initialize();
                String sql = "select RegionUUID, Revision, Heightfield from terrain" +
                             " where RegionUUID=:RegionUUID order by Revision desc";
@@ -887,21 +892,9 @@ namespace OpenSim.Data.SQLite
                        int rev = 0;
                        if (row.Read())
                        {
-                            // TODO: put this into a function
-                            using (MemoryStream str = new MemoryStream((byte[])row["Heightfield"]))
-                            {
-                                using (BinaryReader br = new BinaryReader(str))
-                                {
-                                    for (int x = 0; x < (int)Constants.RegionSize; x++)
-                                    {
-                                        for (int y = 0; y < (int)Constants.RegionSize; y++)
-                                        {
-                                            terret[x, y] = br.ReadDouble();
-                                        }
-                                    }
-                                }
-                            }
                            rev = Convert.ToInt32(row["Revision"]);
+                            byte[] blob = (byte[])row["Heightfield"];
+                            terrData = TerrainData.CreateFromDatabaseBlobFactory(pSizeX, pSizeY, pSizeZ, rev, blob);
                        }
                        else
                        {
@@ -912,8 +905,8 @@ namespace OpenSim.Data.SQLite
                        m_log.Debug("[SQLITE REGION DB]: Loaded terrain revision r" + rev.ToString());
                    }
                }
-                return terret;
            }
+            return terrData;
        }
        public void RemoveLandObject(UUID globalID)
@@ -2019,40 +2012,6 @@ namespace OpenSim.Data.SQLite
        /// <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;
-        //             row["Revision"] = rev;
-        //             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]);
-        //             row["Heightfield"] = str.ToArray();
-        //         }
-        /// <summary>
-        ///
-        /// </summary>
        /// <param name="row"></param>
        /// <param name="prim"></param>
        /// <param name="sceneGroupID"></param>
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..d18b32e 100644
--- a/OpenSim/Framework/Constants.cs
+++ b/OpenSim/Framework/Constants.cs
@@ -30,9 +30,16 @@ 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;
+        // 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..cf909cd 100644
--- a/OpenSim/Framework/RegionInfo.cs
+++ b/OpenSim/Framework/RegionInfo.cs
@@ -99,6 +99,7 @@ namespace OpenSim.Framework
    public class RegionInfo
    {
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly string LogHeader = "[REGION INFO]";
        public bool commFailTF = false;
        public ConfigurationMember configMember;
@@ -137,16 +138,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 +234,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 +449,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 +615,25 @@ 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);
+            DoRegionSizeSanityChecks();
            // InternalAddress
            //
@@ -693,6 +753,48 @@ namespace OpenSim.Framework
            }
        }
+        // Make sure user specified region sizes are sane.
+        // Must be multiples of legacy region size (256).
+        private void DoRegionSizeSanityChecks()
+        {
+            if (RegionSizeX != Constants.RegionSize || RegionSizeY != Constants.RegionSize)
+            {
+                // Doing non-legacy region sizes.
+                // Enforce region size to be multiples of the legacy region size (256)
+                uint partial = RegionSizeX % Constants.RegionSize;
+                if (partial != 0)
+                {
+                    RegionSizeX -= partial;
+                    if (RegionSizeX == 0)
+                        RegionSizeX = Constants.RegionSize;
+                    m_log.ErrorFormat("{0} Region size must be multiple of {1}. Enforcing {2}.RegionSizeX={3} instead of specified {4}",
+                        LogHeader, Constants.RegionSize, m_regionName, RegionSizeX, RegionSizeX + partial);
+                }
+                partial = RegionSizeY % Constants.RegionSize;
+                if (partial != 0)
+                {
+                    RegionSizeY -= partial;
+                    if (RegionSizeY == 0)
+                        RegionSizeY = Constants.RegionSize;
+                    m_log.ErrorFormat("{0} Region size must be multiple of {1}. Enforcing {2}.RegionSizeY={3} instead of specified {4}",
+                        LogHeader, Constants.RegionSize, m_regionName, RegionSizeY, RegionSizeY + partial);
+                }
+                // Because of things in the viewer, regions MUST be square.
+                // Remove this check when viewers have been updated.
+                if (RegionSizeX != RegionSizeY)
+                {
+                    uint minSize = Math.Min(RegionSizeX, RegionSizeY);
+                    RegionSizeX = minSize;
+                    RegionSizeY = minSize;
+                    m_log.ErrorFormat("{0} Regions must be square until viewers are updated. Forcing region {1} size to <{2},{3}>",
+                                                    LogHeader, m_regionName, RegionSizeX, RegionSizeY);
+                }
+                m_log.InfoFormat("{0} Region {1} size set to <{2},{3}>", LogHeader, m_regionName, RegionSizeX, RegionSizeY);
+            }
+        }
        private void WriteNiniConfig(IConfigSource source)
        {
            IConfig config = source.Configs[RegionName];
@@ -704,9 +806,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 +898,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 +972,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 +1041,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 +1134,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 +1171,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 +1222,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..1c52a69
--- /dev/null
+++ b/OpenSim/Framework/TerrainData.cs
@@ -0,0 +1,418 @@
+/*
+ * 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 System.Reflection;
+using OpenMetaverse;
+using log4net;
+namespace OpenSim.Framework
+{
+    public abstract class TerrainData
+    {
+        // Terrain always is a square
+        public int SizeX { get; protected set; }
+        public int SizeY { get; protected set; }
+        public int SizeZ { get; protected set; }
+        // A height used when the user doesn't specify anything
+        public const float DefaultTerrainHeight = 21f;
+        public abstract float this[int x, int y] { get; set; }
+        // Someday terrain will have caves
+        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();
+        public abstract void ClearLand();
+        public abstract void ClearLand(float height);
+        // Return a representation of this terrain for storing as a blob in the database.
+        // Returns 'true' to say blob was stored in the 'out' locations.
+        public abstract bool GetDatabaseBlob(out int DBFormatRevisionCode, out Array blob);
+        // Given a revision code and a blob from the database, create and return the right type of TerrainData.
+        // The sizes passed are the expected size of the region. The database info will be used to
+        //     initialize the heightmap of that sized region with as much data is in the blob.
+        // Return created TerrainData or 'null' if unsuccessful.
+        public static TerrainData CreateFromDatabaseBlobFactory(int pSizeX, int pSizeY, int pSizeZ, int pFormatCode, byte[] pBlob)
+        {
+            // For the moment, there is only one implementation class
+            return new HeightmapTerrainData(pSizeX, pSizeY, pSizeZ, pFormatCode, pBlob);
+        }
+        // return a special compressed representation of the heightmap in shorts
+        public abstract short[] GetCompressedMap();
+        public abstract float CompressionFactor { get; }
+        public abstract double[,] GetDoubles();
+        public abstract TerrainData Clone();
+    }
+    // The terrain is stored in the database as a blob with a 'revision' field.
+    // Some implementations of terrain storage would fill the revision field with
+    //    the time the terrain was stored. When real revisions were added and this
+    //    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 ints are X and Y dimensions
+        // The dimensions are presumed to be multiples of 16 and, more likely, multiples of 256.
+        Variable2D = 22,
+        // Terrain is 'int32, int32, int32, int16[]' where the ints are X and Y dimensions
+        //   and third int is the 'compression factor'. The heights are compressed as
+        //   "short compressedHeight = (short)(height * compressionFactor);"
+        // The dimensions are presumed to be multiples of 16 and, more likely, multiples of 256.
+        Compressed2D = 27,
+        // 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. Shorts are used to limit storage used.
+    public class HeightmapTerrainData : TerrainData
+    {
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[HEIGHTMAP TERRAIN DATA]";
+        // 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;
+        }
+        // TerrainData.ClearLand
+        public override void ClearLand()
+        {
+            ClearLand(DefaultTerrainHeight);
+        }
+        // TerrainData.ClearLand(float)
+        public override void ClearLand(float pHeight)
+        {
+            short flatHeight = ToCompressedHeight(pHeight);
+            for (int xx = 0; xx < SizeX; xx++)
+                for (int yy = 0; yy < SizeY; yy++)
+                    m_heightmap[xx, yy] = flatHeight;
+        }
+        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)
+        {
+            bool ret = false;
+            if (SizeX == Constants.RegionSize && SizeY == Constants.RegionSize)
+            {
+                DBRevisionCode = (int)DBTerrainRevision.Legacy256;
+                blob = ToLegacyTerrainSerialization();
+                ret = true;
+            }
+            else
+            {
+                DBRevisionCode = (int)DBTerrainRevision.Compressed2D;
+                blob = ToCompressedTerrainSerialization();
+                ret = true;
+            }
+            return ret;
+        }
+        // TerrainData.CompressionFactor
+        private float m_compressionFactor = 100.0f;
+        public override float CompressionFactor { get { return m_compressionFactor; } }
+        // TerrainData.GetCompressedMap
+        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;
+        }
+        // TerrainData.Clone
+        public override TerrainData Clone()
+        {
+            HeightmapTerrainData ret = new HeightmapTerrainData(SizeX, SizeY, SizeZ);
+            ret.m_heightmap = (short[,])this.m_heightmap.Clone();
+            return ret;
+        }
+        // TerrainData.GetDoubles
+        public override double[,] GetDoubles()
+        {
+            double[,] ret = new double[SizeX, SizeY];
+            for (int xx = 0; xx < SizeX; xx++)
+                for (int yy = 0; yy < SizeY; yy++)
+                    ret[xx, yy] = FromCompressedHeight(m_heightmap[xx, yy]);
+            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 short ToCompressedHeight(double pHeight)
+        {
+            return (short)(pHeight * CompressionFactor);
+        }
+        public float FromCompressedHeight(short pHeight)
+        {
+            return ((float)pHeight) / CompressionFactor;
+        }
+        // To keep with the legacy theme, create an instance of this class based on the
+        //     way terrain used to be passed around.
+        public HeightmapTerrainData(double[,] pTerrain)
+        {
+            SizeX = pTerrain.GetLength(0);
+            SizeY = pTerrain.GetLength(1);
+            SizeZ = (int)Constants.RegionHeight;
+            m_compressionFactor = 100.0f;
+            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_log.DebugFormat("{0} new by doubles. sizeX={1}, sizeY={2}, sizeZ={3}", LogHeader, SizeX, SizeY, SizeZ);
+            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_compressionFactor = 100.0f;
+            m_heightmap = new short[SizeX, SizeY];
+            m_taint = new bool[SizeX / Constants.TerrainPatchSize, SizeY / Constants.TerrainPatchSize];
+            // m_log.DebugFormat("{0} new by dimensions. sizeX={1}, sizeY={2}, sizeZ={3}", LogHeader, SizeX, SizeY, SizeZ);
+            ClearTaint();
+        }
+        public HeightmapTerrainData(short[] cmap, float pCompressionFactor, int pX, int pY, int pZ) : this(pX, pY, pZ)
+        {
+            m_compressionFactor = pCompressionFactor;
+            int ind = 0;
+            for (int xx = 0; xx < SizeX; xx++)
+                for (int yy = 0; yy < SizeY; yy++)
+                    m_heightmap[xx, yy] = cmap[ind++];
+            // m_log.DebugFormat("{0} new by compressed map. sizeX={1}, sizeY={2}, sizeZ={3}", LogHeader, SizeX, SizeY, SizeZ);
+        }
+        // Create a heighmap from a database blob
+        public HeightmapTerrainData(int pSizeX, int pSizeY, int pSizeZ, int pFormatCode, byte[] pBlob) : this(pSizeX, pSizeY, pSizeZ)
+        {
+            switch ((DBTerrainRevision)pFormatCode)
+            {
+                case DBTerrainRevision.Compressed2D:
+                    FromCompressedTerrainSerialization(pBlob);
+                    m_log.DebugFormat("{0} HeightmapTerrainData create from Compressed2D serialization. Size=<{1},{2}>", LogHeader, SizeX, SizeY);
+                    break;
+                default:
+                    FromLegacyTerrainSerialization(pBlob);
+                    m_log.DebugFormat("{0} HeightmapTerrainData create from legacy serialization. Size=<{1},{2}>", LogHeader, SizeX, SizeY);
+                    break;
+            }
+        }
+        // Just create an array of doubles. Presumes the caller implicitly knows the size.
+        public Array ToLegacyTerrainSerialization()
+        {
+            Array ret = null;
+            using (MemoryStream str = new MemoryStream((int)Constants.RegionSize * (int)Constants.RegionSize * sizeof(double)))
+            {
+                using (BinaryWriter bw = new BinaryWriter(str))
+                {
+                    for (int xx = 0; xx < Constants.RegionSize; xx++)
+                    {
+                        for (int yy = 0; yy < Constants.RegionSize; yy++)
+                        {
+                            double height = this[xx, yy];
+                            if (height == 0.0)
+                                height = double.Epsilon;
+                            bw.Write(height);
+                        }
+                    }
+                }
+                ret = str.ToArray();
+            }
+            return ret;
+        }
+        // Just create an array of doubles. Presumes the caller implicitly knows the size.
+        public void FromLegacyTerrainSerialization(byte[] pBlob)
+        {
+            // In case database info doesn't match real terrain size, initialize the whole terrain.
+            ClearLand();
+            using (MemoryStream mstr = new MemoryStream(pBlob))
+            {
+                using (BinaryReader br = new BinaryReader(mstr))
+                {
+                    for (int xx = 0; xx < (int)Constants.RegionSize; xx++)
+                    {
+                        for (int yy = 0; yy < (int)Constants.RegionSize; yy++)
+                        {
+                            float val = (float)br.ReadDouble();
+                            if (xx < SizeX && yy < SizeY)
+                                m_heightmap[xx, yy] = ToCompressedHeight(val);
+                        }
+                    }
+                }
+                ClearTaint();
+            }
+        }
+        
+        // See the reader below.
+        public Array ToCompressedTerrainSerialization()
+        {
+            Array ret = null;
+            using (MemoryStream str = new MemoryStream((3 * sizeof(Int32)) + (SizeX * SizeY * sizeof(Int16))))
+            {
+                using (BinaryWriter bw = new BinaryWriter(str))
+                {
+                    bw.Write((Int32)DBTerrainRevision.Compressed2D);
+                    bw.Write((Int32)SizeX);
+                    bw.Write((Int32)SizeY);
+                    bw.Write((Int32)CompressionFactor);
+                    for (int yy = 0; yy < SizeY; yy++)
+                        for (int xx = 0; xx < SizeX; xx++)
+                        {
+                            bw.Write((Int16)m_heightmap[xx, yy]);
+                        }
+                }
+                ret = str.ToArray();
+            }
+            return ret;
+        }
+        // Initialize heightmap from blob consisting of:
+        //    int32, int32, int32, int32, int16[]
+        //    where the first int32 is format code, next two int32s are the X and y of heightmap data and
+        //    the forth int is the compression factor for the following int16s
+        // This is just sets heightmap info. The actual size of the region was set on this instance's
+        //    creation and any heights not initialized by theis blob are set to the default height.
+        public void FromCompressedTerrainSerialization(byte[] pBlob)
+        {
+            Int32 hmFormatCode, hmSizeX, hmSizeY, hmCompressionFactor;
+            using (MemoryStream mstr = new MemoryStream(pBlob))
+            {
+                using (BinaryReader br = new BinaryReader(mstr))
+                {
+                    hmFormatCode = br.ReadInt32();
+                    hmSizeX = br.ReadInt32();
+                    hmSizeY = br.ReadInt32();
+                    hmCompressionFactor = br.ReadInt32();
+                    m_compressionFactor = hmCompressionFactor;
+                    // In case database info doesn't match real terrain size, initialize the whole terrain.
+                    ClearLand();
+                    for (int yy = 0; yy < hmSizeY; yy++)
+                    {
+                        for (int xx = 0; xx < hmSizeX; xx++)
+                        {
+                            Int16 val = br.ReadInt16();
+                            if (xx < SizeX && yy < SizeY)
+                                m_heightmap[xx, yy] = val;
+                        }
+                    }
+                }
+                ClearTaint();
+                m_log.InfoFormat("{0} Read compressed 2d heightmap. Heightmap size=<{1},{2}>. Region size=<{3},{4}>. CompFact={5}",
+                                LogHeader, hmSizeX, hmSizeY, SizeX, SizeY, hmCompressionFactor);
+            }
+        }
+    }
+}
diff --git a/OpenSim/Framework/UserProfileData.cs b/OpenSim/Framework/UserProfileData.cs
index 9bac739..266ccf0 100644
--- a/OpenSim/Framework/UserProfileData.cs
+++ b/OpenSim/Framework/UserProfileData.cs
@@ -160,15 +160,19 @@ namespace OpenSim.Framework
        public virtual ulong HomeRegion
        {
            get 
-            { 
+            {
-                return Utils.UIntsToLong(
+                return Util.RegionWorldLocToHandle(Util.RegionToWorldLoc(m_homeRegionX), Util.RegionToWorldLoc(m_homeRegionY));
-                    m_homeRegionX * (uint)Constants.RegionSize, m_homeRegionY * (uint)Constants.RegionSize); 
+                // return Utils.UIntsToLong( m_homeRegionX * (uint)Constants.RegionSize, m_homeRegionY * (uint)Constants.RegionSize); 
            }
            
            set
            {
-                m_homeRegionX = (uint) (value >> 40);
+                uint regionWorldLocX, regionWorldLocY;
-                m_homeRegionY = (((uint) (value)) >> 8);
+                Util.RegionHandleToWorldLoc(value, out regionWorldLocX, out regionWorldLocY);
+                m_homeRegionX = Util.WorldToRegionLoc(regionWorldLocX);
+                m_homeRegionY = Util.WorldToRegionLoc(regionWorldLocY);
+                // m_homeRegionX = (uint) (value >> 40);
+                // m_homeRegionY = (((uint) (value)) >> 8);
            }
        }
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index e8dfec1..105e75d 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -333,6 +333,43 @@ namespace OpenSim.Framework
            return Utils.UIntsToLong(X, Y);
        }
+        // Regions are identified with a 'handle' made up of its region coordinates packed into a ulong.
+        // Several places rely on the ability to extract a region's location from its handle.
+        // Note the location is in 'world coordinates' (see below).
+        public static ulong RegionWorldLocToHandle(uint X, uint Y)
+        {
+            return Utils.UIntsToLong(X, Y);
+        }
+        public static void RegionHandleToWorldLoc(ulong handle, out uint X, out uint Y)
+        {
+            X = (uint)(handle >> 32);
+            Y = (uint)(handle & (ulong)uint.MaxValue);
+        }
+        public static void RegionHandleToRegionLoc(ulong handle, out uint X, out uint Y)
+        {
+            uint worldX, worldY;
+            RegionHandleToWorldLoc(handle, out worldX, out worldY);
+            X = WorldToRegionLoc(worldX);
+            Y = WorldToRegionLoc(worldY);
+        }
+        // A region location can be 'world coordinates' (meters from zero) or 'region coordinates'
+        //      (number of regions from zero). This measurement of regions relies on the legacy 256 region size.
+        // These routines exist to make what is being converted explicit so the next person knows what was meant.
+        // Convert a region's 'world coordinate' to its 'region coordinate'.
+        public static uint WorldToRegionLoc(uint worldCoord)
+        {
+            return worldCoord / Constants.RegionSize;
+        }
+        // Convert a region's 'region coordinate' to its 'world coordinate'.
+        public static uint RegionToWorldLoc(uint regionCoord)
+        {
+            return regionCoord * Constants.RegionSize;
+        }
        public static T Clamp<T>(T x, T min, T max)
            where T : IComparable<T>
        {
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 308638c..7e7f42e 100644
--- a/OpenSim/Region/Application/OpenSimBase.cs
+++ b/OpenSim/Region/Application/OpenSimBase.cs
@@ -690,7 +690,8 @@ namespace OpenSim
            clientServer = clientNetworkServers;
            scene.LoadWorldMap();
-            scene.PhysicsScene = GetPhysicsScene(scene.RegionInfo.RegionName);
+            Vector3 regionExtent = new Vector3(regionInfo.RegionSizeX, regionInfo.RegionSizeY, regionInfo.RegionSizeZ);
+            scene.PhysicsScene = GetPhysicsScene(scene.RegionInfo.RegionName, regionExtent);
            scene.PhysicsScene.RequestAssetMethod = scene.PhysicsRequestAsset;
            scene.PhysicsScene.SetTerrain(scene.Heightmap.GetFloatsSerialised());
            scene.PhysicsScene.SetWaterLevel((float) regionInfo.RegionSettings.WaterHeight);
@@ -742,7 +743,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;
@@ -752,10 +753,10 @@ namespace OpenSim
        # region Setup methods
-        protected override PhysicsScene GetPhysicsScene(string osSceneIdentifier)
+        protected override PhysicsScene GetPhysicsScene(string osSceneIdentifier, Vector3 regionExtent)
        {
            return GetPhysicsScene(
-                m_configSettings.PhysicsEngine, m_configSettings.MeshEngineName, Config, osSceneIdentifier);
+                m_configSettings.PhysicsEngine, m_configSettings.MeshEngineName, Config, osSceneIdentifier, regionExtent);
        }
        /// <summary>
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index 20bc59c..4671ed0 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;
                }
@@ -1153,7 +1154,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        /// <param name="map">heightmap</param>
        public virtual void SendLayerData(float[] map)
        {
-            Util.FireAndForget(DoSendLayerData, map);
+            Util.FireAndForget(DoSendLayerData, m_scene.Heightmap.GetTerrainData());
        }
        /// <summary>
@@ -1162,10 +1163,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        /// <param name="o"></param>
        private void DoSendLayerData(object o)
        {
-            float[] map = LLHeightFieldMoronize((float[])o);
+            TerrainData map = (TerrainData)o;
            try
            {
+                // Send LayerData in typerwriter pattern
                //for (int y = 0; y < 16; y++)
                //{
                //    for (int x = 0; x < 16; x++)
@@ -1175,7 +1177,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                //}
                // Send LayerData in a spiral pattern. Fun!
-                SendLayerTopRight(map, 0, 0, 15, 15);
+                SendLayerTopRight(map, 0, 0, map.SizeX/Constants.TerrainPatchSize-1, map.SizeY/Constants.TerrainPatchSize-1);
            }
            catch (Exception e)
            {
@@ -1183,7 +1185,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            }
        }
-        private void SendLayerTopRight(float[] map, int x1, int y1, int x2, int y2)
+        private void SendLayerTopRight(TerrainData map, int x1, int y1, int x2, int y2)
        {
            // Row
            for (int i = x1; i <= x2; i++)
@@ -1193,11 +1195,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            for (int j = y1 + 1; j <= y2; j++)
                SendLayerData(x2, j, map);
-            if (x2 - x1 > 0)
+            if (x2 - x1 > 0 && y2 - y1 > 0)
                SendLayerBottomLeft(map, x1, y1 + 1, x2 - 1, y2);
        }
-        void SendLayerBottomLeft(float[] map, int x1, int y1, int x2, int y2)
+        void SendLayerBottomLeft(TerrainData map, int x1, int y1, int x2, int y2)
        {
            // Row in reverse
            for (int i = x2; i >= x1; i--)
@@ -1207,7 +1209,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
            for (int j = y2 - 1; j >= y1; j--)
                SendLayerData(x1, j, map);
-            if (x2 - x1 > 0)
+            if (x2 - x1 > 0 && y2 - y1 > 0)
                SendLayerTopRight(map, x1 + 1, y1, x2, y2 - 1);
        }
@@ -1229,22 +1231,26 @@ namespace OpenSim.Region.ClientStack.LindenUDP
        //     OutPacket(layerpack, ThrottleOutPacketType.Land);
        // }
+        // Legacy form of invocation that passes around a bare data array.
+        // Just ignore what was passed and use the real terrain info that is part of the scene.
+        public void SendLayerData(int px, int py, float[] map)
+        {
+            SendLayerData(px, py, m_scene.Heightmap.GetTerrainData());
+        }
        /// <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>
        /// <param name="map">heightmap</param>
-        public void SendLayerData(int px, int py, float[] map)
+        public void SendLayerData(int px, int py, TerrainData terrData)
        {
            try
            {
-                int[] patches = new int[] { py * 16 + px };
+                LayerDataPacket layerpack = OpenSimTerrainCompressor.CreateLandPacket(terrData, px, py);
-                float[] heightmap = (map.Length == 65536) ?
-                    map :
-                    LLHeightFieldMoronize(map);
-                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 +1268,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 +1283,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>
@@ -2788,8 +2760,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;
            }
@@ -2916,8 +2888,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/ClientStack/RegionApplicationBase.cs b/OpenSim/Region/ClientStack/RegionApplicationBase.cs
index 853b72d..1ce166e 100644
--- a/OpenSim/Region/ClientStack/RegionApplicationBase.cs
+++ b/OpenSim/Region/ClientStack/RegionApplicationBase.cs
@@ -69,7 +69,7 @@ namespace OpenSim.Region.ClientStack
        /// The name of the OpenSim scene this physics scene is serving.  This will be used in log messages.
        /// </param>
        /// <returns></returns>
-        protected abstract PhysicsScene GetPhysicsScene(string osSceneIdentifier);
+        protected abstract PhysicsScene GetPhysicsScene(string osSceneIdentifier, Vector3 regionExtent);
        
        protected abstract ClientStackManager CreateClientStackManager();
        protected abstract Scene CreateScene(RegionInfo regionInfo, ISimulationDataService simDataService, IEstateDataService estateDataService, AgentCircuitManager circuitManager);
@@ -123,13 +123,13 @@ namespace OpenSim.Region.ClientStack
        /// </param>
        /// <returns></returns>
        protected PhysicsScene GetPhysicsScene(
-            string engine, string meshEngine, IConfigSource config, string osSceneIdentifier)
+            string engine, string meshEngine, IConfigSource config, string osSceneIdentifier, Vector3 regionExtent)
        {
            PhysicsPluginManager physicsPluginManager;
            physicsPluginManager = new PhysicsPluginManager();
            physicsPluginManager.LoadPluginsFromAssemblies("Physics");
            
-            return physicsPluginManager.GetPhysicsScene(engine, meshEngine, config, osSceneIdentifier);
+            return physicsPluginManager.GetPhysicsScene(engine, meshEngine, config, osSceneIdentifier, regionExtent);
        }
    }
 }
 \ No newline at end of file
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/Caps/CapabilitiesModule.cs b/OpenSim/Region/CoreModules/Framework/Caps/CapabilitiesModule.cs
index 6545a99..13cc99a 100644
--- a/OpenSim/Region/CoreModules/Framework/Caps/CapabilitiesModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/Caps/CapabilitiesModule.cs
@@ -269,9 +269,7 @@ namespace OpenSim.Region.CoreModules.Framework
                foreach (KeyValuePair<ulong, string> kvp in m_childrenSeeds[agentID])
                {
                    uint x, y;
-                    Utils.LongToUInts(kvp.Key, out x, out y);
+                    Util.RegionHandleToRegionLoc(kvp.Key, out x, out y);
-                    x = x / Constants.RegionSize;
-                    y = y / Constants.RegionSize;
                    m_log.Info(" >> "+x+", "+y+": "+kvp.Value);
                }
            }
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/Grid/LocalGridServiceConnector.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/LocalGridServiceConnector.cs
index 31ef79b..828240b 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/LocalGridServiceConnector.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/LocalGridServiceConnector.cs
@@ -268,7 +268,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
                    caps.AppendFormat("*** Neighbours of {0} ({1}) ***\n", kvp.Value.RegionName, kvp.Key);
                    List<GridRegion> regions = kvp.Value.GetNeighbours();
                    foreach (GridRegion r in regions)
-                        caps.AppendFormat("    {0} @ {1}-{2}\n", r.RegionName, r.RegionLocX / Constants.RegionSize, r.RegionLocY / Constants.RegionSize);
+                        caps.AppendFormat("    {0} @ {1}-{2}\n", r.RegionName, Util.WorldToRegionLoc((uint)r.RegionLocX), Util.WorldToRegionLoc((uint)r.RegionLocY));
                }
            }
diff --git a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RegionCache.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RegionCache.cs
index 9172536..a6b1b56 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RegionCache.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RegionCache.cs
@@ -66,7 +66,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
                return;
            m_log.DebugFormat("[REGION CACHE]: (on region {0}) Region {1} is up @ {2}-{3}",
-                m_scene.RegionInfo.RegionName, otherRegion.RegionName, otherRegion.RegionLocX / Constants.RegionSize, otherRegion.RegionLocY / Constants.RegionSize);
+                m_scene.RegionInfo.RegionName, otherRegion.RegionName, Util.WorldToRegionLoc((uint)otherRegion.RegionLocX), Util.WorldToRegionLoc((uint)otherRegion.RegionLocY));
            m_neighbours[otherRegion.RegionHandle] = otherRegion;
        }
@@ -86,7 +86,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
        {
            uint xsnap = (uint)(x / Constants.RegionSize) * Constants.RegionSize;
            uint ysnap = (uint)(y / Constants.RegionSize) * Constants.RegionSize;
-            ulong handle = Utils.UIntsToLong(xsnap, ysnap);
+            ulong handle = Util.RegionWorldLocToHandle(xsnap, ysnap);
            
            if (m_neighbours.ContainsKey(handle))
                return m_neighbours[handle];
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 73c4d6c..092dfa3 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
@@ -64,6 +64,7 @@ namespace OpenSim.Region.CoreModules.World.Land
    public class LandManagementModule : INonSharedRegionModule
    {
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly string LogHeader = "[LAND MANAGEMENT MODULE]";
        private static readonly string remoteParcelRequestPath = "0009/";
@@ -74,15 +75,11 @@ namespace OpenSim.Region.CoreModules.World.Land
        protected IPrimCountModule m_primCountModule;
        protected IDialogModule m_Dialog;
-        // Minimum for parcels to work is 64m even if we don't actually use them.
-        #pragma warning disable 0429
-        private const int landArrayMax = ((int)((int)Constants.RegionSize / 4) >= 64) ? (int)((int)Constants.RegionSize / 4) : 64;
-        #pragma warning restore 0429
        /// <value>
        /// Local land ids at specified region co-ordinates (region size / 4)
        /// </value>
-        private readonly int[,] m_landIDList = new int[landArrayMax, landArrayMax];
+        private int[,] m_landIDList;
+        private const int landUnit = 4;
        /// <value>
        /// Land objects keyed by local id
@@ -115,6 +112,8 @@ namespace OpenSim.Region.CoreModules.World.Land
        public void AddRegion(Scene scene)
        {
            m_scene = scene;
+            m_landIDList = new int[m_scene.RegionInfo.RegionSizeX / landUnit, m_scene.RegionInfo.RegionSizeY / landUnit];
            m_landIDList.Initialize();
            landChannel = new LandChannel(scene, this);
@@ -297,6 +296,7 @@ namespace OpenSim.Region.CoreModules.World.Land
            {
                m_landList.Clear();
                m_lastLandLocalID = LandChannel.START_LAND_LOCAL_ID - 1;
+                m_landIDList = new int[m_scene.RegionInfo.RegionSizeX / landUnit, m_scene.RegionInfo.RegionSizeY / landUnit];
                m_landIDList.Initialize();
            }
        }
@@ -311,7 +311,8 @@ namespace OpenSim.Region.CoreModules.World.Land
                "[LAND MANAGEMENT MODULE]: Creating default parcel for region {0}", m_scene.RegionInfo.RegionName);
            
            ILandObject fullSimParcel = new LandObject(UUID.Zero, false, m_scene);                                                
-            fullSimParcel.SetLandBitmap(fullSimParcel.GetSquareLandBitmap(0, 0, (int)Constants.RegionSize, (int)Constants.RegionSize));
+            fullSimParcel.SetLandBitmap(fullSimParcel.GetSquareLandBitmap(0, 0,
+                                            (int)m_scene.RegionInfo.RegionSizeX, (int)m_scene.RegionInfo.RegionSizeY));
            fullSimParcel.LandData.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
            fullSimParcel.LandData.ClaimDate = Util.UnixTimeSinceEpoch();
            
@@ -438,8 +439,8 @@ namespace OpenSim.Region.CoreModules.World.Land
        public void SendLandUpdate(ScenePresence avatar, bool force)
        {
-            ILandObject over = GetLandObject((int)Math.Min(((int)Constants.RegionSize - 1), Math.Max(0, Math.Round(avatar.AbsolutePosition.X))),
+            ILandObject over = GetLandObject((int)Math.Min(((int)m_scene.RegionInfo.RegionSizeX - 1), Math.Max(0, Math.Round(avatar.AbsolutePosition.X))),
-                                             (int)Math.Min(((int)Constants.RegionSize - 1), Math.Max(0, Math.Round(avatar.AbsolutePosition.Y))));
+                                             (int)Math.Min(((int)m_scene.RegionInfo.RegionSizeY - 1), Math.Max(0, Math.Round(avatar.AbsolutePosition.Y))));
            if (over != null)
            {
@@ -605,17 +606,29 @@ namespace OpenSim.Region.CoreModules.World.Land
                new_land.LandData.LocalID = newLandLocalID;
                bool[,] landBitmap = new_land.GetLandBitmap();
-                for (int x = 0; x < landArrayMax; x++)
+                // m_log.DebugFormat("{0} AddLandObject. new_land.bitmapSize=({1},{2}). newLocalID={3}",
+                //                 LogHeader, landBitmap.GetLength(0), landBitmap.GetLength(1), newLandLocalID);
+                if (landBitmap.GetLength(0) != m_landIDList.GetLength(0) || landBitmap.GetLength(1) != m_landIDList.GetLength(1))
                {
-                    for (int y = 0; y < landArrayMax; y++)
+                    // Going to variable sized regions can cause mismatches
+                    m_log.ErrorFormat("{0} AddLandObject. Added land bitmap different size than region ID map. bitmapSize=({1},{2}), landIDSize=({3},{4})",
+                        LogHeader, landBitmap.GetLength(0), landBitmap.GetLength(1), m_landIDList.GetLength(0), m_landIDList.GetLength(1) );
+                }
+                else
+                {
+                    for (int x = 0; x < landBitmap.GetLength(0); x++)
                    {
-                        if (landBitmap[x, y])
+                        for (int y = 0; y < landBitmap.GetLength(1); y++)
                        {
-//                            m_log.DebugFormat(
+                            if (landBitmap[x, y])
-//                                "[LAND MANAGEMENT MODULE]: Registering parcel {0} for land co-ord ({1}, {2}) on {3}", 
+                            {
-//                                new_land.LandData.Name, x, y, m_scene.RegionInfo.RegionName);
+                                // m_log.DebugFormat(
-                            
+                                //     "[LAND MANAGEMENT MODULE]: Registering parcel {0} for land co-ord ({1}, {2}) on {3}", 
-                            m_landIDList[x, y] = newLandLocalID;
+                                //     new_land.LandData.Name, x, y, m_scene.RegionInfo.RegionName);
+                                m_landIDList[x, y] = newLandLocalID;
+                            }
                        }
                    }
                }
@@ -637,9 +650,9 @@ namespace OpenSim.Region.CoreModules.World.Land
            ILandObject land;
            lock (m_landList)
            {
-                for (int x = 0; x < 64; x++)
+                for (int x = 0; x < m_landIDList.GetLength(0); x++)
                {
-                    for (int y = 0; y < 64; y++)
+                    for (int y = 0; y < m_landIDList.GetLength(1); y++)
                    {
                        if (m_landIDList[x, y] == local_id)
                        {
@@ -691,9 +704,9 @@ namespace OpenSim.Region.CoreModules.World.Land
            bool[,] landBitmapSlave = slave.GetLandBitmap();
            lock (m_landList)
            {
-                for (int x = 0; x < 64; x++)
+                for (int x = 0; x < landBitmapSlave.GetLength(0); x++)
                {
-                    for (int y = 0; y < 64; y++)
+                    for (int y = 0; y < landBitmapSlave.GetLength(1); y++)
                    {
                        if (landBitmapSlave[x, y])
                        {
@@ -727,23 +740,28 @@ namespace OpenSim.Region.CoreModules.World.Land
        /// <returns>Land object at the point supplied</returns>
        public ILandObject GetLandObject(float x_float, float y_float)
        {
+            return GetLandObject((int)x_float, (int)y_float, true /* returnNullIfLandObjectNotFound */);
+            /*
            int x;
            int y;
-            if (x_float >= Constants.RegionSize || x_float < 0 || y_float >= Constants.RegionSize || y_float < 0)
+            if (x_float >= m_scene.RegionInfo.RegionSizeX || x_float < 0 || y_float >= m_scene.RegionInfo.RegionSizeX || y_float < 0)
                return null;
            try
            {
-                x = Convert.ToInt32(Math.Floor(Convert.ToDouble(x_float) / 4.0));
+                x = Convert.ToInt32(Math.Floor(Convert.ToDouble(x_float) / (float)landUnit));
-                y = Convert.ToInt32(Math.Floor(Convert.ToDouble(y_float) / 4.0));
+                y = Convert.ToInt32(Math.Floor(Convert.ToDouble(y_float) / (float)landUnit));
            }
            catch (OverflowException)
            {
                return null;
            }
-            if (x >= 64 || y >= 64 || x < 0 || y < 0)
+            if (x >= (m_scene.RegionInfo.RegionSizeX / landUnit)
+                    || y >= (m_scene.RegionInfo.RegionSizeY / landUnit)
+                    || x < 0
+                    || y < 0)
            {
                return null;
            }
@@ -759,38 +777,122 @@ namespace OpenSim.Region.CoreModules.World.Land
 //                    m_log.DebugFormat(
 //                        "[LAND MANAGEMENT MODULE]: No land object found at ({0}, {1}) on {2}", 
 //                        x, y, m_scene.RegionInfo.RegionName);
-                
-                if (m_landList.ContainsKey(m_landIDList[x, y]))
+                try
-                    return m_landList[m_landIDList[x, y]];
+                {
+                    if (m_landList.ContainsKey(m_landIDList[x, y]))
+                        return m_landList[m_landIDList[x, y]];
+                }
+                catch (Exception e)
+                {
+                    m_log.DebugFormat("{0} GetLandObject exception. x={1}, y={2}, m_landIDList.len=({3},{4})",
+                        LogHeader, x, y, m_landIDList.GetLength(0), m_landIDList.GetLength(1));
+                }
                
                return null;
            }
+             */
        }
+        // Public entry.
+        // Throws exception if land object is not found
        public ILandObject GetLandObject(int x, int y)
        {
-            if (x >= Convert.ToInt32(Constants.RegionSize) || y >= Convert.ToInt32(Constants.RegionSize) || x < 0 || y < 0)
+            return GetLandObject(x, y, false /* returnNullIfLandObjectNotFound */);
+        }
+        // Given a region position, return the parcel land object for that location
+        private ILandObject GetLandObject(int x, int y, bool returnNullIfLandObjectNotFound)
+        {
+            ILandObject ret = null;
+            if (x >= m_scene.RegionInfo.RegionSizeX || y >=  m_scene.RegionInfo.RegionSizeY || x < 0 || y < 0)
            {
                // These exceptions here will cause a lot of complaints from the users specifically because
                // they happen every time at border crossings
-                throw new Exception("Error: Parcel not found at point " + x + ", " + y);
+                if (returnNullIfLandObjectNotFound)
+                    return null;
+                else
+                    throw new Exception(
+                        String.Format("{0} GetLandObject for non-existant position. Region={1}, pos=<{2},{3}",
+                                                LogHeader, m_scene.RegionInfo.RegionName, x, y)
+                );
            }
            lock (m_landIDList)
            {
                try
                {
-                    return m_landList[m_landIDList[x / 4, y / 4]];
+                    int landID = m_landIDList[x / landUnit, y / landUnit];
+                    if (landID == 0)
+                    {
+                        // Zero is the uninitialized value saying there is no parcel for this location.
+                        // This sometimes happens when terrain is resized.
+                        if (m_landList.Count == 1)
+                        {
+                            int onlyParcelID = 0;
+                            ILandObject onlyLandObject = null;
+                            foreach (KeyValuePair<int, ILandObject> kvp in m_landList)
+                            {
+                                onlyParcelID = kvp.Key;
+                                onlyLandObject = kvp.Value;
+                                break;
+                            }
+                            // There is only one parcel. Grow it to fill all the unallocated spaces.
+                            for (int xx = 0; xx < m_landIDList.GetLength(0); xx++)
+                                for (int yy = 0; yy < m_landIDList.GetLength(1); yy++)
+                                    if (m_landIDList[xx, yy] == 0)
+                                        m_landIDList[xx, yy] = onlyParcelID;
+                            onlyLandObject.LandBitmap = CreateBitmapForID(onlyParcelID);
+                            landID = onlyParcelID;
+                        }
+                        else
+                        {
+                            // There are several other parcels so we must create a new one for the unassigned space
+                            ILandObject newLand = new LandObject(UUID.Zero, false, m_scene);                                                
+                            // Claim all the unclaimed "0" ids
+                            newLand.SetLandBitmap(CreateBitmapForID(0));
+                            newLand.LandData.OwnerID = m_scene.RegionInfo.EstateSettings.EstateOwner;
+                            newLand.LandData.ClaimDate = Util.UnixTimeSinceEpoch();
+                            AddLandObject(newLand);
+                            landID = m_lastLandLocalID;
+                        }
+                    }
+                    ret = m_landList[landID];
                }
                catch (IndexOutOfRangeException)
                {
-//                    m_log.WarnFormat(
+                    m_log.ErrorFormat(
-//                        "[LAND MANAGEMENT MODULE]: Tried to retrieve land object from out of bounds co-ordinate ({0},{1}) in {2}", 
+                        "{0} GetLandObject: Tried to retrieve land object from out of bounds co-ordinate ({1},{2}) in {3}. landListSize=({4},{5})",
-//                        x, y, m_scene.RegionInfo.RegionName);
+                        LogHeader, x, y, m_scene.RegionInfo.RegionName, m_landIDList.GetLength(0), m_landIDList.GetLength(1));
-                    
+                    return null;
+                }
+                catch
+                {
+                    m_log.ErrorFormat(
+                        "{0} GetLandObject: LandID not in landlist. XY=<{1},{2}> in {3}. landID[x,y]={4}",
+                        LogHeader, x, y, m_scene.RegionInfo.RegionName, m_landIDList[x/landUnit, y/landUnit]);
                    return null;
                }
            }
+            return ret;
+        }
+        // Create a 'parcel is here' bitmap for the parcel identified by the passed landID
+        private bool[,] CreateBitmapForID(int landID)
+        {
+            bool[,] ret = new bool[m_landIDList.GetLength(0), m_landIDList.GetLength(1)];
+            ret.Initialize();
+            for (int xx = 0; xx < m_landIDList.GetLength(0); xx++)
+                for (int yy = 0; yy < m_landIDList.GetLength(0); yy++)
+                    if (m_landIDList[xx, yy] == landID)
+                        ret[xx, yy] = true;
+            return ret;
        }
        #endregion
@@ -1053,85 +1155,93 @@ namespace OpenSim.Region.CoreModules.World.Land
            byte[] byteArray = new byte[LAND_BLOCKS_PER_PACKET];
            int byteArrayCount = 0;
            int sequenceID = 0;
-            int blockmeters = 4 * (int) Constants.RegionSize/(int)Constants.TerrainPatchSize;
-            for (int y = 0; y < blockmeters; y++)
+            // Layer data is in landUnit (4m) chunks
+            for (int y = 0; y < m_scene.RegionInfo.RegionSizeY / Constants.TerrainPatchSize * (Constants.TerrainPatchSize / landUnit); y++)
            {
-                for (int x = 0; x < blockmeters; x++)
+                for (int x = 0; x < m_scene.RegionInfo.RegionSizeX / Constants.TerrainPatchSize * (Constants.TerrainPatchSize / landUnit); x++)
                {
-                    byte tempByte = 0; //This represents the byte for the current 4x4
+                    byteArray[byteArrayCount] = BuildLayerByte(GetLandObject(x * landUnit, y * landUnit), x, y, remote_client);
+                    byteArrayCount++;
+                    if (byteArrayCount >= LAND_BLOCKS_PER_PACKET)
+                    {
+                        remote_client.SendLandParcelOverlay(byteArray, sequenceID);
+                        byteArrayCount = 0;
+                        sequenceID++;
+                        byteArray = new byte[LAND_BLOCKS_PER_PACKET];
+                    }
-                    ILandObject currentParcelBlock = GetLandObject(x * 4, y * 4);
+                }
+            }
+            if (byteArrayCount != 0)
+            {
+                remote_client.SendLandParcelOverlay(byteArray, sequenceID);
+            }
+        }
-                    if (currentParcelBlock != null)
+        private byte BuildLayerByte(ILandObject currentParcelBlock, int x, int y, IClientAPI remote_client)
-                    {
+        {
-                        if (currentParcelBlock.LandData.OwnerID == remote_client.AgentId)
+            byte tempByte = 0; //This represents the byte for the current 4x4
-                        {
-                            //Owner Flag
-                            tempByte = Convert.ToByte(tempByte | LandChannel.LAND_TYPE_OWNED_BY_REQUESTER);
-                        }
-                        else if (currentParcelBlock.LandData.SalePrice > 0 &&
-                                 (currentParcelBlock.LandData.AuthBuyerID == UUID.Zero ||
-                                  currentParcelBlock.LandData.AuthBuyerID == remote_client.AgentId))
-                        {
-                            //Sale Flag
-                            tempByte = Convert.ToByte(tempByte | LandChannel.LAND_TYPE_IS_FOR_SALE);
-                        }
-                        else if (currentParcelBlock.LandData.OwnerID == UUID.Zero)
-                        {
-                            //Public Flag
-                            tempByte = Convert.ToByte(tempByte | LandChannel.LAND_TYPE_PUBLIC);
-                        }
-                        else
-                        {
-                            //Other Flag
-                            tempByte = Convert.ToByte(tempByte | LandChannel.LAND_TYPE_OWNED_BY_OTHER);
-                        }
-                        //Now for border control
+            if (currentParcelBlock != null)
+            {
+                if (currentParcelBlock.LandData.OwnerID == remote_client.AgentId)
+                {
+                    //Owner Flag
+                    tempByte = Convert.ToByte(tempByte | LandChannel.LAND_TYPE_OWNED_BY_REQUESTER);
+                }
+                else if (currentParcelBlock.LandData.SalePrice > 0 &&
+                         (currentParcelBlock.LandData.AuthBuyerID == UUID.Zero ||
+                          currentParcelBlock.LandData.AuthBuyerID == remote_client.AgentId))
+                {
+                    //Sale Flag
+                    tempByte = Convert.ToByte(tempByte | LandChannel.LAND_TYPE_IS_FOR_SALE);
+                }
+                else if (currentParcelBlock.LandData.OwnerID == UUID.Zero)
+                {
+                    //Public Flag
+                    tempByte = Convert.ToByte(tempByte | LandChannel.LAND_TYPE_PUBLIC);
+                }
+                else
+                {
+                    //Other Flag
+                    tempByte = Convert.ToByte(tempByte | LandChannel.LAND_TYPE_OWNED_BY_OTHER);
+                }
-                        ILandObject westParcel = null;
+                //Now for border control
-                        ILandObject southParcel = null;
-                        if (x > 0)
-                        {
-                            westParcel = GetLandObject((x - 1) * 4, y * 4);
-                        }
-                        if (y > 0)
-                        {
-                            southParcel = GetLandObject(x * 4, (y - 1) * 4);
-                        }
-                        if (x == 0)
+                ILandObject westParcel = null;
-                        {
+                ILandObject southParcel = null;
-                            tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_WEST);
+                if (x > 0)
-                        }
+                {
-                        else if (westParcel != null && westParcel != currentParcelBlock)
+                    westParcel = GetLandObject((x - 1) * landUnit, y * landUnit);
-                        {
+                }
-                            tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_WEST);
+                if (y > 0)
-                        }
+                {
+                    southParcel = GetLandObject(x * landUnit, (y - 1) * landUnit);
+                }
-                        if (y == 0)
+                if (x == 0)
-                        {
+                {
-                            tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_SOUTH);
+                    tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_WEST);
-                        }
+                }
-                        else if (southParcel != null && southParcel != currentParcelBlock)
+                else if (westParcel != null && westParcel != currentParcelBlock)
-                        {
+                {
-                            tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_SOUTH);
+                    tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_WEST);
-                        }
+                }
-                        byteArray[byteArrayCount] = tempByte;
+                if (y == 0)
-                        byteArrayCount++;
+                {
-                        if (byteArrayCount >= LAND_BLOCKS_PER_PACKET)
+                    tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_SOUTH);
-                        {
+                }
-                            remote_client.SendLandParcelOverlay(byteArray, sequenceID);
+                else if (southParcel != null && southParcel != currentParcelBlock)
-                            byteArrayCount = 0;
+                {
-                            sequenceID++;
+                    tempByte = Convert.ToByte(tempByte | LandChannel.LAND_FLAG_PROPERTY_BORDER_SOUTH);
-                            byteArray = new byte[LAND_BLOCKS_PER_PACKET];
-                        }
-                    }
                }
            }
+            return tempByte;
        }
        public void ClientOnParcelPropertiesRequest(int start_x, int start_y, int end_x, int end_y, int sequence_id,
@@ -1688,8 +1798,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);
            }
@@ -2007,4 +2117,4 @@ namespace OpenSim.Region.CoreModules.World.Land
            cdl.AddToStringBuilder(report);
        }
    }
-}
-\ No newline at end of file
+}
diff --git a/OpenSim/Region/CoreModules/World/Land/LandObject.cs b/OpenSim/Region/CoreModules/World/Land/LandObject.cs
index e55c9ed..2a4d8d8 100644
--- a/OpenSim/Region/CoreModules/World/Land/LandObject.cs
+++ b/OpenSim/Region/CoreModules/World/Land/LandObject.cs
@@ -45,10 +45,10 @@ namespace OpenSim.Region.CoreModules.World.Land
        #region Member Variables
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        #pragma warning disable 0429
+        private static readonly string LogHeader = "[LAND OBJECT]";
-        private const int landArrayMax = ((int)((int)Constants.RegionSize / 4) >= 64) ? (int)((int)Constants.RegionSize / 4) : 64;
-        #pragma warning restore 0429
+        private bool[,] m_landBitmap;
-        private bool[,] m_landBitmap = new bool[landArrayMax,landArrayMax];
+        private readonly int landUnit = 4;
        private int m_lastSeqId = 0;
@@ -93,15 +93,17 @@ namespace OpenSim.Region.CoreModules.World.Land
        {
            get
            {
-                for (int y = 0; y < landArrayMax; y++)
+                for (int y = 0; y < LandBitmap.GetLength(1); y++)
                {
-                    for (int x = 0; x < landArrayMax; x++)
+                    for (int x = 0; x < LandBitmap.GetLength(0); x++)
                    {
                        if (LandBitmap[x, y])
-                            return new Vector3(x * 4, y * 4, 0);
+                            return new Vector3(x * landUnit, y * landUnit, 0);
                    }
                }
+                m_log.ErrorFormat("{0} StartPoint. No start point found. bitmapSize=<{1},{2}>",
+                                    LogHeader, LandBitmap.GetLength(0), LandBitmap.GetLength(1));
                return new Vector3(-1, -1, -1);
            }
        }
@@ -110,17 +112,19 @@ namespace OpenSim.Region.CoreModules.World.Land
        {
            get
            {
-                for (int y = landArrayMax - 1; y >= 0; y--)
+                for (int y = LandBitmap.GetLength(1) - 1; y >= 0; y--)
                {
-                    for (int x = landArrayMax - 1; x >= 0; x--)
+                    for (int x = LandBitmap.GetLength(0) - 1; x >= 0; x--)
                    {
                        if (LandBitmap[x, y])
                        {
-                            return new Vector3(x * 4 + 4, y * 4 + 4, 0);
+                            return new Vector3(x * landUnit + landUnit, y * landUnit + landUnit, 0);
                        }
                    }
                }
+                m_log.ErrorFormat("{0} EndPoint. No end point found. bitmapSize=<{1},{2}>",
+                                    LogHeader, LandBitmap.GetLength(0), LandBitmap.GetLength(1));
                return new Vector3(-1, -1, -1);
            }
        }
@@ -130,6 +134,8 @@ namespace OpenSim.Region.CoreModules.World.Land
        public LandObject(UUID owner_id, bool is_group_owned, Scene scene)
        {
            m_scene = scene;
+            m_landBitmap = new bool[m_scene.RegionInfo.RegionSizeX / landUnit, m_scene.RegionInfo.RegionSizeY / landUnit];
            LandData.OwnerID = owner_id;
            if (is_group_owned)
                LandData.GroupID = owner_id;
@@ -152,9 +158,9 @@ namespace OpenSim.Region.CoreModules.World.Land
        /// <returns>Returns true if the piece of land contains the specified point</returns>
        public bool ContainsPoint(int x, int y)
        {
-            if (x >= 0 && y >= 0 && x < Constants.RegionSize && y < Constants.RegionSize)
+            if (x >= 0 && y >= 0 && x < m_scene.RegionInfo.RegionSizeX && y < m_scene.RegionInfo.RegionSizeY)
            {
-                return (LandBitmap[x / 4, y / 4] == true);
+                return (LandBitmap[x / landUnit, y / landUnit] == true);
            }
            else
            {
@@ -194,7 +200,7 @@ namespace OpenSim.Region.CoreModules.World.Land
            else
            {
                // Normal Calculations
-                int parcelMax = (int)(((float)LandData.Area / 65536.0f)
+                int parcelMax = (int)(((float)LandData.Area / (m_scene.RegionInfo.RegionSizeX * m_scene.RegionInfo.RegionSizeY))
                              * (float)m_scene.RegionInfo.ObjectCapacity
                              * (float)m_scene.RegionInfo.RegionSettings.ObjectBonus);
                // TODO: The calculation of ObjectBonus should be refactored. It does still not work in the same manner as SL!
@@ -211,7 +217,7 @@ namespace OpenSim.Region.CoreModules.World.Land
            else
            {
                //Normal Calculations
-                int simMax = (int)(((float)LandData.SimwideArea / 65536.0f)
+                int simMax = (int)(((float)LandData.SimwideArea / (m_scene.RegionInfo.RegionSizeX * m_scene.RegionInfo.RegionSizeY))
                           * (float)m_scene.RegionInfo.ObjectCapacity);
                return simMax;
            }
@@ -224,7 +230,12 @@ namespace OpenSim.Region.CoreModules.World.Land
        public void SendLandProperties(int sequence_id, bool snap_selection, int request_result, IClientAPI remote_client)
        {
            IEstateModule estateModule = m_scene.RequestModuleInterface<IEstateModule>();
-            uint regionFlags = 336723974 & ~((uint)(RegionFlags.AllowLandmark | RegionFlags.AllowSetHome));
+            // uint regionFlags = 336723974 & ~((uint)(RegionFlags.AllowLandmark | RegionFlags.AllowSetHome));
+            uint regionFlags = (uint)(RegionFlags.PublicAllowed
+                                    | RegionFlags.AllowDirectTeleport
+                                    | RegionFlags.AllowParcelChanges
+                                    | RegionFlags.AllowVoice );
            if (estateModule != null)
                regionFlags = estateModule.GetRegionFlags();
@@ -546,8 +557,8 @@ namespace OpenSim.Region.CoreModules.World.Land
                try
                {
                    over =
-                        m_scene.LandChannel.GetLandObject(Util.Clamp<int>((int)Math.Round(avatar.AbsolutePosition.X), 0, ((int)Constants.RegionSize - 1)),
+                        m_scene.LandChannel.GetLandObject(Util.Clamp<int>((int)Math.Round(avatar.AbsolutePosition.X), 0, ((int)m_scene.RegionInfo.RegionSizeX - 1)),
-                                                          Util.Clamp<int>((int)Math.Round(avatar.AbsolutePosition.Y), 0, ((int)Constants.RegionSize - 1)));
+                                                          Util.Clamp<int>((int)Math.Round(avatar.AbsolutePosition.Y), 0, ((int)m_scene.RegionInfo.RegionSizeY - 1)));
                }
                catch (Exception)
                {
@@ -694,15 +705,15 @@ namespace OpenSim.Region.CoreModules.World.Land
        /// </summary>
        private void UpdateAABBAndAreaValues()
        {
-            int min_x = 64;
+            int min_x = 10000;
-            int min_y = 64;
+            int min_y = 10000;
            int max_x = 0;
            int max_y = 0;
            int tempArea = 0;
            int x, y;
-            for (x = 0; x < 64; x++)
+            for (x = 0; x < LandBitmap.GetLength(0); x++)
            {
-                for (y = 0; y < 64; y++)
+                for (y = 0; y < LandBitmap.GetLength(1); y++)
                {
                    if (LandBitmap[x, y] == true)
                    {
@@ -710,31 +721,31 @@ namespace OpenSim.Region.CoreModules.World.Land
                        if (min_y > y) min_y = y;
                        if (max_x < x) max_x = x;
                        if (max_y < y) max_y = y;
-                        tempArea += 16; //16sqm peice of land
+                        tempArea += landUnit * landUnit; //16sqm peice of land
                    }
                }
            }
-            int tx = min_x * 4;
+            int tx = min_x * landUnit;
-            if (tx > ((int)Constants.RegionSize - 1))
+            if (tx > ((int)m_scene.RegionInfo.RegionSizeX - 1))
-                tx = ((int)Constants.RegionSize - 1);
+                tx = ((int)m_scene.RegionInfo.RegionSizeX - 1);
-            int ty = min_y * 4;
+            int ty = min_y * landUnit;
-            if (ty > ((int)Constants.RegionSize - 1))
+            if (ty > ((int)m_scene.RegionInfo.RegionSizeY - 1))
-                ty = ((int)Constants.RegionSize - 1);
+                ty = ((int)m_scene.RegionInfo.RegionSizeY - 1);
            LandData.AABBMin =
                new Vector3(
-                    (float)(min_x * 4), (float)(min_y * 4), m_scene != null ? (float)m_scene.Heightmap[tx, ty] : 0);
+                    (float)(min_x * landUnit), (float)(min_y * landUnit), m_scene != null ? (float)m_scene.Heightmap[tx, ty] : 0);
-            tx = max_x * 4;
+            tx = max_x * landUnit;
-            if (tx > ((int)Constants.RegionSize - 1))
+            if (tx > ((int)m_scene.RegionInfo.RegionSizeX - 1))
-                tx = ((int)Constants.RegionSize - 1);
+                tx = ((int)m_scene.RegionInfo.RegionSizeX - 1);
-            ty = max_y * 4;
+            ty = max_y * landUnit;
-            if (ty > ((int)Constants.RegionSize - 1))
+            if (ty > ((int)m_scene.RegionInfo.RegionSizeY - 1))
-                ty = ((int)Constants.RegionSize - 1);
+                ty = ((int)m_scene.RegionInfo.RegionSizeY - 1);
            LandData.AABBMax 
                = new Vector3(
-                    (float)(max_x * 4), (float)(max_y * 4), m_scene != null ? (float)m_scene.Heightmap[tx, ty] : 0);
+                    (float)(max_x * landUnit), (float)(max_y * landUnit), m_scene != null ? (float)m_scene.Heightmap[tx, ty] : 0);
            LandData.Area = tempArea;
        }
@@ -746,20 +757,12 @@ namespace OpenSim.Region.CoreModules.World.Land
        /// <summary>
        /// Sets the land's bitmap manually
        /// </summary>
-        /// <param name="bitmap">64x64 block representing where this land is on a map</param>
+        /// <param name="bitmap">block representing where this land is on a map mapped in a 4x4 meter grid</param>
        public void SetLandBitmap(bool[,] bitmap)
        {
-            if (bitmap.GetLength(0) != 64 || bitmap.GetLength(1) != 64 || bitmap.Rank != 2)
+            LandBitmap = bitmap;
-            {
+            // m_log.DebugFormat("{0} SetLandBitmap. BitmapSize=<{1},{2}>", LogHeader, LandBitmap.GetLength(0), LandBitmap.GetLength(1));
-                //Throw an exception - The bitmap is not 64x64
+            ForceUpdateLandInfo();
-                //throw new Exception("Error: Invalid Parcel Bitmap");
-            }
-            else
-            {
-                //Valid: Lets set it
-                LandBitmap = bitmap;
-                ForceUpdateLandInfo();
-            }
        }
        /// <summary>
@@ -773,15 +776,19 @@ namespace OpenSim.Region.CoreModules.World.Land
        public bool[,] BasicFullRegionLandBitmap()
        {
-            return GetSquareLandBitmap(0, 0, (int) Constants.RegionSize, (int) Constants.RegionSize);
+            return GetSquareLandBitmap(0, 0, (int)m_scene.RegionInfo.RegionSizeX, (int) m_scene.RegionInfo.RegionSizeY);
        }
        
        public bool[,] GetSquareLandBitmap(int start_x, int start_y, int end_x, int end_y)
        {
-            bool[,] tempBitmap = new bool[64,64];
+            // Empty bitmap for the whole region
+            bool[,] tempBitmap = new bool[m_scene.RegionInfo.RegionSizeX / landUnit, m_scene.RegionInfo.RegionSizeY / landUnit];
            tempBitmap.Initialize();
+            // Fill the bitmap square area specified by state and end
            tempBitmap = ModifyLandBitmapSquare(tempBitmap, start_x, start_y, end_x, end_y, true);
+            // m_log.DebugFormat("{0} GetSquareLandBitmap. tempBitmapSize=<{1},{2}>",
+            //                         LogHeader, tempBitmap.GetLength(0), tempBitmap.GetLength(1));
            return tempBitmap;
        }
@@ -798,24 +805,20 @@ namespace OpenSim.Region.CoreModules.World.Land
        public bool[,] ModifyLandBitmapSquare(bool[,] land_bitmap, int start_x, int start_y, int end_x, int end_y,
                                              bool set_value)
        {
-            if (land_bitmap.GetLength(0) != 64 || land_bitmap.GetLength(1) != 64 || land_bitmap.Rank != 2)
-            {
-                //Throw an exception - The bitmap is not 64x64
-                //throw new Exception("Error: Invalid Parcel Bitmap in modifyLandBitmapSquare()");
-            }
            int x, y;
-            for (y = 0; y < 64; y++)
+            for (y = 0; y < land_bitmap.GetLength(1); y++)
            {
-                for (x = 0; x < 64; x++)
+                for (x = 0; x < land_bitmap.GetLength(0); x++)
                {
-                    if (x >= start_x / 4 && x < end_x / 4
+                    if (x >= start_x / landUnit && x < end_x / landUnit
-                        && y >= start_y / 4 && y < end_y / 4)
+                        && y >= start_y / landUnit && y < end_y / landUnit)
                    {
                        land_bitmap[x, y] = set_value;
                    }
                }
            }
+            // m_log.DebugFormat("{0} ModifyLandBitmapSquare. startXY=<{1},{2}>, endXY=<{3},{4}>, val={5}, landBitmapSize=<{6},{7}>",
+            //                         LogHeader, start_x, start_y, end_x, end_y, set_value, land_bitmap.GetLength(0), land_bitmap.GetLength(1));
            return land_bitmap;
        }
@@ -827,21 +830,21 @@ namespace OpenSim.Region.CoreModules.World.Land
        /// <returns></returns>
        public bool[,] MergeLandBitmaps(bool[,] bitmap_base, bool[,] bitmap_add)
        {
-            if (bitmap_base.GetLength(0) != 64 || bitmap_base.GetLength(1) != 64 || bitmap_base.Rank != 2)
+            if (bitmap_base.GetLength(0) != bitmap_add.GetLength(0)
+                    || bitmap_base.GetLength(1) != bitmap_add.GetLength(1)
+                    || bitmap_add.Rank != 2
+                    || bitmap_base.Rank != 2)
            {
-                //Throw an exception - The bitmap is not 64x64
+                throw new Exception(
-                throw new Exception("Error: Invalid Parcel Bitmap - Bitmap_base in mergeLandBitmaps");
+                    String.Format("{0} MergeLandBitmaps. merging maps not same size. baseSizeXY=<{1},{2}>, addSizeXY=<{3},{4}>",
-            }
+                                LogHeader, bitmap_base.GetLength(0), bitmap_base.GetLength(1), bitmap_add.GetLength(0), bitmap_add.GetLength(1))
-            if (bitmap_add.GetLength(0) != 64 || bitmap_add.GetLength(1) != 64 || bitmap_add.Rank != 2)
+                );
-            {
-                //Throw an exception - The bitmap is not 64x64
-                throw new Exception("Error: Invalid Parcel Bitmap - Bitmap_add in mergeLandBitmaps");
            }
            int x, y;
-            for (y = 0; y < 64; y++)
+            for (y = 0; y < bitmap_base.GetLength(1); y++)
            {
-                for (x = 0; x < 64; x++)
+                for (x = 0; x < bitmap_add.GetLength(0); x++)
                {
                    if (bitmap_add[x, y])
                    {
@@ -858,13 +861,13 @@ namespace OpenSim.Region.CoreModules.World.Land
        /// <returns></returns>
        private byte[] ConvertLandBitmapToBytes()
        {
-            byte[] tempConvertArr = new byte[512];
+            byte[] tempConvertArr = new byte[LandBitmap.GetLength(0) * LandBitmap.GetLength(1) / 8];
            byte tempByte = 0;
-            int x, y, i, byteNum = 0;
+            int byteNum = 0;
-            i = 0;
+            int i = 0;
-            for (y = 0; y < 64; y++)
+            for (int y = 0; y < LandBitmap.GetLength(1); y++)
            {
-                for (x = 0; x < 64; x++)
+                for (int x = 0; x < LandBitmap.GetLength(0); x++)
                {
                    tempByte = Convert.ToByte(tempByte | Convert.ToByte(LandBitmap[x, y]) << (i++ % 8));
                    if (i % 8 == 0)
@@ -876,30 +879,52 @@ namespace OpenSim.Region.CoreModules.World.Land
                    }
                }
            }
+            // m_log.DebugFormat("{0} ConvertLandBitmapToBytes. BitmapSize=<{1},{2}>",
+            //                         LogHeader, LandBitmap.GetLength(0), LandBitmap.GetLength(1));
            return tempConvertArr;
        }
        private bool[,] ConvertBytesToLandBitmap()
        {
-            bool[,] tempConvertMap = new bool[landArrayMax, landArrayMax];
+            bool[,] tempConvertMap = new bool[m_scene.RegionInfo.RegionSizeX / landUnit, m_scene.RegionInfo.RegionSizeY / landUnit];
            tempConvertMap.Initialize();
            byte tempByte = 0;
-            int x = 0, y = 0, i = 0, bitNum = 0;
+            // Math.Min overcomes an old bug that might have made it into the database. Only use the bytes that fit into convertMap.
-            for (i = 0; i < 512; i++)
+            int bitmapLen = Math.Min(LandData.Bitmap.Length, tempConvertMap.GetLength(0) * tempConvertMap.GetLength(1) / 8);
+            int xLen = (int)(m_scene.RegionInfo.RegionSizeX / landUnit);
+            if (bitmapLen == 512)
+            {
+                // Legacy bitmap being passed in. Use the legacy region size
+                //    and only set the lower area of the larger region.
+                xLen = (int)(Constants.RegionSize / landUnit);
+            }
+            // m_log.DebugFormat("{0} ConvertBytesToLandBitmap: bitmapLen={1}, xLen={2}", LogHeader, bitmapLen, xLen);
+            int x = 0, y = 0;
+            for (int i = 0; i < bitmapLen; i++)
            {
                tempByte = LandData.Bitmap[i];
-                for (bitNum = 0; bitNum < 8; bitNum++)
+                for (int bitNum = 0; bitNum < 8; bitNum++)
                {
                    bool bit = Convert.ToBoolean(Convert.ToByte(tempByte >> bitNum) & (byte) 1);
-                    tempConvertMap[x, y] = bit;
+                    try
+                    {
+                        tempConvertMap[x, y] = bit;
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.DebugFormat("{0} ConvertBytestoLandBitmap: i={1}, x={2}, y={3}", LogHeader, i, x, y);
+                    }
                    x++;
-                    if (x > 63)
+                    if (x >= xLen)
                    {
                        x = 0;
                        y++;
                    }
                }
            }
            return tempConvertMap;
        }
diff --git a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
index f8e93e1..45617fc 100644
--- a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
+++ b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
@@ -1571,10 +1571,10 @@ namespace OpenSim.Region.CoreModules.World.Permissions
            float X = position.X;
            float Y = position.Y;
-            if (X > ((int)Constants.RegionSize - 1))
+            if (X > ((int)m_scene.RegionInfo.RegionSizeX - 1))
-                X = ((int)Constants.RegionSize - 1);
+                X = ((int)m_scene.RegionInfo.RegionSizeX - 1);
-            if (Y > ((int)Constants.RegionSize - 1))
+            if (Y > ((int)m_scene.RegionInfo.RegionSizeY - 1))
-                Y = ((int)Constants.RegionSize - 1);
+                Y = ((int)m_scene.RegionInfo.RegionSizeY - 1);
            if (X < 0)
                X = 0;
            if (Y < 0)
diff --git a/OpenSim/Region/CoreModules/World/Terrain/Effects/DefaultTerrainGenerator.cs b/OpenSim/Region/CoreModules/World/Terrain/Effects/DefaultTerrainGenerator.cs
index 7186dd7..89087b1 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/Effects/DefaultTerrainGenerator.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/Effects/DefaultTerrainGenerator.cs
@@ -42,7 +42,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain.Effects
                for (y = 0; y < map.Height; y++)
                {
                    map[x, y] = TerrainUtil.PerlinNoise2D(x, y, 3, 0.25) * 10;
-                    double spherFac = TerrainUtil.SphericalFactor(x, y, Constants.RegionSize / 2, Constants.RegionSize / 2, 50) * 0.01;
+                    double spherFac = TerrainUtil.SphericalFactor(x, y, map.Width / 2, map.Height / 2, 50) * 0.01;
                    if (map[x, y] < spherFac)
                    {
                        map[x, y] = spherFac;
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..d991a30 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;
@@ -70,6 +74,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
        #endregion
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly string LogHeader = "[TERRAIN MODULE]";
        
        private readonly Commander m_commander = new Commander("terrain");
@@ -130,15 +135,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();
                }
@@ -230,11 +235,11 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                        try
                        {
                            ITerrainChannel channel = loader.Value.LoadFile(filename);
-                            if (channel.Width != Constants.RegionSize || channel.Height != Constants.RegionSize)
+                            if (channel.Width != m_scene.RegionInfo.RegionSizeX || channel.Height != m_scene.RegionInfo.RegionSizeY)
                            {
                                // TerrainChannel expects a RegionSize x RegionSize map, currently
                                throw new ArgumentException(String.Format("wrong size, use a file with size {0} x {1}",
-                                                                          Constants.RegionSize, Constants.RegionSize));
+                                                                          m_scene.RegionInfo.RegionSizeX, m_scene.RegionInfo.RegionSizeY));
                            }
                            m_log.DebugFormat("[TERRAIN]: Loaded terrain, wd/ht: {0}/{1}", channel.Width, channel.Height);
                            m_scene.Heightmap = channel;
@@ -532,6 +537,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
        /// </summary>
        public void UpdateRevertMap()
        {
+            /*
            int x;
            for (x = 0; x < m_channel.Width; x++)
            {
@@ -541,6 +547,8 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                    m_revert[x, y] = m_channel[x, y];
                }
            }
+             */
+            m_revert = m_channel.MakeCopy();
        }
        /// <summary>
@@ -553,8 +561,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)
            {
@@ -567,8 +575,8 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                        {
                            ITerrainChannel channel = loader.Value.LoadFile(filename, offsetX, offsetY,
                                                                            fileWidth, fileHeight,
-                                                                            (int) Constants.RegionSize,
+                                                                            (int) m_scene.RegionInfo.RegionSizeX,
-                                                                            (int) Constants.RegionSize);
+                                                                            (int) m_scene.RegionInfo.RegionSizeY);
                            m_scene.Heightmap = channel;
                            m_channel = channel;
                            UpdateRevertMap();
@@ -594,14 +602,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;
            }
@@ -615,8 +623,8 @@ namespace OpenSim.Region.CoreModules.World.Terrain
                    {
                        loader.Value.SaveFile(m_channel, filename, offsetX, offsetY,
                                              fileWidth, fileHeight,
-                                              (int)Constants.RegionSize,
+                                              (int)m_scene.RegionInfo.RegionSizeX,
-                                              (int)Constants.RegionSize);
+                                              (int)m_scene.RegionInfo.RegionSizeY);
                        MainConsole.Instance.OutputFormat(
                            "Saved terrain from ({0},{1}) to ({2},{3}) from {4} to {5}",
@@ -705,7 +713,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain
        private void CheckForTerrainUpdates(bool respectEstateSettings)
        {
            bool shouldTaint = false;
-            float[] serialised = m_channel.GetFloatsSerialised();
+            float[] terrHeights = m_channel.GetFloatsSerialised();
            int x;
            for (x = 0; x < m_channel.Width; x += Constants.TerrainPatchSize)
            {
@@ -714,16 +722,17 @@ 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
+                            terrHeights = m_channel.GetFloatsSerialised();
-                            serialised = m_channel.GetFloatsSerialised();
                        }
-                        SendToClients(serialised, x, y);
+                        // m_log.DebugFormat("{0} Patch modified. Sending (x,y) = ({1},{2})", LogHeader, x, y);
+                        SendToClients(terrHeights, x, y);
                        shouldTaint = true;
                    }
                }
@@ -792,13 +801,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);
-                    }
            );
        }
@@ -984,28 +991,28 @@ namespace OpenSim.Region.CoreModules.World.Terrain
            if (direction.ToLower().StartsWith("y"))
            {
-                for (int x = 0; x < Constants.RegionSize; x++)
+                for (int x = 0; x < m_channel.Width; x++)
                {
-                    for (int y = 0; y < Constants.RegionSize / 2; y++)
+                    for (int y = 0; y < m_channel.Height / 2; y++)
                    {
                        double height = m_channel[x, y];
-                        double flippedHeight = m_channel[x, (int)Constants.RegionSize - 1 - y];
+                        double flippedHeight = m_channel[x, (int)m_channel.Height - 1 - y];
                        m_channel[x, y] = flippedHeight;
-                        m_channel[x, (int)Constants.RegionSize - 1 - y] = height;
+                        m_channel[x, (int)m_channel.Height - 1 - y] = height;
                    }
                }
            }
            else if (direction.ToLower().StartsWith("x"))
            {
-                for (int y = 0; y < Constants.RegionSize; y++)
+                for (int y = 0; y < m_channel.Height; y++)
                {
-                    for (int x = 0; x < Constants.RegionSize / 2; x++)
+                    for (int x = 0; x < m_channel.Width / 2; x++)
                    {
                        double height = m_channel[x, y];
-                        double flippedHeight = m_channel[(int)Constants.RegionSize - 1 - x, y];
+                        double flippedHeight = m_channel[(int)m_channel.Width - 1 - x, y];
                        m_channel[x, y] = flippedHeight;
-                        m_channel[(int)Constants.RegionSize - 1 - x, y] = height;
+                        m_channel[(int)m_channel.Width - 1 - x, y] = height;
                    }
                }
diff --git a/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs b/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
index cdf1467..8383f4e 100644
--- a/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
+++ b/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
@@ -249,7 +249,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;
@@ -278,10 +278,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();
@@ -1218,10 +1218,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>();
@@ -1262,8 +1262,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/ISimulationDataService.cs b/OpenSim/Region/Framework/Interfaces/ISimulationDataService.cs
index 085b5ca..8948f04 100644
--- a/OpenSim/Region/Framework/Interfaces/ISimulationDataService.cs
+++ b/OpenSim/Region/Framework/Interfaces/ISimulationDataService.cs
@@ -68,13 +68,22 @@ namespace OpenSim.Region.Framework.Interfaces
        /// </summary>
        /// <param name="ter">HeightField data</param>
        /// <param name="regionID">region UUID</param>
+        void StoreTerrain(TerrainData terrain, UUID regionID);
+        // Legacy version kept for downward compabibility
        void StoreTerrain(double[,] terrain, UUID regionID);
        /// <summary>
        /// Load the latest terrain revision from region storage
        /// </summary>
        /// <param name="regionID">the region UUID</param>
+        /// <param name="sizeX">the X dimension of the region being filled</param>
+        /// <param name="sizeY">the Y dimension of the region being filled</param>
+        /// <param name="sizeZ">the Z dimension of the region being filled</param>
        /// <returns>Heightfield data</returns>
+        TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ);
+        // Legacy version kept for downward compabibility
        double[,] LoadTerrain(UUID regionID);
        void StoreLandObject(ILandObject Parcel);
diff --git a/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs b/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs
index 3787ca0..917b5d1 100644
--- a/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs
+++ b/OpenSim/Region/Framework/Interfaces/ISimulationDataStore.cs
@@ -79,13 +79,22 @@ namespace OpenSim.Region.Framework.Interfaces
        /// </summary>
        /// <param name="ter">HeightField data</param>
        /// <param name="regionID">region UUID</param>
+        void StoreTerrain(TerrainData terrain, UUID regionID);
+        // Legacy version kept for downward compabibility
        void StoreTerrain(double[,] terrain, UUID regionID);
        
        /// <summary>
        /// Load the latest terrain revision from region storage
        /// </summary>
        /// <param name="regionID">the region UUID</param>
+        /// <param name="pSizeX">the X dimension of the terrain being filled</param>
+        /// <param name="pSizeY">the Y dimension of the terrain being filled</param>
+        /// <param name="pSizeZ">the Z dimension of the terrain being filled</param>
        /// <returns>Heightfield data</returns>
+        TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ);
+        // Legacy version kept for downward compabibility
        double[,] LoadTerrain(UUID regionID);
        void StoreLandObject(ILandObject Parcel);
@@ -135,4 +144,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..99c7079 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -1033,7 +1033,7 @@ namespace OpenSim.Region.Framework.Scenes
            BordersLocked = true;
            Border northBorder = new Border();
-            northBorder.BorderLine = new Vector3(float.MinValue, float.MaxValue, (int)Constants.RegionSize);  //<---
+            northBorder.BorderLine = new Vector3(float.MinValue, float.MaxValue, (float)RegionInfo.RegionSizeY);  //<---
            northBorder.CrossDirection = Cardinals.N;
            NorthBorders.Add(northBorder);
@@ -1043,7 +1043,7 @@ namespace OpenSim.Region.Framework.Scenes
            SouthBorders.Add(southBorder);
            Border eastBorder = new Border();
-            eastBorder.BorderLine = new Vector3(float.MinValue, float.MaxValue, (int)Constants.RegionSize);   //<---
+            eastBorder.BorderLine = new Vector3(float.MinValue, float.MaxValue, (float)RegionInfo.RegionSizeY);   //<---
            eastBorder.CrossDirection = Cardinals.E;
            EastBorders.Add(eastBorder);
@@ -1099,16 +1099,19 @@ namespace OpenSim.Region.Framework.Scenes
        /// <returns>True after all operations complete, throws exceptions otherwise.</returns>
        public override void OtherRegionUp(GridRegion otherRegion)
        {
-            uint xcell = (uint)((int)otherRegion.RegionLocX / (int)Constants.RegionSize);
+            // uint xcell = (uint)((int)otherRegion.RegionLocX / (int)Constants.RegionSize);
-            uint ycell = (uint)((int)otherRegion.RegionLocY / (int)Constants.RegionSize);
+            // uint ycell = (uint)((int)otherRegion.RegionLocY / (int)Constants.RegionSize);
+            uint xcell = Util.WorldToRegionLoc((uint)otherRegion.RegionLocX);
+            uint ycell = Util.WorldToRegionLoc((uint)otherRegion.RegionLocY);
            //m_log.InfoFormat("[SCENE]: (on region {0}): Region {1} up in coords {2}-{3}", 
            //    RegionInfo.RegionName, otherRegion.RegionName, xcell, ycell);
            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 +1186,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;
@@ -1198,14 +1201,16 @@ namespace OpenSim.Region.Framework.Scenes
            else if (dir > 3 && dir < 7) // Heading Sout
                neighboury--;
-            int x = (int)(neighbourx * Constants.RegionSize);
+            // int x = (int)(neighbourx * Constants.RegionSize);
-            int y = (int)(neighboury * Constants.RegionSize);
+            // int y = (int)(neighboury * Constants.RegionSize);
-            GridRegion neighbourRegion = GridService.GetRegionByPosition(RegionInfo.ScopeID, x, y);
+            uint x = Util.RegionToWorldLoc(neighbourx);
+            uint y = Util.RegionToWorldLoc(neighboury);
+            GridRegion neighbourRegion = GridService.GetRegionByPosition(RegionInfo.ScopeID, (int)x, (int)y);
            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
@@ -1894,7 +1899,7 @@ namespace OpenSim.Region.Framework.Scenes
        {
            try
            {
-                double[,] map = SimulationDataService.LoadTerrain(RegionInfo.RegionID);
+                TerrainData map = SimulationDataService.LoadTerrain(RegionInfo.RegionID, (int)RegionInfo.RegionSizeX, (int)RegionInfo.RegionSizeY, (int)RegionInfo.RegionSizeZ);
                if (map == null)
                {
                    // This should be in the Terrain module, but it isn't because
@@ -1905,7 +1910,7 @@ 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);
                }
@@ -3994,12 +3999,12 @@ namespace OpenSim.Region.Framework.Scenes
        {
            if (posX < 0)
                posX = 0;
-            else if (posX >= 256)
+            else if (posX >= (float)RegionInfo.RegionSizeX)
-                posX = 255.999f;
+                posX = (float)RegionInfo.RegionSizeX - 0.001f;
            if (posY < 0)
                posY = 0;
-            else if (posY >= 256)
+            else if (posY >= (float)RegionInfo.RegionSizeY)
-                posY = 255.999f;
+                posY = (float)RegionInfo.RegionSizeY - 0.001f;
            reason = String.Empty;
            if (Permissions.IsGod(agentID))
@@ -4293,7 +4298,7 @@ namespace OpenSim.Region.Framework.Scenes
                "[SCENE]: Incoming child agent update for {0} in {1}", cAgentData.AgentID, RegionInfo.RegionName);
            // TODO: This check should probably be in QueryAccess().
-            ILandObject nearestParcel = GetNearestAllowedParcel(cAgentData.AgentID, Constants.RegionSize / 2, Constants.RegionSize / 2);
+            ILandObject nearestParcel = GetNearestAllowedParcel(cAgentData.AgentID, RegionInfo.RegionSizeX / 2, RegionInfo.RegionSizeY / 2);
            if (nearestParcel == null)
            {
                m_log.InfoFormat(
@@ -4371,8 +4376,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 +4605,22 @@ namespace OpenSim.Region.Framework.Scenes
            ScenePresence sp = GetScenePresence(remoteClient.AgentId);
            if (sp != null)
            {
-                uint regionX = RegionInfo.RegionLocX;
+                /*
-                uint regionY = RegionInfo.RegionLocY;
+                uint regionX = RegionInfo.LegacyRegionLocX;
+                uint regionY = RegionInfo.LegacyRegionLocY;
+                Util.RegionHandleToWorldLoc(regionHandle, out regionX, out regionY);
                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;
+                 */
+                uint regionX, regionY;
+                Util.RegionHandleToWorldLoc(regionHandle, out regionX, out regionY);
+                int shiftx = (int) regionX - (int)RegionInfo.RegionWorldLocX;
+                int shifty = (int) regionY - (int)RegionInfo.RegionWorldLocY;
                position.X += shiftx;
                position.Y += shifty;
@@ -4817,7 +4831,7 @@ namespace OpenSim.Region.Framework.Scenes
                else
                {
-                    if (pos.X > 0f && pos.X < Constants.RegionSize && pos.Y > 0f && pos.Y < Constants.RegionSize)
+                    if (pos.X > 0f && pos.X < RegionInfo.RegionSizeX && pos.Y > 0f && pos.Y < RegionInfo.RegionSizeY)
                    {
                        // The only time parcel != null when an object is inside a region is when
                        // there is nothing behind the landchannel.  IE, no land plugin loaded.
@@ -5478,7 +5492,7 @@ namespace OpenSim.Region.Framework.Scenes
        {
            Vector3 unitDirection = Vector3.Normalize(direction);
            //Making distance to search go through some sane limit of distance
-            for (float distance = 0; distance < Constants.RegionSize * 2; distance += .5f)
+            for (float distance = 0; distance < Math.Max(RegionInfo.RegionSizeX, RegionInfo.RegionSizeY) * 2; distance += .5f)
            {
                Vector3 testPos = Vector3.Add(pos, Vector3.Multiply(unitDirection, distance));
                if (parcel.ContainsPoint((int)testPos.X, (int)testPos.Y))
@@ -5532,9 +5546,9 @@ namespace OpenSim.Region.Framework.Scenes
            int count = 0;
            int avgx = 0;
            int avgy = 0;
-            for (int x = 0; x < Constants.RegionSize; x++)
+            for (int x = 0; x < RegionInfo.RegionSizeX; x++)
            {
-                for (int y = 0; y < Constants.RegionSize; y++)
+                for (int y = 0; y < RegionInfo.RegionSizeY; y++)
                {
                    //Just keep a running average as we check if all the points are inside or not
                    if (parcel.ContainsPoint(x, y))
@@ -5558,31 +5572,33 @@ namespace OpenSim.Region.Framework.Scenes
        private Vector3 GetNearestRegionEdgePosition(ScenePresence avatar)
        {
-            float xdistance = avatar.AbsolutePosition.X < Constants.RegionSize / 2 ? avatar.AbsolutePosition.X : Constants.RegionSize - avatar.AbsolutePosition.X;
+            float xdistance = avatar.AbsolutePosition.X < RegionInfo.RegionSizeX / 2
-            float ydistance = avatar.AbsolutePosition.Y < Constants.RegionSize / 2 ? avatar.AbsolutePosition.Y : Constants.RegionSize - avatar.AbsolutePosition.Y;
+                                ? avatar.AbsolutePosition.X : RegionInfo.RegionSizeX - avatar.AbsolutePosition.X;
+            float ydistance = avatar.AbsolutePosition.Y < RegionInfo.RegionSizeY / 2
+                                ? avatar.AbsolutePosition.Y : RegionInfo.RegionSizeY - avatar.AbsolutePosition.Y;
            //find out what vertical edge to go to
            if (xdistance < ydistance)
            {
-                if (avatar.AbsolutePosition.X < Constants.RegionSize / 2)
+                if (avatar.AbsolutePosition.X < RegionInfo.RegionSizeX / 2)
                {
                    return GetPositionAtAvatarHeightOrGroundHeight(avatar, 0.0f, avatar.AbsolutePosition.Y);
                }
                else
                {
-                    return GetPositionAtAvatarHeightOrGroundHeight(avatar, Constants.RegionSize, avatar.AbsolutePosition.Y);
+                    return GetPositionAtAvatarHeightOrGroundHeight(avatar, RegionInfo.RegionSizeY, avatar.AbsolutePosition.Y);
                }
            }
            //find out what horizontal edge to go to
            else
            {
-                if (avatar.AbsolutePosition.Y < Constants.RegionSize / 2)
+                if (avatar.AbsolutePosition.Y < RegionInfo.RegionSizeY / 2)
                {
                    return GetPositionAtAvatarHeightOrGroundHeight(avatar, avatar.AbsolutePosition.X, 0.0f);
                }
                else
                {
-                    return GetPositionAtAvatarHeightOrGroundHeight(avatar, avatar.AbsolutePosition.X, Constants.RegionSize);
+                    return GetPositionAtAvatarHeightOrGroundHeight(avatar, avatar.AbsolutePosition.X, RegionInfo.RegionSizeY);
                }
            }
        }
diff --git a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
index 77889fa..262b882 100644
--- a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
@@ -92,7 +92,7 @@ namespace OpenSim.Region.Framework.Scenes
            {
                m_log.DebugFormat(
                    "[SCENE COMMUNICATION SERVICE]: Region {0} successfully informed neighbour {1} at {2}-{3} that it is up",
-                    m_scene.Name, neighbour.RegionName, x / Constants.RegionSize, y / Constants.RegionSize);
+                    m_scene.Name, neighbour.RegionName, Util.WorldToRegionLoc(x), Util.WorldToRegionLoc(y));
                m_scene.EventManager.TriggerOnRegionUp(neighbour);
            }
@@ -100,7 +100,7 @@ namespace OpenSim.Region.Framework.Scenes
            {
                m_log.WarnFormat(
                    "[SCENE COMMUNICATION SERVICE]: Region {0} failed to inform neighbour at {1}-{2} that it is up.",
-                    m_scene.Name, x / Constants.RegionSize, y / Constants.RegionSize);
+                    m_scene.Name, Util.WorldToRegionLoc(x), Util.WorldToRegionLoc(y));
            }
        }
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/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 4b4e4ba..eed8908 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -842,9 +842,9 @@ namespace OpenSim.Region.Framework.Scenes
            maxX = -256f;
            maxY = -256f;
            maxZ = -256f;
-            minX = 256f;
+            minX = 10000f;
-            minY = 256f;
+            minY = 10000f;
-            minZ = 8192f;
+            minZ = 10000f;
            SceneObjectPart[] parts = m_parts.GetArray();
            for (int i = 0; i < parts.Length; i++)
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 7243db1..2c64c85 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -707,10 +707,9 @@ namespace OpenSim.Region.Framework.Scenes
            foreach (ulong handle in seeds.Keys)
            {
                uint x, y;
-                Utils.LongToUInts(handle, out x, out y);
+                Util.RegionHandleToRegionLoc(handle, out x, out y);
-                x = x / Constants.RegionSize;
-                y = y / Constants.RegionSize;
+                if (Util.IsOutsideView(DrawDistance, x, Scene.RegionInfo.LegacyRegionLocX, y, Scene.RegionInfo.LegacyRegionLocY))
-                if (Util.IsOutsideView(DrawDistance, x, Scene.RegionInfo.RegionLocX, y, Scene.RegionInfo.RegionLocY))
                {
                    old.Add(handle);
                }
@@ -731,9 +730,7 @@ namespace OpenSim.Region.Framework.Scenes
            foreach (KeyValuePair<ulong, string> kvp in KnownRegions)
            {
                uint x, y;
-                Utils.LongToUInts(kvp.Key, out x, out y);
+                Util.RegionHandleToRegionLoc(kvp.Key, out x, out y);
-                x = x / Constants.RegionSize;
-                y = y / Constants.RegionSize;
                m_log.Info(" >> "+x+", "+y+": "+kvp.Value);
            }
        }
@@ -971,7 +968,7 @@ namespace OpenSim.Region.Framework.Scenes
            float posZLimit = 0;
-            if (pos.X < Constants.RegionSize && pos.Y < Constants.RegionSize)
+            if (pos.X < m_scene.RegionInfo.RegionSizeX && pos.Y < m_scene.RegionInfo.RegionSizeY)
                posZLimit = (float)m_scene.Heightmap[(int)pos.X, (int)pos.Y];
            
            float newPosZ = posZLimit + localAVHeight / 2;
@@ -2076,7 +2073,7 @@ namespace OpenSim.Region.Framework.Scenes
            if (regionCombinerModule != null)
                regionSize = regionCombinerModule.GetSizeOfMegaregion(m_scene.RegionInfo.RegionID);
            else
-                regionSize = new Vector2(Constants.RegionSize);
+                regionSize = new Vector2(m_scene.RegionInfo.RegionSizeX, m_scene.RegionInfo.RegionSizeY);
            if (pos.X < 0 || pos.X >= regionSize.X
                || pos.Y < 0 || pos.Y >= regionSize.Y
@@ -2094,8 +2091,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)
@@ -2106,7 +2103,7 @@ namespace OpenSim.Region.Framework.Scenes
            if (!SceneManager.Instance.TryGetScene(target_regionID, out targetScene))
                targetScene = m_scene;
-            float terrainHeight = (float)targetScene.Heightmap[(int)(pos.X % Constants.RegionSize), (int)(pos.Y % Constants.RegionSize)];
+            float terrainHeight = (float)targetScene.Heightmap[(int)(pos.X % regionSize.X), (int)(pos.Y % regionSize.Y)];
            pos.Z = Math.Max(terrainHeight, pos.Z);
            // Fudge factor.  It appears that if one clicks "go here" on a piece of ground, the go here request is
@@ -3199,11 +3196,11 @@ namespace OpenSim.Region.Framework.Scenes
                                Vector3 pos = AbsolutePosition;
                                if (AbsolutePosition.X < 0)
                                    pos.X += Velocity.X * 2;
-                                else if (AbsolutePosition.X > Constants.RegionSize)
+                                else if (AbsolutePosition.X > m_scene.RegionInfo.RegionSizeX)
                                    pos.X -= Velocity.X * 2;
                                if (AbsolutePosition.Y < 0)
                                    pos.Y += Velocity.Y * 2;
-                                else if (AbsolutePosition.Y > Constants.RegionSize)
+                                else if (AbsolutePosition.Y > m_scene.RegionInfo.RegionSizeY)
                                    pos.Y -= Velocity.Y * 2;
                                Velocity = Vector3.Zero;
                                AbsolutePosition = pos;
@@ -3226,11 +3223,11 @@ namespace OpenSim.Region.Framework.Scenes
                                Vector3 pos = AbsolutePosition;
                                if (AbsolutePosition.X < 0)
                                    pos.X += Velocity.X * 2;
-                                else if (AbsolutePosition.X > Constants.RegionSize)
+                                else if (AbsolutePosition.X > m_scene.RegionInfo.RegionSizeX)
                                    pos.X -= Velocity.X * 2;
                                if (AbsolutePosition.Y < 0)
                                    pos.Y += Velocity.Y * 2;
-                                else if (AbsolutePosition.Y > Constants.RegionSize)
+                                else if (AbsolutePosition.Y > m_scene.RegionInfo.RegionSizeY)
                                    pos.Y -= Velocity.Y * 2;
                                Velocity = Vector3.Zero;
                                AbsolutePosition = pos;
@@ -3279,7 +3276,7 @@ namespace OpenSim.Region.Framework.Scenes
            // Put the child agent back at the center
            AbsolutePosition 
-                = new Vector3(((float)Constants.RegionSize * 0.5f), ((float)Constants.RegionSize * 0.5f), 70);
+                = new Vector3(((float)m_scene.RegionInfo.RegionSizeX * 0.5f), ((float)m_scene.RegionInfo.RegionSizeY * 0.5f), 70);
            Animator.ResetAnimations();
        }
@@ -3306,9 +3303,7 @@ namespace OpenSim.Region.Framework.Scenes
                if (handle != Scene.RegionInfo.RegionHandle)
                {
                    uint x, y;
-                    Utils.LongToUInts(handle, out x, out y);
+                    Util.RegionHandleToRegionLoc(handle, out x, out y);
-                    x = x / Constants.RegionSize;
-                    y = y / Constants.RegionSize;
 //                    m_log.Debug("---> x: " + x + "; newx:" + newRegionX + "; Abs:" + (int)Math.Abs((int)(x - newRegionX)));
 //                    m_log.Debug("---> y: " + y + "; newy:" + newRegionY + "; Abs:" + (int)Math.Abs((int)(y - newRegionY)));
@@ -3389,8 +3384,9 @@ namespace OpenSim.Region.Framework.Scenes
                return;
            //m_log.Debug("   >>> ChildAgentPositionUpdate <<< " + rRegionX + "-" + rRegionY);
-            int shiftx = ((int)rRegionX - (int)tRegionX) * (int)Constants.RegionSize;
+            // Find  the distance (in meters) between the two regions
-            int shifty = ((int)rRegionY - (int)tRegionY) * (int)Constants.RegionSize;
+            uint shiftx = Util.RegionToWorldLoc(rRegionX - tRegionX);
+            uint shifty = Util.RegionToWorldLoc(rRegionY - tRegionY);
            Vector3 offset = new Vector3(shiftx, shifty, 0f);
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..a5b42ff 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,134 @@ 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)
+        // Create channel passed a heightmap and expected dimensions of the region.
+        // The heightmap might not fit the passed size so accomodations must be made.
+        public TerrainChannel(double[,] pM, int pSizeX, int pSizeY, int pAltitude)
        {
-            map = import;
+            int hmSizeX = pM.GetLength(0);
-            taint = new bool[import.GetLength(0),import.GetLength(1)];
+            int hmSizeY = pM.GetLength(1);
-        }
-        public TerrainChannel(bool createMap)
+            m_terrainData = new HeightmapTerrainData(pSizeX, pSizeY, pAltitude);
-        {
-            if (createMap)
+            for (int xx = 0; xx < pSizeX; xx++)
-            {
+                for (int yy = 0; yy < pSizeY; yy++)
-                map = new double[Constants.RegionSize,Constants.RegionSize];
+                    if (xx > hmSizeX || yy > hmSizeY)
-                taint = new bool[Constants.RegionSize / 16,Constants.RegionSize / 16];
+                        m_terrainData[xx, yy] = TerrainData.DefaultTerrainHeight;
-            }
+                    else
+                        m_terrainData[xx, yy] = (float)pM[xx, yy];
        }
-        public TerrainChannel(int w, int h)
+        public TerrainChannel(TerrainData pTerrData)
        {
-            map = new double[w,h];
+            m_terrainData = pTerrData;
-            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()
+        // This one dimensional version is ordered so height = map[y*sizeX+x];
+        // DEPRECATED: don't use this function as it does not retain the dimensions of the terrain
+        //     and the caller will probably do the wrong thing if the terrain is not the legacy 256x256.
+        public 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 jj = 0; jj < Height; jj++)
+                for (int ii = 0; ii < Width; ii++)
+                {
+                    heights[idx++] = m_terrainData[ii, jj];
+                }
+            return heights;
        }
-        public float[] GetFloatsSerialised()
+        // ITerrainChannel.GetDoubles()
+        public double[,] GetDoubles()
        {
-            // Move the member variables into local variables, calling
+            double[,] heights = new double[Width, Height];
-            // member variables 256*256 times gets expensive
-            int w = Width;
-            int h = Height;
-            float[] heights = new float[w * h];
-            int i, j; // map coordinates
            int idx = 0; // index into serialized array
-            for (i = 0; i < h; i++)
+            for (int ii = 0; ii < Width; ii++)
            {
-                for (j = 0; j < w; j++)
+                for (int jj = 0; jj < Height; 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 +188,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 +200,50 @@ namespace OpenSim.Region.Framework.Scenes
            sr.Close();
        }
+        #endregion
+        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 +257,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(Height, Width, (int)Constants.RegionHeight);
+            
            for (int y = 0; y < Height; y++)
            {
                for (int x = 0; x < Width; x++)
@@ -236,35 +278,63 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
+        private class TerrainChannelXMLPackage
+        {
+            public int Version;
+            public int SizeX;
+            public int SizeY;
+            public int SizeZ;
+            public float CompressionFactor;
+            public short[] Map;
+            public TerrainChannelXMLPackage(int pX, int pY, int pZ, float pCompressionFactor, short[] pMap)
+            {
+                Version = 1;
+                SizeX = pX;
+                SizeY = pY;
+                SizeZ = pZ;
+                CompressionFactor = pCompressionFactor;
+                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.CompressionFactor,
+                                            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.CompressionFactor, 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;
+            m_terrainData.ClearLand();
-            for (x = 0; x < Constants.RegionSize; x++)
-            {
-                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..ced62e2
--- /dev/null
+++ b/OpenSim/Region/Framework/Scenes/TerrainCompressor.cs
@@ -0,0 +1,944 @@
+/*
+ * 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;
+        }
+        // Create a land packet for a single patch.
+        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;
+            byte landPacketType = (byte)TerrainPatch.LayerType.Land;
+            if (terrData.SizeX > Constants.RegionSize || terrData.SizeY > Constants.RegionSize)
+            {
+                // libOMV does not have a packet type defined for the extended parcel format.
+                // We just happen to know the extended parcel format code is one more than the usual code.
+                landPacketType++;
+            }
+            return CreateLandPacket(terrData, xPieces, yPieces, landPacketType);
+        }
+        /// <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="terrData">
+        ///     Terrain data that can result in a meter square heightmap.
+        /// </param>
+        /// <param name="x">
+        ///     Array of indexes in the grid of patches
+        ///     for this simulator.
+        ///     If creating a packet for multiple patches, there will be entries in
+        ///     both the X and Y arrays for each of the patches.
+        ///     For example if patches 1 and 17 are to be sent,
+        ///     x[] = {1,1} and y[] = {0,1} which specifies the patches at
+        ///     indexes <1,0> and <1,1> (presuming the terrain size is 16x16 patches).
+        /// </param>
+        /// <param name="y">
+        ///     Array of indexes in the grid of patches.
+        /// </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, (uint)pRegionSizeX, (uint)pRegionSizeY, 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);
+            }
+            // m_log.DebugFormat("{0} CreatePatchFromHeightmap. patchX={1}, patchY={2}, DCOffset={3}, range={4}",
+            //                         LogHeader, patchX, patchY, header.DCOffset, header.Range);
+            // 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*Constants.TerrainPatchSize; j < (patchY + 1)*Constants.TerrainPatchSize; j++)
+            {
+                for (int i = patchX*Constants.TerrainPatchSize; i < (patchX + 1)*Constants.TerrainPatchSize; i++)
+                {
+                    float val = terrData[i, j];
+                    if (val > zmax) zmax = val;
+                    if (val < zmin) zmin = val;
+                }
+            }
+            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 yPatchLimit = patchY >= (terrData.SizeY / Constants.TerrainPatchSize) ?
+                            (terrData.SizeY - Constants.TerrainPatchSize) / Constants.TerrainPatchSize : patchY;
+            yPatchLimit = (yPatchLimit + 1) * Constants.TerrainPatchSize;
+            int xPatchLimit = patchX >= (terrData.SizeX / Constants.TerrainPatchSize) ?
+                            (terrData.SizeX - Constants.TerrainPatchSize) / Constants.TerrainPatchSize : patchX;
+            xPatchLimit = (xPatchLimit + 1) * Constants.TerrainPatchSize;
+            for (int yy = patchY * Constants.TerrainPatchSize; yy < yPatchLimit; yy++)
+            {
+                for (int xx = patchX * Constants.TerrainPatchSize; xx < xPatchLimit; xx++)
+                {
+                    block[k++] = terrData[xx, yy] * 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;
+        }
+        #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
+    }
+}
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/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs b/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
index c550c44..3317b21 100644
--- a/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
+++ b/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
@@ -169,7 +169,10 @@ namespace OpenSim.Region.OptionalModules.Scripting.RegionReady
                c.Channel = m_channelNotify;
                c.Message += numScriptsFailed.ToString() + "," + message;
                c.Type = ChatTypeEnum.Region;
-                c.Position = new Vector3(((int)Constants.RegionSize * 0.5f), ((int)Constants.RegionSize * 0.5f), 30);
+                if (m_scene != null)
+                    c.Position = new Vector3((m_scene.RegionInfo.RegionSizeX * 0.5f), (m_scene.RegionInfo.RegionSizeY * 0.5f), 30);
+                else
+                    c.Position = new Vector3(((int)Constants.RegionSize * 0.5f), ((int)Constants.RegionSize * 0.5f), 30);
                c.Sender = null;
                c.SenderUUID = UUID.Zero;
                c.Scene = m_scene;
diff --git a/OpenSim/Region/OptionalModules/World/TreePopulator/TreePopulatorModule.cs b/OpenSim/Region/OptionalModules/World/TreePopulator/TreePopulatorModule.cs
index 8144870..e4a3382 100644
--- a/OpenSim/Region/OptionalModules/World/TreePopulator/TreePopulatorModule.cs
+++ b/OpenSim/Region/OptionalModules/World/TreePopulator/TreePopulatorModule.cs
@@ -748,8 +748,8 @@ namespace OpenSim.Region.OptionalModules.World.TreePopulator
            position.X = s_tree.AbsolutePosition.X + (float)randX;
            position.Y = s_tree.AbsolutePosition.Y + (float)randY;
-            if (position.X <= ((int)Constants.RegionSize - 1) && position.X >= 0 &&
+            if (position.X <= (m_scene.RegionInfo.RegionSizeX - 1) && position.X >= 0 &&
-                position.Y <= ((int)Constants.RegionSize - 1) && position.Y >= 0 &&
+                position.Y <= (m_scene.RegionInfo.RegionSizeY - 1) && position.Y >= 0 &&
                Util.GetDistanceTo(position, copse.m_seed_point) <= copse.m_range)
            {
                UUID uuid = m_scene.RegionInfo.EstateSettings.EstateOwner;
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
index 15b7090..edec949 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSPrim.cs
@@ -376,18 +376,19 @@ public class BSPrim : BSPhysObject
    {
        bool ret = false;
-        uint wayOutThere = Constants.RegionSize * Constants.RegionSize;
+        int wayOverThere = -1000;
+        int wayOutThere = 10000;
        // There have been instances of objects getting thrown way out of bounds and crashing
        //    the border crossing code.
-        if (   RawPosition.X < -Constants.RegionSize || RawPosition.X > wayOutThere
+        if (   RawPosition.X < wayOverThere || RawPosition.X > wayOutThere
-            || RawPosition.Y < -Constants.RegionSize || RawPosition.Y > wayOutThere
+            || RawPosition.Y < wayOverThere || RawPosition.X > wayOutThere
-            || RawPosition.Z < -Constants.RegionSize || RawPosition.Z > wayOutThere)
+            || RawPosition.Z < wayOverThere || RawPosition.X > wayOutThere)
        {
            RawPosition = new OMV.Vector3(10, 10, 50);
            ZeroMotion(inTaintTime);
            ret = true;
        }
-        if (RawVelocity.LengthSquared() > BSParam.MaxLinearVelocity)
+        if (RawVelocity.LengthSquared() > BSParam.MaxLinearVelocitySquared)
        {
            RawVelocity = Util.ClampV(RawVelocity, BSParam.MaxLinearVelocity);
            ret = true;
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
index b3dfa41..83ef1f6 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
@@ -210,6 +210,14 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
    public override void Initialise(IMesher meshmerizer, IConfigSource config)
    {
+        m_log.ErrorFormat("{0} WARNING WARNING WARNING! BulletSim initialized without region extent specification. Terrain will be messed up.");
+        Vector3 regionExtent = new Vector3( Constants.RegionSize, Constants.RegionSize, Constants.RegionSize);
+        Initialise(meshmerizer, config, regionExtent);
+        
+    }
+    public override void Initialise(IMesher meshmerizer, IConfigSource config, Vector3 regionExtent)
+    {
        mesher = meshmerizer;
        _taintOperations = new List<TaintCallbackEntry>();
        _postTaintOperations = new Dictionary<string, TaintCallbackEntry>();
@@ -250,13 +258,13 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
        //    a child in a mega-region.
        // Bullet actually doesn't care about the extents of the simulated
        //    area. It tracks active objects no matter where they are.
-        Vector3 worldExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
+        Vector3 worldExtent = regionExtent;
        World = PE.Initialize(worldExtent, Params, m_maxCollisionsPerFrame, ref m_collisionArray, m_maxUpdatesPerFrame, ref m_updateArray);
        Constraints = new BSConstraintCollection(World);
-        TerrainManager = new BSTerrainManager(this);
+        TerrainManager = new BSTerrainManager(this, worldExtent);
        TerrainManager.CreateInitialGroundPlaneAndTerrain();
        // Put some informational messages into the log file.
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
index 8888d6d..d70b2fb 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainHeightmap.cs
@@ -58,7 +58,7 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
        {
            initialMap[ii] = BSTerrainManager.HEIGHT_INITIALIZATION;
        }
-        m_mapInfo = new BulletHMapInfo(id, initialMap);
+        m_mapInfo = new BulletHMapInfo(id, initialMap, regionSize.X, regionSize.Y);
        m_mapInfo.minCoords = minTerrainCoords;
        m_mapInfo.maxCoords = maxTerrainCoords;
        m_mapInfo.terrainRegionBase = TerrainBase;
@@ -72,7 +72,7 @@ public sealed class BSTerrainHeightmap : BSTerrainPhys
                                                    Vector3 minCoords, Vector3 maxCoords)
        : base(physicsScene, regionBase, id)
    {
-        m_mapInfo = new BulletHMapInfo(id, initialMap);
+        m_mapInfo = new BulletHMapInfo(id, initialMap, maxCoords.X - minCoords.X, maxCoords.Y - minCoords.Y);
        m_mapInfo.minCoords = minCoords;
        m_mapInfo.maxCoords = maxCoords;
        m_mapInfo.minZ = minCoords.Z;
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
index 441d2d3..3013077 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSTerrainManager.cs
@@ -111,9 +111,11 @@ public sealed class BSTerrainManager : IDisposable
    private Vector3 m_worldMax;
    private PhysicsScene MegaRegionParentPhysicsScene { get; set; }
-    public BSTerrainManager(BSScene physicsScene)
+    public BSTerrainManager(BSScene physicsScene, Vector3 regionSize)
    {
        m_physicsScene = physicsScene;
+        DefaultRegionSize = regionSize;
        m_terrains = new Dictionary<Vector3,BSTerrainPhys>();
        // Assume one region of default size
@@ -268,7 +270,7 @@ public sealed class BSTerrainManager : IDisposable
            {
                // There is already a terrain in this spot. Free the old and build the new.
                DetailLog("{0},BSTErrainManager.UpdateTerrain:UpdateExisting,call,id={1},base={2},minC={3},maxC={4}",
-                                BSScene.DetailLogZero, id, terrainRegionBase, minCoords, minCoords);
+                                BSScene.DetailLogZero, id, terrainRegionBase, minCoords, maxCoords);
                // Remove old terrain from the collection
                m_terrains.Remove(terrainRegionBase);
diff --git a/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs b/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs
index 971ff9f..3425d9e 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BulletSimData.cs
@@ -165,14 +165,15 @@ public class BulletConstraint
 //      than making copies.
 public class BulletHMapInfo
 {
-    public BulletHMapInfo(uint id, float[] hm) {
+    public BulletHMapInfo(uint id, float[] hm, float pSizeX, float pSizeY) {
        ID = id;
        heightMap = hm;
        terrainRegionBase = OMV.Vector3.Zero;
        minCoords = new OMV.Vector3(100f, 100f, 25f);
        maxCoords = new OMV.Vector3(101f, 101f, 26f);
        minZ = maxZ = 0f;
-        sizeX = sizeY = 256f;
+        sizeX = pSizeX;
+        sizeY = pSizeY;
    }
    public uint ID;
    public float[] heightMap;
diff --git a/OpenSim/Region/Physics/Manager/PhysicsPluginManager.cs b/OpenSim/Region/Physics/Manager/PhysicsPluginManager.cs
index 8ccfda5..9b06353 100644
--- a/OpenSim/Region/Physics/Manager/PhysicsPluginManager.cs
+++ b/OpenSim/Region/Physics/Manager/PhysicsPluginManager.cs
@@ -32,6 +32,7 @@ using System.Reflection;
 using Nini.Config;
 using log4net;
 using OpenSim.Framework;
+using OpenMetaverse;
 namespace OpenSim.Region.Physics.Manager
 {
@@ -66,7 +67,8 @@ namespace OpenSim.Region.Physics.Manager
        /// <param name="meshEngineName"></param>
        /// <param name="config"></param>
        /// <returns></returns>
-        public PhysicsScene GetPhysicsScene(string physEngineName, string meshEngineName, IConfigSource config, string regionName)
+        public PhysicsScene GetPhysicsScene(string physEngineName, string meshEngineName,
+                                    IConfigSource config, string regionName, Vector3 regionExtent)
        {
            if (String.IsNullOrEmpty(physEngineName))
            {
@@ -94,7 +96,7 @@ namespace OpenSim.Region.Physics.Manager
            {
                m_log.Info("[PHYSICS]: creating " + physEngineName);
                PhysicsScene result = _PhysPlugins[physEngineName].GetScene(regionName);
-                result.Initialise(meshEngine, config);
+                result.Initialise(meshEngine, config, regionExtent);
                return result;
            }
            else
diff --git a/OpenSim/Region/Physics/Manager/PhysicsScene.cs b/OpenSim/Region/Physics/Manager/PhysicsScene.cs
index c93206d..71ad795 100644
--- a/OpenSim/Region/Physics/Manager/PhysicsScene.cs
+++ b/OpenSim/Region/Physics/Manager/PhysicsScene.cs
@@ -126,8 +126,17 @@ namespace OpenSim.Region.Physics.Manager
            }
        }
+        // Deprecated. Do not use this for new physics engines.
        public abstract void Initialise(IMesher meshmerizer, IConfigSource config);
+        // For older physics engines that do not implement non-legacy region sizes.
+        // If the physics engine handles the region extent feature, it overrides this function.
+        public virtual void Initialise(IMesher meshmerizer, IConfigSource config, Vector3 regionExtent)
+        {
+            // If not overridden, call the old initialization entry.
+            Initialise(meshmerizer, config);
+        }
        /// <summary>
        /// Add an avatar
        /// </summary>
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/RegionCombinerModule/RegionConnections.cs b/OpenSim/Region/RegionCombinerModule/RegionConnections.cs
index fba51d2..62a3a91 100644
--- a/OpenSim/Region/RegionCombinerModule/RegionConnections.cs
+++ b/OpenSim/Region/RegionCombinerModule/RegionConnections.cs
@@ -64,12 +64,12 @@ namespace OpenSim.Region.RegionCombinerModule
        /// <summary>
        /// The X meters position of this connection.
        /// </summary>
-        public uint PosX { get { return X * Constants.RegionSize; } }
+        public uint PosX { get { return Util.RegionToWorldLoc(X); } }
        /// <summary>
        /// The Y meters co-ordinate of this connection.
        /// </summary>
-        public uint PosY { get { return Y * Constants.RegionSize; } }
+        public uint PosY { get { return Util.RegionToWorldLoc(Y); } }
        /// <summary>
        /// The size of the megaregion in meters.
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
index 5663048..f46bdf3 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -2107,7 +2107,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
            //
            // This workaround is to prevent silent failure of this function.
            // According to the specification on the SL Wiki, providing a position outside of the
-            if (pos.x < 0 || pos.x > Constants.RegionSize || pos.y < 0 || pos.y > Constants.RegionSize)
+            if (pos.x < 0 || pos.x > World.RegionInfo.RegionSizeX || pos.y < 0 || pos.y > World.RegionInfo.RegionSizeY)
            {
                return 0;
            }
@@ -2117,9 +2117,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                m_host.ParentGroup.IsAttachment || // return FALSE if attachment
                (
                    pos.x < -10.0 || // return FALSE if more than 10 meters into a west-adjacent region.
-                    pos.x > (Constants.RegionSize + 10) || // return FALSE if more than 10 meters into a east-adjacent region.
+                    pos.x > (World.RegionInfo.RegionSizeX + 10) || // return FALSE if more than 10 meters into a east-adjacent region.
                    pos.y < -10.0 || // return FALSE if more than 10 meters into a south-adjacent region.
-                    pos.y > (Constants.RegionSize + 10) || // return FALSE if more than 10 meters into a north-adjacent region.
+                    pos.y > (World.RegionInfo.RegionSizeY + 10) || // return FALSE if more than 10 meters into a north-adjacent region.
                    pos.z > Constants.RegionHeight // return FALSE if altitude than 4096m
                )
            )
@@ -4244,10 +4244,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)
@@ -5481,7 +5478,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>
@@ -5628,7 +5625,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                LSL_Float mag;
                if (dir.x > 0)
                {
-                    mag = (Constants.RegionSize - pos.x) / dir.x;
+                    mag = (World.RegionInfo.RegionSizeX - pos.x) / dir.x;
                }
                else
                {
@@ -5639,7 +5636,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                edge.y = pos.y + (dir.y * mag);
-                if (edge.y > Constants.RegionSize || edge.y < 0)
+                if (edge.y > World.RegionInfo.RegionSizeY || edge.y < 0)
                {
                    // Y goes out of bounds first
                    edge.y = dir.y / Math.Abs(dir.y);
@@ -5654,8 +5651,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)
            {
@@ -10770,7 +10767,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/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
index f4d5562..4fb0856 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
@@ -450,7 +450,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
        {
            m_host.AddScriptLPS(1);
-            if (x > ((int)Constants.RegionSize - 1) || x < 0 || y > ((int)Constants.RegionSize - 1) || y < 0)
+            if (x > (World.RegionInfo.RegionSizeX - 1) || x < 0 || y > (World.RegionInfo.RegionSizeY - 1) || y < 0)
                OSSLError("osSetTerrainHeight: Coordinate out of bounds");
            if (World.Permissions.CanTerraformLand(m_host.OwnerID, new Vector3(x, y, 0)))
@@ -480,7 +480,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
        private LSL_Float GetTerrainHeight(int x, int y)
        {
            m_host.AddScriptLPS(1);
-            if (x > ((int)Constants.RegionSize - 1) || x < 0 || y > ((int)Constants.RegionSize - 1) || y < 0)
+            if (x > (World.RegionInfo.RegionSizeX - 1) || x < 0 || y > (World.RegionInfo.RegionSizeY - 1) || y < 0)
                OSSLError("osGetTerrainHeight: Coordinate out of bounds");
            return World.Heightmap[x, y];
@@ -814,7 +814,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
        private void TeleportAgent(string agent, int regionX, int regionY,
            LSL_Types.Vector3 position, LSL_Types.Vector3 lookat, bool relaxRestrictions)
        {
-            ulong regionHandle = Util.UIntsToLong(((uint)regionX * (uint)Constants.RegionSize), ((uint)regionY * (uint)Constants.RegionSize));
+            // ulong regionHandle = Util.UIntsToLong(((uint)regionX * (uint)Constants.RegionSize), ((uint)regionY * (uint)Constants.RegionSize));
+            ulong regionHandle = Util.RegionWorldLocToHandle(Util.RegionToWorldLoc((uint)regionX), Util.RegionToWorldLoc((uint)regionY));
            m_host.AddScriptLPS(1);
            UUID agentId = new UUID();
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs
index c9902e4..e3f3fc7 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs
@@ -721,8 +721,8 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
                    Position.y = ((int)Constants.RegionSize - 1);
                if (Position.y < 0)
                    Position.y = 0;
-                if (Position.z > 768)
+                if (Position.z > Constants.RegionHeight)
-                    Position.z = 768;
+                    Position.z = Constants.RegionHeight;
                if (Position.z < 0)
                    Position.z = 0;
                prim.OSSL.llSetPos(Position);
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/Connectors/Simulation/SimulationDataService.cs b/OpenSim/Services/Connectors/Simulation/SimulationDataService.cs
index 504fcaf..2cbf967 100644
--- a/OpenSim/Services/Connectors/Simulation/SimulationDataService.cs
+++ b/OpenSim/Services/Connectors/Simulation/SimulationDataService.cs
@@ -100,6 +100,11 @@ namespace OpenSim.Services.Connectors
            return m_database.LoadObjects(regionUUID);
        }
+        public void StoreTerrain(TerrainData terrain, UUID regionID)
+        {
+            m_database.StoreTerrain(terrain, regionID);
+        }
        public void StoreTerrain(double[,] terrain, UUID regionID)
        {
            m_database.StoreTerrain(terrain, regionID);
@@ -110,6 +115,11 @@ namespace OpenSim.Services.Connectors
            return m_database.LoadTerrain(regionID);
        }
+        public TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ)
+        {
+            return m_database.LoadTerrain(regionID, pSizeX, pSizeY, pSizeZ);
+        }
        public void StoreLandObject(ILandObject Parcel)
        {
            m_database.StoreLandObject(Parcel);
diff --git a/OpenSim/Services/GridService/GridService.cs b/OpenSim/Services/GridService/GridService.cs
index e72b7f9..9fa2dc5 100644
--- a/OpenSim/Services/GridService/GridService.cs
+++ b/OpenSim/Services/GridService/GridService.cs
@@ -441,6 +441,8 @@ namespace OpenSim.Services.GridService
            RegionData rdata = new RegionData();
            rdata.posX = (int)rinfo.RegionLocX;
            rdata.posY = (int)rinfo.RegionLocY;
+            rdata.sizeX = rinfo.RegionSizeX;
+            rdata.sizeY = rinfo.RegionSizeY;
            rdata.RegionID = rinfo.RegionID;
            rdata.RegionName = rinfo.RegionName;
            rdata.Data = rinfo.ToKeyValuePairs();
@@ -454,6 +456,8 @@ namespace OpenSim.Services.GridService
            GridRegion rinfo = new GridRegion(rdata.Data);
            rinfo.RegionLocX = rdata.posX;
            rinfo.RegionLocY = rdata.posY;
+            rinfo.RegionSizeX = rdata.sizeX;
+            rinfo.RegionSizeY = rdata.sizeY;
            rinfo.RegionID = rdata.RegionID;
            rinfo.RegionName = rdata.RegionName;
            rinfo.ScopeID = rdata.ScopeID;
diff --git a/OpenSim/Services/Interfaces/IGridService.cs b/OpenSim/Services/Interfaces/IGridService.cs
index 88ac5b3..e1a3cef 100644
--- a/OpenSim/Services/Interfaces/IGridService.cs
+++ b/OpenSim/Services/Interfaces/IGridService.cs
@@ -168,12 +168,12 @@ namespace OpenSim.Services.Interfaces
        /// <summary>
        /// The co-ordinate of this region.
        /// </summary>
-        public int RegionCoordX { get { return RegionLocX / (int)Constants.RegionSize; } }
+        public int RegionCoordX { get { return (int)Util.WorldToRegionLoc((uint)RegionLocX); } }
        /// <summary>
        /// The co-ordinate of this region
        /// </summary>
-        public int RegionCoordY { get { return RegionLocY / (int)Constants.RegionSize; } }
+        public int RegionCoordY { get { return (int)Util.WorldToRegionLoc((uint)RegionLocY); } }
        /// <summary>
        /// The location of this region in meters.
@@ -185,6 +185,9 @@ namespace OpenSim.Services.Interfaces
        }
        protected int m_regionLocX;
+        public int RegionSizeX { get; set; }
+        public int RegionSizeY { get; set; }
        /// <summary>
        /// The location of this region in meters.
        /// </summary>
@@ -222,6 +225,8 @@ namespace OpenSim.Services.Interfaces
        {
            m_regionLocX = regionLocX;
            m_regionLocY = regionLocY;
+            RegionSizeX = (int)Constants.RegionSize;
+            RegionSizeY = (int)Constants.RegionSize;
            m_internalEndPoint = internalEndPoint;
            m_externalHostName = externalUri;
@@ -231,6 +236,8 @@ namespace OpenSim.Services.Interfaces
        {
            m_regionLocX = regionLocX;
            m_regionLocY = regionLocY;
+            RegionSizeX = (int)Constants.RegionSize;
+            RegionSizeY = (int)Constants.RegionSize;
            m_externalHostName = externalUri;
@@ -239,15 +246,19 @@ namespace OpenSim.Services.Interfaces
        public GridRegion(uint xcell, uint ycell)
        {
-            m_regionLocX = (int)(xcell * Constants.RegionSize);
+            m_regionLocX = (int)Util.RegionToWorldLoc(xcell);
-            m_regionLocY = (int)(ycell * Constants.RegionSize);
+            m_regionLocY = (int)Util.RegionToWorldLoc(ycell);
+            RegionSizeX = (int)Constants.RegionSize;
+            RegionSizeY = (int)Constants.RegionSize;
        }
        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);
+            RegionSizeX = (int)ConvertFrom.RegionSizeX;
+            RegionSizeY = (int)ConvertFrom.RegionSizeY;
            m_internalEndPoint = ConvertFrom.InternalEndPoint;
            m_externalHostName = ConvertFrom.ExternalHostName;
            m_httpPort = ConvertFrom.HttpPort;
@@ -266,6 +277,8 @@ namespace OpenSim.Services.Interfaces
            m_regionName = ConvertFrom.RegionName;
            m_regionLocX = ConvertFrom.RegionLocX;
            m_regionLocY = ConvertFrom.RegionLocY;
+            RegionSizeX = ConvertFrom.RegionSizeX;
+            RegionSizeY = ConvertFrom.RegionSizeY;
            m_internalEndPoint = ConvertFrom.InternalEndPoint;
            m_externalHostName = ConvertFrom.ExternalHostName;
            m_httpPort = ConvertFrom.HttpPort;
@@ -373,6 +386,8 @@ namespace OpenSim.Services.Interfaces
            kvp["uuid"] = RegionID.ToString();
            kvp["locX"] = RegionLocX.ToString();
            kvp["locY"] = RegionLocY.ToString();
+            kvp["sizeX"] = RegionSizeX.ToString();
+            kvp["sizeY"] = RegionSizeY.ToString();
            kvp["regionName"] = RegionName;
            kvp["serverIP"] = ExternalHostName; //ExternalEndPoint.Address.ToString();
            kvp["serverHttpPort"] = HttpPort.ToString();
@@ -399,6 +414,12 @@ namespace OpenSim.Services.Interfaces
            if (kvp.ContainsKey("locY"))
                RegionLocY = Convert.ToInt32((string)kvp["locY"]);
+            if (kvp.ContainsKey("sizeX"))
+                RegionSizeX = Convert.ToInt32((string)kvp["sizeX"]);
+            if (kvp.ContainsKey("sizeY"))
+                RegionSizeY = Convert.ToInt32((string)kvp["sizeY"]);
            if (kvp.ContainsKey("regionName"))
                RegionName = (string)kvp["regionName"];
diff --git a/OpenSim/Services/LLLoginService/LLLoginResponse.cs b/OpenSim/Services/LLLoginService/LLLoginResponse.cs
index 6ab5258..ff51f09 100644
--- a/OpenSim/Services/LLLoginService/LLLoginResponse.cs
+++ b/OpenSim/Services/LLLoginService/LLLoginResponse.cs
@@ -254,11 +254,12 @@ namespace OpenSim.Services.LLLoginService
            Currency = currency;
            ClassifiedFee = classifiedFee;
            FillOutHomeData(pinfo, home);
            LookAt = String.Format("[r{0},r{1},r{2}]", lookAt.X, lookAt.Y, lookAt.Z);
            FillOutRegionData(destination);
+            m_log.DebugFormat("[LOGIN RESPONSE] LLLoginResponse create. sizeX={0}, sizeY={1}", RegionSizeX, RegionSizeY);
+            Util.PrintCallStack();
            FillOutSeedCap(aCircuit, destination, clientIP);
@@ -361,7 +362,9 @@ namespace OpenSim.Services.LLLoginService
        private void FillOutHomeData(GridUserInfo pinfo, GridRegion home)
        {
-            int x = 1000 * (int)Constants.RegionSize, y = 1000 * (int)Constants.RegionSize;
+            // int x = 1000 * (int)Constants.RegionSize, y = 1000 * (int)Constants.RegionSize;
+            int x = (int)Util.RegionToWorldLoc(1000);
+            int y = (int)Util.RegionToWorldLoc(1000);
            if (home != null)
            {
                x = home.RegionLocX;
@@ -384,6 +387,8 @@ namespace OpenSim.Services.LLLoginService
            SimPort = (uint)endPoint.Port;
            RegionX = (uint)destination.RegionLocX;
            RegionY = (uint)destination.RegionLocY;
+            RegionSizeX = destination.RegionSizeX;
+            RegionSizeY = destination.RegionSizeY;
        }
        private void FillOutSeedCap(AgentCircuitData aCircuit, GridRegion destination, IPEndPoint ipepClient)
@@ -433,10 +438,23 @@ namespace OpenSim.Services.LLLoginService
            ErrorReason = "key";
            welcomeMessage = "Welcome to OpenSim!";
            seedCapability = String.Empty;
-            home = "{'region_handle':[r" + (1000*Constants.RegionSize).ToString() + ",r" + (1000*Constants.RegionSize).ToString() + "], 'position':[r" +
+            home = "{'region_handle':[r" 
-                   userProfile.homepos.X.ToString() + ",r" + userProfile.homepos.Y.ToString() + ",r" +
+                    + Util.RegionToWorldLoc(1000).ToString()
-                   userProfile.homepos.Z.ToString() + "], 'look_at':[r" + userProfile.homelookat.X.ToString() + ",r" +
+                    + ",r"
-                   userProfile.homelookat.Y.ToString() + ",r" + userProfile.homelookat.Z.ToString() + "]}";
+                    + Util.RegionToWorldLoc(1000).ToString()
+                    + "], 'position':[r"
+                    + userProfile.homepos.X.ToString()
+                    + ",r"
+                    + userProfile.homepos.Y.ToString()
+                    + ",r"
+                    + userProfile.homepos.Z.ToString()
+                    + "], 'look_at':[r"
+                    + userProfile.homelookat.X.ToString()
+                    + ",r"
+                    + userProfile.homelookat.Y.ToString()
+                    + ",r"
+                    + userProfile.homelookat.Z.ToString()
+                    + "]}";
            lookAt = "[r0.99949799999999999756,r0.03166859999999999814,r0]";
            RegionX = (uint) 255232;
            RegionY = (uint) 254976;
@@ -529,6 +547,9 @@ namespace OpenSim.Services.LLLoginService
                responseData["message"] = welcomeMessage;
                responseData["region_x"] = (Int32)(RegionX);
                responseData["region_y"] = (Int32)(RegionY);
+                responseData["region_size_x"] = (Int32)RegionSizeX;
+                responseData["region_size_y"] = (Int32)RegionSizeY;
+                m_log.DebugFormat("[LOGIN RESPONSE] returning sizeX={0}, sizeY={1}", RegionSizeX, RegionSizeY);
                if (searchURL != String.Empty)
                    responseData["search"] = searchURL;
@@ -918,6 +939,9 @@ namespace OpenSim.Services.LLLoginService
            set { regionY = value; }
        }
+        public int RegionSizeX { get; private set; }
+        public int RegionSizeY { get; private set; }
        public string SunTexture
        {
            get { return sunTexture; }
diff --git a/OpenSim/Services/LLLoginService/LLLoginService.cs b/OpenSim/Services/LLLoginService/LLLoginService.cs
index fe43582..150c2c0 100644
--- a/OpenSim/Services/LLLoginService/LLLoginService.cs
+++ b/OpenSim/Services/LLLoginService/LLLoginService.cs
@@ -50,6 +50,8 @@ namespace OpenSim.Services.LLLoginService
    public class LLLoginService : ILoginService
    {
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly string LogHeader = "[LLOGIN SERVICE]";
        private static bool Initialized = false;
        protected IUserAccountService m_UserAccountService;
@@ -389,6 +391,7 @@ namespace OpenSim.Services.LLLoginService
                if (guinfo == null)
                {
                    // something went wrong, make something up, so that we don't have to test this anywhere else
+                    m_log.DebugFormat("{0} Failed to fetch GridUserInfo. Creating empty GridUserInfo as home", LogHeader);
                    guinfo = new GridUserInfo();
                    guinfo.LastPosition = guinfo.HomePosition = new Vector3(128, 128, 30);
                }
@@ -681,7 +684,7 @@ namespace OpenSim.Services.LLLoginService
        private GridRegion FindAlternativeRegion(UUID scopeID)
        {
            List<GridRegion> hyperlinks = null;
-            List<GridRegion> regions = m_GridService.GetFallbackRegions(scopeID, 1000 * (int)Constants.RegionSize, 1000 * (int)Constants.RegionSize);
+            List<GridRegion> regions = m_GridService.GetFallbackRegions(scopeID, (int)Util.RegionToWorldLoc(1000), (int)Util.RegionToWorldLoc(1000));
            if (regions != null && regions.Count > 0)
            {
                hyperlinks = m_GridService.GetHyperlinks(scopeID);
diff --git a/OpenSim/Tests/Common/Helpers/EntityTransferHelpers.cs b/OpenSim/Tests/Common/Helpers/EntityTransferHelpers.cs
index 52a17e7..049200c 100644
--- a/OpenSim/Tests/Common/Helpers/EntityTransferHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/EntityTransferHelpers.cs
@@ -69,9 +69,7 @@ namespace OpenSim.Tests.Common
            tc.OnTestClientInformClientOfNeighbour += (neighbourHandle, neighbourExternalEndPoint) =>
            {
                uint x, y;
-                Utils.LongToUInts(neighbourHandle, out x, out y);
+                Util.RegionHandleToRegionLoc(neighbourHandle, out x, out y);
-                x /= Constants.RegionSize;
-                y /= Constants.RegionSize;
                m_log.DebugFormat(
                    "[TEST CLIENT]: Processing inform client of neighbour located at {0},{1} at {2}", 
@@ -104,9 +102,7 @@ namespace OpenSim.Tests.Common
                += (regionHandle, simAccess, regionExternalEndPoint, locationID, flags, capsURL) =>
            {
                uint x, y;
-                Utils.LongToUInts(regionHandle, out x, out y);
+                Util.RegionHandleToRegionLoc(regionHandle, out x, out y);
-                x /= Constants.RegionSize;
-                y /= Constants.RegionSize;
                m_log.DebugFormat(
                    "[TEST CLIENT]: Processing send region teleport for destination at {0},{1} at {2}", 
diff --git a/OpenSim/Tests/Common/Helpers/SceneHelpers.cs b/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
index 4cdfe98..008f2d0 100644
--- a/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
+++ b/OpenSim/Tests/Common/Helpers/SceneHelpers.cs
@@ -186,8 +186,9 @@ namespace OpenSim.Tests.Common
            PhysicsPluginManager physicsPluginManager = new PhysicsPluginManager();
            physicsPluginManager.LoadPluginsFromAssembly("Physics/OpenSim.Region.Physics.BasicPhysicsPlugin.dll");
+            Vector3 regionExtent = new Vector3( regInfo.RegionSizeX, regInfo.RegionSizeY, regInfo.RegionSizeZ);
            testScene.PhysicsScene
-                = physicsPluginManager.GetPhysicsScene("basicphysics", "ZeroMesher", new IniConfigSource(), "test");
+                = physicsPluginManager.GetPhysicsScene("basicphysics", "ZeroMesher", new IniConfigSource(), "test", regionExtent);
            testScene.RegionInfo.EstateSettings = new EstateSettings();
            testScene.LoginsEnabled = true;
diff --git a/OpenSim/Tests/Common/Mock/MockRegionDataPlugin.cs b/OpenSim/Tests/Common/Mock/MockRegionDataPlugin.cs
index ed29c39..5df8e04 100644
--- a/OpenSim/Tests/Common/Mock/MockRegionDataPlugin.cs
+++ b/OpenSim/Tests/Common/Mock/MockRegionDataPlugin.cs
@@ -69,11 +69,21 @@ namespace OpenSim.Data.Null
            m_store.StoreTerrain(terrain, regionID);
        }
+        public void StoreTerrain(TerrainData terrain, UUID regionID)
+        {
+            m_store.StoreTerrain(terrain, regionID);
+        }
        public double[,] LoadTerrain(UUID regionID)
        {
            return m_store.LoadTerrain(regionID);
        }
+        public TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ)
+        {
+            return m_store.LoadTerrain(regionID, pSizeX, pSizeY, pSizeZ);
+        }
        public void StoreLandObject(ILandObject Parcel)
        {
            m_store.StoreLandObject(Parcel);
@@ -154,7 +164,7 @@ namespace OpenSim.Data.Null
        protected Dictionary<UUID, SceneObjectPart> m_sceneObjectParts = new Dictionary<UUID, SceneObjectPart>();
        protected Dictionary<UUID, ICollection<TaskInventoryItem>> m_primItems 
            = new Dictionary<UUID, ICollection<TaskInventoryItem>>();
-        protected Dictionary<UUID, double[,]> m_terrains = new Dictionary<UUID, double[,]>();
+        protected Dictionary<UUID, TerrainData> m_terrains = new Dictionary<UUID, TerrainData>();
        protected Dictionary<UUID, LandData> m_landData = new Dictionary<UUID, LandData>();
        
        public void Initialise(string dbfile)
@@ -299,12 +309,17 @@ namespace OpenSim.Data.Null
            return new List<SceneObjectGroup>(objects.Values);
        }
-        public void StoreTerrain(double[,] ter, UUID regionID)
+        public void StoreTerrain(TerrainData ter, UUID regionID)
        {
            m_terrains[regionID] = ter;
        }
-        public double[,] LoadTerrain(UUID regionID)
+        public void StoreTerrain(double[,] ter, UUID regionID)
+        {
+            m_terrains[regionID] = new HeightmapTerrainData(ter);
+        }
+        public TerrainData LoadTerrain(UUID regionID, int pSizeX, int pSizeY, int pSizeZ)
        {
            if (m_terrains.ContainsKey(regionID))
                return m_terrains[regionID];
@@ -312,6 +327,14 @@ namespace OpenSim.Data.Null
                return null;
        }
+        public double[,] LoadTerrain(UUID regionID)
+        {
+            if (m_terrains.ContainsKey(regionID))
+                return m_terrains[regionID].GetDoubles();
+            else
+                return null;
+        }
        public void RemoveLandObject(UUID globalID)
        {
            if (m_landData.ContainsKey(globalID))