88 files changed, 3476 insertions, 1720 deletions
diff --git a/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs b/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs
index 811781c..3cdf8d3 100644
--- a/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs
+++ b/OpenSim/ApplicationPlugins/RemoteController/RemoteAdminPlugin.cs
@@ -1022,7 +1022,7 @@ namespace OpenSim.ApplicationPlugins.RemoteController
                    // Set home position
                    GridRegion home = scene.GridService.GetRegionByPosition(scopeID, 
-                        (int)(regionXLocation * Constants.RegionSize), (int)(regionYLocation * Constants.RegionSize));
+                                        (int)Util.RegionToWorldLoc(regionXLocation), (int)Util.RegionToWorldLoc(regionYLocation));
                    if (null == home)
                    {
                        m_log.WarnFormat("[RADMIN]: Unable to set home region for newly created user account {0} {1}", firstName, lastName);
@@ -1252,7 +1252,7 @@ namespace OpenSim.ApplicationPlugins.RemoteController
                    if ((null != regionXLocation) && (null != regionYLocation))
                    {
                        GridRegion home = scene.GridService.GetRegionByPosition(scopeID, 
-                            (int)(regionXLocation * Constants.RegionSize), (int)(regionYLocation * Constants.RegionSize));
+                                        (int)Util.RegionToWorldLoc((uint)regionXLocation), (int)Util.RegionToWorldLoc((uint)regionYLocation));
                        if (null == home) {
                            m_log.WarnFormat("[RADMIN]: Unable to set home region for updated user account {0} {1}", firstName, lastName);
                        } else {
@@ -2881,7 +2881,7 @@ namespace OpenSim.ApplicationPlugins.RemoteController
                            // Set home position
                            GridRegion home = scene.GridService.GetRegionByPosition(scopeID, 
-                                (int)(regionXLocation * Constants.RegionSize), (int)(regionYLocation * Constants.RegionSize));
+                                        (int)Util.RegionToWorldLoc(regionXLocation), (int)Util.RegionToWorldLoc(regionYLocation));
                            if (null == home) {
                                m_log.WarnFormat("[RADMIN]: Unable to set home region for newly created user account {0} {1}", names[0], names[1]);
                            } else {
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 354d749..1505f87 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>
@@ -1350,30 +1365,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/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/Region/Application/OpenSimBase.cs b/OpenSim/Region/Application/OpenSimBase.cs
index 308638c..0dc9306 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);
@@ -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/Caps/EventQueue/EventQueueGetModule.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
index a05e88c..f98337d 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueGetModule.cs
@@ -59,6 +59,7 @@ namespace OpenSim.Region.ClientStack.Linden
    public class EventQueueGetModule : IEventQueue, INonSharedRegionModule
    {
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[EVENT QUEUE GET MODULE]";
        /// <value>
        /// Debug level.
@@ -714,7 +715,7 @@ namespace OpenSim.Region.ClientStack.Linden
        public virtual void EnableSimulator(ulong handle, IPEndPoint endPoint, UUID avatarID, int regionSizeX, int regionSizeY)
        {
            m_log.DebugFormat("{0} EnableSimulator. handle={1}, avatarID={2}, regionSize={3},{4}>",
-                "[EVENT QUEUE GET MODULE]", handle, avatarID, regionSizeX, regionSizeY);
+                LogHeader, handle, avatarID, regionSizeX, regionSizeY);
            OSD item = EventQueueHelper.EnableSimulator(handle, endPoint, regionSizeX, regionSizeY);
            Enqueue(item, avatarID);
@@ -724,7 +725,7 @@ namespace OpenSim.Region.ClientStack.Linden
                                ulong regionHandle, int regionSizeX, int regionSizeY) 
        {
            m_log.DebugFormat("{0} EstablishAgentCommunication. handle={1}, avatarID={2}, regionSize={3},{4}>",
-                "[EVENT QUEUE GET MODULE]", regionHandle, avatarID, regionSizeX, regionSizeY);
+                LogHeader, regionHandle, avatarID, regionSizeX, regionSizeY);
            OSD item = EventQueueHelper.EstablishAgentCommunication(avatarID, endPoint.ToString(), capsPath, regionHandle, regionSizeX, regionSizeY);
            Enqueue(item, avatarID);
        }
@@ -734,8 +735,8 @@ namespace OpenSim.Region.ClientStack.Linden
                                        uint locationID, uint flags, string capsURL, 
                                        UUID avatarID, int regionSizeX, int regionSizeY)
        {
-            m_log.DebugFormat("{0} TeleportFinishEvent. handle={1}, avatarID={2}, regionSize={3},{4}>",
+            m_log.DebugFormat("{0} TeleportFinishEvent. handle={1}, avatarID={2}, regionSize=<{3},{4}>",
-                "[EVENT QUEUE GET MODULE]", regionHandle, avatarID, regionSizeX, regionSizeY);
+                LogHeader, regionHandle, avatarID, regionSizeX, regionSizeY);
            OSD item = EventQueueHelper.TeleportFinishEvent(regionHandle, simAccess, regionExternalEndPoint,
                                                            locationID, flags, capsURL, avatarID, regionSizeX, regionSizeY);
@@ -747,7 +748,7 @@ namespace OpenSim.Region.ClientStack.Linden
                                string capsURL, UUID avatarID, UUID sessionID, int regionSizeX, int regionSizeY)
        {
            m_log.DebugFormat("{0} CrossRegion. handle={1}, avatarID={2}, regionSize={3},{4}>",
-                "[EVENT QUEUE GET MODULE]", handle, avatarID, regionSizeX, regionSizeY);
+                LogHeader, handle, avatarID, regionSizeX, regionSizeY);
            OSD item = EventQueueHelper.CrossRegion(handle, pos, lookAt, newRegionExternalEndPoint,
                                                    capsURL, avatarID, sessionID, regionSizeX, regionSizeY);
diff --git a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
index ded228d..384af74 100644
--- a/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
+++ b/OpenSim/Region/ClientStack/Linden/Caps/EventQueue/EventQueueHelper.cs
@@ -77,8 +77,8 @@ namespace OpenSim.Region.ClientStack.Linden
            llsdSimInfo.Add("Handle", new OSDBinary(ulongToByteArray(handle)));
            llsdSimInfo.Add("IP", new OSDBinary(endPoint.Address.GetAddressBytes()));
            llsdSimInfo.Add("Port", new OSDInteger(endPoint.Port));
-            llsdSimInfo.Add("RegionSizeX", new OSDInteger(regionSizeX));
+            llsdSimInfo.Add("RegionSizeX", OSD.FromUInteger((uint) regionSizeX));
-            llsdSimInfo.Add("RegionSizeY", new OSDInteger(regionSizeY));
+            llsdSimInfo.Add("RegionSizeY", OSD.FromUInteger((uint) regionSizeY));
            OSDArray arr = new OSDArray(1);
            arr.Add(llsdSimInfo);
@@ -138,8 +138,8 @@ namespace OpenSim.Region.ClientStack.Linden
            regionDataMap.Add("SeedCapability", OSD.FromString(capsURL));
            regionDataMap.Add("SimIP", OSD.FromBinary(newRegionExternalEndPoint.Address.GetAddressBytes()));
            regionDataMap.Add("SimPort", OSD.FromInteger(newRegionExternalEndPoint.Port));
-            regionDataMap.Add("RegionSizeX", new OSDInteger(regionSizeX));
+            regionDataMap.Add("RegionSizeX", OSD.FromUInteger((uint)regionSizeX));
-            regionDataMap.Add("RegionSizeY", new OSDInteger(regionSizeY));
+            regionDataMap.Add("RegionSizeY", OSD.FromUInteger((uint)regionSizeY));
            OSDArray regionDataArr = new OSDArray(1);
            regionDataArr.Add(regionDataMap);
@@ -166,8 +166,8 @@ namespace OpenSim.Region.ClientStack.Linden
            info.Add("SimIP", OSD.FromBinary(regionExternalEndPoint.Address.GetAddressBytes()));
            info.Add("SimPort", OSD.FromInteger(regionExternalEndPoint.Port));
            info.Add("TeleportFlags", OSD.FromULong(1L << 4)); // AgentManager.TeleportFlags.ViaLocation
-            info.Add("RegionSizeX", new OSDInteger(regionSizeX));
+            info.Add("RegionSizeX", OSD.FromUInteger((uint)regionSizeX));
-            info.Add("RegionSizeY", new OSDInteger(regionSizeY));
+            info.Add("RegionSizeY", OSD.FromUInteger((uint)regionSizeY));
            OSDArray infoArr = new OSDArray();
            infoArr.Add(info);
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index 3a0ddae..6861f5b 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>
@@ -2785,8 +2757,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;
            }
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/Agent/TextureSender/J2KDecoderModule.cs b/OpenSim/Region/CoreModules/Agent/TextureSender/J2KDecoderModule.cs
index d9b0eff..732781a 100644
--- a/OpenSim/Region/CoreModules/Agent/TextureSender/J2KDecoderModule.cs
+++ b/OpenSim/Region/CoreModules/Agent/TextureSender/J2KDecoderModule.cs
@@ -27,6 +27,7 @@
 using System;
 using System.Collections.Generic;
+using System.Drawing;
 using System.IO;
 using System.Reflection;
 using System.Text;
@@ -182,6 +183,25 @@ namespace OpenSim.Region.CoreModules.Agent.TextureSender
            return DoJ2KDecode(assetID, j2kData, out layers, out components);
        }
+        public Image DecodeToImage(byte[] j2kData)
+        {
+            if (m_useCSJ2K)
+                return J2kImage.FromBytes(j2kData);
+            else
+            {
+                ManagedImage mimage;
+                Image image;
+                if (OpenJPEG.DecodeToImage(j2kData, out mimage, out image))
+                {
+                    mimage = null;
+                    return image;
+                }
+                else
+                    return null;
+            }
+        }
        #endregion IJ2KDecoder
        /// <summary>
diff --git a/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs b/OpenSim/Region/CoreModules/Avatar/Chat/ChatModule.cs
index 27ace68..10122e6 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.WorldLocX, scene.RegionInfo.WorldLocY, 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.WorldLocX, presence.Scene.RegionInfo.WorldLocY, 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 bfa30e6..7e50cc6 100644
--- a/OpenSim/Region/CoreModules/Avatar/UserProfiles/UserProfileModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/UserProfiles/UserProfileModule.cs
@@ -667,8 +667,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.WorldLocX + avaPos.X,
-                                            remoteClient.Scene.RegionInfo.RegionLocY*Constants.RegionSize + avaPos.Y,
+                                            remoteClient.Scene.RegionInfo.WorldLocY + 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 5fea0cf..85e8159 100644
--- a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
@@ -51,7 +51,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
    [Extension(Path = "/OpenSim/RegionModules", NodeName = "RegionModule", Id = "EntityTransferModule")]
    public class EntityTransferModule : INonSharedRegionModule, IEntityTransferModule
    {
-        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
        private static readonly string LogHeader = "[ENTITY TRANSFER MODULE]";
        public const int DefaultMaxTransferDistance = 4095;
@@ -121,8 +121,53 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
        /// </summary>
        private EntityTransferStateMachine m_entityTransferStateMachine;
-        private ExpiringCache<UUID, ExpiringCache<ulong, DateTime>> m_bannedRegions =
+        // For performance, we keed a cached of banned regions so we don't keep going
-                new ExpiringCache<UUID, ExpiringCache<ulong, DateTime>>();
+        //    to the grid service.
+        private class BannedRegionCache
+        {
+            private ExpiringCache<UUID, ExpiringCache<ulong, DateTime>> m_bannedRegions =
+                    new ExpiringCache<UUID, ExpiringCache<ulong, DateTime>>();
+            ExpiringCache<ulong, DateTime> m_idCache;
+            DateTime m_banUntil;
+            public BannedRegionCache()
+            {
+            }
+            // Return 'true' if there is a valid ban entry for this agent in this region
+            public bool IfBanned(ulong pRegionHandle, UUID pAgentID)
+            {
+                bool ret = false;
+                if (m_bannedRegions.TryGetValue(pAgentID, out m_idCache))
+                {
+                    if (m_idCache.TryGetValue(pRegionHandle, out m_banUntil))
+                    {
+                        if (DateTime.Now < m_banUntil)
+                        {
+                            ret = true;
+                        }
+                    }
+                }
+                return ret;
+            }
+            // Add this agent in this region as a banned person
+            public void Add(ulong pRegionHandle, UUID pAgentID)
+            {
+                if (!m_bannedRegions.TryGetValue(pAgentID, out m_idCache))
+                {
+                    m_idCache = new ExpiringCache<ulong, DateTime>();
+                    m_bannedRegions.Add(pAgentID, m_idCache, TimeSpan.FromSeconds(45));
+                }
+                m_idCache.Add(pRegionHandle, DateTime.Now + TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(15));
+            }
+            // Remove the agent from the region's banned list
+            public void Remove(ulong pRegionHandle, UUID pAgentID)
+            {
+                if (m_bannedRegions.TryGetValue(pAgentID, out m_idCache))
+                {
+                    m_idCache.Remove(pRegionHandle);
+                }
+            }
+        }
+        private BannedRegionCache m_bannedRegionCache = new BannedRegionCache();
        private IEventQueue m_eqModule;
        private IRegionCombinerModule m_regionCombinerModule;
@@ -337,6 +382,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                "[ENTITY TRANSFER MODULE]: Received teleport cancel request from {0} in {1}", client.Name, Scene.Name);
        }
+        // Attempt to teleport the ScenePresence to the specified position in the specified region (spec'ed by its handle).
        public void Teleport(ScenePresence sp, ulong regionHandle, Vector3 position, Vector3 lookAt, uint teleportFlags)
        {
            if (sp.Scene.Permissions.IsGridGod(sp.UUID))
@@ -434,10 +480,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
            float posZLimit = 22;
            // TODO: Check other Scene HeightField
-            if (position.X > 0 && position.X <= (int)Constants.RegionSize && position.Y > 0 && position.Y <= (int)Constants.RegionSize)
+            posZLimit = (float)sp.Scene.Heightmap[(int)position.X, (int)position.Y];
-            {
-                posZLimit = (float)sp.Scene.Heightmap[(int)position.X, (int)position.Y];
-            }
            float newPosZ = posZLimit + localAVHeight;
            if (posZLimit >= (position.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ)))
@@ -481,7 +524,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
            Vector3 lookAt, uint teleportFlags, out GridRegion finalDestination)
        {
            uint x = 0, y = 0;
-            Utils.LongToUInts(regionHandle, out x, out y);
+            Util.RegionHandleToWorldLoc(regionHandle, out x, out y);
            GridRegion reg = Scene.GridService.GetRegionByPosition(sp.Scene.RegionInfo.ScopeID, (int)x, (int)y);
            if (reg != null)
@@ -490,9 +533,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                if (finalDestination == null)
                {
-                    m_log.WarnFormat(
+                    m_log.WarnFormat( "{0} Final destination is having problems. Unable to teleport {1} {2}",
-                        "[ENTITY TRANSFER MODULE]: Final destination is having problems. Unable to teleport {0} {1}",
+                                            LogHeader, sp.Name, sp.UUID);
-                        sp.Name, sp.UUID);
                    sp.ControllingClient.SendTeleportFailed("Problem at destination");
                    return;
@@ -533,11 +575,11 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                // and set the map-tile to '(Offline)'
                uint regX, regY;
-                Utils.LongToUInts(regionHandle, out regX, out regY);
+                Util.RegionHandleToRegionLoc(regionHandle, out regX, out regY);
                MapBlockData block = new MapBlockData();
-                block.X = (ushort)(regX / Constants.RegionSize);
+                block.X = (ushort)regX;
-                block.Y = (ushort)(regY / Constants.RegionSize);
+                block.Y = (ushort)regY;
                block.Access = 254; // == not there
                List<MapBlockData> blocks = new List<MapBlockData>();
@@ -1349,6 +1391,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                if (uinfo.HomeRegionID == UUID.Zero)
                {
                    // can't find the Home region: Tell viewer and abort
+                    m_log.ErrorFormat("{0} No grid user info found for {1} {2}. Cannot send home.",
+                                    LogHeader, client.Name, client.AgentId);
                    client.SendTeleportFailed("You don't have a home position set.");
                    return false;
                }
@@ -1382,7 +1426,11 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
        #region Agent Crossings
-        public GridRegion GetDestination(Scene scene, UUID agentID, Vector3 pos, out uint xDest, out uint yDest, out string version, out Vector3 newpos)
+        // Given a position relative to the current region (which has previously been tested to
+        //    see that it is actually outside the current region), find the new region that the
+        //    point is actually in.
+        // Returns the coordinates and information of the new region or 'null' of it doesn't exist.
+        public GridRegion GetDestination(Scene scene, UUID agentID, Vector3 pos, out string version, out Vector3 newpos)
        {
            version = String.Empty;
            newpos = pos;
@@ -1390,131 +1438,54 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 //            m_log.DebugFormat(
 //                "[ENTITY TRANSFER MODULE]: Crossing agent {0} at pos {1} in {2}", agent.Name, pos, scene.Name);
-            uint neighbourx = scene.RegionInfo.RegionLocX;
+            // Compute world location of the object's position
-            uint neighboury = scene.RegionInfo.RegionLocY;
+            double presenceWorldX = (double)scene.RegionInfo.WorldLocX + pos.X;
-            const float boundaryDistance = 1.7f;
+            double presenceWorldY = (double)scene.RegionInfo.WorldLocY + pos.Y;
-            Vector3 northCross = new Vector3(0, boundaryDistance, 0);
-            Vector3 southCross = new Vector3(0, -1 * boundaryDistance, 0);
-            Vector3 eastCross = new Vector3(boundaryDistance, 0, 0);
-            Vector3 westCross = new Vector3(-1 * boundaryDistance, 0, 0);
-            // distance into new region to place avatar
+            // Call the grid service to lookup the region containing the new position.
-            const float enterDistance = 0.5f;
+            GridRegion neighbourRegion = GetRegionContainingWorldLocation(scene.GridService, scene.RegionInfo.ScopeID,
+                                                        presenceWorldX, presenceWorldY, 
+                                                        Math.Max(scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY));
-            if (scene.TestBorderCross(pos + westCross, Cardinals.W))
+            if (neighbourRegion != null)
            {
-                if (scene.TestBorderCross(pos + northCross, Cardinals.N))
+                // Compute the entity's position relative to the new region
-                {
+                newpos = new Vector3( (float)(presenceWorldX - (double)neighbourRegion.RegionLocX),
-                    Border b = scene.GetCrossedBorder(pos + northCross, Cardinals.N);
+                                      (float)(presenceWorldY - (double)neighbourRegion.RegionLocY),
-                    neighboury += (uint)(int)(b.BorderLine.Z / (int)Constants.RegionSize);
+                                      pos.Z);
-                }
-                else if (scene.TestBorderCross(pos + southCross, Cardinals.S))
-                {
-                    neighboury--;
-                    newpos.Y = Constants.RegionSize - enterDistance;
-                }
-                neighbourx--;
-                newpos.X = Constants.RegionSize - enterDistance;
-            }
-            else if (scene.TestBorderCross(pos + eastCross, Cardinals.E))
-            {
-                Border b = scene.GetCrossedBorder(pos + eastCross, Cardinals.E);
-                neighbourx += (uint)(int)(b.BorderLine.Z / (int)Constants.RegionSize);
-                newpos.X = enterDistance;
-                if (scene.TestBorderCross(pos + southCross, Cardinals.S))
+                if (m_bannedRegionCache.IfBanned(neighbourRegion.RegionHandle, agentID))
                {
-                    neighboury--;
+                    neighbourRegion = null;
-                    newpos.Y = Constants.RegionSize - enterDistance;
                }
-                else if (scene.TestBorderCross(pos + northCross, Cardinals.N))
+                else
                {
-                    Border c = scene.GetCrossedBorder(pos + northCross, Cardinals.N);
+                    // If not banned, make sure this agent is not in the list.
-                    neighboury += (uint)(int)(c.BorderLine.Z / (int)Constants.RegionSize);
+                    m_bannedRegionCache.Remove(neighbourRegion.RegionHandle, agentID);
-                    newpos.Y = enterDistance;
                }
-            }
-            else if (scene.TestBorderCross(pos + southCross, Cardinals.S))
-            {
-                Border b = scene.GetCrossedBorder(pos + southCross, Cardinals.S);
-                neighboury--;
-                newpos.Y = Constants.RegionSize - enterDistance;
-            }
-            else if (scene.TestBorderCross(pos + northCross, Cardinals.N))
-            {
-                Border b = scene.GetCrossedBorder(pos + northCross, Cardinals.N);
-                neighboury += (uint)(int)(b.BorderLine.Z / (int)Constants.RegionSize);
-                newpos.Y = enterDistance;
-            }
-            /*
-            if (pos.X < boundaryDistance) //West
-            {
-                neighbourx--;
-                newpos.X = Constants.RegionSize - enterDistance;
-            }
-            else if (pos.X > Constants.RegionSize - boundaryDistance) // East
-            {
-                neighbourx++;
-                newpos.X = enterDistance;
-            }
-            if (pos.Y < boundaryDistance) // South
-            {
-                neighboury--;
-                newpos.Y = Constants.RegionSize - enterDistance;
-            }
-            else if (pos.Y > Constants.RegionSize - boundaryDistance) // North
-            {
-                neighboury++;
-                newpos.Y = enterDistance;
-            }
-            */
-            xDest = neighbourx;
-            yDest = neighboury;
-            int x = (int)(neighbourx * Constants.RegionSize), y = (int)(neighboury * Constants.RegionSize);
-            ulong neighbourHandle = Utils.UIntsToLong((uint)x, (uint)y);
+                // Check to see if we have access to the target region.
+                string reason;
-            ExpiringCache<ulong, DateTime> r;
+                if (neighbourRegion != null
-            DateTime banUntil;
+                    && !scene.SimulationService.QueryAccess(neighbourRegion, agentID, newpos, out version, out reason))
-            if (m_bannedRegions.TryGetValue(agentID, out r))
-            {
-                if (r.TryGetValue(neighbourHandle, out banUntil))
                {
-                    if (DateTime.Now < banUntil)
+                    // remember banned
-                        return null;
+                    m_bannedRegionCache.Add(neighbourRegion.RegionHandle, agentID);
-                    r.Remove(neighbourHandle);
+                    neighbourRegion = null;
                }
            }
-            else
-            {
-                r = null;
-            }
-            GridRegion neighbourRegion = scene.GridService.GetRegionByPosition(scene.RegionInfo.ScopeID, (int)x, (int)y);
-            string reason;
+            if (neighbourRegion == null)
-            if (!scene.SimulationService.QueryAccess(neighbourRegion, agentID, newpos, out version, out reason))
+                m_log.DebugFormat("{0} GetDestination: region not found. Old region name={1} at <{2},{3}> of size <{4},{5}>. Old pos={6}",
-            {
+                    LogHeader, scene.RegionInfo.RegionName,
-                if (r == null)
+                    scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY,
-                {
+                    scene.RegionInfo.RegionSizeX, scene.RegionInfo.RegionSizeY,
-                    r = new ExpiringCache<ulong, DateTime>();
+                    pos);
-                    r.Add(neighbourHandle, DateTime.Now + TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(15));
+            else
+                m_log.DebugFormat("{0} GetDestination: new region={1} at <{2},{3}> of size <{4},{5}>, newpos=<{6},{7}>",
-                    m_bannedRegions.Add(agentID, r, TimeSpan.FromSeconds(45));
+                    LogHeader, neighbourRegion.RegionName,
-                }
+                    neighbourRegion.RegionLocX, neighbourRegion.RegionLocY, neighbourRegion.RegionSizeX, neighbourRegion.RegionSizeY,
-                else
+                    newpos.X, newpos.Y);
-                {
-                    r.Add(neighbourHandle, DateTime.Now + TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(15));
-                }
-                return null;
-            }
            return neighbourRegion;
        }
@@ -1526,7 +1497,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
            Vector3 newpos;
            string version;
-            GridRegion neighbourRegion = GetDestination(agent.Scene, agent.UUID, agent.AbsolutePosition, out x, out y, out version, out newpos);
+            GridRegion neighbourRegion = GetDestination(agent.Scene, agent.UUID, agent.AbsolutePosition, out version, out newpos);
            if (neighbourRegion == null)
            {
                agent.ControllingClient.SendAlertMessage("Cannot region cross into banned parcel");
@@ -1568,7 +1539,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
            agent.Scene.RequestTeleportLocation(
                agent.ControllingClient, 
-                Utils.UIntsToLong(regionX * (uint)Constants.RegionSize, regionY * (uint)Constants.RegionSize), 
+                Util.RegionLocToHandle(regionX, regionY),
                position, 
                agent.Lookat, 
                (uint)Constants.TeleportFlags.ViaLocation);
@@ -1578,11 +1549,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
            if (im != null)
            {
                UUID gotoLocation = Util.BuildFakeParcelID(
-                    Util.UIntsToLong(
+                    Util.RegionLocToHandle(regionX, regionY),
-                                              (regionX *
-                                               (uint)Constants.RegionSize),
-                                              (regionY *
-                                               (uint)Constants.RegionSize)),
                    (uint)(int)position.X,
                    (uint)(int)position.Y,
                    (uint)(int)position.Z);
@@ -1635,17 +1602,22 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
        /// Calls an asynchronous method to do so..  so it doesn't lag the sim.
        /// </summary>
        public ScenePresence CrossAgentToNewRegionAsync(
-            ScenePresence agent, Vector3 pos, GridRegion neighbourRegion,
+                                ScenePresence agent, Vector3 pos, GridRegion neighbourRegion,
-            bool isFlying, string version)
+                                bool isFlying, string version)
        {
+            m_log.DebugFormat("{0} CrossAgentToNewRegionAsync: new region={1} at <{2},{3}>. newpos={4}",
+                        LogHeader, neighbourRegion.RegionName, neighbourRegion.RegionLocX, neighbourRegion.RegionLocY, pos);
            if (!CrossAgentToNewRegionPrep(agent, neighbourRegion))
            {
+                m_log.DebugFormat("{0} CrossAgentToNewRegionAsync: prep failed. Resetting transfer state", LogHeader);
                m_entityTransferStateMachine.ResetFromTransit(agent.UUID);
                return agent;
            }
            if (!CrossAgentIntoNewRegionMain(agent, pos, neighbourRegion, isFlying))
            {
+                m_log.DebugFormat("{0} CrossAgentToNewRegionAsync: cross main failed. Resetting transfer state", LogHeader);
                m_entityTransferStateMachine.ResetFromTransit(agent.UUID);
                return agent;
            }
@@ -2038,15 +2010,195 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
            }
        }
+        // Computes the difference between two region bases.
+        // Returns a vector of world coordinates (meters) from base of first region to the second.
+        // The first region is the home region of the passed scene presence.
        Vector3 CalculateOffset(ScenePresence sp, GridRegion neighbour)
        {
-            int rRegionX = (int)sp.Scene.RegionInfo.RegionLocX;
+            /*
-            int rRegionY = (int)sp.Scene.RegionInfo.RegionLocY;
+            int rRegionX = (int)sp.Scene.RegionInfo.LegacyRegionLocX;
+            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;
            int shifty = (rRegionY - tRegionY) * (int)Constants.RegionSize;
            return new Vector3(shiftx, shifty, 0f);
+             */
+            return new Vector3( sp.Scene.RegionInfo.WorldLocX - neighbour.RegionLocX,
+                                sp.Scene.RegionInfo.WorldLocY - neighbour.RegionLocY,
+                                0f);
+        }
+        public GridRegion GetRegionContainingWorldLocation(IGridService pGridService, UUID pScopeID, double px, double py)
+        {
+            // Since we don't know how big the regions could be, we have to search a very large area
+            //    to find possible regions.
+            return GetRegionContainingWorldLocation(pGridService, pScopeID, px, py, Constants.MaximumRegionSize);
+        }
+        #region NotFoundLocationCache class
+        // A collection of not found locations to make future lookups 'not found' lookups quick.
+        // A simple expiring cache that keeps not found locations for some number of seconds.
+        // A 'not found' location is presumed to be anywhere in the minimum sized region that
+        //    contains that point. A conservitive estimate.
+        private class NotFoundLocationCache
+        {
+            private struct NotFoundLocation
+            {
+                public double minX, maxX, minY, maxY;
+                public DateTime expireTime;
+            }
+            private List<NotFoundLocation> m_notFoundLocations = new List<NotFoundLocation>();
+            public NotFoundLocationCache()
+            {
+            }
+            // Add an area to the lost of 'not found' places. The area is the snapped region
+            //    area around the added point.
+            public void Add(double pX, double pY)
+            {
+                lock (m_notFoundLocations)
+                {
+                    if (!LockedContains(pX, pY))
+                    {
+                        NotFoundLocation nfl = new NotFoundLocation();
+                        // A not found location is not found for at least a whole region sized area
+                        nfl.minX = pX - (pX % (double)Constants.RegionSize);
+                        nfl.minY = pY - (pY % (double)Constants.RegionSize);
+                        nfl.maxX = nfl.minX + (double)Constants.RegionSize;
+                        nfl.maxY = nfl.minY + (double)Constants.RegionSize;
+                        nfl.expireTime = DateTime.Now + TimeSpan.FromSeconds(30);
+                        m_notFoundLocations.Add(nfl);
+                    }
+                }
+                
+            }
+            // Test to see of this point is in any of the 'not found' areas.
+            // Return 'true' if the point is found inside the 'not found' areas.
+            public bool Contains(double pX, double pY)
+            {
+                bool ret = false;
+                lock (m_notFoundLocations)
+                    ret = LockedContains(pX, pY);
+                return ret;
+            }
+            private bool LockedContains(double pX, double pY)
+            {
+                bool ret = false;
+                this.DoExpiration();
+                foreach (NotFoundLocation nfl in m_notFoundLocations)
+                {
+                    if (pX >= nfl.minX && pX < nfl.maxX && pY >= nfl.minY && pY < nfl.maxY)
+                    {
+                        ret = true;
+                        break;
+                    }
+                }
+                return ret;
+            }
+            private void DoExpiration()
+            {
+                List<NotFoundLocation> m_toRemove = null;
+                DateTime now = DateTime.Now;
+                foreach (NotFoundLocation nfl in m_notFoundLocations)
+                {
+                    if (nfl.expireTime < now)
+                    {
+                        if (m_toRemove == null)
+                            m_toRemove = new List<NotFoundLocation>();
+                        m_toRemove.Add(nfl);
+                    }
+                }
+                if (m_toRemove != null)
+                {
+                    foreach (NotFoundLocation nfl in m_toRemove)
+                        m_notFoundLocations.Remove(nfl);
+                    m_toRemove.Clear();
+                }
+            }
+        }
+        #endregion // NotFoundLocationCache class
+        private NotFoundLocationCache m_notFoundLocationCache = new NotFoundLocationCache();
+        // Given a world position (fractional meter coordinate), get the GridRegion info for
+        //   the region containing that point.
+        // Someday this should be a method on GridService.
+        // 'pSizeHint' is the size of the source region but since the destination point can be anywhere
+        //     the size of the target region is unknown thus the search area might have to be very large.
+        // Return 'null' if no such region exists.
+        public GridRegion GetRegionContainingWorldLocation(IGridService pGridService, UUID pScopeID,
+                            double px, double py, uint pSizeHint)
+        {
+            m_log.DebugFormat("{0} GetRegionContainingWorldLocation: call, XY=<{1},{2}>", LogHeader, px, py);
+            GridRegion ret = null;
+            const double fudge = 2.0;
+            // One problem with this routine is negative results. That is, this can be called lots of times
+            //   for regions that don't exist. m_notFoundLocationCache remembers 'not found' results so they
+            //   will be quick 'not found's next time.
+            // NotFoundLocationCache is an expiring cache so it will eventually forget about 'not found' and
+            //   thus re-ask the GridService about the location.
+            if (m_notFoundLocationCache.Contains(px, py))
+            {
+                m_log.DebugFormat("{0} GetRegionContainingWorldLocation: Not found via cache. loc=<{1},{2}>", LogHeader, px, py);
+                return null;
+            }
+            // As an optimization, since most regions will be legacy sized regions (256x256), first try to get
+            //   the region at the appropriate legacy region location.
+            uint possibleX = (uint)Math.Floor(px);
+            possibleX -= possibleX % Constants.RegionSize;
+            uint possibleY = (uint)Math.Floor(py);
+            possibleY -= possibleY % Constants.RegionSize;
+            ret = pGridService.GetRegionByPosition(pScopeID, (int)possibleX, (int)possibleY);
+            if (ret != null)
+            {
+                m_log.DebugFormat("{0} GetRegionContainingWorldLocation: Found region using legacy size. rloc=<{1},{2}>. Rname={3}",
+                                    LogHeader, possibleX, possibleY, ret.RegionName);
+            }
+            if (ret == null)
+            {
+                // If the simple lookup failed, search the larger area for a region that contains this point
+                double range = (double)pSizeHint + fudge;
+                while (ret == null && range <= (Constants.MaximumRegionSize + Constants.RegionSize))
+                {
+                    // Get from the grid service a list of regions that might contain this point.
+                    // The region origin will be in the zero direction so only subtract the range.
+                    List<GridRegion> possibleRegions = pGridService.GetRegionRange(pScopeID,
+                                        (int)(px - range), (int)(px),
+                                        (int)(py - range), (int)(py));
+                    m_log.DebugFormat("{0} GetRegionContainingWorldLocation: possibleRegions cnt={1}, range={2}",
+                                        LogHeader, possibleRegions.Count, range);
+                    if (possibleRegions != null && possibleRegions.Count > 0)
+                    {
+                        // If we found some regions, check to see if the point is within
+                        foreach (GridRegion gr in possibleRegions)
+                        {
+                            m_log.DebugFormat("{0} GetRegionContainingWorldLocation: possibleRegion nm={1}, regionLoc=<{2},{3}>, regionSize=<{4},{5}>",
+                                                LogHeader, gr.RegionName, gr.RegionLocX, gr.RegionLocY, gr.RegionSizeX, gr.RegionSizeY);
+                            if (px >= (double)gr.RegionLocX && px < (double)(gr.RegionLocX + gr.RegionSizeX)
+                                && py >= (double)gr.RegionLocY && py < (double)(gr.RegionLocY + gr.RegionSizeY))
+                            {
+                                // Found a region that contains the point
+                                ret = gr;
+                                m_log.DebugFormat("{0} GetRegionContainingWorldLocation: found. RegionName={1}", LogHeader, ret.RegionName);
+                                break;
+                            }
+                        }
+                    }
+                    // Larger search area for next time around if not found
+                    range *= 2;
+                }
+            }
+            if (ret == null)
+            {
+                // remember this location was not found so we can quickly not find it next time
+                m_notFoundLocationCache.Add(px, py);
+                m_log.DebugFormat("{0} GetRegionContainingWorldLocation: Not found. Remembering loc=<{1},{2}>", LogHeader, px, py);
+            }
+            return ret;
        }
        private void InformClientOfNeighbourCompleted(IAsyncResult iar)
@@ -2168,16 +2320,19 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
            // view to include everything in the megaregion
            if (m_regionCombinerModule == null || !m_regionCombinerModule.IsRootForMegaregion(Scene.RegionInfo.RegionID))
            {
-                int dd = avatar.DrawDistance < Constants.RegionSize ? (int)Constants.RegionSize : (int)avatar.DrawDistance;
+                // The area to check is as big as the current region.
+                // We presume all adjacent regions are the same size as this region.
+                uint dd = Math.Max((uint)avatar.DrawDistance, 
+                                Math.Max(Scene.RegionInfo.RegionSizeX, Scene.RegionInfo.RegionSizeY));
-                int startX = (int)pRegionLocX * (int)Constants.RegionSize - dd + (int)(Constants.RegionSize/2);
+                uint startX = Util.RegionToWorldLoc(pRegionLocX) - dd + Constants.RegionSize/2;
-                int startY = (int)pRegionLocY * (int)Constants.RegionSize - dd + (int)(Constants.RegionSize/2);
+                uint startY = Util.RegionToWorldLoc(pRegionLocY) - dd + Constants.RegionSize/2;
-                int endX = (int)pRegionLocX * (int)Constants.RegionSize + dd + (int)(Constants.RegionSize/2);
+                uint endX = Util.RegionToWorldLoc(pRegionLocX) + dd + Constants.RegionSize/2;
-                int endY = (int)pRegionLocY * (int)Constants.RegionSize + dd + (int)(Constants.RegionSize/2);
+                uint endY = Util.RegionToWorldLoc(pRegionLocY) + dd + Constants.RegionSize/2;
                List<GridRegion> neighbours =
-                    avatar.Scene.GridService.GetRegionRange(m_regionInfo.ScopeID, startX, endX, startY, endY);
+                    avatar.Scene.GridService.GetRegionRange(m_regionInfo.ScopeID, (int)startX, (int)endX, (int)startY, (int)endY);
                neighbours.RemoveAll(delegate(GridRegion r) { return r.RegionID == m_regionInfo.RegionID; });
                return neighbours;
@@ -2190,10 +2345,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                List<GridRegion> neighbours 
                    = pScene.GridService.GetRegionRange(
                        m_regionInfo.ScopeID, 
-                        (int)swCorner.X * (int)Constants.RegionSize, 
+                        (int)Util.RegionToWorldLoc((uint)swCorner.X), (int)Util.RegionToWorldLoc((uint)neCorner.X),
-                        (int)neCorner.X * (int)Constants.RegionSize,
+                        (int)Util.RegionToWorldLoc((uint)swCorner.Y), (int)Util.RegionToWorldLoc((uint)neCorner.Y) );
-                        (int)swCorner.Y * (int)Constants.RegionSize,
-                        (int)neCorner.Y * (int)Constants.RegionSize);
                neighbours.RemoveAll(delegate(GridRegion r) { return r.RegionID == m_regionInfo.RegionID; });
@@ -2256,10 +2409,13 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
        /// Move the given scene object into a new region depending on which region its absolute position has moved
        /// into.
        ///
-        /// This method locates the new region handle and offsets the prim position for the new region
+        /// Using the objects new world location, ask the grid service for a the new region and adjust the prim
+        /// position to be relative to the new region.
        /// </summary>
-        /// <param name="attemptedPosition">the attempted out of region position of the scene object</param>
        /// <param name="grp">the scene object that we're crossing</param>
+        /// <param name="attemptedPosition">the attempted out of region position of the scene object. This position is
+        /// relative to the region the object currently is in.</param>
+        /// <param name="silent">if 'true', the deletion of the client from the region is not broadcast to the clients</param>
        public void Cross(SceneObjectGroup grp, Vector3 attemptedPosition, bool silent)
        {
            if (grp == null)
@@ -2285,208 +2441,49 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                return;
            }
-            int thisx = (int)scene.RegionInfo.RegionLocX;
+            // Remember the old group position in case the region lookup fails so position can be restored.
-            int thisy = (int)scene.RegionInfo.RegionLocY;
+            Vector3 oldGroupPosition = grp.RootPart.GroupPosition;
-            Vector3 EastCross = new Vector3(0.1f, 0, 0);
-            Vector3 WestCross = new Vector3(-0.1f, 0, 0);
-            Vector3 NorthCross = new Vector3(0, 0.1f, 0);
-            Vector3 SouthCross = new Vector3(0, -0.1f, 0);
-            // use this if no borders were crossed!
-            ulong newRegionHandle
-                        = Util.UIntsToLong((uint)((thisx) * Constants.RegionSize),
-                                           (uint)((thisy) * Constants.RegionSize));
-            Vector3 pos = attemptedPosition;
-            int changeX = 1;
-            int changeY = 1;
-            if (scene.TestBorderCross(attemptedPosition + WestCross, Cardinals.W))
-            {
-                if (scene.TestBorderCross(attemptedPosition + SouthCross, Cardinals.S))
-                {
-                    Border crossedBorderx = scene.GetCrossedBorder(attemptedPosition + WestCross, Cardinals.W);
-                    if (crossedBorderx.BorderLine.Z > 0)
-                    {
-                        pos.X = ((pos.X + crossedBorderx.BorderLine.Z));
-                        changeX = (int)(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize);
-                    }
-                    else
-                        pos.X = ((pos.X + Constants.RegionSize));
-                    Border crossedBordery = scene.GetCrossedBorder(attemptedPosition + SouthCross, Cardinals.S);
-                    //(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize)
-                    if (crossedBordery.BorderLine.Z > 0)
-                    {
-                        pos.Y = ((pos.Y + crossedBordery.BorderLine.Z));
-                        changeY = (int)(crossedBordery.BorderLine.Z / (int)Constants.RegionSize);
-                    }
-                    else
-                        pos.Y = ((pos.Y + Constants.RegionSize));
-                    newRegionHandle
-                        = Util.UIntsToLong((uint)((thisx - changeX) * Constants.RegionSize),
-                                           (uint)((thisy - changeY) * Constants.RegionSize));
-                    // x - 1
-                    // y - 1
-                }
-                else if (scene.TestBorderCross(attemptedPosition + NorthCross, Cardinals.N))
-                {
-                    Border crossedBorderx = scene.GetCrossedBorder(attemptedPosition + WestCross, Cardinals.W);
-                    if (crossedBorderx.BorderLine.Z > 0)
-                    {
-                        pos.X = ((pos.X + crossedBorderx.BorderLine.Z));
-                        changeX = (int)(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize);
-                    }
-                    else
-                        pos.X = ((pos.X + Constants.RegionSize));
-                    Border crossedBordery = scene.GetCrossedBorder(attemptedPosition + SouthCross, Cardinals.S);
+            // Compute the absolute position of the object.
-                    //(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize)
+            double objectWorldLocX = (double)scene.RegionInfo.WorldLocX + attemptedPosition.X;
+            double objectWorldLocY = (double)scene.RegionInfo.WorldLocY + attemptedPosition.Y;
-                    if (crossedBordery.BorderLine.Z > 0)
+            // Ask the grid service for the region that contains the passed address
-                    {
+            GridRegion destination = GetRegionContainingWorldLocation(scene.GridService, scene.RegionInfo.ScopeID,
-                        pos.Y = ((pos.Y + crossedBordery.BorderLine.Z));
+                                objectWorldLocX, objectWorldLocY);
-                        changeY = (int)(crossedBordery.BorderLine.Z / (int)Constants.RegionSize);
-                    }
-                    else
-                        pos.Y = ((pos.Y + Constants.RegionSize));
-                    newRegionHandle
+            Vector3 pos = Vector3.Zero;
-                        = Util.UIntsToLong((uint)((thisx - changeX) * Constants.RegionSize),
+            if (destination != null)
-                                           (uint)((thisy + changeY) * Constants.RegionSize));
-                    // x - 1
-                    // y + 1
-                }
-                else
-                {
-                    Border crossedBorderx = scene.GetCrossedBorder(attemptedPosition + WestCross, Cardinals.W);
-                    if (crossedBorderx.BorderLine.Z > 0)
-                    {
-                        pos.X = ((pos.X + crossedBorderx.BorderLine.Z));
-                        changeX = (int)(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize);
-                    }
-                    else
-                        pos.X = ((pos.X + Constants.RegionSize));
-                    newRegionHandle
-                        = Util.UIntsToLong((uint)((thisx - changeX) * Constants.RegionSize),
-                                           (uint)(thisy * Constants.RegionSize));
-                    // x - 1
-                }
-            }
-            else if (scene.TestBorderCross(attemptedPosition + EastCross, Cardinals.E))
            {
-                if (scene.TestBorderCross(attemptedPosition + SouthCross, Cardinals.S))
+                // Adjust the object's relative position from the old region (attemptedPosition)
-                {
+                //    to be relative to the new region (pos).
+                pos = new Vector3(  (float)(objectWorldLocX - (double)destination.RegionLocX),
-                    pos.X = ((pos.X - Constants.RegionSize));
+                                    (float)(objectWorldLocY - (double)destination.RegionLocY),
-                    Border crossedBordery = scene.GetCrossedBorder(attemptedPosition + SouthCross, Cardinals.S);
+                                    attemptedPosition.Z);
-                    //(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize)
-                    if (crossedBordery.BorderLine.Z > 0)
-                    {
-                        pos.Y = ((pos.Y + crossedBordery.BorderLine.Z));
-                        changeY = (int)(crossedBordery.BorderLine.Z / (int)Constants.RegionSize);
-                    }
-                    else
-                        pos.Y = ((pos.Y + Constants.RegionSize));
-                    newRegionHandle
-                        = Util.UIntsToLong((uint)((thisx + changeX) * Constants.RegionSize),
-                                           (uint)((thisy - changeY) * Constants.RegionSize));
-                    // x + 1
-                    // y - 1
-                }
-                else if (scene.TestBorderCross(attemptedPosition + NorthCross, Cardinals.N))
-                {
-                    pos.X = ((pos.X - Constants.RegionSize));
-                    pos.Y = ((pos.Y - Constants.RegionSize));
-                    newRegionHandle
-                        = Util.UIntsToLong((uint)((thisx + changeX) * Constants.RegionSize),
-                                           (uint)((thisy + changeY) * Constants.RegionSize));
-                    // x + 1
-                    // y + 1
-                }
-                else
-                {
-                    pos.X = ((pos.X - Constants.RegionSize));
-                    newRegionHandle
-                        = Util.UIntsToLong((uint)((thisx + changeX) * Constants.RegionSize),
-                                           (uint)(thisy * Constants.RegionSize));
-                    // x + 1
-                }
            }
-            else if (scene.TestBorderCross(attemptedPosition + SouthCross, Cardinals.S))
-            {
-                Border crossedBordery = scene.GetCrossedBorder(attemptedPosition + SouthCross, Cardinals.S);
-                //(crossedBorderx.BorderLine.Z / (int)Constants.RegionSize)
-                if (crossedBordery.BorderLine.Z > 0)
-                {
-                    pos.Y = ((pos.Y + crossedBordery.BorderLine.Z));
-                    changeY = (int)(crossedBordery.BorderLine.Z / (int)Constants.RegionSize);
-                }
-                else
-                    pos.Y = ((pos.Y + Constants.RegionSize));
-                newRegionHandle
+            if (destination == null || !CrossPrimGroupIntoNewRegion(destination, pos, grp, silent))
-                    = Util.UIntsToLong((uint)(thisx * Constants.RegionSize), (uint)((thisy - changeY) * Constants.RegionSize));
-                // y - 1
-            }
-            else if (scene.TestBorderCross(attemptedPosition + NorthCross, Cardinals.N))
            {
+                m_log.InfoFormat("[ENTITY TRANSFER MODULE] cross region transfer failed for object {0}", grp.UUID);
-                pos.Y = ((pos.Y - Constants.RegionSize));
+                // We are going to move the object back to the old position so long as the old position
-                newRegionHandle
+                // is in the region
-                    = Util.UIntsToLong((uint)(thisx * Constants.RegionSize), (uint)((thisy + changeY) * Constants.RegionSize));
+                oldGroupPosition.X = Util.Clamp<float>(oldGroupPosition.X, 1.0f, (float)(scene.RegionInfo.RegionSizeX - 1));
-                // y + 1
+                oldGroupPosition.Y = Util.Clamp<float>(oldGroupPosition.Y, 1.0f, (float)(scene.RegionInfo.RegionSizeY - 1));
-            }
+                oldGroupPosition.Z = Util.Clamp<float>(oldGroupPosition.Z, 1.0f, Constants.RegionHeight);
-            // Offset the positions for the new region across the border
+                grp.AbsolutePosition = oldGroupPosition;
-            Vector3 oldGroupPosition = grp.RootPart.GroupPosition;
+                grp.Velocity = Vector3.Zero;
+                if (grp.RootPart.PhysActor != null)
+                    grp.RootPart.PhysActor.CrossingFailure();
-            // If we fail to cross the border, then reset the position of the scene object on that border.
+                if (grp.RootPart.KeyframeMotion != null)
-            uint x = 0, y = 0;
+                    grp.RootPart.KeyframeMotion.CrossingFailure();
-            Utils.LongToUInts(newRegionHandle, out x, out y);
-            GridRegion destination = scene.GridService.GetRegionByPosition(scene.RegionInfo.ScopeID, (int)x, (int)y);
-            if (destination != null)
+                grp.ScheduleGroupForFullUpdate();
-            {
-                if (CrossPrimGroupIntoNewRegion(destination, pos, grp, silent))
-                    return; // we did it
            }
-            // no one or failed lets go back and tell physics to go on
-            oldGroupPosition.X = Util.Clamp<float>(oldGroupPosition.X, 0.5f, (float)Constants.RegionSize - 0.5f);
-            oldGroupPosition.Y = Util.Clamp<float>(oldGroupPosition.Y, 0.5f, (float)Constants.RegionSize - 0.5f);
-            oldGroupPosition.Z = Util.Clamp<float>(oldGroupPosition.Z, 0.5f, 4096.0f);
-            grp.AbsolutePosition = oldGroupPosition;
-            grp.Velocity = Vector3.Zero;
-            if (grp.RootPart.PhysActor != null)
-                grp.RootPart.PhysActor.CrossingFailure();
-            if (grp.RootPart.KeyframeMotion != null)
-                grp.RootPart.KeyframeMotion.CrossingFailure();
-            grp.ScheduleGroupForFullUpdate();
        }
        /// <summary>
        /// Move the given scene object into a new region
        /// </summary>
diff --git a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs
index fc02916..6a04acf 100644
--- a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferStateMachine.cs
@@ -77,6 +77,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
    public class EntityTransferStateMachine
    {
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly string LogHeader = "[ENTITY TRANSFER STATE MACHINE]";
        /// <summary>
        /// If true then on a teleport, the source region waits for a callback from the destination region.  If
@@ -100,6 +101,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
        /// <returns>true if the agent was not already in transit, false if it was</returns>
        internal bool SetInTransit(UUID id)
        {
+            m_log.DebugFormat("{0} SetInTransit. agent={1}, newState=Preparing", LogHeader, id);
            lock (m_agentsInTransit)
            {
                if (!m_agentsInTransit.ContainsKey(id))
@@ -121,6 +123,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
        /// <exception cref='Exception'>Illegal transitions will throw an Exception</exception>
        internal bool UpdateInTransit(UUID id, AgentTransferState newState)
        {
+            m_log.DebugFormat("{0} UpdateInTransit. agent={1}, newState={2}", LogHeader, id, newState);
            bool transitionOkay = false;
            // We don't want to throw an exception on cancel since this can come it at any time.
@@ -193,6 +197,7 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                }
                else if (failIfNotOkay)
                {
+                    m_log.DebugFormat("{0} UpdateInTransit. Throwing transition failure = {1}", LogHeader, failureMessage);
                    throw new Exception(failureMessage);
                }
 //                else
diff --git a/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs b/OpenSim/Region/CoreModules/Scripting/EMailModules/EmailModule.cs
index d943b20..4e7ad75 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.WorldLocX;
-                        uint localY = (s.RegionInfo.RegionLocY * (int)Constants.RegionSize);
+                        uint localY = s.RegionInfo.WorldLocY;
                        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..3b38c71 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/LocalGridServiceConnector.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/LocalGridServiceConnector.cs
@@ -48,6 +48,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
        private static readonly ILog m_log =
                LogManager.GetLogger(
                MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[LOCAL GRID SERVICE CONNECTOR]";
        private IGridService m_GridService;
        private Dictionary<UUID, RegionCache> m_LocalCache = new Dictionary<UUID, RegionCache>();
@@ -56,12 +57,12 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
        public LocalGridServicesConnector()
        {
-            m_log.Debug("[LOCAL GRID SERVICE CONNECTOR]: LocalGridServicesConnector no parms.");
+            m_log.DebugFormat("{0} LocalGridServicesConnector no parms.", LogHeader);
        }
        public LocalGridServicesConnector(IConfigSource source)
        {
-            m_log.Debug("[LOCAL GRID SERVICE CONNECTOR]: LocalGridServicesConnector instantiated directly.");
+            m_log.DebugFormat("{0} LocalGridServicesConnector instantiated directly.", LogHeader);
            InitialiseService(source);
        }
@@ -192,6 +193,9 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
            return m_GridService.GetRegionByUUID(scopeID, regionID);
        }
+        // Get a region given its base coordinates.
+        // NOTE: this is NOT 'get a region by some point in the region'. The coordinate MUST
+        //     be the base coordinate of the region.
        public GridRegion GetRegionByPosition(UUID scopeID, int x, int y)
        {
            GridRegion region = null;
@@ -206,13 +210,25 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
                    region = rcache.GetRegionByPosition(x, y);
                    if (region != null)
                    {
-                        return region;
+                        // m_log.DebugFormat("{0} GetRegionByPosition. Found region {1} in cache. Pos=<{2},{3}>",
+                        //                 LogHeader, region.RegionName, x, y);
+                        break;
                    }
                }
            }
            // Then try on this sim (may be a lookup in DB if this is using MySql).
-            return m_GridService.GetRegionByPosition(scopeID, x, y);
+            if (region == null)
+            {
+                region = m_GridService.GetRegionByPosition(scopeID, x, y);
+                if (region == null)
+                    m_log.DebugFormat("{0} GetRegionByPosition. Region not found by grid service. Pos=<{1},{2}>",
+                                        LogHeader, x, y);
+                else
+                    m_log.DebugFormat("{0} GetRegionByPosition. Requested region {1} from grid service. Pos=<{2},{3}>",
+                                        LogHeader, region.RegionName, x, y);
+            }
+            return region;
        }
        public GridRegion GetRegionByName(UUID scopeID, string regionName)
@@ -268,7 +284,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..ae76288 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;
        }
@@ -82,11 +82,16 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
            return new List<GridRegion>(m_neighbours.Values);
        }
+        // Get a region given its base coordinates (in meters).
+        // NOTE: this is NOT 'get a region by some point in the region'. The coordinate MUST
+        //     be the base coordinate of the region.
+        // The snapping is technically unnecessary but is harmless because regions are always
+        //     multiples of the legacy region size (256).
        public GridRegion GetRegionByPosition(int x, int y)
        {
            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/Grid/RemoteGridServiceConnector.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RemoteGridServiceConnector.cs
index 6a57d1f..ae5081c 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RemoteGridServiceConnector.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/RemoteGridServiceConnector.cs
@@ -186,10 +186,14 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid
            return rinfo;
        }
+        // Get a region given its base world coordinates (in meters).
+        // NOTE: this is NOT 'get a region by some point in the region'. The coordinate MUST
+        //     be the base coordinate of the region.
+        // The coordinates are world coords (meters), NOT region units.
        public GridRegion GetRegionByPosition(UUID scopeID, int x, int y)
        {
            bool inCache = false;
-            GridRegion rinfo = m_RegionInfoCache.Get(scopeID, Util.UIntsToLong((uint)x, (uint)y), out inCache);
+            GridRegion rinfo = m_RegionInfoCache.Get(scopeID, Util.RegionWorldLocToHandle((uint)x, (uint)y), out inCache);
            if (inCache)
                return rinfo;
diff --git a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/Tests/GridConnectorsTests.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/Tests/GridConnectorsTests.cs
index 4338133..25ae689 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/Tests/GridConnectorsTests.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Grid/Tests/GridConnectorsTests.cs
@@ -34,6 +34,7 @@ using log4net.Config;
 using Nini.Config;
 using NUnit.Framework;
 using OpenMetaverse;
 using OpenSim.Framework;
 using OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid;
 using OpenSim.Region.Framework.Scenes;
@@ -141,7 +142,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Grid.Tests
            Assert.IsNotNull(result, "Retrieved GetRegionByUUID is null");
            Assert.That(result.RegionID, Is.EqualTo(new UUID(1)), "Retrieved region's UUID does not match");
-            result = m_LocalConnector.GetRegionByPosition(UUID.Zero, 1000 * (int)Constants.RegionSize, 1000 * (int)Constants.RegionSize);
+            result = m_LocalConnector.GetRegionByPosition(UUID.Zero, (int)Util.RegionToWorldLoc(1000), (int)Util.RegionToWorldLoc(1000));
            Assert.IsNotNull(result, "Retrieved GetRegionByPosition is null");
            Assert.That(result.RegionLocX, Is.EqualTo(1000 * (int)Constants.RegionSize), "Retrieved region's position does not match");
diff --git a/OpenSim/Region/CoreModules/ServiceConnectorsOut/MapImage/MapImageServiceModule.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/MapImage/MapImageServiceModule.cs
index 26d22b8..4d7538c 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/MapImage/MapImageServiceModule.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/MapImage/MapImageServiceModule.cs
@@ -57,6 +57,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.MapImage
    {
        private static readonly ILog m_log =
            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[MAP IMAGE SERVICE MODULE]";
        private bool m_enabled = false;
        private IMapImageService m_MapService;
@@ -192,42 +193,85 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.MapImage
        ///</summary>
        private void UploadMapTile(IScene scene)
        {
-            m_log.DebugFormat("[MAP IMAGE SERVICE MODULE]: upload maptile for {0}", scene.RegionInfo.RegionName);
+            m_log.DebugFormat("{0} Upload maptile for {1}", LogHeader, scene.RegionInfo.RegionName);
+            string regionName = scene.RegionInfo.RegionName;
            // Create a JPG map tile and upload it to the AddMapTile API
-            byte[] jpgData = Utils.EmptyBytes;
            IMapImageGenerator tileGenerator = scene.RequestModuleInterface<IMapImageGenerator>();
            if (tileGenerator == null)
            {
-                m_log.Warn("[MAP IMAGE SERVICE MODULE]: Cannot upload PNG map tile without an ImageGenerator");
+                m_log.WarnFormat("{0} Cannot upload map tile without an ImageGenerator", LogHeader);
                return;
            }
+            using (Bitmap mapTile = tileGenerator.CreateMapTile())
-            using (Image mapTile = tileGenerator.CreateMapTile())
            {
-                // XXX: The MapImageModule will return a null if the user has chosen not to create map tiles and there
+                if (mapTile != null)
-                // is no static map tile.
+                {
-                if (mapTile == null)
+                    // mapTile.Save(   // DEBUG DEBUG
-                    return;
+                    //     String.Format("maptiles/raw-{0}-{1}-{2}.jpg", regionName, scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY),
+                    //     ImageFormat.Jpeg);
-                using (MemoryStream stream = new MemoryStream())
+                    // If the region/maptile is legacy sized, just upload the one tile like it has always been done
+                    if (mapTile.Width == Constants.RegionSize && mapTile.Height == Constants.RegionSize)
+                    {
+                        ConvertAndUploadMaptile(mapTile,
+                                    scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY,
+                                    scene.RegionInfo.RegionName);
+                    }
+                    else
+                    {
+                        // For larger regions (varregion) we must cut the region image into legacy sized
+                        //    pieces since that is how the maptile system works.
+                        // Note the assumption that varregions are always a multiple of legacy size.
+                        for (uint xx = 0; xx < mapTile.Width; xx += Constants.RegionSize)
+                        {
+                            for (uint yy = 0; yy < mapTile.Height; yy += Constants.RegionSize)
+                            {
+                                // Images are addressed from the upper left corner so have to do funny
+                                //     math to pick out the sub-tile since regions are numbered from
+                                //     the lower left.
+                                Rectangle rect = new Rectangle(
+                                            (int)xx,
+                                            mapTile.Height - (int)yy - (int)Constants.RegionSize,
+                                            (int)Constants.RegionSize, (int)Constants.RegionSize);
+                                using (Bitmap subMapTile = mapTile.Clone(rect, mapTile.PixelFormat))
+                                {
+                                    ConvertAndUploadMaptile(subMapTile,
+                                                scene.RegionInfo.RegionLocX + (xx / Constants.RegionSize),
+                                                scene.RegionInfo.RegionLocY + (yy / Constants.RegionSize),
+                                                regionName);
+                                }
+                            }
+                        }
+                    }
+                }
+                else
                {
-                    mapTile.Save(stream, ImageFormat.Jpeg);
+                    m_log.WarnFormat("{0} Tile image generation failed", LogHeader);
-                    jpgData = stream.ToArray();
                }
            }
+        }
-            if (jpgData == Utils.EmptyBytes)
+        private void ConvertAndUploadMaptile(Image tileImage, uint locX, uint locY, string regionName)
+        {
+            byte[] jpgData = Utils.EmptyBytes;
+            using (MemoryStream stream = new MemoryStream())
            {
-                m_log.WarnFormat("[MAP IMAGE SERVICE MODULE]: Tile image generation failed");
+                tileImage.Save(stream, ImageFormat.Jpeg);
-                return;
+                jpgData = stream.ToArray();
            }
+            if (jpgData != Utils.EmptyBytes)
-            string reason = string.Empty;
+            {
-            if (!m_MapService.AddMapTile((int)scene.RegionInfo.RegionLocX, (int)scene.RegionInfo.RegionLocY, jpgData, out reason))
+                string reason = string.Empty;
+                if (!m_MapService.AddMapTile((int)locX, (int)locY, jpgData, out reason))
+                {
+                    m_log.DebugFormat("{0} Unable to upload tile image for {1} at {2}-{3}: {4}", LogHeader,
+                        regionName, locX, locY, reason);
+                }
+            }
+            else
            {
-                m_log.DebugFormat("[MAP IMAGE SERVICE MODULE]: Unable to upload tile image for {0} at {1}-{2}: {3}",
+                m_log.WarnFormat("{0} Tile image generation failed for region {1}", LogHeader, regionName);
-                    scene.RegionInfo.RegionName, scene.RegionInfo.RegionLocX, scene.RegionInfo.RegionLocY, reason);
            }
        }
    }
diff --git a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Neighbour/LocalNeighbourServiceConnector.cs b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Neighbour/LocalNeighbourServiceConnector.cs
index fd89428..56d9937 100644
--- a/OpenSim/Region/CoreModules/ServiceConnectorsOut/Neighbour/LocalNeighbourServiceConnector.cs
+++ b/OpenSim/Region/CoreModules/ServiceConnectorsOut/Neighbour/LocalNeighbourServiceConnector.cs
@@ -132,7 +132,7 @@ namespace OpenSim.Region.CoreModules.ServiceConnectorsOut.Neighbour
                if (s.RegionInfo.RegionHandle == regionHandle)
                {
                    m_log.DebugFormat("[LOCAL NEIGHBOUR SERVICE CONNECTOR]: HelloNeighbour from region {0} to neighbour {1} at {2}-{3}",
-                        thisRegion.RegionName, s.Name, x / Constants.RegionSize, y / Constants.RegionSize);
+                        thisRegion.RegionName, s.Name, Util.WorldToRegionLoc(x), Util.WorldToRegionLoc(y) );
                    //m_log.Debug("[NEIGHBOUR CONNECTOR]: Found region to SendHelloNeighbour");
                    return s.IncomingHelloNeighbour(thisRegion);
diff --git a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequest.cs b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequest.cs
index a990898..9f39aa2 100644
--- a/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequest.cs
+++ b/OpenSim/Region/CoreModules/World/Archiver/ArchiveWriteRequest.cs
@@ -533,7 +533,7 @@ namespace OpenSim.Region.CoreModules.World.Archiver
            if (isMegaregion)
                size = rcMod.GetSizeOfMegaregion(scene.RegionInfo.RegionID);
            else
-                size = new Vector2((float)Constants.RegionSize, (float)Constants.RegionSize);
+                size = new Vector2((float)scene.RegionInfo.RegionSizeX, (float)scene.RegionInfo.RegionSizeY);
    
            xtw.WriteElementString("is_megaregion", isMegaregion.ToString());
            xtw.WriteElementString("size_in_meters", string.Format("{0},{1}", size.X, size.Y));
diff --git a/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs b/OpenSim/Region/CoreModules/World/Land/LandManagementModule.cs
index 73c4d6c..99db7ff 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,
@@ -1679,7 +1789,7 @@ namespace OpenSim.Region.CoreModules.World.Land
                {
                    // most likely still cached from building the extLandData entry
                    uint x = 0, y = 0;
-                    Utils.LongToUInts(data.RegionHandle, out x, out y);
+                    Util.RegionHandleToWorldLoc(data.RegionHandle, out x, out y);
                    info = m_scene.GridService.GetRegionByPosition(m_scene.RegionInfo.ScopeID, (int)x, (int)y);
                }
                // we need to transfer the fake parcelID, not the one in landData, so the viewer can match it to the landmark.
@@ -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 e54c849..f8f4986 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();
@@ -559,8 +570,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)
                {
@@ -707,15 +718,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)
                    {
@@ -723,31 +734,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;
        }
@@ -759,20 +770,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>
@@ -786,15 +789,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;
        }
@@ -811,24 +818,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;
        }
@@ -840,21 +843,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])
                    {
@@ -871,13 +874,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)
@@ -889,30 +892,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/LegacyMap/MapImageModule.cs b/OpenSim/Region/CoreModules/World/LegacyMap/MapImageModule.cs
index 40638f8..1007e0b 100644
--- a/OpenSim/Region/CoreModules/World/LegacyMap/MapImageModule.cs
+++ b/OpenSim/Region/CoreModules/World/LegacyMap/MapImageModule.cs
@@ -102,7 +102,8 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
                terrainRenderer.Initialise(m_scene, m_config);
-                mapbmp = new Bitmap((int)Constants.RegionSize, (int)Constants.RegionSize, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
+                mapbmp = new Bitmap((int)m_scene.Heightmap.Width, (int)m_scene.Heightmap.Height,
+                                        System.Drawing.Imaging.PixelFormat.Format24bppRgb);
                //long t = System.Environment.TickCount;
                //for (int i = 0; i < 10; ++i) {
                terrainRenderer.TerrainToBitmap(mapbmp);
@@ -273,7 +274,7 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
        private Bitmap DrawObjectVolume(Scene whichScene, Bitmap mapbmp)
        {
            int tc = 0;
-            double[,] hm = whichScene.Heightmap.GetDoubles();
+            ITerrainChannel hm = whichScene.Heightmap;
            tc = Environment.TickCount;
            m_log.Debug("[MAPTILE]: Generating Maptile Step 2: Object Volume Profile");
            EntityBase[] objs = whichScene.GetEntities();
@@ -356,7 +357,7 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
                                Vector3 pos = part.GetWorldPosition();
                                // skip prim outside of retion
-                                if (pos.X < 0f || pos.X > 256f || pos.Y < 0f || pos.Y > 256f)
+                                if (!m_scene.PositionIsInCurrentRegion(pos))
                                    continue;
                                // skip prim in non-finite position
@@ -399,9 +400,14 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
                                    int mapdrawendY = (int)(pos.Y + scale.Y);
                                    // If object is beyond the edge of the map, don't draw it to avoid errors
-                                    if (mapdrawstartX < 0 || mapdrawstartX > ((int)Constants.RegionSize - 1) || mapdrawendX < 0 || mapdrawendX > ((int)Constants.RegionSize - 1)
+                                    if (mapdrawstartX < 0
-                                                          || mapdrawstartY < 0 || mapdrawstartY > ((int)Constants.RegionSize - 1) || mapdrawendY < 0
+                                                || mapdrawstartX > (hm.Width - 1)
-                                                          || mapdrawendY > ((int)Constants.RegionSize - 1))
+                                                || mapdrawendX < 0
+                                                || mapdrawendX > (hm.Width - 1)
+                                                || mapdrawstartY < 0
+                                                || mapdrawstartY > (hm.Height - 1)
+                                                || mapdrawendY < 0
+                                                || mapdrawendY > (hm.Height - 1))
                                        continue;
 #region obb face reconstruction part duex
@@ -523,11 +529,11 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
                                    for (int i = 0; i < FaceA.Length; i++)
                                    {
                                        Point[] working = new Point[5];
-                                        working[0] = project(FaceA[i], axPos);
+                                        working[0] = project(hm, FaceA[i], axPos);
-                                        working[1] = project(FaceB[i], axPos);
+                                        working[1] = project(hm, FaceB[i], axPos);
-                                        working[2] = project(FaceD[i], axPos);
+                                        working[2] = project(hm, FaceD[i], axPos);
-                                        working[3] = project(FaceC[i], axPos);
+                                        working[3] = project(hm, FaceC[i], axPos);
-                                        working[4] = project(FaceA[i], axPos);
+                                        working[4] = project(hm, FaceA[i], axPos);
                                        face workingface = new face();
                                        workingface.pts = working;
@@ -595,17 +601,17 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
            return mapbmp;
        }
-        private Point project(Vector3 point3d, Vector3 originpos)
+        private Point project(ITerrainChannel hm, Vector3 point3d, Vector3 originpos)
        {
            Point returnpt = new Point();
            //originpos = point3d;
            //int d = (int)(256f / 1.5f);
            //Vector3 topos = new Vector3(0, 0, 0);
-           // float z = -point3d.z - topos.z;
+            // float z = -point3d.z - topos.z;
            returnpt.X = (int)point3d.X;//(int)((topos.x - point3d.x) / z * d);
-            returnpt.Y = (int)(((int)Constants.RegionSize - 1) - point3d.Y);//(int)(255 - (((topos.y - point3d.y) / z * d)));
+            returnpt.Y = (int)((hm.Width - 1) - point3d.Y);//(int)(255 - (((topos.y - point3d.y) / z * d)));
            return returnpt;
        }
diff --git a/OpenSim/Region/CoreModules/World/LegacyMap/ShadedMapTileRenderer.cs b/OpenSim/Region/CoreModules/World/LegacyMap/ShadedMapTileRenderer.cs
index 992bff3..9b939c9 100644
--- a/OpenSim/Region/CoreModules/World/LegacyMap/ShadedMapTileRenderer.cs
+++ b/OpenSim/Region/CoreModules/World/LegacyMap/ShadedMapTileRenderer.cs
@@ -31,6 +31,7 @@ using System.Reflection;
 using log4net;
 using Nini.Config;
 using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 namespace OpenSim.Region.CoreModules.World.LegacyMap
@@ -39,8 +40,8 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
    {
        private static readonly Color WATER_COLOR = Color.FromArgb(29, 71, 95);
-        private static readonly ILog m_log =
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly string LogHeader = "[SHADED MAPTILE RENDERER]";
        private Scene m_scene;
        //private IConfigSource m_config; // not used currently
@@ -53,19 +54,26 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
        public void TerrainToBitmap(Bitmap mapbmp)
        {
+            m_log.DebugFormat("{0} Generating Maptile Step 1: Terrain", LogHeader);
            int tc = Environment.TickCount;
-            m_log.Debug("[MAPTILE]: Generating Maptile Step 1: Terrain");
-            double[,] hm = m_scene.Heightmap.GetDoubles();
+            ITerrainChannel hm = m_scene.Heightmap;
+            if (mapbmp.Width != hm.Width || mapbmp.Height != hm.Height)
+            {
+                m_log.ErrorFormat("{0} TerrainToBitmap. Passed bitmap wrong dimensions. passed=<{1},{2}>, size=<{3},{4}>",
+                    LogHeader, mapbmp.Width, mapbmp.Height, hm.Width, hm.Height);
+            }
            bool ShadowDebugContinue = true;
            bool terraincorruptedwarningsaid = false;
            float low = 255;
            float high = 0;
-            for (int x = 0; x < (int)Constants.RegionSize; x++)
+            for (int x = 0; x < hm.Width; x++)
            {
-                for (int y = 0; y < (int)Constants.RegionSize; y++)
+                for (int y = 0; y < hm.Height; y++)
                {
                    float hmval = (float)hm[x, y];
                    if (hmval < low)
@@ -77,12 +85,12 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
            float waterHeight = (float)m_scene.RegionInfo.RegionSettings.WaterHeight;
-            for (int x = 0; x < (int)Constants.RegionSize; x++)
+            for (int x = 0; x < hm.Width; x++)
            {
-                for (int y = 0; y < (int)Constants.RegionSize; y++)
+                for (int y = 0; y < hm.Height; y++)
                {
                    // Y flip the cordinates for the bitmap: hf origin is lower left, bm origin is upper left
-                    int yr = ((int)Constants.RegionSize - 1) - y;
+                    int yr = ((int)hm.Height - 1) - y;
                    float heightvalue = (float)hm[x, y];
@@ -109,12 +117,12 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
                            // .
                            //
                            // Shade the terrain for shadows
-                            if (x < ((int)Constants.RegionSize - 1) && yr < ((int)Constants.RegionSize - 1))
+                            if (x < (hm.Width - 1) && yr < (hm.Height - 1))
                            {
                                float hfvalue = (float)hm[x, y];
                                float hfvaluecompare = 0f;
-                                if ((x + 1 < (int)Constants.RegionSize) && (y + 1 < (int)Constants.RegionSize))
+                                if ((x + 1 < hm.Width) && (y + 1 < hm.Height))
                                {
                                    hfvaluecompare = (float)hm[x + 1, y + 1]; // light from north-east => look at land height there
                                }
@@ -179,7 +187,7 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
                                    if (ShadowDebugContinue)
                                    {
-                                        if ((x - 1 > 0) && (yr + 1 < (int)Constants.RegionSize))
+                                        if ((x - 1 > 0) && (yr + 1 < hm.Height))
                                        {
                                            color = mapbmp.GetPixel(x - 1, yr + 1);
                                            int r = color.R;
@@ -233,7 +241,7 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
                                terraincorruptedwarningsaid = true;
                            }
                            Color black = Color.Black;
-                            mapbmp.SetPixel(x, ((int)Constants.RegionSize - y) - 1, black);
+                            mapbmp.SetPixel(x, (hm.Width - y) - 1, black);
                        }
                    }
                }
diff --git a/OpenSim/Region/CoreModules/World/LegacyMap/TexturedMapTileRenderer.cs b/OpenSim/Region/CoreModules/World/LegacyMap/TexturedMapTileRenderer.cs
index d13c2ef..413ac64 100644
--- a/OpenSim/Region/CoreModules/World/LegacyMap/TexturedMapTileRenderer.cs
+++ b/OpenSim/Region/CoreModules/World/LegacyMap/TexturedMapTileRenderer.cs
@@ -34,6 +34,8 @@ using Nini.Config;
 using OpenMetaverse;
 using OpenMetaverse.Imaging;
 using OpenSim.Framework;
+using OpenSim.Region.Framework;
+using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 namespace OpenSim.Region.CoreModules.World.LegacyMap
@@ -122,8 +124,8 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
    {
        #region Constants
-        private static readonly ILog m_log =
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly string LogHeader = "[TEXTURED MAPTILE RENDERER]";
        // some hardcoded terrain UUIDs that work with SL 1.20 (the four default textures and "Blank").
        // The color-values were choosen because they "look right" (at least to me) ;-)
@@ -173,7 +175,7 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
        private Bitmap fetchTexture(UUID id)
        {
            AssetBase asset = m_scene.AssetService.Get(id.ToString());
-            m_log.DebugFormat("[TexturedMapTileRenderer]: Fetched texture {0}, found: {1}", id, asset != null);
+            m_log.DebugFormat("{0} Fetched texture {1}, found: {2}", LogHeader, id, asset != null);
            if (asset == null) return null;
            ManagedImage managedImage;
@@ -188,18 +190,15 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
            }
            catch (DllNotFoundException)
            {
-                m_log.ErrorFormat("[TexturedMapTileRenderer]: OpenJpeg is not installed correctly on this system.   Asset Data is empty for {0}", id);
+                m_log.ErrorFormat("{0} OpenJpeg is not installed correctly on this system.   Asset Data is empty for {1}", LogHeader, id);
-                
            }
            catch (IndexOutOfRangeException)
            {
-                m_log.ErrorFormat("[TexturedMapTileRenderer]: OpenJpeg was unable to encode this.   Asset Data is empty for {0}", id);
+                m_log.ErrorFormat("{0} OpenJpeg was unable to encode this.   Asset Data is empty for {1}", LogHeader, id);
-                
            }
            catch (Exception)
            {
-                m_log.ErrorFormat("[TexturedMapTileRenderer]: OpenJpeg was unable to encode this.   Asset Data is empty for {0}", id);
+                m_log.ErrorFormat("{0} OpenJpeg was unable to encode this.   Asset Data is empty for {1}", LogHeader, id);
-                
            }
            return null;
            
@@ -267,8 +266,8 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
        // the heigthfield might have some jumps in values. Rendered land is smooth, though,
        // as a slope is rendered at that place. So average 4 neighbour values to emulate that.
-        private float getHeight(double[,] hm, int x, int y) {
+        private float getHeight(ITerrainChannel hm, int x, int y) {
-            if (x < ((int)Constants.RegionSize - 1) && y < ((int)Constants.RegionSize - 1))
+            if (x < (hm.Width - 1) && y < (hm.Height - 1))
                return (float)(hm[x, y] * .444 + (hm[x + 1, y] + hm[x, y + 1]) * .222 + hm[x + 1, y +1] * .112);
            else
                return (float)hm[x, y];
@@ -278,7 +277,15 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
        public void TerrainToBitmap(Bitmap mapbmp)
        {
            int tc = Environment.TickCount;
-            m_log.Debug("[MAPTILE]: Generating Maptile Step 1: Terrain");
+            m_log.DebugFormat("{0} Generating Maptile Step 1: Terrain", LogHeader);
+            ITerrainChannel hm = m_scene.Heightmap;
+            if (mapbmp.Width != hm.Width || mapbmp.Height != hm.Height)
+            {
+                m_log.ErrorFormat("{0} TerrainToBitmap. Passed bitmap wrong dimensions. passed=<{1},{2}>, size=<{3},{4}>",
+                    LogHeader, mapbmp.Width, mapbmp.Height, hm.Width, hm.Height);
+            }
            // These textures should be in the AssetCache anyway, as every client conneting to this
            // region needs them. Except on start, when the map is recreated (before anyone connected),
@@ -306,19 +313,17 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
            float waterHeight = (float)settings.WaterHeight;
-            double[,] hm = m_scene.Heightmap.GetDoubles();
+            for (int x = 0; x < hm.Width; x++)
-            for (int x = 0; x < (int)Constants.RegionSize; x++)
            {
-                float columnRatio = x / ((float)Constants.RegionSize - 1); // 0 - 1, for interpolation
+                float columnRatio = x / (hm.Width - 1); // 0 - 1, for interpolation
-                for (int y = 0; y < (int)Constants.RegionSize; y++)
+                for (int y = 0; y < hm.Height; y++)
                {
-                    float rowRatio = y / ((float)Constants.RegionSize - 1); // 0 - 1, for interpolation
+                    float rowRatio = y / (hm.Height - 1); // 0 - 1, for interpolation
                    // Y flip the cordinates for the bitmap: hf origin is lower left, bm origin is upper left
-                    int yr = ((int)Constants.RegionSize - 1) - y;
+                    int yr = (hm.Height - 1) - y;
-                    float heightvalue = getHeight(hm, x, y);
+                    float heightvalue = getHeight(m_scene.Heightmap, x, y);
                    if (Single.IsInfinity(heightvalue) || Single.IsNaN(heightvalue))
                        heightvalue = 0;
@@ -368,9 +373,9 @@ namespace OpenSim.Region.CoreModules.World.LegacyMap
                        }
                        // Shade the terrain for shadows
-                        if (x < ((int)Constants.RegionSize - 1) && y < ((int)Constants.RegionSize - 1))
+                        if (x < (hm.Width - 1) && y < (hm.Height - 1))
                        {
-                            float hfvaluecompare = getHeight(hm, x + 1, y + 1); // light from north-east => look at land height there
+                            float hfvaluecompare = getHeight(m_scene.Heightmap, x + 1, y + 1); // light from north-east => look at land height there
                            if (Single.IsInfinity(hfvaluecompare) || Single.IsNaN(hfvaluecompare))
                                hfvaluecompare = 0f;
diff --git a/OpenSim/Region/CoreModules/World/Objects/BuySell/BuySellModule.cs b/OpenSim/Region/CoreModules/World/Objects/BuySell/BuySellModule.cs
index 0cb574a..b8d4855 100644
--- a/OpenSim/Region/CoreModules/World/Objects/BuySell/BuySellModule.cs
+++ b/OpenSim/Region/CoreModules/World/Objects/BuySell/BuySellModule.cs
@@ -151,14 +151,9 @@ namespace OpenSim.Region.CoreModules.World.Objects.BuySell
                break;
            case 2: // Sell a copy
-                Vector3 inventoryStoredPosition = new Vector3
+                Vector3 inventoryStoredPosition = new Vector3(
-                       (((group.AbsolutePosition.X > (int)Constants.RegionSize)
+                        Math.Min(group.AbsolutePosition.X, m_scene.RegionInfo.RegionSizeX - 6),
-                             ? 250
+                        Math.Min(group.AbsolutePosition.Y, m_scene.RegionInfo.RegionSizeY - 6),
-                             : group.AbsolutePosition.X)
-                        ,
-                        (group.AbsolutePosition.X > (int)Constants.RegionSize)
-                            ? 250
-                            : group.AbsolutePosition.X,
                        group.AbsolutePosition.Z);
                Vector3 originalPosition = group.AbsolutePosition;
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/FloodBrushes/NoiseArea.cs b/OpenSim/Region/CoreModules/World/Terrain/FloodBrushes/NoiseArea.cs
index 630473e..b6c635c 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/FloodBrushes/NoiseArea.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/FloodBrushes/NoiseArea.cs
@@ -45,7 +45,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain.FloodBrushes
                {
                    if (fillArea[x, y])
                    {
-                        double noise = TerrainUtil.PerlinNoise2D((double) x / Constants.RegionSize, (double) y / Constants.RegionSize, 8, 1.0);
+                        double noise = TerrainUtil.PerlinNoise2D((double) x / map.Width, (double) y / map.Height, 8, 1.0);
                        map[x, y] += noise * strength;
                    }
diff --git a/OpenSim/Region/CoreModules/World/Terrain/PaintBrushes/NoiseSphere.cs b/OpenSim/Region/CoreModules/World/Terrain/PaintBrushes/NoiseSphere.cs
index 989b7d8..e7df3f8 100644
--- a/OpenSim/Region/CoreModules/World/Terrain/PaintBrushes/NoiseSphere.cs
+++ b/OpenSim/Region/CoreModules/World/Terrain/PaintBrushes/NoiseSphere.cs
@@ -53,7 +53,7 @@ namespace OpenSim.Region.CoreModules.World.Terrain.PaintBrushes
                    z *= z;
                    z -= ((x - rx) * (x - rx)) + ((y - ry) * (y - ry));
-                    double noise = TerrainUtil.PerlinNoise2D(x / (double) Constants.RegionSize, y / (double) Constants.RegionSize, 8, 1.0);
+                    double noise = TerrainUtil.PerlinNoise2D(x / (double) map.Width, y / (double) map.Height, 8, 1.0);
                    if (z > 0.0)
                        map[x, y] += noise * z * duration;
diff --git a/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs b/OpenSim/Region/CoreModules/World/Terrain/TerrainModule.cs
index fd30c46..9766bfe 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>
@@ -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();
@@ -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/Warp3DMap/TerrainSplat.cs b/OpenSim/Region/CoreModules/World/Warp3DMap/TerrainSplat.cs
index df5ac92..9534ad3 100644
--- a/OpenSim/Region/CoreModules/World/Warp3DMap/TerrainSplat.cs
+++ b/OpenSim/Region/CoreModules/World/Warp3DMap/TerrainSplat.cs
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
@@ -32,6 +32,7 @@ using System.Drawing.Imaging;
 using log4net;
 using OpenMetaverse;
 using OpenSim.Framework;
+using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Services.Interfaces;
 namespace OpenSim.Region.CoreModules.World.Warp3DMap
@@ -66,261 +67,271 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
        #endregion Constants
        private static readonly ILog m_log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType.Name);
+        private static string LogHeader = "[WARP3D TERRAIN SPLAT]";
        /// <summary>
        /// Builds a composited terrain texture given the region texture
        /// and heightmap settings
        /// </summary>
-        /// <param name="heightmap">Terrain heightmap</param>
+        /// <param name="terrain">Terrain heightmap</param>
        /// <param name="regionInfo">Region information including terrain texture parameters</param>
-        /// <returns>A composited 256x256 RGB texture ready for rendering</returns>
+        /// <returns>A 256x256 square RGB texture ready for rendering</returns>
        /// <remarks>Based on the algorithm described at http://opensimulator.org/wiki/Terrain_Splatting
+        /// Note we create a 256x256 dimension texture even if the actual terrain is larger.
        /// </remarks>
-        public static Bitmap Splat(float[] heightmap, UUID[] textureIDs, float[] startHeights, float[] heightRanges, Vector3d regionPosition, IAssetService assetService, bool textureTerrain)
+        public static Bitmap Splat(ITerrainChannel terrain,
+                UUID[] textureIDs, float[] startHeights, float[] heightRanges,
+                Vector3d regionPosition, IAssetService assetService, bool textureTerrain)
        {
-            Debug.Assert(heightmap.Length == 256 * 256);
            Debug.Assert(textureIDs.Length == 4);
            Debug.Assert(startHeights.Length == 4);
            Debug.Assert(heightRanges.Length == 4);
            Bitmap[] detailTexture = new Bitmap[4];
-            Bitmap output = null;
-            BitmapData outputData = null;
-            try
+            if (textureTerrain)
            {
-                if (textureTerrain)
+                // Swap empty terrain textureIDs with default IDs
+                for (int i = 0; i < textureIDs.Length; i++)
                {
-                    // Swap empty terrain textureIDs with default IDs
+                    if (textureIDs[i] == UUID.Zero)
-                    for (int i = 0; i < textureIDs.Length; i++)
+                        textureIDs[i] = DEFAULT_TERRAIN_DETAIL[i];
-                    {
+                }
-                        if (textureIDs[i] == UUID.Zero)
-                            textureIDs[i] = DEFAULT_TERRAIN_DETAIL[i];
+                #region Texture Fetching
-                    }
-    
+                if (assetService != null)
-                    #region Texture Fetching
+                {
-    
+                    for (int i = 0; i < 4; i++)
-                    if (assetService != null)
                    {
-                        for (int i = 0; i < 4; i++)
+                        AssetBase asset;
+                        UUID cacheID = UUID.Combine(TERRAIN_CACHE_MAGIC, textureIDs[i]);
+                        // Try to fetch a cached copy of the decoded/resized version of this texture
+                        asset = assetService.GetCached(cacheID.ToString());
+                        if (asset != null)
+                        {
+                            try
+                            {
+                                using (System.IO.MemoryStream stream = new System.IO.MemoryStream(asset.Data))
+                                    detailTexture[i] = (Bitmap)Image.FromStream(stream);
+                            }
+                            catch (Exception ex)
+                            {
+                                m_log.Warn("Failed to decode cached terrain texture " + cacheID +
+                                    " (textureID: " + textureIDs[i] + "): " + ex.Message);
+                            }
+                        }
+                        if (detailTexture[i] == null)
                        {
-                            AssetBase asset;
+                            // Try to fetch the original JPEG2000 texture, resize if needed, and cache as PNG
-                            UUID cacheID = UUID.Combine(TERRAIN_CACHE_MAGIC, textureIDs[i]);
+                            asset = assetService.Get(textureIDs[i].ToString());
-    
-                            // Try to fetch a cached copy of the decoded/resized version of this texture
-                            asset = assetService.GetCached(cacheID.ToString());
                            if (asset != null)
                            {
-//                                m_log.DebugFormat(
+//                                    m_log.DebugFormat(
-//                                    "[TERRAIN SPLAT]: Got asset service cached terrain texture {0} {1}", i, asset.ID);
+//                                        "[TERRAIN SPLAT]: Got cached original JPEG2000 terrain texture {0} {1}", i, asset.ID);
-                                try
+                                try { detailTexture[i] = (Bitmap)CSJ2K.J2kImage.FromBytes(asset.Data); }
-                                {
-                                    using (System.IO.MemoryStream stream = new System.IO.MemoryStream(asset.Data))
-                                        detailTexture[i] = (Bitmap)Image.FromStream(stream);
-                                }
                                catch (Exception ex)
                                {
-                                    m_log.Warn("Failed to decode cached terrain texture " + cacheID +
+                                    m_log.Warn("Failed to decode terrain texture " + asset.ID + ": " + ex.Message);
-                                        " (textureID: " + textureIDs[i] + "): " + ex.Message);
                                }
                            }
-    
-                            if (detailTexture[i] == null)
-                            {
-                                // Try to fetch the original JPEG2000 texture, resize if needed, and cache as PNG
-                                asset = assetService.Get(textureIDs[i].ToString());
-                                if (asset != null)
-                                {
-//                                    m_log.DebugFormat(
-//                                        "[TERRAIN SPLAT]: Got cached original JPEG2000 terrain texture {0} {1}", i, asset.ID);
-                                    try { detailTexture[i] = (Bitmap)CSJ2K.J2kImage.FromBytes(asset.Data); }
+                            if (detailTexture[i] != null)
-                                    catch (Exception ex)
+                            {    
+                                // Make sure this texture is the correct size, otherwise resize
+                                if (detailTexture[i].Width != 256 || detailTexture[i].Height != 256)
+                                {
+                                    using (Bitmap origBitmap = detailTexture[i])
                                    {
-                                        m_log.Warn("Failed to decode terrain texture " + asset.ID + ": " + ex.Message);
+                                        detailTexture[i] = ImageUtils.ResizeImage(origBitmap, 256, 256);
                                    }
                                }
-    
-                                if (detailTexture[i] != null)
+                                // Save the decoded and resized texture to the cache
-                                {    
+                                byte[] data;
-                                    // Make sure this texture is the correct size, otherwise resize
+                                using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
-                                    if (detailTexture[i].Width != 256 || detailTexture[i].Height != 256)
+                                {
-                                    {
+                                    detailTexture[i].Save(stream, ImageFormat.Png);
-                                        using (Bitmap origBitmap = detailTexture[i])
+                                    data = stream.ToArray();
-                                        {
-                                            detailTexture[i] = ImageUtils.ResizeImage(origBitmap, 256, 256);
-                                        }
-                                    }
-    
-                                    // Save the decoded and resized texture to the cache
-                                    byte[] data;
-                                    using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
-                                    {
-                                        detailTexture[i].Save(stream, ImageFormat.Png);
-                                        data = stream.ToArray();
-                                    }
-    
-                                    // Cache a PNG copy of this terrain texture
-                                    AssetBase newAsset = new AssetBase
-                                    {
-                                        Data = data,
-                                        Description = "PNG",
-                                        Flags = AssetFlags.Collectable,
-                                        FullID = cacheID,
-                                        ID = cacheID.ToString(),
-                                        Local = true,
-                                        Name = String.Empty,
-                                        Temporary = true,
-                                        Type = (sbyte)AssetType.Unknown
-                                    };
-                                    newAsset.Metadata.ContentType = "image/png";
-                                    assetService.Store(newAsset);
                                }
+                                // Cache a PNG copy of this terrain texture
+                                AssetBase newAsset = new AssetBase
+                                {
+                                    Data = data,
+                                    Description = "PNG",
+                                    Flags = AssetFlags.Collectable,
+                                    FullID = cacheID,
+                                    ID = cacheID.ToString(),
+                                    Local = true,
+                                    Name = String.Empty,
+                                    Temporary = true,
+                                    Type = (sbyte)AssetType.Unknown
+                                };
+                                newAsset.Metadata.ContentType = "image/png";
+                                assetService.Store(newAsset);
                            }
                        }
                    }
-    
-                    #endregion Texture Fetching
                }
-    
-                // Fill in any missing textures with a solid color
+                #endregion Texture Fetching
-                for (int i = 0; i < 4; i++)
+            }
+            // Fill in any missing textures with a solid color
+            for (int i = 0; i < 4; i++)
+            {
+                if (detailTexture[i] == null)
                {
-                    if (detailTexture[i] == null)
+                    m_log.DebugFormat("{0} Missing terrain texture for layer {1}. Filling with solid default color",
+                                                            LogHeader, i);
+                    // Create a solid color texture for this layer
+                    detailTexture[i] = new Bitmap(256, 256, PixelFormat.Format24bppRgb);
+                    using (Graphics gfx = Graphics.FromImage(detailTexture[i]))
                    {
-//                        m_log.DebugFormat(
+                        using (SolidBrush brush = new SolidBrush(DEFAULT_TERRAIN_COLOR[i]))
-//                            "[TERRAIN SPLAT]: Generating solid colour for missing texture {0}", i);
+                            gfx.FillRectangle(brush, 0, 0, 256, 256);
-                        // Create a solid color texture for this layer
-                        detailTexture[i] = new Bitmap(256, 256, PixelFormat.Format24bppRgb);
-                        using (Graphics gfx = Graphics.FromImage(detailTexture[i]))
-                        {
-                            using (SolidBrush brush = new SolidBrush(DEFAULT_TERRAIN_COLOR[i]))
-                                gfx.FillRectangle(brush, 0, 0, 256, 256);
-                        }
                    }
                }
-    
+                else
-                #region Layer Map
-    
-                float[] layermap = new float[256 * 256];
-    
-                for (int y = 0; y < 256; y++)
                {
-                    for (int x = 0; x < 256; x++)
+                    if (detailTexture[i].Width != 256 || detailTexture[i].Height != 256)
                    {
-                        float height = heightmap[y * 256 + x];
+                        detailTexture[i] = ResizeBitmap(detailTexture[i], 256, 256);
-    
-                        float pctX = (float)x / 255f;
-                        float pctY = (float)y / 255f;
-    
-                        // Use bilinear interpolation between the four corners of start height and 
-                        // height range to select the current values at this position
-                        float startHeight = ImageUtils.Bilinear(
-                            startHeights[0],
-                            startHeights[2],
-                            startHeights[1],
-                            startHeights[3],
-                            pctX, pctY);
-                        startHeight = Utils.Clamp(startHeight, 0f, 255f);
-    
-                        float heightRange = ImageUtils.Bilinear(
-                            heightRanges[0],
-                            heightRanges[2],
-                            heightRanges[1],
-                            heightRanges[3],
-                            pctX, pctY);
-                        heightRange = Utils.Clamp(heightRange, 0f, 255f);
-    
-                        // Generate two frequencies of perlin noise based on our global position
-                        // The magic values were taken from http://opensimulator.org/wiki/Terrain_Splatting
-                        Vector3 vec = new Vector3
-                        (
-                            ((float)regionPosition.X + x) * 0.20319f,
-                            ((float)regionPosition.Y + y) * 0.20319f,
-                            height * 0.25f
-                        );
-    
-                        float lowFreq = Perlin.noise2(vec.X * 0.222222f, vec.Y * 0.222222f) * 6.5f;
-                        float highFreq = Perlin.turbulence2(vec.X, vec.Y, 2f) * 2.25f;
-                        float noise = (lowFreq + highFreq) * 2f;
-    
-                        // Combine the current height, generated noise, start height, and height range parameters, then scale all of it 
-                        float layer = ((height + noise - startHeight) / heightRange) * 4f;
-                        if (Single.IsNaN(layer)) layer = 0f;
-                        layermap[y * 256 + x] = Utils.Clamp(layer, 0f, 3f);
                    }
                }
-    
+            }
-                #endregion Layer Map
-    
+            #region Layer Map
-                #region Texture Compositing
-    
+            float[,] layermap = new float[256, 256];
-                output = new Bitmap(256, 256, PixelFormat.Format24bppRgb);
-                outputData = output.LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);
+            // Scale difference between actual region size and the 256 texture being created
-    
+            int xFactor = terrain.Width / 256;
-                unsafe
+            int yFactor = terrain.Height / 256;
+            // Create 'layermap' where each value is the fractional layer number to place
+            //    at that point. For instance, a value of 1.345 gives the blending of
+            //    layer 1 and layer 2 for that point.
+            for (int y = 0; y < 256; y++)
+            {
+                for (int x = 0; x < 256; x++)
                {
-                    // Get handles to all of the texture data arrays
+                    float height = (float)terrain[x * xFactor, y * yFactor];
-                    BitmapData[] datas = new BitmapData[]
-                    {
+                    float pctX = (float)x / 255f;
-                        detailTexture[0].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[0].PixelFormat),
+                    float pctY = (float)y / 255f;
-                        detailTexture[1].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[1].PixelFormat),
-                        detailTexture[2].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[2].PixelFormat),
+                    // Use bilinear interpolation between the four corners of start height and 
-                        detailTexture[3].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[3].PixelFormat)
+                    // height range to select the current values at this position
-                    };
+                    float startHeight = ImageUtils.Bilinear(
-    
+                        startHeights[0],
-                    int[] comps = new int[]
+                        startHeights[2],
-                    {
+                        startHeights[1],
-                        (datas[0].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3,
+                        startHeights[3],
-                        (datas[1].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3,
+                        pctX, pctY);
-                        (datas[2].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3,
+                    startHeight = Utils.Clamp(startHeight, 0f, 255f);
-                        (datas[3].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3
-                    };
+                    float heightRange = ImageUtils.Bilinear(
-    
+                        heightRanges[0],
-                    for (int y = 0; y < 256; y++)
+                        heightRanges[2],
-                    {
+                        heightRanges[1],
-                        for (int x = 0; x < 256; x++)
+                        heightRanges[3],
-                        {
+                        pctX, pctY);
-                            float layer = layermap[y * 256 + x];
+                    heightRange = Utils.Clamp(heightRange, 0f, 255f);
-    
-                            // Select two textures
+                    // Generate two frequencies of perlin noise based on our global position
-                            int l0 = (int)Math.Floor(layer);
+                    // The magic values were taken from http://opensimulator.org/wiki/Terrain_Splatting
-                            int l1 = Math.Min(l0 + 1, 3);
+                    Vector3 vec = new Vector3
-    
+                    (
-                            byte* ptrA = (byte*)datas[l0].Scan0 + y * datas[l0].Stride + x * comps[l0];
+                        ((float)regionPosition.X + (x * xFactor)) * 0.20319f,
-                            byte* ptrB = (byte*)datas[l1].Scan0 + y * datas[l1].Stride + x * comps[l1];
+                        ((float)regionPosition.Y + (y * yFactor)) * 0.20319f,
-                            byte* ptrO = (byte*)outputData.Scan0 + y * outputData.Stride + x * 3;
+                        height * 0.25f
-    
+                    );
-                            float aB = *(ptrA + 0);
-                            float aG = *(ptrA + 1);
+                    float lowFreq = Perlin.noise2(vec.X * 0.222222f, vec.Y * 0.222222f) * 6.5f;
-                            float aR = *(ptrA + 2);
+                    float highFreq = Perlin.turbulence2(vec.X, vec.Y, 2f) * 2.25f;
-    
+                    float noise = (lowFreq + highFreq) * 2f;
-                            float bB = *(ptrB + 0);
-                            float bG = *(ptrB + 1);
+                    // Combine the current height, generated noise, start height, and height range parameters, then scale all of it 
-                            float bR = *(ptrB + 2);
+                    float layer = ((height + noise - startHeight) / heightRange) * 4f;
-    
+                    if (Single.IsNaN(layer))
-                            float layerDiff = layer - l0;
+                        layer = 0f;
-    
+                    layermap[x, y] = Utils.Clamp(layer, 0f, 3f);
-                            // Interpolate between the two selected textures
-                            *(ptrO + 0) = (byte)Math.Floor(aB + layerDiff * (bB - aB));
-                            *(ptrO + 1) = (byte)Math.Floor(aG + layerDiff * (bG - aG));
-                            *(ptrO + 2) = (byte)Math.Floor(aR + layerDiff * (bR - aR));
-                        }
-                    }
-    
-                    for (int i = 0; i < 4; i++)
-                        detailTexture[i].UnlockBits(datas[i]);
                }
            }
-            finally
+            #endregion Layer Map
+            #region Texture Compositing
+            Bitmap output = new Bitmap(256, 256, PixelFormat.Format24bppRgb);
+            BitmapData outputData = output.LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb);
+            // Unsafe work as we lock down the source textures for quicker access and access the
+            //    pixel data directly
+            unsafe
            {
-                for (int i = 0; i < 4; i++)
+                // Get handles to all of the texture data arrays
-                    if (detailTexture[i] != null)
+                BitmapData[] datas = new BitmapData[]
-                        detailTexture[i].Dispose();
+                {
+                    detailTexture[0].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[0].PixelFormat),
+                    detailTexture[1].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[1].PixelFormat),
+                    detailTexture[2].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[2].PixelFormat),
+                    detailTexture[3].LockBits(new Rectangle(0, 0, 256, 256), ImageLockMode.ReadOnly, detailTexture[3].PixelFormat)
+                };
+                // Compute size of each pixel data (used to address into the pixel data array)
+                int[] comps = new int[]
+                {
+                    (datas[0].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3,
+                    (datas[1].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3,
+                    (datas[2].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3,
+                    (datas[3].PixelFormat == PixelFormat.Format32bppArgb) ? 4 : 3
+                };
+                for (int y = 0; y < 256; y++)
+                {
+                    for (int x = 0; x < 256; x++)
+                    {
+                        float layer = layermap[x, y];
+                        // Select two textures
+                        int l0 = (int)Math.Floor(layer);
+                        int l1 = Math.Min(l0 + 1, 3);
+                        byte* ptrA = (byte*)datas[l0].Scan0 + y * datas[l0].Stride + x * comps[l0];
+                        byte* ptrB = (byte*)datas[l1].Scan0 + y * datas[l1].Stride + x * comps[l1];
+                        byte* ptrO = (byte*)outputData.Scan0 + y * outputData.Stride + x * 3;
+                        float aB = *(ptrA + 0);
+                        float aG = *(ptrA + 1);
+                        float aR = *(ptrA + 2);
+                        float bB = *(ptrB + 0);
+                        float bG = *(ptrB + 1);
+                        float bR = *(ptrB + 2);
+                        float layerDiff = layer - l0;
+                        // Interpolate between the two selected textures
+                        *(ptrO + 0) = (byte)Math.Floor(aB + layerDiff * (bB - aB));
+                        *(ptrO + 1) = (byte)Math.Floor(aG + layerDiff * (bG - aG));
+                        *(ptrO + 2) = (byte)Math.Floor(aR + layerDiff * (bR - aR));
+                    }
+                }
+                for (int i = 0; i < detailTexture.Length; i++)
+                    detailTexture[i].UnlockBits(datas[i]);
            }
+            for (int i = 0; i < detailTexture.Length; i++)
+                if (detailTexture[i] != null)
+                    detailTexture[i].Dispose();
            output.UnlockBits(outputData);
            // We generated the texture upside down, so flip it
@@ -331,6 +342,17 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
            return output;
        }
+        public static Bitmap ResizeBitmap(Bitmap b, int nWidth, int nHeight)
+        {
+            m_log.DebugFormat("{0} ResizeBitmap. From <{1},{2}> to <{3},{4}>",
+                                LogHeader, b.Width, b.Height, nWidth, nHeight);
+            Bitmap result = new Bitmap(nWidth, nHeight);
+            using (Graphics g = Graphics.FromImage(result))
+                g.DrawImage(b, 0, 0, nWidth, nHeight);
+            b.Dispose();
+            return result;
+        }
        public static Bitmap SplatSimple(float[] heightmap)
        {
            const float BASE_HSV_H = 93f / 360f;
diff --git a/OpenSim/Region/CoreModules/World/Warp3DMap/Warp3DImageModule.cs b/OpenSim/Region/CoreModules/World/Warp3DMap/Warp3DImageModule.cs
index ed2b06a..f072268 100644
--- a/OpenSim/Region/CoreModules/World/Warp3DMap/Warp3DImageModule.cs
+++ b/OpenSim/Region/CoreModules/World/Warp3DMap/Warp3DImageModule.cs
@@ -31,21 +31,25 @@ using System.Drawing;
 using System.Drawing.Imaging;
 using System.IO;
 using System.Reflection;
 using CSJ2K;
 using Nini.Config;
 using log4net;
 using Rednettle.Warp3D;
 using Mono.Addins;
-using OpenMetaverse;
-using OpenMetaverse.Imaging;
-using OpenMetaverse.Rendering;
-using OpenMetaverse.StructuredData;
 using OpenSim.Framework;
 using OpenSim.Region.Framework.Interfaces;
 using OpenSim.Region.Framework.Scenes;
 using OpenSim.Region.Physics.Manager;
 using OpenSim.Services.Interfaces;
+using OpenMetaverse;
+using OpenMetaverse.Assets;
+using OpenMetaverse.Imaging;
+using OpenMetaverse.Rendering;
+using OpenMetaverse.StructuredData;
 using WarpRenderer = global::Warp3D.Warp3D;
 namespace OpenSim.Region.CoreModules.World.Warp3DMap
@@ -57,12 +61,20 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
        private static readonly Color4 WATER_COLOR = new Color4(29, 72, 96, 216);
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static string LogHeader = "[WARP 3D IMAGE MODULE]";
        private Scene m_scene;
        private IRendering m_primMesher;
-        private IConfigSource m_config;
        private Dictionary<UUID, Color4> m_colors = new Dictionary<UUID, Color4>();
-        private bool m_useAntiAliasing = false; // TODO: Make this a config option
+        private IConfigSource m_config;
+        private bool m_drawPrimVolume = true;   // true if should render the prims on the tile
+        private bool m_textureTerrain = true;   // true if to create terrain splatting texture
+        private bool m_texturePrims = true;     // true if should texture the rendered prims
+        private float m_texturePrimSize = 48f;  // size of prim before we consider texturing it
+        private bool m_renderMeshes = false;    // true if to render meshes rather than just bounding boxes
+        private bool m_useAntiAliasing = false; // true if to anti-alias the rendered image
        private bool m_Enabled = false;
        #region Region Module interface
@@ -71,11 +83,27 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
        {
            m_config = source;
+            string[] configSections = new string[] { "Map", "Startup" };
            if (Util.GetConfigVarFromSections<string>(
-                m_config, "MapImageModule", new string[] { "Startup", "Map" }, "MapImageModule") != "Warp3DImageModule")
+                m_config, "MapImageModule", configSections, "MapImageModule") != "Warp3DImageModule")
                return;
            m_Enabled = true;
+            m_drawPrimVolume 
+                = Util.GetConfigVarFromSections<bool>(m_config, "DrawPrimOnMapTile", configSections, m_drawPrimVolume);
+            m_textureTerrain 
+                = Util.GetConfigVarFromSections<bool>(m_config, "TextureOnMapTile", configSections, m_textureTerrain);
+            m_texturePrims
+                = Util.GetConfigVarFromSections<bool>(m_config, "TexturePrims", configSections, m_texturePrims);
+            m_texturePrimSize
+                = Util.GetConfigVarFromSections<float>(m_config, "TexturePrimSize", configSections, m_texturePrimSize);
+            m_renderMeshes
+                = Util.GetConfigVarFromSections<bool>(m_config, "RenderMeshes", configSections, m_renderMeshes);
+            m_useAntiAliasing
+                = Util.GetConfigVarFromSections<bool>(m_config, "UseAntiAliasing", configSections, m_useAntiAliasing);
        }
        public void AddRegion(Scene scene)
@@ -127,29 +155,28 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
        public Bitmap CreateMapTile()
        {
-            Vector3 camPos = new Vector3(127.5f, 127.5f, 221.7025033688163f);
+            // Vector3 camPos = new Vector3(127.5f, 127.5f, 221.7025033688163f);
-            Viewport viewport = new Viewport(camPos, -Vector3.UnitZ, 1024f, 0.1f, (int)Constants.RegionSize, (int)Constants.RegionSize, (float)Constants.RegionSize, (float)Constants.RegionSize);
+            // Camera above the middle of the region
+            Vector3 camPos = new Vector3(
+                            m_scene.RegionInfo.RegionSizeX/2 - 0.5f,
+                            m_scene.RegionInfo.RegionSizeY/2 - 0.5f,
+                            221.7025033688163f);
+            // Viewport viewing down onto the region
+            Viewport viewport = new Viewport(camPos, -Vector3.UnitZ, 1024f, 0.1f,
+                        (int)m_scene.RegionInfo.RegionSizeX, (int)m_scene.RegionInfo.RegionSizeY,
+                        (float)m_scene.RegionInfo.RegionSizeX, (float)m_scene.RegionInfo.RegionSizeY );
+            // Fill the viewport and return the image
            return CreateMapTile(viewport, false);
        }
        public Bitmap CreateViewImage(Vector3 camPos, Vector3 camDir, float fov, int width, int height, bool useTextures)
        {
-            Viewport viewport = new Viewport(camPos, camDir, fov, (float)Constants.RegionSize, 0.1f, width, height);
+            Viewport viewport = new Viewport(camPos, camDir, fov, Constants.RegionSize,  0.1f, width, height);
            return CreateMapTile(viewport, useTextures);
        }
        public Bitmap CreateMapTile(Viewport viewport, bool useTextures)
        {
-            bool drawPrimVolume = true;
-            bool textureTerrain = true;
-            string[] configSections = new string[] { "Map", "Startup" };
-            drawPrimVolume 
-                = Util.GetConfigVarFromSections<bool>(m_config, "DrawPrimOnMapTile", configSections, drawPrimVolume);
-            textureTerrain 
-                = Util.GetConfigVarFromSections<bool>(m_config, "TextureOnMapTile", configSections, textureTerrain);
            m_colors.Clear();
            int width = viewport.Width;
@@ -193,8 +220,8 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
            renderer.Scene.addLight("Light2", new warp_Light(new warp_Vector(-1f, -1f, 1f), 0xffffff, 0, 100, 40));
            CreateWater(renderer);
-            CreateTerrain(renderer, textureTerrain);
+            CreateTerrain(renderer, m_textureTerrain);
-            if (drawPrimVolume)
+            if (m_drawPrimVolume)
                CreateAllPrims(renderer, useTextures);
            renderer.Render();
@@ -210,6 +237,16 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
            // afterwards.  It's generally regarded as a bad idea to manually GC.  If Warp3D is using lots of memory
            // then this may be some issue with the Warp3D code itself, though it's also quite possible that generating
            // this map tile simply takes a lot of memory.
+            foreach (var o in renderer.Scene.objectData.Values)
+            {
+                warp_Object obj = (warp_Object)o;
+                obj.vertexData = null;
+                obj.triangleData = null;
+            }
+            renderer.Scene.removeAllObjects();
+            renderer = null;
+            viewport = null;
+            m_colors.Clear();
            GC.Collect();
            m_log.Debug("[WARP 3D IMAGE MODULE]: GC.Collect()");
@@ -236,61 +273,74 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
        #region Rendering Methods
+        // Add a water plane to the renderer.
        private void CreateWater(WarpRenderer renderer)
        {
            float waterHeight = (float)m_scene.RegionInfo.RegionSettings.WaterHeight;
-            renderer.AddPlane("Water", 256f * 0.5f);
+            renderer.AddPlane("Water", m_scene.RegionInfo.RegionSizeX * 0.5f);
-            renderer.Scene.sceneobject("Water").setPos(127.5f, waterHeight, 127.5f);
+            renderer.Scene.sceneobject("Water").setPos(m_scene.RegionInfo.RegionSizeX/2 - 0.5f,
+                                                       waterHeight,
+                                                       m_scene.RegionInfo.RegionSizeY/2 - 0.5f );
-            renderer.AddMaterial("WaterColor", ConvertColor(WATER_COLOR));
+            warp_Material waterColorMaterial = new warp_Material(ConvertColor(WATER_COLOR));
-                        renderer.Scene.material("WaterColor").setReflectivity(0);  // match water color with standard map module thanks lkalif
+                        waterColorMaterial.setReflectivity(0);  // match water color with standard map module thanks lkalif
-            renderer.Scene.material("WaterColor").setTransparency((byte)((1f - WATER_COLOR.A) * 255f));
+            waterColorMaterial.setTransparency((byte)((1f - WATER_COLOR.A) * 255f));
+            renderer.Scene.addMaterial("WaterColor", waterColorMaterial);
            renderer.SetObjectMaterial("Water", "WaterColor");
        }
+        // Add a terrain to the renderer.
+        // Note that we create a 'low resolution' 256x256 vertex terrain rather than trying for
+        //    full resolution. This saves a lot of memory especially for very large regions.
        private void CreateTerrain(WarpRenderer renderer, bool textureTerrain)
        {
            ITerrainChannel terrain = m_scene.Heightmap;
-            float[] heightmap = terrain.GetFloatsSerialised();
+            // 'diff' is the difference in scale between the real region size and the size of terrain we're buiding
+            float diff = (float)m_scene.RegionInfo.RegionSizeX / 256f;
            warp_Object obj = new warp_Object(256 * 256, 255 * 255 * 2);
-            for (int y = 0; y < 256; y++)
+            // Create all the vertices for the terrain
+            for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diff)
            {
-                for (int x = 0; x < 256; x++)
+                for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diff)
                {
-                    int v = y * 256 + x;
+                    warp_Vector pos = ConvertVector(x, y, (float)terrain[(int)x, (int)y]);
-                    float height = heightmap[v];
+                    obj.addVertex(new warp_Vertex(pos,
+                        x / (float)m_scene.RegionInfo.RegionSizeX,
-                    warp_Vector pos = ConvertVector(new Vector3(x, y, height));
+                        (((float)m_scene.RegionInfo.RegionSizeY) - y) / m_scene.RegionInfo.RegionSizeY) );
-                    obj.addVertex(new warp_Vertex(pos, (float)x / 255f, (float)(255 - y) / 255f));
                }
            }
-            for (int y = 0; y < 256; y++)
+            // Now that we have all the vertices, make another pass and create
+            //     the normals for each of the surface triangles and
+            //     create the list of triangle indices.
+            for (float y = 0; y < m_scene.RegionInfo.RegionSizeY; y += diff)
            {
-                for (int x = 0; x < 256; x++)
+                for (float x = 0; x < m_scene.RegionInfo.RegionSizeX; x += diff)
                {
-                    if (x < 255 && y < 255)
+                    float newX = x / diff;
+                    float newY = y / diff;
+                    if (newX < 255 && newY < 255)
                    {
-                        int v = y * 256 + x;
+                        int v = (int)newY * 256 + (int)newX;
-                        // Normal
+                        // Normal for a triangle made up of three adjacent vertices
-                        Vector3 v1 = new Vector3(x, y, heightmap[y * 256 + x]);
+                        Vector3 v1 = new Vector3(newX, newY, (float)terrain[(int)x, (int)y]);
-                        Vector3 v2 = new Vector3(x + 1, y, heightmap[y * 256 + x + 1]);
+                        Vector3 v2 = new Vector3(newX + 1, newY, (float)terrain[(int)(x + 1), (int)y]);
-                        Vector3 v3 = new Vector3(x, y + 1, heightmap[(y + 1) * 256 + x]);
+                        Vector3 v3 = new Vector3(newX, newY + 1, (float)terrain[(int)x, ((int)(y + 1))]);
                        warp_Vector norm = ConvertVector(SurfaceNormal(v1, v2, v3));
                        norm = norm.reverse();
                        obj.vertex(v).n = norm;
-                        // Triangle 1
+                        // Make two triangles for each of the squares in the grid of vertices
                        obj.addTriangle(
                            v,
                            v + 1,
                            v + 256);
-                        // Triangle 2
                        obj.addTriangle(
                            v + 256 + 1,
                            v + 256,
@@ -305,7 +355,7 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
            float[] startHeights = new float[4];
            float[] heightRanges = new float[4];
-            RegionSettings regionInfo = m_scene.RegionInfo.RegionSettings;
+            OpenSim.Framework.RegionSettings regionInfo = m_scene.RegionInfo.RegionSettings;
            textureIDs[0] = regionInfo.TerrainTexture1;
            textureIDs[1] = regionInfo.TerrainTexture2;
@@ -323,16 +373,18 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
            heightRanges[3] = (float)regionInfo.Elevation2NE;
            uint globalX, globalY;
-            Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out globalX, out globalY);
+            Util.RegionHandleToWorldLoc(m_scene.RegionInfo.RegionHandle, out globalX, out globalY);
            warp_Texture texture;
            using (
                Bitmap image
-                    = TerrainSplat.Splat(
+                    = TerrainSplat.Splat(terrain, textureIDs, startHeights, heightRanges,
-                        heightmap, textureIDs, startHeights, heightRanges,
                        new Vector3d(globalX, globalY, 0.0), m_scene.AssetService, textureTerrain))
            {
+                image.Save( // DEBUG DEBUG
+                            String.Format("maptiles/splat-{0}-{1}-{2}.jpg", m_scene.RegionInfo.RegionName,
+                                        m_scene.RegionInfo.RegionLocX, m_scene.RegionInfo.RegionLocY),
+                            ImageFormat.Jpeg);
                texture = new warp_Texture(image);
            }
@@ -368,8 +420,48 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
            if (prim.Scale.LengthSquared() < MIN_SIZE * MIN_SIZE)
                return;
+            FacetedMesh renderMesh = null;
            Primitive omvPrim = prim.Shape.ToOmvPrimitive(prim.OffsetPosition, prim.RotationOffset);
-            FacetedMesh renderMesh = m_primMesher.GenerateFacetedMesh(omvPrim, DetailLevel.Medium);
+            if (m_renderMeshes)
+            {
+                if (omvPrim.Sculpt != null && omvPrim.Sculpt.SculptTexture != UUID.Zero)
+                {
+                    // Try fetchinng the asset
+                    byte[] sculptAsset = m_scene.AssetService.GetData(omvPrim.Sculpt.SculptTexture.ToString());
+                    if (sculptAsset != null)
+                    {
+                        // Is it a mesh?
+                        if (omvPrim.Sculpt.Type == SculptType.Mesh)
+                        {
+                            AssetMesh meshAsset = new AssetMesh(omvPrim.Sculpt.SculptTexture, sculptAsset);
+                            FacetedMesh.TryDecodeFromAsset(omvPrim, meshAsset, DetailLevel.Highest, out renderMesh);
+                            meshAsset = null;
+                        }
+                        else // It's sculptie
+                        {
+                            IJ2KDecoder imgDecoder = m_scene.RequestModuleInterface<IJ2KDecoder>();
+                            if (imgDecoder != null)
+                            {
+                                Image sculpt = imgDecoder.DecodeToImage(sculptAsset);
+                                if (sculpt != null)
+                                {
+                                    renderMesh = m_primMesher.GenerateFacetedSculptMesh(omvPrim, (Bitmap)sculpt,
+                                                                                        DetailLevel.Medium);
+                                    sculpt.Dispose();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // If not a mesh or sculptie, try the regular mesher
+            if (renderMesh == null)
+            {
+                renderMesh = m_primMesher.GenerateFacetedMesh(omvPrim, DetailLevel.Medium);
+            }
            if (renderMesh == null)
                return;
@@ -428,7 +520,11 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
                Primitive.TextureEntryFace teFace = prim.Shape.Textures.GetFace((uint)i);
                Color4 faceColor = GetFaceColor(teFace);
-                string materialName = GetOrCreateMaterial(renderer, faceColor);
+                string materialName = String.Empty;
+                if (m_texturePrims && prim.Scale.LengthSquared() > m_texturePrimSize*m_texturePrimSize)
+                    materialName = GetOrCreateMaterial(renderer, faceColor, teFace.TextureID);
+                else
+                    materialName = GetOrCreateMaterial(renderer, faceColor);
                faceObj.transform(m);
                faceObj.setPos(primPos);
@@ -517,10 +613,51 @@ namespace OpenSim.Region.CoreModules.World.Warp3DMap
            return name;
        }
+        public string GetOrCreateMaterial(WarpRenderer renderer, Color4 faceColor, UUID textureID)
+        {
+            string materialName = "Color-" + faceColor.ToString() + "-Texture-" + textureID.ToString();
+            if (renderer.Scene.material(materialName) == null)
+            {
+                renderer.AddMaterial(materialName, ConvertColor(faceColor));
+                if (faceColor.A < 1f)
+                {
+                    renderer.Scene.material(materialName).setTransparency((byte) ((1f - faceColor.A)*255f));
+                }
+                warp_Texture texture = GetTexture(textureID);
+                if (texture != null)
+                    renderer.Scene.material(materialName).setTexture(texture);
+            }
+            return materialName;
+        }
+        private warp_Texture GetTexture(UUID id)
+        {
+            warp_Texture ret = null;
+            byte[] asset = m_scene.AssetService.GetData(id.ToString());
+            if (asset != null)
+            {
+                IJ2KDecoder imgDecoder = m_scene.RequestModuleInterface<IJ2KDecoder>();
+                Bitmap img = (Bitmap) imgDecoder.DecodeToImage(asset);
+                if (img != null)
+                {
+                    return new warp_Texture(img);
+                }
+            }
+            return ret;
+        }
        #endregion Rendering Methods
        #region Static Helpers
+        // Note: axis change.
+        private static warp_Vector ConvertVector(float x, float y, float z)
+        {
+            return new warp_Vector(x, z, y);
+        }
        private static warp_Vector ConvertVector(Vector3 vector)
        {
            return new warp_Vector(vector.X, vector.Z, vector.Y);
diff --git a/OpenSim/Region/CoreModules/World/WorldMap/MapSearchModule.cs b/OpenSim/Region/CoreModules/World/WorldMap/MapSearchModule.cs
index 708a9a2..1fb1aba 100644
--- a/OpenSim/Region/CoreModules/World/WorldMap/MapSearchModule.cs
+++ b/OpenSim/Region/CoreModules/World/WorldMap/MapSearchModule.cs
@@ -184,8 +184,8 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
                        data.Name = info.RegionName;
                    data.RegionFlags = 0; // TODO not used?
                    data.WaterHeight = 0; // not used
-                    data.X = (ushort)(info.RegionLocX / Constants.RegionSize);
+                    data.X = (ushort)Util.WorldToRegionLoc((uint)info.RegionLocX);
-                    data.Y = (ushort)(info.RegionLocY / Constants.RegionSize);
+                    data.Y = (ushort)Util.WorldToRegionLoc((uint)info.RegionLocY);
                    blocks.Add(data);
                }
            }
diff --git a/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs b/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
index cdf1467..e925f0d 100644
--- a/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
+++ b/OpenSim/Region/CoreModules/World/WorldMap/WorldMapModule.cs
@@ -277,11 +277,12 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
                    {
                        List<MapBlockData> mapBlocks = new List<MapBlockData>(); ;
+                        // Get regions that are within 8 regions of here
                        List<GridRegion> regions = m_scene.GridService.GetRegionRange(m_scene.RegionInfo.ScopeID,
-                            (int)(m_scene.RegionInfo.RegionLocX - 8) * (int)Constants.RegionSize,
+                                    (int)Util.RegionToWorldLoc(m_scene.RegionInfo.RegionLocX - 8),
-                            (int)(m_scene.RegionInfo.RegionLocX + 8) * (int)Constants.RegionSize,
+                                    (int)Util.RegionToWorldLoc(m_scene.RegionInfo.RegionLocX + 8),
-                            (int)(m_scene.RegionInfo.RegionLocY - 8) * (int)Constants.RegionSize,
+                                    (int)Util.RegionToWorldLoc(m_scene.RegionInfo.RegionLocY - 8),
-                            (int)(m_scene.RegionInfo.RegionLocY + 8) * (int)Constants.RegionSize);
+                                    (int)Util.RegionToWorldLoc(m_scene.RegionInfo.RegionLocY + 8) );
                        foreach (GridRegion r in regions)
                        {
                            MapBlockData block = new MapBlockData();
@@ -405,7 +406,7 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
            }
            uint xstart = 0;
            uint ystart = 0;
-            Utils.LongToUInts(m_scene.RegionInfo.RegionHandle, out xstart, out ystart);
+            Util.RegionHandleToWorldLoc(m_scene.RegionInfo.RegionHandle, out xstart, out ystart);
            if (itemtype == 6) // Service 6 right now (MAP_ITEM_AGENTS_LOCATION; green dots)
            {
                if (regionhandle == 0 || regionhandle == m_scene.RegionInfo.RegionHandle)
@@ -803,7 +804,7 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
            if (httpserver.Length == 0)
            {
                uint x = 0, y = 0;
-                Utils.LongToUInts(regionhandle, out x, out y);
+                Util.RegionHandleToWorldLoc(regionhandle, out x, out y);
                GridRegion mreg = m_scene.GridService.GetRegionByPosition(m_scene.RegionInfo.ScopeID, (int)x, (int)y);
                if (mreg != null)
@@ -1011,17 +1012,15 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
                // on an unloaded square.
                // But make sure: Look whether the one we requested is in there
                List<GridRegion> regions = m_scene.GridService.GetRegionRange(m_scene.RegionInfo.ScopeID,
-                    minX * (int)Constants.RegionSize,
+                                    (int)Util.RegionToWorldLoc((uint)minX), (int)Util.RegionToWorldLoc((uint)maxX),
-                    maxX * (int)Constants.RegionSize,
+                                    (int)Util.RegionToWorldLoc((uint)minY), (int)Util.RegionToWorldLoc((uint)maxY) );
-                    minY * (int)Constants.RegionSize,
-                    maxY * (int)Constants.RegionSize);
                if (regions != null)
                {
                    foreach (GridRegion r in regions)
                    {
-                        if ((r.RegionLocX == minX * (int)Constants.RegionSize) &&
+                        if (r.RegionLocX == Util.RegionToWorldLoc((uint)minX)
-                            (r.RegionLocY == minY * (int)Constants.RegionSize))
+                            && r.RegionLocY == Util.RegionToWorldLoc((uint)minY) )
                        {
                            // found it => add it to response
                            MapBlockData block = new MapBlockData();
@@ -1055,10 +1054,8 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
        {
            List<MapBlockData> mapBlocks = new List<MapBlockData>();
            List<GridRegion> regions = m_scene.GridService.GetRegionRange(m_scene.RegionInfo.ScopeID,
-                (minX - 4) * (int)Constants.RegionSize,
+                        (int)Util.RegionToWorldLoc((uint)(minX - 4)), (int)Util.RegionToWorldLoc((uint)(maxX + 4)),
-                (maxX + 4) * (int)Constants.RegionSize,
+                        (int)Util.RegionToWorldLoc((uint)(minY - 4)), (int)Util.RegionToWorldLoc((uint)(maxY + 4)) );
-                (minY - 4) * (int)Constants.RegionSize,
-                (maxY + 4) * (int)Constants.RegionSize);
            foreach (GridRegion r in regions)
            {
                MapBlockData block = new MapBlockData();
@@ -1086,8 +1083,8 @@ namespace OpenSim.Region.CoreModules.World.WorldMap
                break;
            }
            block.Name = r.RegionName;
-            block.X = (ushort)(r.RegionLocX / Constants.RegionSize);
+            block.X = (ushort)Util.WorldToRegionLoc((uint)r.RegionLocX);
-            block.Y = (ushort)(r.RegionLocY / Constants.RegionSize);
+            block.Y = (ushort)Util.WorldToRegionLoc((uint)r.RegionLocY);
        }
        public Hashtable OnHTTPThrottled(Hashtable keysvals)
@@ -1218,10 +1215,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)Util.RegionToWorldLoc(m_scene.RegionInfo.RegionLocX - 9),
-                    (int)(m_scene.RegionInfo.RegionLocX + 9) * (int)Constants.RegionSize,
+                    (int)Util.RegionToWorldLoc(m_scene.RegionInfo.RegionLocX + 9),
-                    (int)(m_scene.RegionInfo.RegionLocY - 9) * (int)Constants.RegionSize,
+                    (int)Util.RegionToWorldLoc(m_scene.RegionInfo.RegionLocY - 9),
-                    (int)(m_scene.RegionInfo.RegionLocY + 9) * (int)Constants.RegionSize);
+                    (int)Util.RegionToWorldLoc(m_scene.RegionInfo.RegionLocY + 9));
            List<AssetBase> textures = new List<AssetBase>();
            List<Image> bitImages = new List<Image>();
diff --git a/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs b/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
index 214b07a..709d8fc 100644
--- a/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
@@ -92,12 +92,11 @@ namespace OpenSim.Region.Framework.Interfaces
        void EnableChildAgent(ScenePresence agent, GridRegion region);
-        GridRegion GetDestination(Scene scene, UUID agentID, Vector3 pos, out uint xDest, out uint yDest, out string version, out Vector3 newpos);
+        GridRegion GetDestination(Scene scene, UUID agentID, Vector3 pos, out string version, out Vector3 newpos);
        void Cross(SceneObjectGroup sog, Vector3 position, bool silent);
-        ScenePresence CrossAgentToNewRegionAsync(ScenePresence agent, Vector3 pos, GridRegion neighbourRegion, bool isFlying, string version);
+        ScenePresence CrossAgentToNewRegionAsync(ScenePresence agent, Vector3 pos, GridRegion neighbourRegion, bool isFlying, string version);
    }
    public interface IUserAgentVerificationModule
diff --git a/OpenSim/Region/Framework/Interfaces/IJ2KDecoder.cs b/OpenSim/Region/Framework/Interfaces/IJ2KDecoder.cs
index 46d03b3..1cbd045 100644
--- a/OpenSim/Region/Framework/Interfaces/IJ2KDecoder.cs
+++ b/OpenSim/Region/Framework/Interfaces/IJ2KDecoder.cs
@@ -1,4 +1,4 @@
-/*
+/*
 * Copyright (c) Contributors, http://opensimulator.org/
 * See CONTRIBUTORS.TXT for a full list of copyright holders.
 *
@@ -25,6 +25,7 @@
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
+using System.Drawing;
 using OpenMetaverse;
 using OpenMetaverse.Imaging;
@@ -53,5 +54,12 @@ namespace OpenSim.Region.Framework.Interfaces
        /// <param name="components">number of components</param>
        /// <returns>true if decode was successful.  false otherwise.</returns>
        bool Decode(UUID assetID, byte[] j2kData, out OpenJPEG.J2KLayerInfo[] layers, out int components);
+        /// <summary>
+        /// Provides a synchronous decode direct to an image object
+        /// </summary>
+        /// <param name="j2kData"></param>
+        /// <returns>decoded image or 'null' of unsuccessful</returns>
+        Image DecodeToImage(byte[] j2kData);
    }
 }
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..469bd31 100644
--- a/OpenSim/Region/Framework/Interfaces/ITerrainChannel.cs
+++ b/OpenSim/Region/Framework/Interfaces/ITerrainChannel.cs
@@ -25,13 +25,22 @@
 * 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; }
+        float GetHeightAtXYZ(float x, float y, float z);
+        // 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 +49,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.Inventory.cs b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
index 9cc5cde..b86f349 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.Inventory.cs
@@ -46,8 +46,8 @@ namespace OpenSim.Region.Framework.Scenes
 {
    public partial class Scene
    {
-        private static readonly ILog m_log
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-            = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly string LogHeader = "[SCENE INVENTORY]";
        /// <summary>
        /// Allows asynchronous derezzing of objects from the scene into a client's inventory.
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index a9fe556..aee621f 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,8 +1099,9 @@ 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 = Util.WorldToRegionLoc((uint)otherRegion.RegionLocX);
-            uint ycell = (uint)((int)otherRegion.RegionLocY / (int)Constants.RegionSize);
+            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);
@@ -1172,46 +1173,6 @@ namespace OpenSim.Region.Framework.Scenes
            return found;
        }
-        /// <summary>
-        /// Checks whether this region has a neighbour in the given direction.
-        /// </summary>
-        /// <param name="car"></param>
-        /// <param name="fix"></param>
-        /// <returns>
-        /// An integer which represents a compass point.  N == 1, going clockwise until we reach NW == 8.
-        /// Returns a positive integer if there is a region in that direction, a negative integer if not.
-        /// </returns>
-        public int HaveNeighbor(Cardinals car, ref int[] fix)
-        {
-            uint neighbourx = RegionInfo.RegionLocX;
-            uint neighboury = RegionInfo.RegionLocY;
-            int dir = (int)car;
-            if (dir > 1 && dir < 5) //Heading East
-                neighbourx++;
-            else if (dir > 5) // Heading West
-                neighbourx--;
-            if (dir < 3 || dir == 8) // Heading North
-                neighboury++;
-            else if (dir > 3 && dir < 7) // Heading Sout
-                neighboury--;
-            int x = (int)(neighbourx * Constants.RegionSize);
-            int y = (int)(neighboury * Constants.RegionSize);
-            GridRegion neighbourRegion = GridService.GetRegionByPosition(RegionInfo.ScopeID, x, y);
-            if (neighbourRegion == null)
-            {
-                fix[0] = (int)(RegionInfo.RegionLocX - neighbourx);
-                fix[1] = (int)(RegionInfo.RegionLocY - neighboury);
-                return dir * (-1);
-            }
-            else
-                return dir;
-        }
        // Alias IncomingHelloNeighbour OtherRegionUp, for now
        public GridRegion IncomingHelloNeighbour(RegionInfo neighbour)
        {
@@ -1894,7 +1855,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 +1866,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);
                }
@@ -2483,6 +2444,23 @@ namespace OpenSim.Region.Framework.Scenes
                EntityTransferModule.Cross(grp, attemptedPosition, silent);
        }
+        // Simple test to see if a position is in the current region.
+        // Resuming the position is relative to the region so anything outside its bounds.
+        // Return 'true' if position inside region.
+        public bool PositionIsInCurrentRegion(Vector3 pos)
+        {
+            bool ret = true;
+            int xx = (int)Math.Floor(pos.X);
+            int yy = (int)Math.Floor(pos.Y);
+            if (xx < 0
+                    || xx >= RegionInfo.RegionSizeX
+                    || yy < 0
+                    || yy >= RegionInfo.RegionSizeY)
+                ret = false;
+            return ret;
+        }
        public Border GetCrossedBorder(Vector3 position, Cardinals gridline)
        {
            if (BordersLocked)
@@ -3900,6 +3878,7 @@ namespace OpenSim.Region.Framework.Scenes
                {
                    Border crossedBorder = GetCrossedBorder(acd.startpos, Cardinals.E);
                    acd.startpos.X = crossedBorder.BorderLine.Z - 1;
+                    m_log.DebugFormat("{0} NewUserConnection Adjusted border E. startpos={1}", LogHeader, acd.startpos);
                }
                if (TestBorderCross(acd.startpos, Cardinals.N))
@@ -3999,12 +3978,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))
@@ -4298,7 +4277,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(
@@ -4593,44 +4572,6 @@ namespace OpenSim.Region.Framework.Scenes
            ScenePresence sp = GetScenePresence(remoteClient.AgentId);
            if (sp != null)
            {
-                uint regionX = RegionInfo.RegionLocX;
-                uint regionY = RegionInfo.RegionLocY;
-                Utils.LongToUInts(regionHandle, out regionX, out regionY);
-                int shiftx = (int) regionX - (int) RegionInfo.RegionLocX * (int)Constants.RegionSize;
-                int shifty = (int) regionY - (int) RegionInfo.RegionLocY * (int)Constants.RegionSize;
-                position.X += shiftx;
-                position.Y += shifty;
-                bool result = false;
-                if (TestBorderCross(position,Cardinals.N))
-                    result = true;
-                if (TestBorderCross(position, Cardinals.S))
-                    result = true;
-                if (TestBorderCross(position, Cardinals.E))
-                    result = true;
-                if (TestBorderCross(position, Cardinals.W))
-                    result = true;
-                // bordercross if position is outside of region
-                if (!result)
-                {
-                    regionHandle = RegionInfo.RegionHandle;
-                }
-                else
-                {
-                    // not in this region, undo the shift!
-                    position.X -= shiftx;
-                    position.Y -= shifty;
-                }
                if (EntityTransferModule != null)
                {
                    EntityTransferModule.Teleport(sp, regionHandle, position, lookAt, teleportFlags);
@@ -4810,7 +4751,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.
@@ -5471,7 +5412,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))
@@ -5525,9 +5466,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))
@@ -5551,31 +5492,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/SceneBase.cs b/OpenSim/Region/Framework/Scenes/SceneBase.cs
index c86f412..b059ecf 100644
--- a/OpenSim/Region/Framework/Scenes/SceneBase.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneBase.cs
@@ -42,8 +42,8 @@ namespace OpenSim.Region.Framework.Scenes
 {
    public abstract class SceneBase : IScene
    {
-        protected static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
-        protected static readonly string LogHeader = "[SCENE]";
+        private static readonly string LogHeader = "[SCENE]";
        #region Events
diff --git a/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs b/OpenSim/Region/Framework/Scenes/SceneCommunicationService.cs
index 77889fa..c873e40 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));
            }
        }
@@ -166,7 +166,7 @@ namespace OpenSim.Region.Framework.Scenes
                        // we only want to send one update to each simulator; the simulator will
                        // hand it off to the regions where a child agent exists, this does assume
                        // that the region position is cached or performance will degrade
-                        Utils.LongToUInts(regionHandle, out x, out y);
+                        Util.RegionHandleToWorldLoc(regionHandle, out x, out y);
                        GridRegion dest = m_scene.GridService.GetRegionByPosition(UUID.Zero, (int)x, (int)y);
                        if (dest == null)
                            continue;
@@ -203,7 +203,7 @@ namespace OpenSim.Region.Framework.Scenes
            //m_commsProvider.InterRegion.TellRegionToCloseChildConnection(regionHandle, agentID);
            uint x = 0, y = 0;
-            Utils.LongToUInts(regionHandle, out x, out y);
+            Util.RegionHandleToWorldLoc(regionHandle, out x, out y);
            GridRegion destination = m_scene.GridService.GetRegionByPosition(m_regionInfo.ScopeID, (int)x, (int)y);
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 9bd7632..c6b98ca 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -334,7 +334,7 @@ namespace OpenSim.Region.Framework.Scenes
        {
            get
            {
-                Vector3 minScale = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionSize);
+                Vector3 minScale = new Vector3(Constants.MaximumRegionSize, Constants.MaximumRegionSize, Constants.MaximumRegionSize);
                Vector3 maxScale = Vector3.Zero;
                Vector3 finalScale = new Vector3(0.5f, 0.5f, 0.5f);
    
@@ -466,8 +466,6 @@ namespace OpenSim.Region.Framework.Scenes
                        && !IsAttachmentCheckFull() && (!Scene.LoadingPrims))
                    {
                        IEntityTransferModule entityTransfer = m_scene.RequestModuleInterface<IEntityTransferModule>();
-                        uint x = 0;
-                        uint y = 0;
                        string version = String.Empty;
                        Vector3 newpos = Vector3.Zero;
                        OpenSim.Services.Interfaces.GridRegion destination = null;
@@ -487,7 +485,7 @@ namespace OpenSim.Region.Framework.Scenes
                            // We set the avatar position as being the object
                            // position to get the region to send to
-                            if ((destination = entityTransfer.GetDestination(m_scene, av.UUID, val, out x, out y, out version, out newpos)) == null)
+                            if ((destination = entityTransfer.GetDestination(m_scene, av.UUID, val, out version, out newpos)) == null)
                            {
                                canCross = false;
                                break;
@@ -522,14 +520,14 @@ namespace OpenSim.Region.Framework.Scenes
                            m_scene.CrossPrimGroupIntoNewRegion(val, this, true);
                            // Normalize
-                            if (val.X >= Constants.RegionSize)
+                            if (val.X >= m_scene.RegionInfo.RegionSizeX)
-                                val.X -= Constants.RegionSize;
+                                val.X -= m_scene.RegionInfo.RegionSizeX;
-                            if (val.Y >= Constants.RegionSize)
+                            if (val.Y >= m_scene.RegionInfo.RegionSizeY)
-                                val.Y -= Constants.RegionSize;
+                                val.Y -= m_scene.RegionInfo.RegionSizeY;
                            if (val.X < 0)
-                                val.X += Constants.RegionSize;
+                                val.X += m_scene.RegionInfo.RegionSizeX;
                            if (val.Y < 0)
-                                val.Y += Constants.RegionSize;
+                                val.Y += m_scene.RegionInfo.RegionSizeY;
                            // If it's deleted, crossing was successful
                            if (IsDeleted)
@@ -577,9 +575,9 @@ namespace OpenSim.Region.Framework.Scenes
                            }
                        }
                        Vector3 oldp = AbsolutePosition;
-                        val.X = Util.Clamp<float>(oldp.X, 0.5f, (float)Constants.RegionSize - 0.5f);
+                        val.X = Util.Clamp<float>(oldp.X, 0.5f, (float)m_scene.RegionInfo.RegionSizeX - 0.5f);
-                        val.Y = Util.Clamp<float>(oldp.Y, 0.5f, (float)Constants.RegionSize - 0.5f);
+                        val.Y = Util.Clamp<float>(oldp.Y, 0.5f, (float)m_scene.RegionInfo.RegionSizeY - 0.5f);
-                        val.Z = Util.Clamp<float>(oldp.Z, 0.5f, 4096.0f);
+                        val.Z = Util.Clamp<float>(oldp.Z, 0.5f, Constants.RegionHeight);
                    }
                }
@@ -996,9 +994,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 85a20e9..b4274ba 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -76,6 +76,7 @@ namespace OpenSim.Region.Framework.Scenes
    public class ScenePresence : EntityBase, IScenePresence
    {
        private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        private static readonly String LogHeader = "[SCENE PRESENCE]";
 //        ~ScenePresence()
 //        {
@@ -759,9 +760,8 @@ 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.RegionLocX, y, Scene.RegionInfo.RegionLocY))
                {
                    old.Add(handle);
@@ -783,9 +783,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);
            }
        }
@@ -1092,6 +1090,10 @@ namespace OpenSim.Region.Framework.Scenes
                // before the inventory is processed in MakeRootAgent. This fixes a race condition
                // related to the handling of attachments
                //m_scene.GetAvatarAppearance(ControllingClient, out Appearance);
+                /* RA 20140111: Commented out these TestBorderCross's.
+                 * Not sure why this code is here. It is not checking all the borders
+                 * and 'in region' sanity checking is done in CheckAndAdjustLandingPoint and below.
                if (m_scene.TestBorderCross(pos, Cardinals.E))
                {
                    Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.E);
@@ -1103,6 +1105,7 @@ namespace OpenSim.Region.Framework.Scenes
                    Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.N);
                    pos.Y = crossedBorder.BorderLine.Z - 1;
                }
+                 */
                CheckAndAdjustLandingPoint(ref pos);
@@ -1123,7 +1126,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;
@@ -2386,7 +2389,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
@@ -2404,8 +2407,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.WorldLocX) + pos.X);
-            int Y = (int)((m_scene.RegionInfo.RegionLocY * Constants.RegionSize) + pos.Y);
+            int Y = (int)((m_scene.RegionInfo.WorldLocY) + 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)
@@ -2416,7 +2419,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
@@ -3451,10 +3454,14 @@ namespace OpenSim.Region.Framework.Scenes
            if (!IsInTransit)
            {
                Vector3 pos2 = AbsolutePosition;
+                Vector3 origPosition = pos2;
                Vector3 vel = Velocity;
                int neighbor = 0;
                int[] fix = new int[2];
+                // Compute the avatar position in the next physics tick.
+                // If the avatar will be crossing, we force the crossing to happen now
+                //     in the hope that this will make the avatar movement smoother when crossing.
                float timeStep = 0.1f;
                pos2.X = pos2.X + (vel.X * timeStep);
                pos2.Y = pos2.Y + (vel.Y * timeStep);
@@ -3462,111 +3469,44 @@ namespace OpenSim.Region.Framework.Scenes
                if (!IsInTransit)
                {
-//                    m_log.DebugFormat(
+                    if (!m_scene.PositionIsInCurrentRegion(pos2))
-//                        "[SCENE PRESENCE]: Testing border check for projected position {0} of {1} in {2}", 
-//                        pos2, Name, Scene.Name);
-                    // Checks if where it's headed exists a region
-                    bool needsTransit = false;
-                    if (m_scene.TestBorderCross(pos2, Cardinals.W))
-                    {
-                        if (m_scene.TestBorderCross(pos2, Cardinals.S))
-                        {
-                            needsTransit = true;
-                            neighbor = m_scene.HaveNeighbor(Cardinals.SW, ref fix);
-                        }
-                        else if (m_scene.TestBorderCross(pos2, Cardinals.N))
-                        {
-                            needsTransit = true;
-                            neighbor = m_scene.HaveNeighbor(Cardinals.NW, ref fix);
-                        }
-                        else
-                        {
-                            needsTransit = true;
-                            neighbor = m_scene.HaveNeighbor(Cardinals.W, ref fix);
-                        }
-                    }
-                    else if (m_scene.TestBorderCross(pos2, Cardinals.E))
                    {
-                        if (m_scene.TestBorderCross(pos2, Cardinals.S))
+                        m_log.DebugFormat("{0} CheckForBorderCrossing: position outside region. {1} in {2} at pos {3}", 
+                                                LogHeader, Name, Scene.Name, pos2);
+                        // Disconnect from the current region
+                        bool isFlying = Flying;
+                        RemoveFromPhysicalScene();
+                        // pos2 is the forcasted position so make that the 'current' position so the crossing
+                        //    code will move us into the newly addressed region.
+                        m_pos = pos2;
+                        if (CrossToNewRegion())
                        {
-                            needsTransit = true;
+                            AddToPhysicalScene(isFlying);
-                            neighbor = m_scene.HaveNeighbor(Cardinals.SE, ref fix);
-                        }
-                        else if (m_scene.TestBorderCross(pos2, Cardinals.N))
-                        {
-                            needsTransit = true;
-                            neighbor = m_scene.HaveNeighbor(Cardinals.NE, ref fix);
                        }
                        else
                        {
-                            needsTransit = true;
+                            // Tried to make crossing happen but it failed.
-                            neighbor = m_scene.HaveNeighbor(Cardinals.E, ref fix);
-                        }
-                    }
-                    else if (m_scene.TestBorderCross(pos2, Cardinals.S))
-                    {
-                        needsTransit = true;
-                        neighbor = m_scene.HaveNeighbor(Cardinals.S, ref fix);
-                    }
-                    else if (m_scene.TestBorderCross(pos2, Cardinals.N))
-                    {
-                        needsTransit = true;
-                        neighbor = m_scene.HaveNeighbor(Cardinals.N, ref fix);
-                    }
-                    // Makes sure avatar does not end up outside region
-                    if (neighbor <= 0)
-                    {
-                        if (needsTransit)
-                        {
-                            if (m_requestedSitTargetUUID == UUID.Zero)
-                            {
-                                bool isFlying = Flying;
-                                RemoveFromPhysicalScene();
-                                Vector3 pos = AbsolutePosition;
-                                if (AbsolutePosition.X < 0)
-                                    pos.X += Velocity.X * 2;
-                                else if (AbsolutePosition.X > Constants.RegionSize)
-                                    pos.X -= Velocity.X * 2;
-                                if (AbsolutePosition.Y < 0)
-                                    pos.Y += Velocity.Y * 2;
-                                else if (AbsolutePosition.Y > Constants.RegionSize)
-                                    pos.Y -= Velocity.Y * 2;
-                                Velocity = Vector3.Zero;
-                                AbsolutePosition = pos;
-//                                m_log.DebugFormat("[SCENE PRESENCE]: Prevented flyoff for {0} at {1}", Name, AbsolutePosition);
-                                AddToPhysicalScene(isFlying);
-                            }
-                        }
-                    }
-                    else if (neighbor > 0)
-                    {
-                        if (!CrossToNewRegion())
-                        {
                            if (m_requestedSitTargetUUID == UUID.Zero)
                            {
-                                bool isFlying = Flying;
+                                m_log.DebugFormat("{0} CheckForBorderCrossing: Crossing failed. Restoring old position.", LogHeader);
-                                RemoveFromPhysicalScene();
+                                const float borderFudge = 0.1f;
-                                Vector3 pos = AbsolutePosition;
+                                if (origPosition.X < 0)
-                                if (AbsolutePosition.X < 0)
+                                    origPosition.X = borderFudge;
-                                    pos.X += Velocity.X * 2;
+                                else if (origPosition.X > (float)m_scene.RegionInfo.RegionSizeX)
-                                else if (AbsolutePosition.X > Constants.RegionSize)
+                                    origPosition.X = (float)m_scene.RegionInfo.RegionSizeX - borderFudge;
-                                    pos.X -= Velocity.X * 2;
+                                if (origPosition.Y < 0)
-                                if (AbsolutePosition.Y < 0)
+                                    origPosition.Y = borderFudge;
-                                    pos.Y += Velocity.Y * 2;
+                                else if (origPosition.Y > (float)m_scene.RegionInfo.RegionSizeY)
-                                else if (AbsolutePosition.Y > Constants.RegionSize)
+                                    origPosition.Y = (float)m_scene.RegionInfo.RegionSizeY - borderFudge;
-                                    pos.Y -= Velocity.Y * 2;
                                Velocity = Vector3.Zero;
-                                AbsolutePosition = pos;
+                                AbsolutePosition = origPosition;
                                AddToPhysicalScene(isFlying);
                            }
                        }
+                             
                    }
                }
                else
@@ -3608,7 +3548,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();
        }
@@ -3635,9 +3575,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)));
@@ -3718,8 +3656,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);
@@ -4755,6 +4694,7 @@ namespace OpenSim.Region.Framework.Scenes
            }
        }
+        // Modify landing point based on possible banning, telehubs or parcel restrictions.
        private void CheckAndAdjustLandingPoint(ref Vector3 pos)
        {
            string reason;
diff --git a/OpenSim/Region/Framework/Scenes/TerrainChannel.cs b/OpenSim/Region/Framework/Scenes/TerrainChannel.cs
index c0ca48e..b4b1823 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,146 @@ 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 {
+                if (x < 0 || x >= Width || y < 0 || y >= Height)
+                    return 0;
+                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;
-                }
            }
        }
-        public bool Tainted(int x, int y)
+        // ITerrainChannel.GetHieghtAtXYZ(x, y, z)
+        public float GetHeightAtXYZ(float x, float y, float z)
        {
-            if (taint[x / 16, y / 16])
+            if (x < 0 || x >= Width || y < 0 || y >= Height)
-            {
+                return 0;
-                taint[x / 16, y / 16] = false;
+            return m_terrainData[(int)x, (int)y];
-                return true;
-            }
-            return false;
        }
-        #endregion
+        // ITerrainChannel.Tainted()
+        public bool Tainted(int x, int y)
-        public TerrainChannel Copy()
        {
-            TerrainChannel copy = new TerrainChannel(false);
+            return m_terrainData.IsTaintedAt(x, y);
-            copy.map = (double[,]) map.Clone();
-            return copy;
        }
+        // ITerrainChannel.SaveToXmlString()
        public string SaveToXmlString()
        {
            XmlWriterSettings settings = new XmlWriterSettings();
@@ -181,13 +200,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 +212,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 +269,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 +290,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/Agent/InternetRelayClientView/Server/IRCClientView.cs b/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
index b3fdd22..c8320d0 100644
--- a/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
+++ b/OpenSim/Region/OptionalModules/Agent/InternetRelayClientView/Server/IRCClientView.cs
@@ -516,7 +516,7 @@ namespace OpenSim.Region.OptionalModules.Agent.InternetRelayClientView.Server
        public Vector3 StartPos
        {
-            get { return new Vector3(((int)Constants.RegionSize * 0.5f), ((int)Constants.RegionSize * 0.5f), 50); }
+            get { return new Vector3(m_scene.RegionInfo.RegionSizeX * 0.5f, m_scene.RegionInfo.RegionSizeY * 0.5f, 50f); }
            set { }
        }
diff --git a/OpenSim/Region/OptionalModules/Avatar/Chat/IRCConnector.cs b/OpenSim/Region/OptionalModules/Avatar/Chat/IRCConnector.cs
index c5cba8e..f5bd44d 100644
--- a/OpenSim/Region/OptionalModules/Avatar/Chat/IRCConnector.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/Chat/IRCConnector.cs
@@ -52,6 +52,8 @@ namespace OpenSim.Region.OptionalModules.Avatar.Chat
        // Local constants
+        // This computation is not the real region center if the region is larger than 256.
+        //     This computation isn't fixed because there is not a handle back to the region.
        private static readonly Vector3 CenterOfRegion = new Vector3(((int)Constants.RegionSize * 0.5f), ((int)Constants.RegionSize * 0.5f), 20);
        private static readonly char[] CS_SPACE = { ' ' };
diff --git a/OpenSim/Region/OptionalModules/Avatar/Chat/RegionState.cs b/OpenSim/Region/OptionalModules/Avatar/Chat/RegionState.cs
index d4fe5e0..5505001 100644
--- a/OpenSim/Region/OptionalModules/Avatar/Chat/RegionState.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/Chat/RegionState.cs
@@ -44,6 +44,8 @@ namespace OpenSim.Region.OptionalModules.Avatar.Chat
        private static readonly ILog m_log =
            LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        // This computation is not the real region center if the region is larger than 256.
+        //     This computation isn't fixed because there is not a handle back to the region.
        private static readonly OpenMetaverse.Vector3 CenterOfRegion = new OpenMetaverse.Vector3(((int)Constants.RegionSize * 0.5f), ((int)Constants.RegionSize * 0.5f), 20);
        private const int DEBUG_CHANNEL = 2147483647;
diff --git a/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs b/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
index eb386fe..296ab87 100644
--- a/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
+++ b/OpenSim/Region/OptionalModules/Scripting/RegionReadyModule/RegionReadyModule.cs
@@ -170,7 +170,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/BSAPIXNA.cs b/OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs
index 17ebed2..aca1ed4 100755
--- a/OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSAPIXNA.cs
@@ -1311,7 +1311,7 @@ private sealed class BulletConstraintXNA : BulletConstraint
        /* TODO */
        ConfigurationParameters[] configparms = new ConfigurationParameters[1];
        configparms[0] = parms;
-        Vector3 worldExtent = new Vector3(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
+        Vector3 worldExtent = maxPosition;
        m_maxCollisions = maxCollisions;
        m_maxUpdatesPerFrame = maxUpdates;
        specialCollisionObjects = new Dictionary<uint, GhostObject>();
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..fe014fc 100644
--- a/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
+++ b/OpenSim/Region/Physics/BulletSPlugin/BSScene.cs
@@ -208,8 +208,17 @@ public sealed class BSScene : PhysicsScene, IPhysicsParameters
        Name = EngineType + "/" + RegionName;
    }
+    // Old version of initialization that assumes legacy sized regions (256x256)
    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 +259,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/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 e54b697..7b56abf 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.WorldLocX, World.RegionInfo.WorldLocY, 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)
@@ -4336,7 +4333,7 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
            m_host.AddScriptLPS(1);
            UUID agentId = new UUID();
-            ulong regionHandle = Utils.UIntsToLong((uint)global_coords.x, (uint)global_coords.y);
+            ulong regionHandle = Util.RegionWorldLocToHandle((uint)global_coords.x, (uint)global_coords.y);
            if (UUID.TryParse(agent, out agentId))
            {
@@ -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.WorldLocX, World.RegionInfo.WorldLocY, 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);
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/OSSL_Api.cs
index f4d5562..31ea067 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.RegionLocToHandle((uint)regionX, (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..d81cddc 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Runtime/OSSL_Stub.cs
@@ -713,16 +713,18 @@ namespace OpenSim.Region.ScriptEngine.Shared.ScriptBase
            }
            private void Save()
            {
+                /* Remove temporarily until we have a handle to the region size
                if (Position.x > ((int)Constants.RegionSize - 1))
                    Position.x = ((int)Constants.RegionSize - 1);
-                if (Position.x < 0)
-                    Position.x = 0;
                if (Position.y > ((int)Constants.RegionSize - 1))
                    Position.y = ((int)Constants.RegionSize - 1);
+                 */
+                if (Position.z > Constants.RegionHeight)
+                    Position.z = Constants.RegionHeight;
+                if (Position.x < 0)
+                    Position.x = 0;
                if (Position.y < 0)
                    Position.y = 0;
-                if (Position.z > 768)
-                    Position.z = 768;
                if (Position.z < 0)
                    Position.z = 0;
                prim.OSSL.llSetPos(Position);
diff --git a/OpenSim/Server/Handlers/Map/MapAddServerConnector.cs b/OpenSim/Server/Handlers/Map/MapAddServerConnector.cs
index d438fc7..4d1729e 100644
--- a/OpenSim/Server/Handlers/Map/MapAddServerConnector.cs
+++ b/OpenSim/Server/Handlers/Map/MapAddServerConnector.cs
@@ -116,9 +116,9 @@ namespace OpenSim.Server.Handlers.MapImage
                    httpResponse.StatusCode = (int)OSHttpStatusCode.ClientErrorBadRequest;
                    return FailureResult("Bad request.");
                }
-                int x = 0, y = 0;
+                uint x = 0, y = 0;
-                Int32.TryParse(request["X"].ToString(), out x);
+                UInt32.TryParse(request["X"].ToString(), out x);
-                Int32.TryParse(request["Y"].ToString(), out y);
+                UInt32.TryParse(request["Y"].ToString(), out y);
                m_log.DebugFormat("[MAP ADD SERVER CONNECTOR]: Received map data for region at {0}-{1}", x, y);
@@ -130,7 +130,7 @@ namespace OpenSim.Server.Handlers.MapImage
                if (m_GridService != null)
                {
                    System.Net.IPAddress ipAddr = GetCallerIP(httpRequest);
-                    GridRegion r = m_GridService.GetRegionByPosition(UUID.Zero, x * (int)Constants.RegionSize, y * (int)Constants.RegionSize);
+                    GridRegion r = m_GridService.GetRegionByPosition(UUID.Zero, (int)Util.RegionToWorldLoc(x), (int)Util.RegionToWorldLoc(y));
                    if (r != null)
                    {
                        if (r.ExternalEndPoint.Address.ToString() != ipAddr.ToString())
@@ -151,7 +151,7 @@ namespace OpenSim.Server.Handlers.MapImage
                byte[] data = Convert.FromBase64String(request["DATA"].ToString());
                string reason = string.Empty;
-                bool result = m_MapService.AddMapTile(x, y, data, out reason);
+                bool result = m_MapService.AddMapTile((int)x, (int)y, data, out reason);
                if (result)
                    return SuccessResult();
diff --git a/OpenSim/Services/Connectors/Land/LandServicesConnector.cs b/OpenSim/Services/Connectors/Land/LandServicesConnector.cs
index 30a73a4..644331a 100644
--- a/OpenSim/Services/Connectors/Land/LandServicesConnector.cs
+++ b/OpenSim/Services/Connectors/Land/LandServicesConnector.cs
@@ -78,7 +78,7 @@ namespace OpenSim.Services.Connectors
            try
            {
                uint xpos = 0, ypos = 0;
-                Utils.LongToUInts(regionHandle, out xpos, out ypos);
+                Util.RegionHandleToWorldLoc(regionHandle, out xpos, out ypos);
                GridRegion info = m_GridService.GetRegionByPosition(scopeID, (int)xpos, (int)ypos);
                if (info != null) // just to be sure
                {
diff --git a/OpenSim/Services/Connectors/Neighbour/NeighbourServicesConnector.cs b/OpenSim/Services/Connectors/Neighbour/NeighbourServicesConnector.cs
index 774fe2a..beead97 100644
--- a/OpenSim/Services/Connectors/Neighbour/NeighbourServicesConnector.cs
+++ b/OpenSim/Services/Connectors/Neighbour/NeighbourServicesConnector.cs
@@ -69,7 +69,7 @@ namespace OpenSim.Services.Connectors
        public virtual GridRegion HelloNeighbour(ulong regionHandle, RegionInfo thisRegion)
        {
            uint x = 0, y = 0;
-            Utils.LongToUInts(regionHandle, out x, out y);
+            Util.RegionHandleToWorldLoc(regionHandle, out x, out y);
            GridRegion regInfo = m_GridService.GetRegionByPosition(thisRegion.ScopeID, (int)x, (int)y);
            if ((regInfo != null) &&
                // Don't remote-call this instance; that's a startup hickup
diff --git a/OpenSim/Services/Connectors/SimianGrid/SimianGridServiceConnector.cs b/OpenSim/Services/Connectors/SimianGrid/SimianGridServiceConnector.cs
index c928f16..6b59f94 100644
--- a/OpenSim/Services/Connectors/SimianGrid/SimianGridServiceConnector.cs
+++ b/OpenSim/Services/Connectors/SimianGrid/SimianGridServiceConnector.cs
@@ -101,7 +101,7 @@ namespace OpenSim.Services.Connectors.SimianGrid
        public string RegisterRegion(UUID scopeID, GridRegion regionInfo)
        {
            Vector3d minPosition = new Vector3d(regionInfo.RegionLocX, regionInfo.RegionLocY, 0.0);
-            Vector3d maxPosition = minPosition + new Vector3d(Constants.RegionSize, Constants.RegionSize, Constants.RegionHeight);
+            Vector3d maxPosition = minPosition + new Vector3d(regionInfo.RegionSizeX, regionInfo.RegionSizeY, Constants.RegionHeight);
            OSDMap extraData = new OSDMap
            {
@@ -156,15 +156,15 @@ namespace OpenSim.Services.Connectors.SimianGrid
        public List<GridRegion> GetNeighbours(UUID scopeID, UUID regionID)
        {
-            const int NEIGHBOR_RADIUS = 128;
            GridRegion region = GetRegionByUUID(scopeID, regionID);
+            int NEIGHBOR_RADIUS = Math.Max(region.RegionSizeX, region.RegionSizeY) / 2;
            if (region != null)
            {
                List<GridRegion> regions = GetRegionRange(scopeID,
-                    region.RegionLocX - NEIGHBOR_RADIUS, region.RegionLocX + (int)Constants.RegionSize + NEIGHBOR_RADIUS,
+                    region.RegionLocX - NEIGHBOR_RADIUS, region.RegionLocX + region.RegionSizeX + NEIGHBOR_RADIUS,
-                    region.RegionLocY - NEIGHBOR_RADIUS, region.RegionLocY + (int)Constants.RegionSize + NEIGHBOR_RADIUS);
+                    region.RegionLocY - NEIGHBOR_RADIUS, region.RegionLocY + region.RegionSizeY + NEIGHBOR_RADIUS);
                for (int i = 0; i < regions.Count; i++)
                {
@@ -229,7 +229,7 @@ namespace OpenSim.Services.Connectors.SimianGrid
            else
            {
                // m_log.InfoFormat("[SIMIAN GRID CONNECTOR]: Grid service did not find a match for region at {0},{1}",
-                //     x / Constants.RegionSize, y / Constants.RegionSize);
+                //     Util.WorldToRegionLoc(x), Util.WorldToRegionLoc(y));
                return null;
            }
        }
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 137ce04..8198592 100644
--- a/OpenSim/Services/GridService/GridService.cs
+++ b/OpenSim/Services/GridService/GridService.cs
@@ -313,6 +313,7 @@ namespace OpenSim.Services.GridService
            if (region != null)
            {
                // Not really? Maybe?
+                // The adjacent regions are presumed to be the same size as the current region
                List<RegionData> rdatas = m_Database.Get(
                    region.posX - region.sizeX - 1, region.posY - region.sizeY - 1, 
                    region.posX + region.sizeX + 1, region.posY + region.sizeY + 1, scopeID);
@@ -643,20 +644,20 @@ namespace OpenSim.Services.GridService
                return;
            }
-            int x, y;
+            uint x, y;
-            if (!int.TryParse(cmd[3], out x))
+            if (!uint.TryParse(cmd[3], out x))
            {
                MainConsole.Instance.Output("x-coord must be an integer");
                return;
            }
-            if (!int.TryParse(cmd[4], out y))
+            if (!uint.TryParse(cmd[4], out y))
            {
                MainConsole.Instance.Output("y-coord must be an integer");
                return;
            }
-            RegionData region = m_Database.Get(x * (int)Constants.RegionSize, y * (int)Constants.RegionSize, UUID.Zero);
+            RegionData region = m_Database.Get((int)Util.RegionToWorldLoc(x), (int)Util.RegionToWorldLoc(y), UUID.Zero);
            if (region == null)
            {
                MainConsole.Instance.OutputFormat("No region found at {0},{1}", x, y);
diff --git a/OpenSim/Services/GridService/HypergridLinker.cs b/OpenSim/Services/GridService/HypergridLinker.cs
index 4024295..4ebfd5c 100644
--- a/OpenSim/Services/GridService/HypergridLinker.cs
+++ b/OpenSim/Services/GridService/HypergridLinker.cs
@@ -183,8 +183,8 @@ namespace OpenSim.Services.GridService
        public GridRegion LinkRegion(UUID scopeID, string regionDescriptor)
        {
            string reason = string.Empty;
-            int xloc = random.Next(0, Int16.MaxValue) * (int)Constants.RegionSize;
+            uint xloc = Util.RegionToWorldLoc((uint)random.Next(0, Int16.MaxValue));
-            return TryLinkRegionToCoords(scopeID, regionDescriptor, xloc, 0, out reason);
+            return TryLinkRegionToCoords(scopeID, regionDescriptor, (int)xloc, 0, out reason);
        }
        private static Random random = new Random();
@@ -260,7 +260,7 @@ namespace OpenSim.Services.GridService
        {
            m_log.DebugFormat("[HYPERGRID LINKER]: Link to {0} {1}, in {2}-{3}", 
                ((serverURI == null) ? (externalHostName + ":" + externalPort) : serverURI),
-                remoteRegionName, xloc / Constants.RegionSize, yloc / Constants.RegionSize);
+                remoteRegionName, Util.WorldToRegionLoc((uint)xloc), Util.WorldToRegionLoc((uint)yloc));
            reason = string.Empty;
            Uri uri = null;
@@ -311,7 +311,7 @@ namespace OpenSim.Services.GridService
            if (region != null)
            {
                m_log.WarnFormat("[HYPERGRID LINKER]: Coordinates {0}-{1} are already occupied by region {2} with uuid {3}",
-                    regInfo.RegionLocX / Constants.RegionSize, regInfo.RegionLocY / Constants.RegionSize,
+                    Util.WorldToRegionLoc((uint)regInfo.RegionLocX), Util.WorldToRegionLoc((uint)regInfo.RegionLocY),
                    region.RegionName, region.RegionID);
                reason = "Coordinates are already in use";
                return false;
@@ -347,7 +347,7 @@ namespace OpenSim.Services.GridService
            if (region != null)
            {
                m_log.DebugFormat("[HYPERGRID LINKER]: Region already exists in coordinates {0} {1}",
-                    region.RegionLocX / Constants.RegionSize, region.RegionLocY / Constants.RegionSize);
+                    Util.WorldToRegionLoc((uint)regInfo.RegionLocX), Util.WorldToRegionLoc((uint)regInfo.RegionLocY));
                regInfo = region;
                return true;
            }
@@ -424,10 +424,10 @@ namespace OpenSim.Services.GridService
 //        {
 //            uint ux = 0, uy = 0;
 //            Utils.LongToUInts(realHandle, out ux, out uy);
-//            x = ux / Constants.RegionSize;
+//            x = Util.WorldToRegionLoc(ux);
-//            y = uy / Constants.RegionSize;
+//            y = Util.WorldToRegionLoc(uy);
 //
-//            const uint limit = (4096 - 1) * Constants.RegionSize;
+//            const uint limit = Util.RegionToWorldLoc(4096 - 1);
 //            uint xmin = ux - limit;
 //            uint xmax = ux + limit;
 //            uint ymin = uy - limit;
@@ -502,9 +502,14 @@ namespace OpenSim.Services.GridService
            MainConsole.Instance.Output(new string('-', 72));
            foreach (RegionData r in regions)
            {
-                MainConsole.Instance.Output(String.Format("{0}\n{2,-32} {1}\n",
+                MainConsole.Instance.Output(
-                        r.RegionName, r.RegionID, String.Format("{0},{1} ({2},{3})", r.posX, r.posY,
+                    String.Format("{0}\n{2,-32} {1}\n",
-                            r.posX / Constants.RegionSize, r.posY / Constants.RegionSize)));
+                        r.RegionName, r.RegionID, 
+                        String.Format("{0},{1} ({2},{3})", r.posX, r.posY,
+                                    Util.WorldToRegionLoc((uint)r.posX), Util.WorldToRegionLoc((uint)r.posY)
+                        )
+                    )
+                );
            }
            return;
        }
@@ -529,8 +534,8 @@ namespace OpenSim.Services.GridService
            int xloc, yloc;
            string serverURI;
            string remoteName = null;
-            xloc = Convert.ToInt32(cmdparams[0]) * (int)Constants.RegionSize;
+            xloc = (int)Util.RegionToWorldLoc((uint)Convert.ToInt32(cmdparams[0]));
-            yloc = Convert.ToInt32(cmdparams[1]) * (int)Constants.RegionSize;
+            yloc = (int)Util.RegionToWorldLoc((uint)Convert.ToInt32(cmdparams[1]));
            serverURI = cmdparams[2];
            if (cmdparams.Length > 3)
                remoteName = string.Join(" ", cmdparams, 3, cmdparams.Length - 3);
@@ -601,13 +606,13 @@ namespace OpenSim.Services.GridService
                {
                    // old format
                    GridRegion regInfo;
-                    int xloc, yloc;
+                    uint xloc, yloc;
                    uint externalPort;
                    string externalHostName;
                    try
                    {
-                        xloc = Convert.ToInt32(cmdparams[0]);
+                        xloc = Convert.ToUInt32(cmdparams[0]);
-                        yloc = Convert.ToInt32(cmdparams[1]);
+                        yloc = Convert.ToUInt32(cmdparams[1]);
                        externalPort = Convert.ToUInt32(cmdparams[3]);
                        externalHostName = cmdparams[2];
                        //internalPort = Convert.ToUInt32(cmdparams[4]);
@@ -621,10 +626,11 @@ namespace OpenSim.Services.GridService
                    }
                    // Convert cell coordinates given by the user to meters
-                    xloc = xloc * (int)Constants.RegionSize;
+                    xloc = Util.RegionToWorldLoc(xloc);
-                    yloc = yloc * (int)Constants.RegionSize;
+                    yloc = Util.RegionToWorldLoc(yloc);
                    string reason = string.Empty;
-                    if (TryCreateLink(UUID.Zero, xloc, yloc, string.Empty, externalPort, externalHostName, UUID.Zero, out regInfo, out reason))
+                    if (TryCreateLink(UUID.Zero, (int)xloc, (int)yloc,
+                                    string.Empty, externalPort, externalHostName, UUID.Zero, out regInfo, out reason))
                    {
                        // What is this? The GridRegion instance will be discarded anyway,
                        // which effectively ignores any local name given with the command.
@@ -704,13 +710,13 @@ namespace OpenSim.Services.GridService
        private void ReadLinkFromConfig(IConfig config)
        {
            GridRegion regInfo;
-            int xloc, yloc;
+            uint xloc, yloc;
            uint externalPort;
            string externalHostName;
            uint realXLoc, realYLoc;
-            xloc = Convert.ToInt32(config.GetString("xloc", "0"));
+            xloc = Convert.ToUInt32(config.GetString("xloc", "0"));
-            yloc = Convert.ToInt32(config.GetString("yloc", "0"));
+            yloc = Convert.ToUInt32(config.GetString("yloc", "0"));
            externalPort = Convert.ToUInt32(config.GetString("externalPort", "0"));
            externalHostName = config.GetString("externalHostName", "");
            realXLoc = Convert.ToUInt32(config.GetString("real-xloc", "0"));
@@ -718,18 +724,19 @@ namespace OpenSim.Services.GridService
            if (m_enableAutoMapping)
            {
-                xloc = (int)((xloc % 100) + m_autoMappingX);
+                xloc = (xloc % 100) + m_autoMappingX;
-                yloc = (int)((yloc % 100) + m_autoMappingY);
+                yloc = (yloc % 100) + m_autoMappingY;
            }
            if (((realXLoc == 0) && (realYLoc == 0)) ||
                (((realXLoc - xloc < 3896) || (xloc - realXLoc < 3896)) &&
                 ((realYLoc - yloc < 3896) || (yloc - realYLoc < 3896))))
            {
-                xloc = xloc * (int)Constants.RegionSize;
+                xloc = Util.RegionToWorldLoc(xloc);
-                yloc = yloc * (int)Constants.RegionSize;
+                yloc = Util.RegionToWorldLoc(yloc);
                string reason = string.Empty;
-                if (TryCreateLink(UUID.Zero, xloc, yloc, string.Empty, externalPort, externalHostName, UUID.Zero, out regInfo, out reason))
+                if (TryCreateLink(UUID.Zero, (int)xloc, (int)yloc,
+                                string.Empty, externalPort, externalHostName, UUID.Zero, out regInfo, out reason))
                {
                    regInfo.RegionName = config.GetString("localName", "");
                }
diff --git a/OpenSim/Services/Interfaces/IGridService.cs b/OpenSim/Services/Interfaces/IGridService.cs
index 739e279..8e6279e 100644
--- a/OpenSim/Services/Interfaces/IGridService.cs
+++ b/OpenSim/Services/Interfaces/IGridService.cs
@@ -175,12 +175,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.
@@ -259,8 +259,8 @@ 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;
        }
@@ -268,8 +268,8 @@ namespace OpenSim.Services.Interfaces
        public GridRegion(RegionInfo ConvertFrom)
        {
            m_regionName = ConvertFrom.RegionName;
-            m_regionLocX = (int)(ConvertFrom.RegionLocX * Constants.RegionSize);
+            m_regionLocX = (int)(ConvertFrom.WorldLocX);
-            m_regionLocY = (int)(ConvertFrom.RegionLocY * Constants.RegionSize);
+            m_regionLocY = (int)(ConvertFrom.WorldLocY);
            RegionSizeX = (int)ConvertFrom.RegionSizeX;
            RegionSizeY = (int)ConvertFrom.RegionSizeY;
            m_internalEndPoint = ConvertFrom.InternalEndPoint;
diff --git a/OpenSim/Services/LLLoginService/LLLoginResponse.cs b/OpenSim/Services/LLLoginService/LLLoginResponse.cs
index 5256b74..e67ecf0 100644
--- a/OpenSim/Services/LLLoginService/LLLoginResponse.cs
+++ b/OpenSim/Services/LLLoginService/LLLoginResponse.cs
@@ -258,7 +258,7 @@ namespace OpenSim.Services.LLLoginService
            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},{1}>", RegionSizeX, RegionSizeY);
+            m_log.DebugFormat("[LOGIN RESPONSE] LLLoginResponse create. sizeX={0}, sizeY={1}", RegionSizeX, RegionSizeY);
            FillOutSeedCap(aCircuit, destination, clientIP);
@@ -361,7 +361,8 @@ namespace OpenSim.Services.LLLoginService
        private void FillOutHomeData(GridUserInfo pinfo, GridRegion home)
        {
-            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;
@@ -435,10 +436,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':[" 
-                   userProfile.homepos.X.ToString() + ",r" + userProfile.homepos.Y.ToString() + ",r" +
+                    + "r" + Util.RegionToWorldLoc(1000).ToString()
-                   userProfile.homepos.Z.ToString() + "], 'look_at':[r" + userProfile.homelookat.X.ToString() + ",r" +
+                    + ","
-                   userProfile.homelookat.Y.ToString() + ",r" + userProfile.homelookat.Z.ToString() + "]}";
+                    + "r" + 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;
@@ -533,7 +547,7 @@ namespace OpenSim.Services.LLLoginService
                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},{1}>", RegionSizeX, RegionSizeY);
+                m_log.DebugFormat("[LOGIN RESPONSE] returning sizeX={0}, sizeY={1}", RegionSizeX, RegionSizeY);
                if (searchURL != String.Empty)
                    responseData["search"] = searchURL;
diff --git a/OpenSim/Services/LLLoginService/LLLoginService.cs b/OpenSim/Services/LLLoginService/LLLoginService.cs
index e2f9966..150c2c0 100644
--- a/OpenSim/Services/LLLoginService/LLLoginService.cs
+++ b/OpenSim/Services/LLLoginService/LLLoginService.cs
@@ -684,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/Clients/Grid/GridClient.cs b/OpenSim/Tests/Clients/Grid/GridClient.cs
index 8e33373..fed7a16 100644
--- a/OpenSim/Tests/Clients/Grid/GridClient.cs
+++ b/OpenSim/Tests/Clients/Grid/GridClient.cs
@@ -150,16 +150,16 @@ namespace OpenSim.Tests.Clients.GridClient
            Console.WriteLine("[GRID CLIENT]: *** GetRegionRange (this should return 2 regions)");
            regions = m_Connector.GetRegionRange(UUID.Zero, 
-                900 * (int)Constants.RegionSize, 1002 * (int) Constants.RegionSize,
+                (int)Util.RegionToWorldLoc(900), (int)Util.RegionToWorldLoc(1002),
-                900 * (int)Constants.RegionSize, 1002 * (int) Constants.RegionSize);
+                (int)Util.RegionToWorldLoc(900), (int)Util.RegionToWorldLoc(1002) );
            if (regions == null)
                Console.WriteLine("[GRID CLIENT]: GetRegionRange returned null");
            else
                Console.WriteLine("[GRID CLIENT]: GetRegionRange returned " + regions.Count + " regions");
            Console.WriteLine("[GRID CLIENT]: *** GetRegionRange (this should return 0 regions)");
            regions = m_Connector.GetRegionRange(UUID.Zero,
-                900 * (int)Constants.RegionSize, 950 * (int)Constants.RegionSize,
+                (int)Util.RegionToWorldLoc(900), (int)Util.RegionToWorldLoc(950),
-                900 * (int)Constants.RegionSize, 950 * (int)Constants.RegionSize);
+                (int)Util.RegionToWorldLoc(900), (int)Util.RegionToWorldLoc(950) );
            if (regions == null)
                Console.WriteLine("[GRID CLIENT]: GetRegionRange returned null");
            else
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))