Merge branch 'master' of ssh://3dhosting.de/var/git/careminster into ubitwork

28 files changed, 1225 insertions, 534 deletions

diff --git a/OpenSim/Data/MSSQL/Resources/GridStore.migrations b/OpenSim/Data/MSSQL/Resources/GridStore.migrations
index c6342fc..de0cea7 100644
--- a/OpenSim/Data/MSSQL/Resources/GridStore.migrations
+++ b/OpenSim/Data/MSSQL/Resources/GridStore.migrations
@@ -235,4 +235,11 @@ CREATE NONCLUSTERED INDEX IX_regions_name ON dbo.regions
         regionName
         ) WITH( STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
 
-COMMIT
\ No newline at end of file
+COMMIT
+
+:VERSION 9
+
+BEGIN TRANSACTION
+ALTER TABLE regions ADD parcelMapTexture uniqueidentifier NULL;
+
+COMMIT
diff --git a/OpenSim/Data/SQLite/Resources/RegionStore.migrations b/OpenSim/Data/SQLite/Resources/RegionStore.migrations
index 31195af..0f40cdc 100644
--- a/OpenSim/Data/SQLite/Resources/RegionStore.migrations
+++ b/OpenSim/Data/SQLite/Resources/RegionStore.migrations
@@ -472,3 +472,73 @@ COMMIT;
 BEGIN;
 ALTER TABLE regionsettings ADD COLUMN covenant_datetime INTEGER NOT NULL default 0;
 COMMIT;
+
+:VERSION 23
+BEGIN;
+CREATE TABLE regionwindlight (
+  region_id VARCHAR(36) NOT NULL DEFAULT '000000-0000-0000-0000-000000000000' PRIMARY KEY,
+  water_color_r FLOAT NOT NULL DEFAULT '4.000000',
+  water_color_g FLOAT NOT NULL DEFAULT '38.000000',
+  water_color_b FLOAT NOT NULL DEFAULT '64.000000',
+  water_color_i FLOAT NOT NULL DEFAULT '1.000000',
+  water_fog_density_exponent FLOAT NOT NULL DEFAULT '4.0',
+  underwater_fog_modifier FLOAT NOT NULL DEFAULT '0.25',
+  reflection_wavelet_scale_1 FLOAT NOT NULL DEFAULT '2.0',
+  reflection_wavelet_scale_2 FLOAT NOT NULL DEFAULT '2.0',
+  reflection_wavelet_scale_3 FLOAT NOT NULL DEFAULT '2.0',
+  fresnel_scale FLOAT NOT NULL DEFAULT '0.40',
+  fresnel_offset FLOAT NOT NULL DEFAULT '0.50',
+  refract_scale_above FLOAT NOT NULL DEFAULT '0.03',
+  refract_scale_below FLOAT NOT NULL DEFAULT '0.20',
+  blur_multiplier FLOAT NOT NULL DEFAULT '0.040',
+  big_wave_direction_x FLOAT NOT NULL DEFAULT '1.05',
+  big_wave_direction_y FLOAT NOT NULL DEFAULT '-0.42',
+  little_wave_direction_x FLOAT NOT NULL DEFAULT '1.11',
+  little_wave_direction_y FLOAT NOT NULL DEFAULT '-1.16',
+  normal_map_texture VARCHAR(36) NOT NULL DEFAULT '822ded49-9a6c-f61c-cb89-6df54f42cdf4',
+  horizon_r FLOAT NOT NULL DEFAULT '0.25',
+  horizon_g FLOAT NOT NULL DEFAULT '0.25',
+  horizon_b FLOAT NOT NULL DEFAULT '0.32',
+  horizon_i FLOAT NOT NULL DEFAULT '0.32',
+  haze_horizon FLOAT NOT NULL DEFAULT '0.19',
+  blue_density_r FLOAT NOT NULL DEFAULT '0.12',
+  blue_density_g FLOAT NOT NULL DEFAULT '0.22',
+  blue_density_b FLOAT NOT NULL DEFAULT '0.38',
+  blue_density_i FLOAT NOT NULL DEFAULT '0.38',
+  haze_density FLOAT NOT NULL DEFAULT '0.70',
+  density_multiplier FLOAT NOT NULL DEFAULT '0.18',
+  distance_multiplier FLOAT NOT NULL DEFAULT '0.8',
+  max_altitude INTEGER NOT NULL DEFAULT '1605',
+  sun_moon_color_r FLOAT NOT NULL DEFAULT '0.24',
+  sun_moon_color_g FLOAT NOT NULL DEFAULT '0.26',
+  sun_moon_color_b FLOAT NOT NULL DEFAULT '0.30',
+  sun_moon_color_i FLOAT NOT NULL DEFAULT '0.30',
+  sun_moon_position FLOAT NOT NULL DEFAULT '0.317',
+  ambient_r FLOAT NOT NULL DEFAULT '0.35',
+  ambient_g FLOAT NOT NULL DEFAULT '0.35',
+  ambient_b FLOAT NOT NULL DEFAULT '0.35',
+  ambient_i FLOAT NOT NULL DEFAULT '0.35',
+  east_angle FLOAT NOT NULL DEFAULT '0.00',
+  sun_glow_focus FLOAT NOT NULL DEFAULT '0.10',
+  sun_glow_size FLOAT NOT NULL DEFAULT '1.75',
+  scene_gamma FLOAT NOT NULL DEFAULT '1.00',
+  star_brightness FLOAT NOT NULL DEFAULT '0.00',
+  cloud_color_r FLOAT NOT NULL DEFAULT '0.41',
+  cloud_color_g FLOAT NOT NULL DEFAULT '0.41',
+  cloud_color_b FLOAT NOT NULL DEFAULT '0.41',
+  cloud_color_i FLOAT NOT NULL DEFAULT '0.41',
+  cloud_x FLOAT NOT NULL DEFAULT '1.00',
+  cloud_y FLOAT NOT NULL DEFAULT '0.53',
+  cloud_density FLOAT NOT NULL DEFAULT '1.00',
+  cloud_coverage FLOAT NOT NULL DEFAULT '0.27',
+  cloud_scale FLOAT NOT NULL DEFAULT '0.42',
+  cloud_detail_x FLOAT NOT NULL DEFAULT '1.00',
+  cloud_detail_y FLOAT NOT NULL DEFAULT '0.53',
+  cloud_detail_density FLOAT NOT NULL DEFAULT '0.12',
+  cloud_scroll_x FLOAT NOT NULL DEFAULT '0.20',
+  cloud_scroll_x_lock INTEGER NOT NULL DEFAULT '0',
+  cloud_scroll_y FLOAT NOT NULL DEFAULT '0.01',
+  cloud_scroll_y_lock INTEGER NOT NULL DEFAULT '0',
+  draw_classic_clouds INTEGER NOT NULL DEFAULT '1');
+
+COMMIT;
\ No newline at end of file
diff --git a/OpenSim/Data/SQLite/SQLiteSimulationData.cs b/OpenSim/Data/SQLite/SQLiteSimulationData.cs
index a313c4f..ce1b7b4 100644
--- a/OpenSim/Data/SQLite/SQLiteSimulationData.cs
+++ b/OpenSim/Data/SQLite/SQLiteSimulationData.cs
@@ -35,7 +35,7 @@ using log4net;
 #if CSharpSqlite
     using Community.CsharpSqlite.Sqlite;
 #else
-    using Mono.Data.Sqlite;
+using Mono.Data.Sqlite;
 #endif
 using OpenMetaverse;
 using OpenMetaverse.StructuredData;
@@ -60,6 +60,7 @@ namespace OpenSim.Data.SQLite
         private const string landAccessListSelect = "select distinct * from landaccesslist";
         private const string regionbanListSelect = "select * from regionban";
         private const string regionSettingsSelect = "select * from regionsettings";
+        private const string regionWindlightSelect = "select * from regionwindlight";
 
         private DataSet ds;
         private SqliteDataAdapter primDa;
@@ -69,9 +70,9 @@ namespace OpenSim.Data.SQLite
         private SqliteDataAdapter landDa;
         private SqliteDataAdapter landAccessListDa;
         private SqliteDataAdapter regionSettingsDa;
+        private SqliteDataAdapter regionWindlightDa;
 
         private SqliteConnection m_conn;
-
         private String m_connectionString;
 
         protected virtual Assembly Assembly
@@ -136,6 +137,9 @@ namespace OpenSim.Data.SQLite
 
                 SqliteCommand regionSettingsSelectCmd = new SqliteCommand(regionSettingsSelect, m_conn);
                 regionSettingsDa = new SqliteDataAdapter(regionSettingsSelectCmd);
+
+                SqliteCommand regionWindlightSelectCmd = new SqliteCommand(regionWindlightSelect, m_conn);
+                regionWindlightDa = new SqliteDataAdapter(regionWindlightSelectCmd);
                 // This actually does the roll forward assembly stuff
                 Migration m = new Migration(m_conn, Assembly, "RegionStore");
                 m.Update();
@@ -163,6 +167,9 @@ namespace OpenSim.Data.SQLite
                     ds.Tables.Add(createRegionSettingsTable());
                     setupRegionSettingsCommands(regionSettingsDa, m_conn);
 
+                    ds.Tables.Add(createRegionWindlightTable());
+                    setupRegionWindlightCommands(regionWindlightDa, m_conn);
+
                     // WORKAROUND: This is a work around for sqlite on
                     // windows, which gets really unhappy with blob columns
                     // that have no sample data in them.  At some point we
@@ -171,63 +178,72 @@ namespace OpenSim.Data.SQLite
                     {
                         primDa.Fill(ds.Tables["prims"]);
                     }
-                    catch (Exception)
+                    catch (Exception e)
                     {
-                        m_log.Info("[SQLITE REGION DB]: Caught fill error on prims table");
+                        m_log.ErrorFormat("[SQLITE REGION DB]: Caught fill error on prims table :{0}", e.Message);
                     }
 
                     try
                     {
                         shapeDa.Fill(ds.Tables["primshapes"]);
                     }
-                    catch (Exception)
+                    catch (Exception e)
                     {
-                        m_log.Info("[SQLITE REGION DB]: Caught fill error on primshapes table");
+                        m_log.ErrorFormat("[SQLITE REGION DB]: Caught fill error on primshapes table :{0}", e.Message);
                     }
 
                     try
                     {
                         itemsDa.Fill(ds.Tables["primitems"]);
                     }
-                    catch (Exception)
+                    catch (Exception e)
                     {
-                        m_log.Info("[SQLITE REGION DB]: Caught fill error on primitems table");
+                        m_log.ErrorFormat("[SQLITE REGION DB]: Caught fill error on primitems table :{0}", e.Message);
                     }
 
                     try
                     {
                         terrainDa.Fill(ds.Tables["terrain"]);
                     }
-                    catch (Exception)
+                    catch (Exception e)
                     {
-                        m_log.Info("[SQLITE REGION DB]: Caught fill error on terrain table");
+                        m_log.ErrorFormat("[SQLITE REGION DB]: Caught fill error on terrain table :{0}", e.Message);
                     }
 
                     try
                     {
                         landDa.Fill(ds.Tables["land"]);
                     }
-                    catch (Exception)
+                    catch (Exception e)
                     {
-                        m_log.Info("[SQLITE REGION DB]: Caught fill error on land table");
+                        m_log.ErrorFormat("[SQLITE REGION DB]: Caught fill error on land table :{0}", e.Message);
                     }
 
                     try
                     {
                         landAccessListDa.Fill(ds.Tables["landaccesslist"]);
                     }
-                    catch (Exception)
+                    catch (Exception e)
                     {
-                        m_log.Info("[SQLITE REGION DB]: Caught fill error on landaccesslist table");
+                        m_log.ErrorFormat("[SQLITE REGION DB]: Caught fill error on landaccesslist table :{0}", e.Message);
                     }
 
                     try
                     {
                         regionSettingsDa.Fill(ds.Tables["regionsettings"]);
                     }
-                    catch (Exception)
+                    catch (Exception e)
+                    {
+                        m_log.ErrorFormat("[SQLITE REGION DB]: Caught fill error on regionsettings table :{0}", e.Message);
+                    }
+
+                    try
+                    {
+                        regionWindlightDa.Fill(ds.Tables["regionwindlight"]);
+                    }
+                    catch (Exception e)
                     {
-                        m_log.Info("[SQLITE REGION DB]: Caught fill error on regionsettings table");
+                        m_log.ErrorFormat("[SQLITE REGION DB]: Caught fill error on regionwindlight table :{0}", e.Message);
                     }
 
                     // We have to create a data set mapping for every table, otherwise the IDataAdaptor.Update() will not populate rows with values!
@@ -240,14 +256,14 @@ namespace OpenSim.Data.SQLite
                     CreateDataSetMapping(landDa, "land");
                     CreateDataSetMapping(landAccessListDa, "landaccesslist");
                     CreateDataSetMapping(regionSettingsDa, "regionsettings");
+                    CreateDataSetMapping(regionWindlightDa, "regionwindlight");
                 }
             }
             catch (Exception e)
             {
-              m_log.Error(e);
-              Environment.Exit(23);
+                m_log.ErrorFormat("[SQLITE REGION DB]: ", e);
+                Environment.Exit(23);
             }
-
             return;
         }
 
@@ -298,6 +314,11 @@ namespace OpenSim.Data.SQLite
                 regionSettingsDa.Dispose();
                 regionSettingsDa = null;
             }
+            if (regionWindlightDa != null)
+            {
+                regionWindlightDa.Dispose();
+                regionWindlightDa = null;
+            }
         }
 
         public void StoreRegionSettings(RegionSettings rs)
@@ -321,19 +342,76 @@ namespace OpenSim.Data.SQLite
                 Commit();
             }
         }
+
+        /// <summary>
+        /// Load windlight settings from region storage
+        /// </summary>
+        /// <param name="regionUUID">RegionID</param>
         public RegionLightShareData LoadRegionWindlightSettings(UUID regionUUID)
         {
-            //This connector doesn't support the windlight module yet
-            //Return default LL windlight settings
-            return new RegionLightShareData();
+            RegionLightShareData wl = null;
+
+            lock (ds)
+            {
+                DataTable windlightTable = ds.Tables["regionwindlight"];
+                DataRow windlightRow = windlightTable.Rows.Find(regionUUID.ToString());
+                if (windlightRow == null)
+                {
+                    wl = new RegionLightShareData();
+                    wl.regionID = regionUUID;
+                    StoreRegionWindlightSettings(wl);
+                    return wl;
+                }
+                wl = buildRegionWindlight(windlightRow);
+                return wl;
+            }
         }
+
+        /// <summary>
+        /// Remove windlight settings from region storage
+        /// </summary>
+        /// <param name="regionID">RegionID</param>
         public void RemoveRegionWindlightSettings(UUID regionID)
         {
+            lock (ds)
+            {
+                DataTable windlightTable = ds.Tables["regionwindlight"];
+                DataRow windlightRow = windlightTable.Rows.Find(regionID.ToString());
+
+                if (windlightRow != null)
+                {
+                    windlightRow.Delete();
+                }
+            }
+            Commit();
         }
+
+        /// <summary>
+        /// Adds an windlight into region storage
+        /// </summary>
+        /// <param name="wl">RegionLightShareData</param>
         public void StoreRegionWindlightSettings(RegionLightShareData wl)
         {
-            //This connector doesn't support the windlight module yet
+            lock (ds)
+            {
+                DataTable windlightTable = ds.Tables["regionwindlight"];
+                DataRow windlightRow = windlightTable.Rows.Find(wl.regionID.ToString());
+
+                if (windlightRow == null)
+                {
+                    windlightRow = windlightTable.NewRow();
+                    fillRegionWindlightRow(windlightRow, wl);
+                    windlightTable.Rows.Add(windlightRow);
+                }
+                else
+                {
+                    fillRegionWindlightRow(windlightRow, wl);
+                }
+
+                Commit();
+            }
         }
+
         public RegionSettings LoadRegionSettings(UUID regionUUID)
         {
             lock (ds)
@@ -387,7 +465,7 @@ namespace OpenSim.Data.SQLite
             }
 
             Commit();
-            // m_log.Info("[Dump of prims]: " + ds.GetXml());
+//            m_log.Info("[Dump of prims]: " + ds.GetXml());
         }
 
         /// <summary>
@@ -397,7 +475,7 @@ namespace OpenSim.Data.SQLite
         /// <param name="regionUUID">the region UUID</param>
         public void RemoveObject(UUID obj, UUID regionUUID)
         {
-            // m_log.InfoFormat("[REGION DB]: Removing obj: {0} from region: {1}", obj.Guid, regionUUID);
+//            m_log.InfoFormat("[REGION DB]: Removing obj: {0} from region: {1}", obj.Guid, regionUUID);
 
             DataTable prims = ds.Tables["prims"];
             DataTable shapes = ds.Tables["primshapes"];
@@ -409,7 +487,7 @@ namespace OpenSim.Data.SQLite
                 foreach (DataRow row in primRows)
                 {
                     // Remove shape rows
-                    UUID uuid = new UUID((string) row["UUID"]);
+                    UUID uuid = new UUID((string)row["UUID"]);
                     DataRow shapeRow = shapes.Rows.Find(uuid.ToString());
                     if (shapeRow != null)
                     {
@@ -464,7 +542,7 @@ namespace OpenSim.Data.SQLite
             {
                 DataRow[] primsForRegion = prims.Select(byRegion);
 //                m_log.Info("[SQLITE REGION DB]: Loaded " + primsForRegion.Length + " prims for region: " + regionUUID);
-                
+
                 // First, create all groups 
                 foreach (DataRow primRow in primsForRegion)
                 {
@@ -472,9 +550,9 @@ namespace OpenSim.Data.SQLite
                     {
                         SceneObjectPart prim = null;
 
-                        string uuid = (string) primRow["UUID"];
-                        string objID = (string) primRow["SceneGroupID"];
-                        
+                        string uuid = (string)primRow["UUID"];
+                        string objID = (string)primRow["SceneGroupID"];
+
                         if (uuid == objID) //is new SceneObjectGroup ?
                         {
                             prim = buildPrim(primRow);
@@ -489,7 +567,7 @@ namespace OpenSim.Data.SQLite
                                     "[SQLITE REGION DB]: No shape found for prim in storage, so setting default box shape");
                                 prim.Shape = PrimitiveBaseShape.Default;
                             }
-                            
+
                             SceneObjectGroup group = new SceneObjectGroup(prim);
                             createdObjects.Add(group.UUID, group);
                             retvals.Add(group);
@@ -506,7 +584,7 @@ namespace OpenSim.Data.SQLite
                         }
                     }
                 }
-                
+
                 // Now fill the groups with part data
                 foreach (DataRow primRow in primsForRegion)
                 {
@@ -514,8 +592,8 @@ namespace OpenSim.Data.SQLite
                     {
                         SceneObjectPart prim = null;
 
-                        string uuid = (string) primRow["UUID"];
-                        string objID = (string) primRow["SceneGroupID"];
+                        string uuid = (string)primRow["UUID"];
+                        string objID = (string)primRow["SceneGroupID"];
                         if (uuid != objID) //is new SceneObjectGroup ?
                         {
                             prim = buildPrim(primRow);
@@ -562,8 +640,7 @@ namespace OpenSim.Data.SQLite
             DataRow[] dbItemRows = dbItems.Select(sql);
             IList<TaskInventoryItem> inventory = new List<TaskInventoryItem>();
 
-//            m_log.DebugFormat(
-//                "[SQLITE REGION DB]: Found {0} items for {1} {2}", dbItemRows.Length, prim.Name, prim.UUID);
+//            m_log.DebugFormat("[SQLITE REGION DB]: Found {0} items for {1} {2}", dbItemRows.Length, prim.Name, prim.UUID);
 
             foreach (DataRow row in dbItemRows)
             {
@@ -742,7 +819,7 @@ namespace OpenSim.Data.SQLite
                 //    cmd.Parameters.Add(new SqliteParameter(":LandUUID", parcel.LandData.GlobalID.ToString()));
                 //    cmd.ExecuteNonQuery();
 
-//                }
+                //                }
 
                 // This is the slower..  but more appropriate thing to do
 
@@ -805,7 +882,7 @@ namespace OpenSim.Data.SQLite
         /// </summary>
         public void Commit()
         {
-            //m_log.Debug("[SQLITE]: Starting commit");
+//            m_log.Debug("[SQLITE]: Starting commit");
             lock (ds)
             {
                 primDa.Update(ds, "prims");
@@ -819,6 +896,7 @@ namespace OpenSim.Data.SQLite
                 try
                 {
                     regionSettingsDa.Update(ds, "regionsettings");
+                    regionWindlightDa.Update(ds, "regionwindlight");
                 }
                 catch (SqliteException SqlEx)
                 {
@@ -875,9 +953,9 @@ namespace OpenSim.Data.SQLite
         {
             DataTable terrain = new DataTable("terrain");
 
-            createCol(terrain, "RegionUUID", typeof (String));
-            createCol(terrain, "Revision", typeof (Int32));
-            createCol(terrain, "Heightfield", typeof (Byte[]));
+            createCol(terrain, "RegionUUID", typeof(String));
+            createCol(terrain, "Revision", typeof(Int32));
+            createCol(terrain, "Heightfield", typeof(Byte[]));
 
             return terrain;
         }
@@ -890,62 +968,62 @@ namespace OpenSim.Data.SQLite
         {
             DataTable prims = new DataTable("prims");
 
-            createCol(prims, "UUID", typeof (String));
-            createCol(prims, "RegionUUID", typeof (String));
-            createCol(prims, "CreationDate", typeof (Int32));
-            createCol(prims, "Name", typeof (String));
-            createCol(prims, "SceneGroupID", typeof (String));
+            createCol(prims, "UUID", typeof(String));
+            createCol(prims, "RegionUUID", typeof(String));
+            createCol(prims, "CreationDate", typeof(Int32));
+            createCol(prims, "Name", typeof(String));
+            createCol(prims, "SceneGroupID", typeof(String));
             // various text fields
-            createCol(prims, "Text", typeof (String));
-            createCol(prims, "ColorR", typeof (Int32));
-            createCol(prims, "ColorG", typeof (Int32));
-            createCol(prims, "ColorB", typeof (Int32));
-            createCol(prims, "ColorA", typeof (Int32));
-            createCol(prims, "Description", typeof (String));
-            createCol(prims, "SitName", typeof (String));
-            createCol(prims, "TouchName", typeof (String));
+            createCol(prims, "Text", typeof(String));
+            createCol(prims, "ColorR", typeof(Int32));
+            createCol(prims, "ColorG", typeof(Int32));
+            createCol(prims, "ColorB", typeof(Int32));
+            createCol(prims, "ColorA", typeof(Int32));
+            createCol(prims, "Description", typeof(String));
+            createCol(prims, "SitName", typeof(String));
+            createCol(prims, "TouchName", typeof(String));
             // permissions
-            createCol(prims, "ObjectFlags", typeof (Int32));
-            createCol(prims, "CreatorID", typeof (String));
-            createCol(prims, "OwnerID", typeof (String));
-            createCol(prims, "GroupID", typeof (String));
-            createCol(prims, "LastOwnerID", typeof (String));
-            createCol(prims, "OwnerMask", typeof (Int32));
-            createCol(prims, "NextOwnerMask", typeof (Int32));
-            createCol(prims, "GroupMask", typeof (Int32));
-            createCol(prims, "EveryoneMask", typeof (Int32));
-            createCol(prims, "BaseMask", typeof (Int32));
+            createCol(prims, "ObjectFlags", typeof(Int32));
+            createCol(prims, "CreatorID", typeof(String));
+            createCol(prims, "OwnerID", typeof(String));
+            createCol(prims, "GroupID", typeof(String));
+            createCol(prims, "LastOwnerID", typeof(String));
+            createCol(prims, "OwnerMask", typeof(Int32));
+            createCol(prims, "NextOwnerMask", typeof(Int32));
+            createCol(prims, "GroupMask", typeof(Int32));
+            createCol(prims, "EveryoneMask", typeof(Int32));
+            createCol(prims, "BaseMask", typeof(Int32));
             // vectors
-            createCol(prims, "PositionX", typeof (Double));
-            createCol(prims, "PositionY", typeof (Double));
-            createCol(prims, "PositionZ", typeof (Double));
-            createCol(prims, "GroupPositionX", typeof (Double));
-            createCol(prims, "GroupPositionY", typeof (Double));
-            createCol(prims, "GroupPositionZ", typeof (Double));
-            createCol(prims, "VelocityX", typeof (Double));
-            createCol(prims, "VelocityY", typeof (Double));
-            createCol(prims, "VelocityZ", typeof (Double));
-            createCol(prims, "AngularVelocityX", typeof (Double));
-            createCol(prims, "AngularVelocityY", typeof (Double));
-            createCol(prims, "AngularVelocityZ", typeof (Double));
-            createCol(prims, "AccelerationX", typeof (Double));
-            createCol(prims, "AccelerationY", typeof (Double));
-            createCol(prims, "AccelerationZ", typeof (Double));
+            createCol(prims, "PositionX", typeof(Double));
+            createCol(prims, "PositionY", typeof(Double));
+            createCol(prims, "PositionZ", typeof(Double));
+            createCol(prims, "GroupPositionX", typeof(Double));
+            createCol(prims, "GroupPositionY", typeof(Double));
+            createCol(prims, "GroupPositionZ", typeof(Double));
+            createCol(prims, "VelocityX", typeof(Double));
+            createCol(prims, "VelocityY", typeof(Double));
+            createCol(prims, "VelocityZ", typeof(Double));
+            createCol(prims, "AngularVelocityX", typeof(Double));
+            createCol(prims, "AngularVelocityY", typeof(Double));
+            createCol(prims, "AngularVelocityZ", typeof(Double));
+            createCol(prims, "AccelerationX", typeof(Double));
+            createCol(prims, "AccelerationY", typeof(Double));
+            createCol(prims, "AccelerationZ", typeof(Double));
             // quaternions
-            createCol(prims, "RotationX", typeof (Double));
-            createCol(prims, "RotationY", typeof (Double));
-            createCol(prims, "RotationZ", typeof (Double));
-            createCol(prims, "RotationW", typeof (Double));
+            createCol(prims, "RotationX", typeof(Double));
+            createCol(prims, "RotationY", typeof(Double));
+            createCol(prims, "RotationZ", typeof(Double));
+            createCol(prims, "RotationW", typeof(Double));
 
             // sit target
-            createCol(prims, "SitTargetOffsetX", typeof (Double));
-            createCol(prims, "SitTargetOffsetY", typeof (Double));
-            createCol(prims, "SitTargetOffsetZ", typeof (Double));
+            createCol(prims, "SitTargetOffsetX", typeof(Double));
+            createCol(prims, "SitTargetOffsetY", typeof(Double));
+            createCol(prims, "SitTargetOffsetZ", typeof(Double));
 
-            createCol(prims, "SitTargetOrientW", typeof (Double));
-            createCol(prims, "SitTargetOrientX", typeof (Double));
-            createCol(prims, "SitTargetOrientY", typeof (Double));
-            createCol(prims, "SitTargetOrientZ", typeof (Double));
+            createCol(prims, "SitTargetOrientW", typeof(Double));
+            createCol(prims, "SitTargetOrientX", typeof(Double));
+            createCol(prims, "SitTargetOrientY", typeof(Double));
+            createCol(prims, "SitTargetOrientZ", typeof(Double));
 
             createCol(prims, "PayPrice", typeof(Int32));
             createCol(prims, "PayButton1", typeof(Int32));
@@ -981,7 +1059,7 @@ namespace OpenSim.Data.SQLite
             createCol(prims, "SaleType", typeof(Int16));
 
             // click action
-            createCol(prims, "ClickAction", typeof (Byte));
+            createCol(prims, "ClickAction", typeof(Byte));
 
             createCol(prims, "Material", typeof(Byte));
 
@@ -993,7 +1071,7 @@ namespace OpenSim.Data.SQLite
             createCol(prims, "MediaURL", typeof(String));
 
             // Add in contraints
-            prims.PrimaryKey = new DataColumn[] {prims.Columns["UUID"]};
+            prims.PrimaryKey = new DataColumn[] { prims.Columns["UUID"] };
 
             return prims;
         }
@@ -1005,42 +1083,42 @@ namespace OpenSim.Data.SQLite
         private static DataTable createShapeTable()
         {
             DataTable shapes = new DataTable("primshapes");
-            createCol(shapes, "UUID", typeof (String));
+            createCol(shapes, "UUID", typeof(String));
             // shape is an enum
-            createCol(shapes, "Shape", typeof (Int32));
+            createCol(shapes, "Shape", typeof(Int32));
             // vectors
-            createCol(shapes, "ScaleX", typeof (Double));
-            createCol(shapes, "ScaleY", typeof (Double));
-            createCol(shapes, "ScaleZ", typeof (Double));
+            createCol(shapes, "ScaleX", typeof(Double));
+            createCol(shapes, "ScaleY", typeof(Double));
+            createCol(shapes, "ScaleZ", typeof(Double));
             // paths
-            createCol(shapes, "PCode", typeof (Int32));
-            createCol(shapes, "PathBegin", typeof (Int32));
-            createCol(shapes, "PathEnd", typeof (Int32));
-            createCol(shapes, "PathScaleX", typeof (Int32));
-            createCol(shapes, "PathScaleY", typeof (Int32));
-            createCol(shapes, "PathShearX", typeof (Int32));
-            createCol(shapes, "PathShearY", typeof (Int32));
-            createCol(shapes, "PathSkew", typeof (Int32));
-            createCol(shapes, "PathCurve", typeof (Int32));
-            createCol(shapes, "PathRadiusOffset", typeof (Int32));
-            createCol(shapes, "PathRevolutions", typeof (Int32));
-            createCol(shapes, "PathTaperX", typeof (Int32));
-            createCol(shapes, "PathTaperY", typeof (Int32));
-            createCol(shapes, "PathTwist", typeof (Int32));
-            createCol(shapes, "PathTwistBegin", typeof (Int32));
+            createCol(shapes, "PCode", typeof(Int32));
+            createCol(shapes, "PathBegin", typeof(Int32));
+            createCol(shapes, "PathEnd", typeof(Int32));
+            createCol(shapes, "PathScaleX", typeof(Int32));
+            createCol(shapes, "PathScaleY", typeof(Int32));
+            createCol(shapes, "PathShearX", typeof(Int32));
+            createCol(shapes, "PathShearY", typeof(Int32));
+            createCol(shapes, "PathSkew", typeof(Int32));
+            createCol(shapes, "PathCurve", typeof(Int32));
+            createCol(shapes, "PathRadiusOffset", typeof(Int32));
+            createCol(shapes, "PathRevolutions", typeof(Int32));
+            createCol(shapes, "PathTaperX", typeof(Int32));
+            createCol(shapes, "PathTaperY", typeof(Int32));
+            createCol(shapes, "PathTwist", typeof(Int32));
+            createCol(shapes, "PathTwistBegin", typeof(Int32));
             // profile
-            createCol(shapes, "ProfileBegin", typeof (Int32));
-            createCol(shapes, "ProfileEnd", typeof (Int32));
-            createCol(shapes, "ProfileCurve", typeof (Int32));
-            createCol(shapes, "ProfileHollow", typeof (Int32));
+            createCol(shapes, "ProfileBegin", typeof(Int32));
+            createCol(shapes, "ProfileEnd", typeof(Int32));
+            createCol(shapes, "ProfileCurve", typeof(Int32));
+            createCol(shapes, "ProfileHollow", typeof(Int32));
             createCol(shapes, "State", typeof(Int32));
             // text TODO: this isn't right, but I'm not sure the right
             // way to specify this as a blob atm
-            createCol(shapes, "Texture", typeof (Byte[]));
-            createCol(shapes, "ExtraParams", typeof (Byte[]));
+            createCol(shapes, "Texture", typeof(Byte[]));
+            createCol(shapes, "ExtraParams", typeof(Byte[]));
             createCol(shapes, "Media", typeof(String));
 
-            shapes.PrimaryKey = new DataColumn[] {shapes.Columns["UUID"]};
+            shapes.PrimaryKey = new DataColumn[] { shapes.Columns["UUID"] };
 
             return shapes;
         }
@@ -1053,29 +1131,29 @@ namespace OpenSim.Data.SQLite
         {
             DataTable items = new DataTable("primitems");
 
-            createCol(items, "itemID", typeof (String));
-            createCol(items, "primID", typeof (String));
-            createCol(items, "assetID", typeof (String));
-            createCol(items, "parentFolderID", typeof (String));
+            createCol(items, "itemID", typeof(String));
+            createCol(items, "primID", typeof(String));
+            createCol(items, "assetID", typeof(String));
+            createCol(items, "parentFolderID", typeof(String));
 
-            createCol(items, "invType", typeof (Int32));
-            createCol(items, "assetType", typeof (Int32));
+            createCol(items, "invType", typeof(Int32));
+            createCol(items, "assetType", typeof(Int32));
 
-            createCol(items, "name", typeof (String));
-            createCol(items, "description", typeof (String));
+            createCol(items, "name", typeof(String));
+            createCol(items, "description", typeof(String));
 
-            createCol(items, "creationDate", typeof (Int64));
-            createCol(items, "creatorID", typeof (String));
-            createCol(items, "ownerID", typeof (String));
-            createCol(items, "lastOwnerID", typeof (String));
-            createCol(items, "groupID", typeof (String));
+            createCol(items, "creationDate", typeof(Int64));
+            createCol(items, "creatorID", typeof(String));
+            createCol(items, "ownerID", typeof(String));
+            createCol(items, "lastOwnerID", typeof(String));
+            createCol(items, "groupID", typeof(String));
 
-            createCol(items, "nextPermissions", typeof (UInt32));
-            createCol(items, "currentPermissions", typeof (UInt32));
-            createCol(items, "basePermissions", typeof (UInt32));
-            createCol(items, "everyonePermissions", typeof (UInt32));
-            createCol(items, "groupPermissions", typeof (UInt32));
-            createCol(items, "flags", typeof (UInt32));
+            createCol(items, "nextPermissions", typeof(UInt32));
+            createCol(items, "currentPermissions", typeof(UInt32));
+            createCol(items, "basePermissions", typeof(UInt32));
+            createCol(items, "everyonePermissions", typeof(UInt32));
+            createCol(items, "groupPermissions", typeof(UInt32));
+            createCol(items, "flags", typeof(UInt32));
 
             items.PrimaryKey = new DataColumn[] { items.Columns["itemID"] };
 
@@ -1089,44 +1167,44 @@ namespace OpenSim.Data.SQLite
         private static DataTable createLandTable()
         {
             DataTable land = new DataTable("land");
-            createCol(land, "UUID", typeof (String));
-            createCol(land, "RegionUUID", typeof (String));
-            createCol(land, "LocalLandID", typeof (UInt32));
+            createCol(land, "UUID", typeof(String));
+            createCol(land, "RegionUUID", typeof(String));
+            createCol(land, "LocalLandID", typeof(UInt32));
 
             // Bitmap is a byte[512]
-            createCol(land, "Bitmap", typeof (Byte[]));
-
-            createCol(land, "Name", typeof (String));
-            createCol(land, "Desc", typeof (String));
-            createCol(land, "OwnerUUID", typeof (String));
-            createCol(land, "IsGroupOwned", typeof (Boolean));
-            createCol(land, "Area", typeof (Int32));
-            createCol(land, "AuctionID", typeof (Int32)); //Unemplemented
-            createCol(land, "Category", typeof (Int32)); //Enum OpenMetaverse.Parcel.ParcelCategory
-            createCol(land, "ClaimDate", typeof (Int32));
-            createCol(land, "ClaimPrice", typeof (Int32));
-            createCol(land, "GroupUUID", typeof (string));
-            createCol(land, "SalePrice", typeof (Int32));
-            createCol(land, "LandStatus", typeof (Int32)); //Enum. OpenMetaverse.Parcel.ParcelStatus
-            createCol(land, "LandFlags", typeof (UInt32));
-            createCol(land, "LandingType", typeof (Byte));
-            createCol(land, "MediaAutoScale", typeof (Byte));
-            createCol(land, "MediaTextureUUID", typeof (String));
-            createCol(land, "MediaURL", typeof (String));
-            createCol(land, "MusicURL", typeof (String));
-            createCol(land, "PassHours", typeof (Double));
-            createCol(land, "PassPrice", typeof (UInt32));
-            createCol(land, "SnapshotUUID", typeof (String));
-            createCol(land, "UserLocationX", typeof (Double));
-            createCol(land, "UserLocationY", typeof (Double));
-            createCol(land, "UserLocationZ", typeof (Double));
-            createCol(land, "UserLookAtX", typeof (Double));
-            createCol(land, "UserLookAtY", typeof (Double));
-            createCol(land, "UserLookAtZ", typeof (Double));
+            createCol(land, "Bitmap", typeof(Byte[]));
+
+            createCol(land, "Name", typeof(String));
+            createCol(land, "Desc", typeof(String));
+            createCol(land, "OwnerUUID", typeof(String));
+            createCol(land, "IsGroupOwned", typeof(Boolean));
+            createCol(land, "Area", typeof(Int32));
+            createCol(land, "AuctionID", typeof(Int32)); //Unemplemented
+            createCol(land, "Category", typeof(Int32)); //Enum OpenMetaverse.Parcel.ParcelCategory
+            createCol(land, "ClaimDate", typeof(Int32));
+            createCol(land, "ClaimPrice", typeof(Int32));
+            createCol(land, "GroupUUID", typeof(string));
+            createCol(land, "SalePrice", typeof(Int32));
+            createCol(land, "LandStatus", typeof(Int32)); //Enum. OpenMetaverse.Parcel.ParcelStatus
+            createCol(land, "LandFlags", typeof(UInt32));
+            createCol(land, "LandingType", typeof(Byte));
+            createCol(land, "MediaAutoScale", typeof(Byte));
+            createCol(land, "MediaTextureUUID", typeof(String));
+            createCol(land, "MediaURL", typeof(String));
+            createCol(land, "MusicURL", typeof(String));
+            createCol(land, "PassHours", typeof(Double));
+            createCol(land, "PassPrice", typeof(UInt32));
+            createCol(land, "SnapshotUUID", typeof(String));
+            createCol(land, "UserLocationX", typeof(Double));
+            createCol(land, "UserLocationY", typeof(Double));
+            createCol(land, "UserLocationZ", typeof(Double));
+            createCol(land, "UserLookAtX", typeof(Double));
+            createCol(land, "UserLookAtY", typeof(Double));
+            createCol(land, "UserLookAtZ", typeof(Double));
             createCol(land, "AuthbuyerID", typeof(String));
             createCol(land, "OtherCleanTime", typeof(Int32));
 
-            land.PrimaryKey = new DataColumn[] {land.Columns["UUID"]};
+            land.PrimaryKey = new DataColumn[] { land.Columns["UUID"] };
 
             return land;
         }
@@ -1138,9 +1216,9 @@ namespace OpenSim.Data.SQLite
         private static DataTable createLandAccessListTable()
         {
             DataTable landaccess = new DataTable("landaccesslist");
-            createCol(landaccess, "LandUUID", typeof (String));
-            createCol(landaccess, "AccessUUID", typeof (String));
-            createCol(landaccess, "Flags", typeof (UInt32));
+            createCol(landaccess, "LandUUID", typeof(String));
+            createCol(landaccess, "AccessUUID", typeof(String));
+            createCol(landaccess, "Flags", typeof(UInt32));
 
             return landaccess;
         }
@@ -1149,41 +1227,41 @@ namespace OpenSim.Data.SQLite
         {
             DataTable regionsettings = new DataTable("regionsettings");
             createCol(regionsettings, "regionUUID", typeof(String));
-            createCol(regionsettings, "block_terraform", typeof (Int32));
-            createCol(regionsettings, "block_fly", typeof (Int32));
-            createCol(regionsettings, "allow_damage", typeof (Int32));
-            createCol(regionsettings, "restrict_pushing", typeof (Int32));
-            createCol(regionsettings, "allow_land_resell", typeof (Int32));
-            createCol(regionsettings, "allow_land_join_divide", typeof (Int32));
-            createCol(regionsettings, "block_show_in_search", typeof (Int32));
-            createCol(regionsettings, "agent_limit", typeof (Int32));
-            createCol(regionsettings, "object_bonus", typeof (Double));
-            createCol(regionsettings, "maturity", typeof (Int32));
-            createCol(regionsettings, "disable_scripts", typeof (Int32));
-            createCol(regionsettings, "disable_collisions", typeof (Int32));
-            createCol(regionsettings, "disable_physics", typeof (Int32));
+            createCol(regionsettings, "block_terraform", typeof(Int32));
+            createCol(regionsettings, "block_fly", typeof(Int32));
+            createCol(regionsettings, "allow_damage", typeof(Int32));
+            createCol(regionsettings, "restrict_pushing", typeof(Int32));
+            createCol(regionsettings, "allow_land_resell", typeof(Int32));
+            createCol(regionsettings, "allow_land_join_divide", typeof(Int32));
+            createCol(regionsettings, "block_show_in_search", typeof(Int32));
+            createCol(regionsettings, "agent_limit", typeof(Int32));
+            createCol(regionsettings, "object_bonus", typeof(Double));
+            createCol(regionsettings, "maturity", typeof(Int32));
+            createCol(regionsettings, "disable_scripts", typeof(Int32));
+            createCol(regionsettings, "disable_collisions", typeof(Int32));
+            createCol(regionsettings, "disable_physics", typeof(Int32));
             createCol(regionsettings, "terrain_texture_1", typeof(String));
             createCol(regionsettings, "terrain_texture_2", typeof(String));
             createCol(regionsettings, "terrain_texture_3", typeof(String));
             createCol(regionsettings, "terrain_texture_4", typeof(String));
-            createCol(regionsettings, "elevation_1_nw", typeof (Double));
-            createCol(regionsettings, "elevation_2_nw", typeof (Double));
-            createCol(regionsettings, "elevation_1_ne", typeof (Double));
-            createCol(regionsettings, "elevation_2_ne", typeof (Double));
-            createCol(regionsettings, "elevation_1_se", typeof (Double));
-            createCol(regionsettings, "elevation_2_se", typeof (Double));
-            createCol(regionsettings, "elevation_1_sw", typeof (Double));
-            createCol(regionsettings, "elevation_2_sw", typeof (Double));
-            createCol(regionsettings, "water_height", typeof (Double));
-            createCol(regionsettings, "terrain_raise_limit", typeof (Double));
-            createCol(regionsettings, "terrain_lower_limit", typeof (Double));
-            createCol(regionsettings, "use_estate_sun", typeof (Int32));
-            createCol(regionsettings, "sandbox", typeof (Int32));
-            createCol(regionsettings, "sunvectorx",typeof (Double));
-            createCol(regionsettings, "sunvectory",typeof (Double));
-            createCol(regionsettings, "sunvectorz",typeof (Double));
-            createCol(regionsettings, "fixed_sun", typeof (Int32));
-            createCol(regionsettings, "sun_position", typeof (Double));
+            createCol(regionsettings, "elevation_1_nw", typeof(Double));
+            createCol(regionsettings, "elevation_2_nw", typeof(Double));
+            createCol(regionsettings, "elevation_1_ne", typeof(Double));
+            createCol(regionsettings, "elevation_2_ne", typeof(Double));
+            createCol(regionsettings, "elevation_1_se", typeof(Double));
+            createCol(regionsettings, "elevation_2_se", typeof(Double));
+            createCol(regionsettings, "elevation_1_sw", typeof(Double));
+            createCol(regionsettings, "elevation_2_sw", typeof(Double));
+            createCol(regionsettings, "water_height", typeof(Double));
+            createCol(regionsettings, "terrain_raise_limit", typeof(Double));
+            createCol(regionsettings, "terrain_lower_limit", typeof(Double));
+            createCol(regionsettings, "use_estate_sun", typeof(Int32));
+            createCol(regionsettings, "sandbox", typeof(Int32));
+            createCol(regionsettings, "sunvectorx", typeof(Double));
+            createCol(regionsettings, "sunvectory", typeof(Double));
+            createCol(regionsettings, "sunvectorz", typeof(Double));
+            createCol(regionsettings, "fixed_sun", typeof(Int32));
+            createCol(regionsettings, "sun_position", typeof(Double));
             createCol(regionsettings, "covenant", typeof(String));
             createCol(regionsettings, "covenant_datetime", typeof(Int32));
             createCol(regionsettings, "map_tile_ID", typeof(String));
@@ -1191,6 +1269,82 @@ namespace OpenSim.Data.SQLite
             return regionsettings;
         }
 
+        /// <summary>
+        /// create "regionwindlight" table
+        /// </summary>
+        /// <returns>RegionWindlight DataTable</returns>
+        private static DataTable createRegionWindlightTable()
+        {
+            DataTable regionwindlight = new DataTable("regionwindlight");
+            createCol(regionwindlight, "region_id", typeof(String));
+            createCol(regionwindlight, "water_color_r", typeof(Double));
+            createCol(regionwindlight, "water_color_g", typeof(Double));
+            createCol(regionwindlight, "water_color_b", typeof(Double));
+            createCol(regionwindlight, "water_color_i", typeof(Double));
+            createCol(regionwindlight, "water_fog_density_exponent", typeof(Double));
+            createCol(regionwindlight, "underwater_fog_modifier", typeof(Double));
+            createCol(regionwindlight, "reflection_wavelet_scale_1", typeof(Double));
+            createCol(regionwindlight, "reflection_wavelet_scale_2", typeof(Double));
+            createCol(regionwindlight, "reflection_wavelet_scale_3", typeof(Double));
+            createCol(regionwindlight, "fresnel_scale", typeof(Double));
+            createCol(regionwindlight, "fresnel_offset", typeof(Double));
+            createCol(regionwindlight, "refract_scale_above", typeof(Double));
+            createCol(regionwindlight, "refract_scale_below", typeof(Double));
+            createCol(regionwindlight, "blur_multiplier", typeof(Double));
+            createCol(regionwindlight, "big_wave_direction_x", typeof(Double));
+            createCol(regionwindlight, "big_wave_direction_y", typeof(Double));
+            createCol(regionwindlight, "little_wave_direction_x", typeof(Double));
+            createCol(regionwindlight, "little_wave_direction_y", typeof(Double));
+            createCol(regionwindlight, "normal_map_texture", typeof(String));
+            createCol(regionwindlight, "horizon_r", typeof(Double));
+            createCol(regionwindlight, "horizon_g", typeof(Double));
+            createCol(regionwindlight, "horizon_b", typeof(Double));
+            createCol(regionwindlight, "horizon_i", typeof(Double));
+            createCol(regionwindlight, "haze_horizon", typeof(Double));
+            createCol(regionwindlight, "blue_density_r", typeof(Double));
+            createCol(regionwindlight, "blue_density_g", typeof(Double));
+            createCol(regionwindlight, "blue_density_b", typeof(Double));
+            createCol(regionwindlight, "blue_density_i", typeof(Double));
+            createCol(regionwindlight, "haze_density", typeof(Double));
+            createCol(regionwindlight, "density_multiplier", typeof(Double));
+            createCol(regionwindlight, "distance_multiplier", typeof(Double));
+            createCol(regionwindlight, "max_altitude", typeof(Int32));
+            createCol(regionwindlight, "sun_moon_color_r", typeof(Double));
+            createCol(regionwindlight, "sun_moon_color_g", typeof(Double));
+            createCol(regionwindlight, "sun_moon_color_b", typeof(Double));
+            createCol(regionwindlight, "sun_moon_color_i", typeof(Double));
+            createCol(regionwindlight, "sun_moon_position", typeof(Double));
+            createCol(regionwindlight, "ambient_r", typeof(Double));
+            createCol(regionwindlight, "ambient_g", typeof(Double));
+            createCol(regionwindlight, "ambient_b", typeof(Double));
+            createCol(regionwindlight, "ambient_i", typeof(Double));
+            createCol(regionwindlight, "east_angle", typeof(Double));
+            createCol(regionwindlight, "sun_glow_focus", typeof(Double));
+            createCol(regionwindlight, "sun_glow_size", typeof(Double));
+            createCol(regionwindlight, "scene_gamma", typeof(Double));
+            createCol(regionwindlight, "star_brightness", typeof(Double));
+            createCol(regionwindlight, "cloud_color_r", typeof(Double));
+            createCol(regionwindlight, "cloud_color_g", typeof(Double));
+            createCol(regionwindlight, "cloud_color_b", typeof(Double));
+            createCol(regionwindlight, "cloud_color_i", typeof(Double));
+            createCol(regionwindlight, "cloud_x", typeof(Double));
+            createCol(regionwindlight, "cloud_y", typeof(Double));
+            createCol(regionwindlight, "cloud_density", typeof(Double));
+            createCol(regionwindlight, "cloud_coverage", typeof(Double));
+            createCol(regionwindlight, "cloud_scale", typeof(Double));
+            createCol(regionwindlight, "cloud_detail_x", typeof(Double));
+            createCol(regionwindlight, "cloud_detail_y", typeof(Double));
+            createCol(regionwindlight, "cloud_detail_density", typeof(Double));
+            createCol(regionwindlight, "cloud_scroll_x", typeof(Double));
+            createCol(regionwindlight, "cloud_scroll_x_lock", typeof(Int32));
+            createCol(regionwindlight, "cloud_scroll_y", typeof(Double));
+            createCol(regionwindlight, "cloud_scroll_y_lock", typeof(Int32));
+            createCol(regionwindlight, "draw_classic_clouds", typeof(Int32));
+
+            regionwindlight.PrimaryKey = new DataColumn[] { regionwindlight.Columns["region_id"] };
+            return regionwindlight;
+        }
+
         /***********************************************************************
          *
          *  Convert between ADO.NET <=> OpenSim Objects
@@ -1229,26 +1383,26 @@ namespace OpenSim.Data.SQLite
             // back out.  Not enough time to figure it out yet.
 
             SceneObjectPart prim = new SceneObjectPart();
-            prim.UUID = new UUID((String) row["UUID"]);
+            prim.UUID = new UUID((String)row["UUID"]);
             // explicit conversion of integers is required, which sort
             // of sucks.  No idea if there is a shortcut here or not.
             prim.CreationDate = Convert.ToInt32(row["CreationDate"]);
             prim.Name = row["Name"] == DBNull.Value ? string.Empty : (string)row["Name"];
             // various text fields
-            prim.Text = (String) row["Text"];
+            prim.Text = (String)row["Text"];
             prim.Color = Color.FromArgb(Convert.ToInt32(row["ColorA"]),
                                         Convert.ToInt32(row["ColorR"]),
                                         Convert.ToInt32(row["ColorG"]),
                                         Convert.ToInt32(row["ColorB"]));
-            prim.Description = (String) row["Description"];
-            prim.SitName = (String) row["SitName"];
-            prim.TouchName = (String) row["TouchName"];
+            prim.Description = (String)row["Description"];
+            prim.SitName = (String)row["SitName"];
+            prim.TouchName = (String)row["TouchName"];
             // permissions
             prim.ObjectFlags = Convert.ToUInt32(row["ObjectFlags"]);
-            prim.CreatorIdentification = (String) row["CreatorID"];
-            prim.OwnerID = new UUID((String) row["OwnerID"]);
-            prim.GroupID = new UUID((String) row["GroupID"]);
-            prim.LastOwnerID = new UUID((String) row["LastOwnerID"]);
+            prim.CreatorIdentification = (String)row["CreatorID"];
+            prim.OwnerID = new UUID((String)row["OwnerID"]);
+            prim.GroupID = new UUID((String)row["GroupID"]);
+            prim.LastOwnerID = new UUID((String)row["LastOwnerID"]);
             prim.OwnerMask = Convert.ToUInt32(row["OwnerMask"]);
             prim.NextOwnerMask = Convert.ToUInt32(row["NextOwnerMask"]);
             prim.GroupMask = Convert.ToUInt32(row["GroupMask"]);
@@ -1360,7 +1514,7 @@ namespace OpenSim.Data.SQLite
 
             if (!(row["MediaURL"] is System.DBNull))
             {
-                //m_log.DebugFormat("[SQLITE]: MediaUrl type [{0}]", row["MediaURL"].GetType());
+//                m_log.DebugFormat("[SQLITE]: MediaUrl type [{0}]", row["MediaURL"].GetType());
                 prim.MediaUrl = (string)row["MediaURL"];
             }
 
@@ -1376,28 +1530,28 @@ namespace OpenSim.Data.SQLite
         {
             TaskInventoryItem taskItem = new TaskInventoryItem();
 
-            taskItem.ItemID        = new UUID((String)row["itemID"]);
-            taskItem.ParentPartID  = new UUID((String)row["primID"]);
-            taskItem.AssetID       = new UUID((String)row["assetID"]);
-            taskItem.ParentID      = new UUID((String)row["parentFolderID"]);
+            taskItem.ItemID = new UUID((String)row["itemID"]);
+            taskItem.ParentPartID = new UUID((String)row["primID"]);
+            taskItem.AssetID = new UUID((String)row["assetID"]);
+            taskItem.ParentID = new UUID((String)row["parentFolderID"]);
 
-            taskItem.InvType       = Convert.ToInt32(row["invType"]);
-            taskItem.Type          = Convert.ToInt32(row["assetType"]);
+            taskItem.InvType = Convert.ToInt32(row["invType"]);
+            taskItem.Type = Convert.ToInt32(row["assetType"]);
 
-            taskItem.Name          = (String)row["name"];
-            taskItem.Description   = (String)row["description"];
-            taskItem.CreationDate  = Convert.ToUInt32(row["creationDate"]);
+            taskItem.Name = (String)row["name"];
+            taskItem.Description = (String)row["description"];
+            taskItem.CreationDate = Convert.ToUInt32(row["creationDate"]);
             taskItem.CreatorIdentification = (String)row["creatorID"];
-            taskItem.OwnerID       = new UUID((String)row["ownerID"]);
-            taskItem.LastOwnerID   = new UUID((String)row["lastOwnerID"]);
-            taskItem.GroupID       = new UUID((String)row["groupID"]);
+            taskItem.OwnerID = new UUID((String)row["ownerID"]);
+            taskItem.LastOwnerID = new UUID((String)row["lastOwnerID"]);
+            taskItem.GroupID = new UUID((String)row["groupID"]);
 
             taskItem.NextPermissions = Convert.ToUInt32(row["nextPermissions"]);
-            taskItem.CurrentPermissions     = Convert.ToUInt32(row["currentPermissions"]);
-            taskItem.BasePermissions      = Convert.ToUInt32(row["basePermissions"]);
-            taskItem.EveryonePermissions  = Convert.ToUInt32(row["everyonePermissions"]);
-            taskItem.GroupPermissions     = Convert.ToUInt32(row["groupPermissions"]);
-            taskItem.Flags         = Convert.ToUInt32(row["flags"]);
+            taskItem.CurrentPermissions = Convert.ToUInt32(row["currentPermissions"]);
+            taskItem.BasePermissions = Convert.ToUInt32(row["basePermissions"]);
+            taskItem.EveryonePermissions = Convert.ToUInt32(row["everyonePermissions"]);
+            taskItem.GroupPermissions = Convert.ToUInt32(row["groupPermissions"]);
+            taskItem.Flags = Convert.ToUInt32(row["flags"]);
 
             return taskItem;
         }
@@ -1411,35 +1565,35 @@ namespace OpenSim.Data.SQLite
         {
             LandData newData = new LandData();
 
-            newData.GlobalID = new UUID((String) row["UUID"]);
+            newData.GlobalID = new UUID((String)row["UUID"]);
             newData.LocalID = Convert.ToInt32(row["LocalLandID"]);
 
             // Bitmap is a byte[512]
-            newData.Bitmap = (Byte[]) row["Bitmap"];
+            newData.Bitmap = (Byte[])row["Bitmap"];
 
-            newData.Name = (String) row["Name"];
-            newData.Description = (String) row["Desc"];
-            newData.OwnerID = (UUID)(String) row["OwnerUUID"];
-            newData.IsGroupOwned = (Boolean) row["IsGroupOwned"];
+            newData.Name = (String)row["Name"];
+            newData.Description = (String)row["Desc"];
+            newData.OwnerID = (UUID)(String)row["OwnerUUID"];
+            newData.IsGroupOwned = (Boolean)row["IsGroupOwned"];
             newData.Area = Convert.ToInt32(row["Area"]);
             newData.AuctionID = Convert.ToUInt32(row["AuctionID"]); //Unemplemented
-            newData.Category = (ParcelCategory) Convert.ToInt32(row["Category"]);
-                //Enum OpenMetaverse.Parcel.ParcelCategory
+            newData.Category = (ParcelCategory)Convert.ToInt32(row["Category"]);
+            //Enum OpenMetaverse.Parcel.ParcelCategory
             newData.ClaimDate = Convert.ToInt32(row["ClaimDate"]);
             newData.ClaimPrice = Convert.ToInt32(row["ClaimPrice"]);
-            newData.GroupID = new UUID((String) row["GroupUUID"]);
+            newData.GroupID = new UUID((String)row["GroupUUID"]);
             newData.SalePrice = Convert.ToInt32(row["SalePrice"]);
-            newData.Status = (ParcelStatus) Convert.ToInt32(row["LandStatus"]);
-                //Enum. OpenMetaverse.Parcel.ParcelStatus
+            newData.Status = (ParcelStatus)Convert.ToInt32(row["LandStatus"]);
+            //Enum. OpenMetaverse.Parcel.ParcelStatus
             newData.Flags = Convert.ToUInt32(row["LandFlags"]);
-            newData.LandingType = (Byte) row["LandingType"];
-            newData.MediaAutoScale = (Byte) row["MediaAutoScale"];
-            newData.MediaID = new UUID((String) row["MediaTextureUUID"]);
-            newData.MediaURL = (String) row["MediaURL"];
-            newData.MusicURL = (String) row["MusicURL"];
+            newData.LandingType = (Byte)row["LandingType"];
+            newData.MediaAutoScale = (Byte)row["MediaAutoScale"];
+            newData.MediaID = new UUID((String)row["MediaTextureUUID"]);
+            newData.MediaURL = (String)row["MediaURL"];
+            newData.MusicURL = (String)row["MusicURL"];
             newData.PassHours = Convert.ToSingle(row["PassHours"]);
             newData.PassPrice = Convert.ToInt32(row["PassPrice"]);
-            newData.SnapshotID = (UUID)(String) row["SnapshotUUID"];
+            newData.SnapshotID = (UUID)(String)row["SnapshotUUID"];
             try
             {
 
@@ -1471,7 +1625,7 @@ namespace OpenSim.Data.SQLite
         {
             RegionSettings newSettings = new RegionSettings();
 
-            newSettings.RegionUUID = new UUID((string) row["regionUUID"]);
+            newSettings.RegionUUID = new UUID((string)row["regionUUID"]);
             newSettings.BlockTerraform = Convert.ToBoolean(row["block_terraform"]);
             newSettings.AllowDamage = Convert.ToBoolean(row["allow_damage"]);
             newSettings.BlockFly = Convert.ToBoolean(row["block_fly"]);
@@ -1485,10 +1639,10 @@ namespace OpenSim.Data.SQLite
             newSettings.DisableScripts = Convert.ToBoolean(row["disable_scripts"]);
             newSettings.DisableCollisions = Convert.ToBoolean(row["disable_collisions"]);
             newSettings.DisablePhysics = Convert.ToBoolean(row["disable_physics"]);
-            newSettings.TerrainTexture1 = new UUID((String) row["terrain_texture_1"]);
-            newSettings.TerrainTexture2 = new UUID((String) row["terrain_texture_2"]);
-            newSettings.TerrainTexture3 = new UUID((String) row["terrain_texture_3"]);
-            newSettings.TerrainTexture4 = new UUID((String) row["terrain_texture_4"]);
+            newSettings.TerrainTexture1 = new UUID((String)row["terrain_texture_1"]);
+            newSettings.TerrainTexture2 = new UUID((String)row["terrain_texture_2"]);
+            newSettings.TerrainTexture3 = new UUID((String)row["terrain_texture_3"]);
+            newSettings.TerrainTexture4 = new UUID((String)row["terrain_texture_4"]);
             newSettings.Elevation1NW = Convert.ToDouble(row["elevation_1_nw"]);
             newSettings.Elevation2NW = Convert.ToDouble(row["elevation_2_nw"]);
             newSettings.Elevation1NE = Convert.ToDouble(row["elevation_1_ne"]);
@@ -1502,14 +1656,14 @@ namespace OpenSim.Data.SQLite
             newSettings.TerrainLowerLimit = Convert.ToDouble(row["terrain_lower_limit"]);
             newSettings.UseEstateSun = Convert.ToBoolean(row["use_estate_sun"]);
             newSettings.Sandbox = Convert.ToBoolean(row["sandbox"]);
-            newSettings.SunVector = new Vector3 (
+            newSettings.SunVector = new Vector3(
                                      Convert.ToSingle(row["sunvectorx"]),
                                      Convert.ToSingle(row["sunvectory"]),
                                      Convert.ToSingle(row["sunvectorz"])
                                      );
             newSettings.FixedSun = Convert.ToBoolean(row["fixed_sun"]);
             newSettings.SunPosition = Convert.ToDouble(row["sun_position"]);
-            newSettings.Covenant = new UUID((String) row["covenant"]);
+            newSettings.Covenant = new UUID((String)row["covenant"]);
             newSettings.CovenantChangedDateTime = Convert.ToInt32(row["covenant_datetime"]);
             newSettings.TerrainImageID = new UUID((String)row["map_tile_ID"]);
 
@@ -1517,6 +1671,83 @@ namespace OpenSim.Data.SQLite
         }
 
         /// <summary>
+        /// Build a windlight entry from the persisted data.
+        /// </summary>
+        /// <param name="row"></param>
+        /// <returns>RegionLightShareData</returns>
+        private RegionLightShareData buildRegionWindlight(DataRow row)
+        {
+            RegionLightShareData windlight = new RegionLightShareData();
+
+            windlight.regionID = new UUID((string)row["region_id"]);
+            windlight.waterColor.X = Convert.ToSingle(row["water_color_r"]);
+            windlight.waterColor.Y = Convert.ToSingle(row["water_color_g"]);
+            windlight.waterColor.Z = Convert.ToSingle(row["water_color_b"]);
+            //windlight.waterColor.W = Convert.ToSingle(row["water_color_i"]); //not implemented
+            windlight.waterFogDensityExponent = Convert.ToSingle(row["water_fog_density_exponent"]);
+            windlight.underwaterFogModifier = Convert.ToSingle(row["underwater_fog_modifier"]);
+            windlight.reflectionWaveletScale.X = Convert.ToSingle(row["reflection_wavelet_scale_1"]);
+            windlight.reflectionWaveletScale.Y = Convert.ToSingle(row["reflection_wavelet_scale_2"]);
+            windlight.reflectionWaveletScale.Z = Convert.ToSingle(row["reflection_wavelet_scale_3"]);
+            windlight.fresnelScale = Convert.ToSingle(row["fresnel_scale"]);
+            windlight.fresnelOffset = Convert.ToSingle(row["fresnel_offset"]);
+            windlight.refractScaleAbove = Convert.ToSingle(row["refract_scale_above"]);
+            windlight.refractScaleBelow = Convert.ToSingle(row["refract_scale_below"]);
+            windlight.blurMultiplier = Convert.ToSingle(row["blur_multiplier"]);
+            windlight.bigWaveDirection.X = Convert.ToSingle(row["big_wave_direction_x"]);
+            windlight.bigWaveDirection.Y = Convert.ToSingle(row["big_wave_direction_y"]);
+            windlight.littleWaveDirection.X = Convert.ToSingle(row["little_wave_direction_x"]);
+            windlight.littleWaveDirection.Y = Convert.ToSingle(row["little_wave_direction_y"]);
+            windlight.normalMapTexture = new UUID((string)row["normal_map_texture"]);
+            windlight.horizon.X = Convert.ToSingle(row["horizon_r"]);
+            windlight.horizon.Y = Convert.ToSingle(row["horizon_g"]);
+            windlight.horizon.Z = Convert.ToSingle(row["horizon_b"]);
+            windlight.horizon.W = Convert.ToSingle(row["horizon_i"]);
+            windlight.hazeHorizon = Convert.ToSingle(row["haze_horizon"]);
+            windlight.blueDensity.X = Convert.ToSingle(row["blue_density_r"]);
+            windlight.blueDensity.Y = Convert.ToSingle(row["blue_density_g"]);
+            windlight.blueDensity.Z = Convert.ToSingle(row["blue_density_b"]);
+            windlight.blueDensity.W = Convert.ToSingle(row["blue_density_i"]);
+            windlight.hazeDensity = Convert.ToSingle(row["haze_density"]);
+            windlight.densityMultiplier = Convert.ToSingle(row["density_multiplier"]);
+            windlight.distanceMultiplier = Convert.ToSingle(row["distance_multiplier"]);
+            windlight.maxAltitude = Convert.ToUInt16(row["max_altitude"]);
+            windlight.sunMoonColor.X = Convert.ToSingle(row["sun_moon_color_r"]);
+            windlight.sunMoonColor.Y = Convert.ToSingle(row["sun_moon_color_g"]);
+            windlight.sunMoonColor.Z = Convert.ToSingle(row["sun_moon_color_b"]);
+            windlight.sunMoonColor.W = Convert.ToSingle(row["sun_moon_color_i"]);
+            windlight.sunMoonPosition = Convert.ToSingle(row["sun_moon_position"]);
+            windlight.ambient.X = Convert.ToSingle(row["ambient_r"]);
+            windlight.ambient.Y = Convert.ToSingle(row["ambient_g"]);
+            windlight.ambient.Z = Convert.ToSingle(row["ambient_b"]);
+            windlight.ambient.W = Convert.ToSingle(row["ambient_i"]);
+            windlight.eastAngle = Convert.ToSingle(row["east_angle"]);
+            windlight.sunGlowFocus = Convert.ToSingle(row["sun_glow_focus"]);
+            windlight.sunGlowSize = Convert.ToSingle(row["sun_glow_size"]);
+            windlight.sceneGamma = Convert.ToSingle(row["scene_gamma"]);
+            windlight.starBrightness = Convert.ToSingle(row["star_brightness"]);
+            windlight.cloudColor.X = Convert.ToSingle(row["cloud_color_r"]);
+            windlight.cloudColor.Y = Convert.ToSingle(row["cloud_color_g"]);
+            windlight.cloudColor.Z = Convert.ToSingle(row["cloud_color_b"]);
+            windlight.cloudColor.W = Convert.ToSingle(row["cloud_color_i"]);
+            windlight.cloudXYDensity.X = Convert.ToSingle(row["cloud_x"]);
+            windlight.cloudXYDensity.Y = Convert.ToSingle(row["cloud_y"]);
+            windlight.cloudXYDensity.Z = Convert.ToSingle(row["cloud_density"]);
+            windlight.cloudCoverage = Convert.ToSingle(row["cloud_coverage"]);
+            windlight.cloudScale = Convert.ToSingle(row["cloud_scale"]);
+            windlight.cloudDetailXYDensity.X = Convert.ToSingle(row["cloud_detail_x"]);
+            windlight.cloudDetailXYDensity.Y = Convert.ToSingle(row["cloud_detail_y"]);
+            windlight.cloudDetailXYDensity.Z = Convert.ToSingle(row["cloud_detail_density"]);
+            windlight.cloudScrollX = Convert.ToSingle(row["cloud_scroll_x"]);
+            windlight.cloudScrollXLock = Convert.ToBoolean(row["cloud_scroll_x_lock"]);
+            windlight.cloudScrollY = Convert.ToSingle(row["cloud_scroll_y"]);
+            windlight.cloudScrollYLock = Convert.ToBoolean(row["cloud_scroll_y_lock"]);
+            windlight.drawClassicClouds = Convert.ToBoolean(row["draw_classic_clouds"]);
+
+            return windlight;
+        }
+
+        /// <summary>
         /// Build a land access entry from the persisted data.
         /// </summary>
         /// <param name="row"></param>
@@ -1524,8 +1755,8 @@ namespace OpenSim.Data.SQLite
         private static LandAccessEntry buildLandAccessData(DataRow row)
         {
             LandAccessEntry entry = new LandAccessEntry();
-            entry.AgentID = new UUID((string) row["AccessUUID"]);
-            entry.Flags = (AccessList) row["Flags"];
+            entry.AgentID = new UUID((string)row["AccessUUID"]);
+            entry.Flags = (AccessList)row["Flags"];
             entry.Expires = 0;
             return entry;
         }
@@ -1537,7 +1768,7 @@ namespace OpenSim.Data.SQLite
         /// <returns></returns>
         private static Array serializeTerrain(double[,] val)
         {
-            MemoryStream str = new MemoryStream(((int)Constants.RegionSize * (int)Constants.RegionSize) *sizeof (double));
+            MemoryStream str = new MemoryStream(((int)Constants.RegionSize * (int)Constants.RegionSize) * sizeof(double));
             BinaryWriter bw = new BinaryWriter(str);
 
             // TODO: COMPATIBILITY - Add byte-order conversions
@@ -1548,21 +1779,21 @@ namespace OpenSim.Data.SQLite
             return str.ToArray();
         }
 
-//         private void fillTerrainRow(DataRow row, UUID regionUUID, int rev, double[,] val)
-//         {
-//             row["RegionUUID"] = regionUUID;
-//             row["Revision"] = rev;
+        //         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);
+        //             BinaryWriter bw = new BinaryWriter(str);
 
-//             // TODO: COMPATIBILITY - Add byte-order conversions
+        //             // 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]);
+        //                     bw.Write(val[x, y]);
 
-//             row["Heightfield"] = str.ToArray();
-//         }
+        //             row["Heightfield"] = str.ToArray();
+        //         }
 
         /// <summary>
         ///
@@ -1843,6 +2074,79 @@ namespace OpenSim.Data.SQLite
         ///
         /// </summary>
         /// <param name="row"></param>
+        /// <param name="windlight"></param>
+        private static void fillRegionWindlightRow(DataRow row, RegionLightShareData windlight)
+        {
+            row["region_id"] = windlight.regionID.ToString();
+            row["water_color_r"] = windlight.waterColor.X;
+            row["water_color_g"] = windlight.waterColor.Y;
+            row["water_color_b"] = windlight.waterColor.Z;
+            row["water_color_i"] = 1; //windlight.waterColor.W;  //not implemented
+            row["water_fog_density_exponent"] = windlight.waterFogDensityExponent;
+            row["underwater_fog_modifier"] = windlight.underwaterFogModifier;
+            row["reflection_wavelet_scale_1"] = windlight.reflectionWaveletScale.X;
+            row["reflection_wavelet_scale_2"] = windlight.reflectionWaveletScale.Y;
+            row["reflection_wavelet_scale_3"] = windlight.reflectionWaveletScale.Z;
+            row["fresnel_scale"] = windlight.fresnelScale;
+            row["fresnel_offset"] = windlight.fresnelOffset;
+            row["refract_scale_above"] = windlight.refractScaleAbove;
+            row["refract_scale_below"] = windlight.refractScaleBelow;
+            row["blur_multiplier"] = windlight.blurMultiplier;
+            row["big_wave_direction_x"] = windlight.bigWaveDirection.X;
+            row["big_wave_direction_y"] = windlight.bigWaveDirection.Y;
+            row["little_wave_direction_x"] = windlight.littleWaveDirection.X;
+            row["little_wave_direction_y"] = windlight.littleWaveDirection.Y;
+            row["normal_map_texture"] = windlight.normalMapTexture.ToString();
+            row["horizon_r"] = windlight.horizon.X;
+            row["horizon_g"] = windlight.horizon.Y;
+            row["horizon_b"] = windlight.horizon.Z;
+            row["horizon_i"] = windlight.horizon.W;
+            row["haze_horizon"] = windlight.hazeHorizon;
+            row["blue_density_r"] = windlight.blueDensity.X;
+            row["blue_density_g"] = windlight.blueDensity.Y;
+            row["blue_density_b"] = windlight.blueDensity.Z;
+            row["blue_density_i"] = windlight.blueDensity.W;
+            row["haze_density"] = windlight.hazeDensity;
+            row["density_multiplier"] = windlight.densityMultiplier;
+            row["distance_multiplier"] = windlight.distanceMultiplier;
+            row["max_altitude"] = windlight.maxAltitude;
+            row["sun_moon_color_r"] = windlight.sunMoonColor.X;
+            row["sun_moon_color_g"] = windlight.sunMoonColor.Y;
+            row["sun_moon_color_b"] = windlight.sunMoonColor.Z;
+            row["sun_moon_color_i"] = windlight.sunMoonColor.W;
+            row["sun_moon_position"] = windlight.sunMoonPosition;
+            row["ambient_r"] = windlight.ambient.X;
+            row["ambient_g"] = windlight.ambient.Y;
+            row["ambient_b"] = windlight.ambient.Z;
+            row["ambient_i"] = windlight.ambient.W;
+            row["east_angle"] = windlight.eastAngle;
+            row["sun_glow_focus"] = windlight.sunGlowFocus;
+            row["sun_glow_size"] = windlight.sunGlowSize;
+            row["scene_gamma"] = windlight.sceneGamma;
+            row["star_brightness"] = windlight.starBrightness;
+            row["cloud_color_r"] = windlight.cloudColor.X;
+            row["cloud_color_g"] = windlight.cloudColor.Y;
+            row["cloud_color_b"] = windlight.cloudColor.Z;
+            row["cloud_color_i"] = windlight.cloudColor.W;
+            row["cloud_x"] = windlight.cloudXYDensity.X;
+            row["cloud_y"] = windlight.cloudXYDensity.Y;
+            row["cloud_density"] = windlight.cloudXYDensity.Z;
+            row["cloud_coverage"] = windlight.cloudCoverage;
+            row["cloud_scale"] = windlight.cloudScale;
+            row["cloud_detail_x"] = windlight.cloudDetailXYDensity.X;
+            row["cloud_detail_y"] = windlight.cloudDetailXYDensity.Y;
+            row["cloud_detail_density"] = windlight.cloudDetailXYDensity.Z;
+            row["cloud_scroll_x"] = windlight.cloudScrollX;
+            row["cloud_scroll_x_lock"] = windlight.cloudScrollXLock;
+            row["cloud_scroll_y"] = windlight.cloudScrollY;
+            row["cloud_scroll_y_lock"] = windlight.cloudScrollYLock;
+            row["draw_classic_clouds"] = windlight.drawClassicClouds;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="row"></param>
         /// <returns></returns>
         private PrimitiveBaseShape buildShape(DataRow row)
         {
@@ -1878,7 +2182,7 @@ namespace OpenSim.Data.SQLite
             byte[] textureEntry = (byte[])row["Texture"];
             s.TextureEntry = textureEntry;
 
-            s.ExtraParams = (byte[]) row["ExtraParams"];
+            s.ExtraParams = (byte[])row["ExtraParams"];
 
             if (!(row["Media"] is System.DBNull))
                 s.Media = PrimitiveBaseShape.MediaList.FromXml((string)row["Media"]);
@@ -1986,10 +2290,10 @@ namespace OpenSim.Data.SQLite
                 // repalce with current inventory details
                 foreach (TaskInventoryItem newItem in items)
                 {
-//                    m_log.InfoFormat(
-//                        "[DATASTORE]: ",
-//                        "Adding item {0}, {1} to prim ID {2}",
-//                        newItem.Name, newItem.ItemID, newItem.ParentPartID);
+                    //                    m_log.InfoFormat(
+                    //                        "[DATASTORE]: ",
+                    //                        "Adding item {0}, {1} to prim ID {2}",
+                    //                        newItem.Name, newItem.ItemID, newItem.ParentPartID);
 
                     DataRow newItemRow = dbItems.NewRow();
                     fillItemRow(newItemRow, newItem);
@@ -2040,7 +2344,7 @@ namespace OpenSim.Data.SQLite
             sql += ") values (:";
             sql += String.Join(", :", cols);
             sql += ")";
-            //m_log.DebugFormat("[SQLITE]: Created insert command {0}", sql);
+//            m_log.DebugFormat("[SQLITE]: Created insert command {0}", sql);
             SqliteCommand cmd = new SqliteCommand(sql);
 
             // this provides the binding for all our parameters, so
@@ -2192,7 +2496,7 @@ namespace OpenSim.Data.SQLite
             da.UpdateCommand.Connection = conn;
 
             SqliteCommand delete = new SqliteCommand("delete from prims where UUID = :UUID");
-            delete.Parameters.Add(createSqliteParameter("UUID", typeof (String)));
+            delete.Parameters.Add(createSqliteParameter("UUID", typeof(String)));
             delete.Connection = conn;
             da.DeleteCommand = delete;
         }
@@ -2211,7 +2515,7 @@ namespace OpenSim.Data.SQLite
             da.UpdateCommand.Connection = conn;
 
             SqliteCommand delete = new SqliteCommand("delete from primitems where itemID = :itemID");
-            delete.Parameters.Add(createSqliteParameter("itemID", typeof (String)));
+            delete.Parameters.Add(createSqliteParameter("itemID", typeof(String)));
             delete.Connection = conn;
             da.DeleteCommand = delete;
         }
@@ -2279,6 +2583,19 @@ namespace OpenSim.Data.SQLite
         /// </summary>
         /// <param name="da"></param>
         /// <param name="conn"></param>
+        private void setupRegionWindlightCommands(SqliteDataAdapter da, SqliteConnection conn)
+        {
+            da.InsertCommand = createInsertCommand("regionwindlight", ds.Tables["regionwindlight"]);
+            da.InsertCommand.Connection = conn;
+            da.UpdateCommand = createUpdateCommand("regionwindlight", "region_id=:region_id", ds.Tables["regionwindlight"]);
+            da.UpdateCommand.Connection = conn;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="da"></param>
+        /// <param name="conn"></param>
         private void setupShapeCommands(SqliteDataAdapter da, SqliteConnection conn)
         {
             da.InsertCommand = createInsertCommand("primshapes", ds.Tables["primshapes"]);
@@ -2288,7 +2605,7 @@ namespace OpenSim.Data.SQLite
             da.UpdateCommand.Connection = conn;
 
             SqliteCommand delete = new SqliteCommand("delete from primshapes where UUID = :UUID");
-            delete.Parameters.Add(createSqliteParameter("UUID", typeof (String)));
+            delete.Parameters.Add(createSqliteParameter("UUID", typeof(String)));
             delete.Connection = conn;
             da.DeleteCommand = delete;
         }
@@ -2306,27 +2623,27 @@ namespace OpenSim.Data.SQLite
         /// <returns></returns>
         private static DbType dbtypeFromType(Type type)
         {
-            if (type == typeof (String))
+            if (type == typeof(String))
             {
                 return DbType.String;
             }
-            else if (type == typeof (Int32))
+            else if (type == typeof(Int32))
             {
                 return DbType.Int32;
             }
-            else if (type == typeof (Double))
+            else if (type == typeof(Double))
             {
                 return DbType.Double;
             }
-            else if (type == typeof (Byte))
+            else if (type == typeof(Byte))
             {
                 return DbType.Byte;
             }
-            else if (type == typeof (Double))
+            else if (type == typeof(Double))
             {
                 return DbType.Double;
             }
-            else if (type == typeof (Byte[]))
+            else if (type == typeof(Byte[]))
             {
                 return DbType.Binary;
             }
@@ -2338,32 +2655,32 @@ namespace OpenSim.Data.SQLite
 
         static void PrintDataSet(DataSet ds)
         {
-          // Print out any name and extended properties.
-          Console.WriteLine("DataSet is named: {0}", ds.DataSetName);
-          foreach (System.Collections.DictionaryEntry de in ds.ExtendedProperties)
-          {
-            Console.WriteLine("Key = {0}, Value = {1}", de.Key, de.Value);
-          }
-          Console.WriteLine();
-          foreach (DataTable dt in ds.Tables)
-          {
-            Console.WriteLine("=> {0} Table:", dt.TableName);
-            // Print out the column names.
-            for (int curCol = 0; curCol < dt.Columns.Count; curCol++)
+            // Print out any name and extended properties.
+            Console.WriteLine("DataSet is named: {0}", ds.DataSetName);
+            foreach (System.Collections.DictionaryEntry de in ds.ExtendedProperties)
             {
-              Console.Write(dt.Columns[curCol].ColumnName + "\t");
+                Console.WriteLine("Key = {0}, Value = {1}", de.Key, de.Value);
             }
-            Console.WriteLine("\n----------------------------------");
-            // Print the DataTable.
-            for (int curRow = 0; curRow < dt.Rows.Count; curRow++)
+            Console.WriteLine();
+            foreach (DataTable dt in ds.Tables)
             {
-              for (int curCol = 0; curCol < dt.Columns.Count; curCol++)
-              {
-                Console.Write(dt.Rows[curRow][curCol].ToString() + "\t");
-              }
-              Console.WriteLine();
+                Console.WriteLine("=> {0} Table:", dt.TableName);
+                // Print out the column names.
+                for (int curCol = 0; curCol < dt.Columns.Count; curCol++)
+                {
+                    Console.Write(dt.Columns[curCol].ColumnName + "\t");
+                }
+                Console.WriteLine("\n----------------------------------");
+                // Print the DataTable.
+                for (int curRow = 0; curRow < dt.Rows.Count; curRow++)
+                {
+                    for (int curCol = 0; curCol < dt.Columns.Count; curCol++)
+                    {
+                        Console.Write(dt.Rows[curRow][curCol].ToString() + "\t");
+                    }
+                    Console.WriteLine();
+                }
             }
-          }
         }
 
     }
diff --git a/OpenSim/Framework/ChildAgentDataUpdate.cs b/OpenSim/Framework/ChildAgentDataUpdate.cs
index 6d048f4..fe12874 100644
--- a/OpenSim/Framework/ChildAgentDataUpdate.cs
+++ b/OpenSim/Framework/ChildAgentDataUpdate.cs
@@ -308,6 +308,8 @@ namespace OpenSim.Framework
         public Animation[] Anims;
 
         public UUID GranterID;
+        public UUID ParentPart;
+        public Vector3 SitOffset;
 
         // Appearance
         public AvatarAppearance Appearance;
@@ -468,6 +470,10 @@ namespace OpenSim.Framework
                 }
                 args["attach_objects"] = attObjs;
             }
+
+            args["parent_part"] = OSD.FromUUID(ParentPart);
+            args["sit_offset"] = OSD.FromString(SitOffset.ToString());
+
             return args;
         }
 
@@ -675,6 +681,11 @@ namespace OpenSim.Framework
                     }
                 }
             }
+
+            if (args["parent_part"] != null)
+                ParentPart = args["parent_part"].AsUUID();
+            if (args["sit_offset"] != null)
+                Vector3.TryParse(args["sit_offset"].AsString(), out SitOffset);
         }
 
         public AgentData()
diff --git a/OpenSim/Framework/Console/CommandConsole.cs b/OpenSim/Framework/Console/CommandConsole.cs
index a0d3541..0d6288b 100644
--- a/OpenSim/Framework/Console/CommandConsole.cs
+++ b/OpenSim/Framework/Console/CommandConsole.cs
@@ -31,6 +31,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Reflection;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Threading;
 using log4net;
 using OpenSim.Framework;
@@ -531,6 +532,11 @@ namespace OpenSim.Framework.Console
 
     public class Parser
     {
+        // If an unquoted portion ends with an element matching this regex
+        // and the next element contains a space, then we have stripped
+        // embedded quotes that should not have been stripped
+        private static Regex optionRegex = new Regex("^--[a-zA-Z0-9-]+=$");
+
         public static string[] Parse(string text)
         {
             List<string> result = new List<string>();
@@ -544,10 +550,38 @@ namespace OpenSim.Framework.Console
                 if (index % 2 == 0)
                 {
                     string[] words = unquoted[index].Split(new char[] {' '});
+
+                    bool option = false;
                     foreach (string w in words)
                     {
                         if (w != String.Empty)
+                        {
+                            if (optionRegex.Match(w) == Match.Empty)
+                                option = false;
+                            else
+                                option = true;
                             result.Add(w);
+                        }
+                    }
+                    // The last item matched the regex, put the quotes back
+                    if (option)
+                    {
+                        // If the line ended with it, don't do anything
+                        if (index < (unquoted.Length - 1))
+                        {
+                            // Get and remove the option name
+                            string optionText = result[result.Count - 1];
+                            result.RemoveAt(result.Count - 1);
+
+                            // Add the quoted value back
+                            optionText += "\"" + unquoted[index + 1] + "\"";
+
+                            // Push the result into our return array
+                            result.Add(optionText);
+
+                            // Skip the already used value
+                            index++;
+                        }
                     }
                 }
                 else
diff --git a/OpenSim/Framework/RegionInfo.cs b/OpenSim/Framework/RegionInfo.cs
index c531e8a..7a3e67f 100644
--- a/OpenSim/Framework/RegionInfo.cs
+++ b/OpenSim/Framework/RegionInfo.cs
@@ -627,7 +627,6 @@ namespace OpenSim.Framework
 
             foreach (String s in allKeys)
             {
-                string val = config.GetString(s);
                 SetOtherSetting(s, config.GetString(s));
             }
         }
diff --git a/OpenSim/Framework/Serialization/External/ExternalRepresentationUtils.cs b/OpenSim/Framework/Serialization/External/ExternalRepresentationUtils.cs
index a392af6..c56f213 100644
--- a/OpenSim/Framework/Serialization/External/ExternalRepresentationUtils.cs
+++ b/OpenSim/Framework/Serialization/External/ExternalRepresentationUtils.cs
@@ -49,15 +49,16 @@ namespace OpenSim.Framework.Serialization.External
         /// <param name="nodeToFill"></param>
         /// <param name="processors">/param>
         /// <param name="xtr"></param>
-        public static void ExecuteReadProcessors<NodeType>(
+        /// <returns>true on successful, false if there were any processing failures</returns>
+        public static bool ExecuteReadProcessors<NodeType>(
             NodeType nodeToFill, Dictionary<string, Action<NodeType, XmlTextReader>> processors, XmlTextReader xtr)
         {
-            ExecuteReadProcessors(
+            return ExecuteReadProcessors(
                 nodeToFill,
                 processors,
                 xtr,
                 (o, name, e)
-                    => m_log.ErrorFormat(
+                    => m_log.DebugFormat(
                         "[ExternalRepresentationUtils]: Exception while parsing element {0}, continuing.  Exception {1}{2}",
                         name, e.Message, e.StackTrace));
         }
@@ -71,12 +72,15 @@ namespace OpenSim.Framework.Serialization.External
         /// <param name="parseExceptionAction">
         /// Action to take if there is a parsing problem.  This will usually just be to log the exception
         /// </param>
-        public static void ExecuteReadProcessors<NodeType>(
+        /// <returns>true on successful, false if there were any processing failures</returns>
+        public static bool ExecuteReadProcessors<NodeType>(
             NodeType nodeToFill,
             Dictionary<string, Action<NodeType, XmlTextReader>> processors,
             XmlTextReader xtr,
             Action<NodeType, string, Exception> parseExceptionAction)
         {
+            bool errors = false;
+
             string nodeName = string.Empty;
             while (xtr.NodeType != XmlNodeType.EndElement)
             {
@@ -95,6 +99,7 @@ namespace OpenSim.Framework.Serialization.External
                     }
                     catch (Exception e)
                     {
+                        errors = true;
                         parseExceptionAction(nodeToFill, nodeName, e);
 
                         if (xtr.NodeType == XmlNodeType.EndElement)
@@ -107,6 +112,8 @@ namespace OpenSim.Framework.Serialization.External
                     xtr.ReadOuterXml(); // ignore
                 }
             }
+
+            return errors;
         }
 
         /// <summary>
@@ -140,6 +147,7 @@ namespace OpenSim.Framework.Serialization.External
                         UUID.TryParse(node.InnerText, out uuid);
                         creator = userService.GetUserAccount(scopeID, uuid);
                     }
+
                     if (node.Name == "CreatorData" && node.InnerText != null && node.InnerText != string.Empty)
                         hasCreatorData = true;
 
@@ -163,7 +171,6 @@ namespace OpenSim.Framework.Serialization.External
                 doc.Save(wr);
                 return wr.ToString();
             }
-
         }
     }
-}
+}
\ No newline at end of file
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index fae6802..dd30c2f 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -1676,13 +1676,14 @@ namespace OpenSim.Framework
         /// </summary>
         public static void PrintCallStack()
         {
-            StackTrace stackTrace = new StackTrace();           // get call stack
+            StackTrace stackTrace = new StackTrace(true);           // get call stack
             StackFrame[] stackFrames = stackTrace.GetFrames();  // get method calls (frames)
 
             // write call stack method names
             foreach (StackFrame stackFrame in stackFrames)
             {
-                m_log.Debug(stackFrame.GetMethod().DeclaringType + "." + stackFrame.GetMethod().Name); // write method name
+                MethodBase mb = stackFrame.GetMethod();
+                m_log.DebugFormat("{0}.{1}:{2}", mb.DeclaringType, mb.Name, stackFrame.GetFileLineNumber()); // write method name
             }
         }
 
diff --git a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
index c20f7b2..161feda 100644
--- a/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/Linden/UDP/LLClientView.cs
@@ -1549,7 +1549,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void SendKillObject(ulong regionHandle, List<uint> localIDs)
         {
-//            m_log.DebugFormat("[CLIENT]: Sending KillObjectPacket to {0} for {1} in {2}", Name, localID, regionHandle);
+//            foreach (uint id in localIDs)
+//                m_log.DebugFormat("[CLIENT]: Sending KillObjectPacket to {0} for {1} in {2}", Name, id, regionHandle);
 
             KillObjectPacket kill = (KillObjectPacket)PacketPool.Instance.GetPacket(PacketType.KillObject);
             // TODO: don't create new blocks if recycling an old packet
@@ -7689,6 +7690,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     }
                 }
             }
+            else
+                if (transfer.TransferInfo.SourceType == (int)SourceType.SimEstate)
+                {
+                    //TransferRequestPacket does not include covenant uuid?
+                    //get scene covenant uuid
+                    taskID = m_scene.RegionInfo.RegionSettings.Covenant;
+                }
 
             MakeAssetRequest(transfer, taskID);
 
@@ -12113,6 +12121,11 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 requestID = new UUID(transferRequest.TransferInfo.Params, 80);
             }
+            else if (transferRequest.TransferInfo.SourceType == (int)SourceType.SimEstate)
+            {
+                requestID = taskID;
+            }
+
 
 //            m_log.DebugFormat("[CLIENT]: {0} requesting asset {1}", Name, requestID);
 
diff --git a/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
index 8d503bd..c7f4c20 100644
--- a/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
+++ b/OpenSim/Region/CoreModules/Avatar/AvatarFactory/AvatarFactoryModule.cs
@@ -111,6 +111,15 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
 
         #region IAvatarFactoryModule
 
+        /// </summary>
+        /// <param name="sp"></param>
+        /// <param name="texture"></param>
+        /// <param name="visualParam"></param>
+        public void SetAppearance(IScenePresence sp, AvatarAppearance appearance)
+        {
+            SetAppearance(sp, appearance.Texture, appearance.VisualParams);
+        }
+
         /// <summary>
         /// Set appearance data (texture asset IDs and slider settings) 
         /// </summary>
@@ -156,14 +165,23 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                     changed = sp.Appearance.SetTextureEntries(textureEntry) || changed;
 
 //                    WriteBakedTexturesReport(sp, m_log.DebugFormat);
-                    if (!ValidateBakedTextureCache(sp))
+
+                    // If bake textures are missing and this is not an NPC, request a rebake from client
+                    if (!ValidateBakedTextureCache(sp) && (((ScenePresence)sp).PresenceType != PresenceType.Npc))
                         RequestRebake(sp, true);
 
                     // This appears to be set only in the final stage of the appearance
                     // update transaction. In theory, we should be able to do an immediate
                     // appearance send and save here.
                 }
-                
+
+                // NPC should send to clients immediately and skip saving appearance
+                if (((ScenePresence)sp).PresenceType == PresenceType.Npc)
+                {
+                    SendAppearance((ScenePresence)sp);
+                    return;
+                }
+
                 // save only if there were changes, send no matter what (doesn't hurt to send twice)
                 if (changed)
                     QueueAppearanceSave(sp.ControllingClient.AgentId);
@@ -174,6 +192,15 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             // m_log.WarnFormat("[AVFACTORY]: complete SetAppearance for {0}:\n{1}",client.AgentId,sp.Appearance.ToString());
         }
 
+        private void SendAppearance(ScenePresence sp)
+        {
+            // Send the appearance to everyone in the scene
+            sp.SendAppearanceToAllOtherAgents();
+
+            // Send animations back to the avatar as well
+            sp.Animator.SendAnimPack();
+        }
+
         public bool SendAppearance(UUID agentId)
         {
 //            m_log.DebugFormat("[AVFACTORY]: Sending appearance for {0}", agentId);
@@ -185,12 +212,7 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
                 return false;
             }
 
-            // Send the appearance to everyone in the scene
-            sp.SendAppearanceToAllOtherAgents();
-
-            // Send animations back to the avatar as well
-            sp.Animator.SendAnimPack();
-
+            SendAppearance(sp);
             return true;
         }
 
@@ -626,4 +648,4 @@ namespace OpenSim.Region.CoreModules.Avatar.AvatarFactory
             outputAction("{0} baked appearance texture is {1}", sp.Name, bakedTextureValid ? "OK" : "corrupt");
         }
     }
-}
\ No newline at end of file
+}
diff --git a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
index f1399af..9a6dfe1 100644
--- a/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/EntityTransfer/EntityTransferModule.cs
@@ -681,11 +681,10 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
         #region Agent Crossings
 
-        public bool Cross(ScenePresence agent, bool isFlying)
+        public GridRegion GetDestination(Scene scene, UUID agentID, Vector3 pos, out uint xDest, out uint yDest, out string version, out Vector3 newpos)
         {
-            Scene scene = agent.Scene;
-            Vector3 pos = agent.AbsolutePosition;
-            Vector3 newpos = new Vector3(pos.X, pos.Y, pos.Z);
+            version = String.Empty;
+            newpos = new Vector3(pos.X, pos.Y, pos.Z);
             uint neighbourx = scene.RegionInfo.RegionLocX;
             uint neighboury = scene.RegionInfo.RegionLocY;
             const float boundaryDistance = 1.7f;
@@ -706,53 +705,12 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                 }
                 else if (scene.TestBorderCross(pos + southCross, Cardinals.S))
                 {
-                    Border b = scene.GetCrossedBorder(pos + southCross, Cardinals.S);
-                    if (b.TriggerRegionX == 0 && b.TriggerRegionY == 0)
-                    {
-                        neighboury--;
-                        newpos.Y = Constants.RegionSize - enterDistance;
-                    }
-                    else
-                    {
-                        agent.IsInTransit = true;
-
-                        neighboury = b.TriggerRegionY;
-                        neighbourx = b.TriggerRegionX;
-
-                        Vector3 newposition = pos;
-                        newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
-                        newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
-                        agent.ControllingClient.SendAgentAlertMessage(
-                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
-                        InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
-                        return true;
-                    }
-                }
-
-                Border ba = scene.GetCrossedBorder(pos + westCross, Cardinals.W);
-                if (ba.TriggerRegionX == 0 && ba.TriggerRegionY == 0)
-                {
-                    neighbourx--;
-                    newpos.X = Constants.RegionSize - enterDistance;
+                    neighboury--;
+                    newpos.Y = Constants.RegionSize - enterDistance;
                 }
-                else
-                {
-                    agent.IsInTransit = true;
-
-                    neighboury = ba.TriggerRegionY;
-                    neighbourx = ba.TriggerRegionX;
-
-
-                    Vector3 newposition = pos;
-                    newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
-                    newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
-                    agent.ControllingClient.SendAgentAlertMessage(
-                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
-                    InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
 
-
-                    return true;
-                }
+                neighbourx--;
+                newpos.X = Constants.RegionSize - enterDistance;
 
             }
             else if (scene.TestBorderCross(pos + eastCross, Cardinals.E))
@@ -763,26 +721,8 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
 
                 if (scene.TestBorderCross(pos + southCross, Cardinals.S))
                 {
-                    Border ba = scene.GetCrossedBorder(pos + southCross, Cardinals.S);
-                    if (ba.TriggerRegionX == 0 && ba.TriggerRegionY == 0)
-                    {
-                        neighboury--;
-                        newpos.Y = Constants.RegionSize - enterDistance;
-                    }
-                    else
-                    {
-                        agent.IsInTransit = true;
-
-                        neighboury = ba.TriggerRegionY;
-                        neighbourx = ba.TriggerRegionX;
-                        Vector3 newposition = pos;
-                        newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
-                        newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
-                        agent.ControllingClient.SendAgentAlertMessage(
-                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
-                        InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
-                        return true;
-                    }
+                    neighboury--;
+                    newpos.Y = Constants.RegionSize - enterDistance;
                 }
                 else if (scene.TestBorderCross(pos + northCross, Cardinals.N))
                 {
@@ -790,35 +730,15 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
                     neighboury += (uint)(int)(c.BorderLine.Z / (int)Constants.RegionSize);
                     newpos.Y = enterDistance;
                 }
-
-
             }
             else if (scene.TestBorderCross(pos + southCross, Cardinals.S))
             {
                 Border b = scene.GetCrossedBorder(pos + southCross, Cardinals.S);
-                if (b.TriggerRegionX == 0 && b.TriggerRegionY == 0)
-                {
-                    neighboury--;
-                    newpos.Y = Constants.RegionSize - enterDistance;
-                }
-                else
-                {
-                    agent.IsInTransit = true;
-
-                    neighboury = b.TriggerRegionY;
-                    neighbourx = b.TriggerRegionX;
-                    Vector3 newposition = pos;
-                    newposition.X += (scene.RegionInfo.RegionLocX - neighbourx) * Constants.RegionSize;
-                    newposition.Y += (scene.RegionInfo.RegionLocY - neighboury) * Constants.RegionSize;
-                    agent.ControllingClient.SendAgentAlertMessage(
-                            String.Format("Moving you to region {0},{1}", neighbourx, neighboury), false);
-                    InformClientToInitateTeleportToLocation(agent, neighbourx, neighboury, newposition, scene);
-                    return true;
-                }
+                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;
@@ -849,19 +769,22 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             }
             */
 
-            ulong neighbourHandle = Utils.UIntsToLong((uint)(neighbourx * Constants.RegionSize), (uint)(neighboury * Constants.RegionSize));
+            xDest = neighbourx;
+            yDest = neighboury;
 
             int x = (int)(neighbourx * Constants.RegionSize), y = (int)(neighboury * Constants.RegionSize);
 
+            ulong neighbourHandle = Utils.UIntsToLong((uint)x, (uint)y);
+
             ExpiringCache<ulong, DateTime> r;
             DateTime banUntil;
 
-            if (m_bannedRegions.TryGetValue(agent.ControllingClient.AgentId, out r))
+            if (m_bannedRegions.TryGetValue(agentID, out r))
             {
                 if (r.TryGetValue(neighbourHandle, out banUntil))
                 {
                     if (DateTime.Now < banUntil)
-                        return false;
+                        return null;
                     r.Remove(neighbourHandle);
                 }
             }
@@ -873,28 +796,43 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             GridRegion neighbourRegion = scene.GridService.GetRegionByPosition(scene.RegionInfo.ScopeID, (int)x, (int)y);
 
             string reason;
-            string version;
-            if (!scene.SimulationService.QueryAccess(neighbourRegion, agent.ControllingClient.AgentId, newpos, out version, out reason))
+            if (!scene.SimulationService.QueryAccess(neighbourRegion, agentID, newpos, out version, out reason))
             {
-                agent.ControllingClient.SendAlertMessage("Cannot region cross into banned parcel");
                 if (r == null)
                 {
                     r = new ExpiringCache<ulong, DateTime>();
                     r.Add(neighbourHandle, DateTime.Now + TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(15));
 
-                    m_bannedRegions.Add(agent.ControllingClient.AgentId, r, TimeSpan.FromSeconds(45));
+                    m_bannedRegions.Add(agentID, r, TimeSpan.FromSeconds(45));
                 }
                 else
                 {
                     r.Add(neighbourHandle, DateTime.Now + TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(15));
                 }
+                return null;
+            }
+
+            return neighbourRegion;
+        }
+
+        public bool Cross(ScenePresence agent, bool isFlying)
+        {
+            uint x;
+            uint y;
+            Vector3 newpos;
+            string version;
+
+            GridRegion neighbourRegion = GetDestination(agent.Scene, agent.UUID, agent.AbsolutePosition, out x, out y, out version, out newpos);
+            if (neighbourRegion == null)
+            {
+                agent.ControllingClient.SendAlertMessage("Cannot region cross into banned parcel");
                 return false;
             }
 
             agent.IsInTransit = true;
 
             CrossAgentToNewRegionDelegate d = CrossAgentToNewRegionAsync;
-            d.BeginInvoke(agent, newpos, neighbourx, neighboury, neighbourRegion, isFlying, version, CrossAgentToNewRegionCompleted, d);
+            d.BeginInvoke(agent, newpos, x, y, neighbourRegion, isFlying, version, CrossAgentToNewRegionCompleted, d);
 
             return true;
         }
@@ -951,13 +889,11 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             icon.EndInvoke(iar);
         }
 
-        public delegate ScenePresence CrossAgentToNewRegionDelegate(ScenePresence agent, Vector3 pos, uint neighbourx, uint neighboury, GridRegion neighbourRegion, bool isFlying, string version);
-
         /// <summary>
         /// This Closes child agents on neighbouring regions
         /// Calls an asynchronous method to do so..  so it doesn't lag the sim.
         /// </summary>
-        protected ScenePresence CrossAgentToNewRegionAsync(
+        public ScenePresence CrossAgentToNewRegionAsync(
             ScenePresence agent, Vector3 pos, uint neighbourx, uint neighboury, GridRegion neighbourRegion,
             bool isFlying, string version)
         {
@@ -1731,17 +1667,17 @@ namespace OpenSim.Region.CoreModules.Framework.EntityTransfer
             {
                 m_log.InfoFormat("[ENTITY TRANSFER MODULE] cross region transfer failed for object {0}",grp.UUID);
 
+                // Need to turn off the physics flags, otherwise the object will continue to attempt to
+                // move out of the region creating an infinite loop of failed attempts to cross
+                grp.UpdatePrimFlags(grp.RootPart.LocalId,false,grp.IsTemporary,grp.IsPhantom,false);
+
                 // We are going to move the object back to the old position so long as the old position
                 // is in the region
                 oldGroupPosition.X = Util.Clamp<float>(oldGroupPosition.X,1.0f,(float)Constants.RegionSize-1);
                 oldGroupPosition.Y = Util.Clamp<float>(oldGroupPosition.Y,1.0f,(float)Constants.RegionSize-1);
                 oldGroupPosition.Z = Util.Clamp<float>(oldGroupPosition.Z,1.0f,4096.0f);
 
-                grp.RootPart.GroupPosition = oldGroupPosition;
-
-                // Need to turn off the physics flags, otherwise the object will continue to attempt to
-                // move out of the region creating an infinite loop of failed attempts to cross
-                grp.UpdatePrimFlags(grp.RootPart.LocalId,false,grp.IsTemporary,grp.IsPhantom,false);
+                grp.AbsolutePosition = oldGroupPosition;
 
                 grp.ScheduleGroupForFullUpdate();
             }
diff --git a/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs b/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
index a47bc9a..82a035b 100644
--- a/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
+++ b/OpenSim/Region/CoreModules/Framework/InventoryAccess/InventoryAccessModule.cs
@@ -560,12 +560,20 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                     return null;
 
                 userID = remoteClient.AgentId;
+
+//                m_log.DebugFormat(
+//                    "[INVENTORY ACCESS MODULE]: Target of {0} in CreateItemForObject() is {1} {2}",
+//                    action, remoteClient.Name, userID);
             }
             else
             {
                 // All returns / deletes go to the object owner
                 //
                 userID = so.RootPart.OwnerID;
+
+//                m_log.DebugFormat(
+//                    "[INVENTORY ACCESS MODULE]: Target of {0} in CreateItemForObject() is object owner {1}",
+//                    action, userID);
             }
 
             if (userID == UUID.Zero) // Can't proceed
@@ -651,11 +659,11 @@ namespace OpenSim.Region.CoreModules.Framework.InventoryAccess
                 }
 
                 // Override and put into where it came from, if it came
-                // from anywhere in inventory
+                // from anywhere in inventory and the owner is taking it back.
                 //
                 if (action == DeRezAction.Take || action == DeRezAction.TakeCopy)
                 {
-                    if (so.RootPart.FromFolderID != UUID.Zero)
+                    if (so.RootPart.FromFolderID != UUID.Zero && userID == remoteClient.AgentId)
                     {
                         InventoryFolderBase f = new InventoryFolderBase(so.RootPart.FromFolderID, userID);
                         if (f != null)
diff --git a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
index 5e7d37a..ba38488 100644
--- a/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
+++ b/OpenSim/Region/CoreModules/World/Permissions/PermissionsModule.cs
@@ -707,7 +707,12 @@ namespace OpenSim.Region.CoreModules.World.Permissions
             // Object owners should be able to edit their own content
             if (currentUser == objectOwner)
             {
-                permission = true;
+                // there is no way that later code can change this back to false
+                // so just return true immediately and short circuit the more
+                // expensive group checks
+                return true;
+                
+                //permission = true;
             }
             else if (group.IsAttachment)
             {
diff --git a/OpenSim/Region/Framework/Interfaces/IAvatarFactoryModule.cs b/OpenSim/Region/Framework/Interfaces/IAvatarFactoryModule.cs
index 39a760c..34aca33 100644
--- a/OpenSim/Region/Framework/Interfaces/IAvatarFactoryModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IAvatarFactoryModule.cs
@@ -35,6 +35,7 @@ namespace OpenSim.Region.Framework.Interfaces
 
     public interface IAvatarFactoryModule
     {
+        void SetAppearance(IScenePresence sp, AvatarAppearance appearance);
         void SetAppearance(IScenePresence sp, Primitive.TextureEntry textureEntry, byte[] visualParams);
 
         /// <summary>
diff --git a/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs b/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
index c38ecd9..76f1641 100644
--- a/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
+++ b/OpenSim/Region/Framework/Interfaces/IEntityTransferModule.cs
@@ -35,6 +35,8 @@ using OpenSim.Region.Framework.Scenes;
 
 namespace OpenSim.Region.Framework.Interfaces
 {
+    public delegate ScenePresence CrossAgentToNewRegionDelegate(ScenePresence agent, Vector3 pos, uint neighbourx, uint neighboury, GridRegion neighbourRegion, bool isFlying, string version);
+
     public interface IEntityTransferModule
     {
         void Teleport(ScenePresence agent, ulong regionHandle, Vector3 position,
@@ -53,7 +55,12 @@ 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);
+
         void Cross(SceneObjectGroup sog, Vector3 position, bool silent);
+
+        ScenePresence CrossAgentToNewRegionAsync(ScenePresence agent, Vector3 pos, uint neighbourx, uint neighboury, GridRegion neighbourRegion, bool isFlying, string version);
+
     }
 
     public interface IUserAgentVerificationModule
diff --git a/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs b/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
index 5dfd3e0..f678d07 100644
--- a/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
+++ b/OpenSim/Region/Framework/Scenes/AsyncSceneObjectGroupDeleter.cs
@@ -148,7 +148,8 @@ namespace OpenSim.Region.Framework.Scenes
                         x = m_inventoryDeletes.Dequeue();
 
                         m_log.DebugFormat(
-                            "[ASYNC DELETER]: Sending object to user's inventory, action {1}, count {2}, {0} item(s) remaining.", left, x.action, x.objectGroups.Count);
+                            "[ASYNC DELETER]: Sending object to user's inventory, action {1}, count {2}, {0} item(s) remaining.",
+                            left, x.action, x.objectGroups.Count);
                         
                         try
                         {
diff --git a/OpenSim/Region/Framework/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index 456e86b..8552d4c 100644
--- a/OpenSim/Region/Framework/Scenes/Scene.cs
+++ b/OpenSim/Region/Framework/Scenes/Scene.cs
@@ -3408,9 +3408,9 @@ namespace OpenSim.Region.Framework.Scenes
 
             // Don't disable this log message - it's too helpful
             m_log.DebugFormat(
-                "[SCENE]: Region {0} told of incoming {1} agent {2} {3} {4} (circuit code {5}, teleportflags {6}, position {7})",
-                RegionInfo.RegionName, (agent.child ? "child" : "root"), agent.firstname, agent.lastname,
-                agent.AgentID, agent.circuitcode, teleportFlags, agent.startpos);
+                "[SCENE]: Region {0} told of incoming {1} agent {2} {3} {4} (circuit code {5}, IP {6}, viewer {7}, teleportflags {8}, position {9})",
+                RegionInfo.RegionName, (agent.child ? "child" : "root"),agent.firstname, agent.lastname,
+                agent.AgentID, agent.circuitcode, agent.IPAddress, agent.Viewer, teleportFlags, agent.startpos);
 
             if (LoginsDisabled)
             {
diff --git a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
index 9961438..644b78a 100644
--- a/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
+++ b/OpenSim/Region/Framework/Scenes/SceneObjectGroup.cs
@@ -465,7 +465,77 @@ namespace OpenSim.Region.Framework.Scenes
                         || Scene.TestBorderCross(val - Vector3.UnitY, Cardinals.N) || Scene.TestBorderCross(val + Vector3.UnitY, Cardinals.S)) 
                         && !IsAttachmentCheckFull() && (!Scene.LoadingPrims))
                     {
-                        m_scene.CrossPrimGroupIntoNewRegion(val, this, true);
+                        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;
+
+                        bool canCross = true;
+                        foreach (ScenePresence av in m_linkedAvatars)
+                        {
+                            // We need to cross these agents. First, let's find
+                            // out if any of them can't cross for some reason.
+                            // We have to deny the crossing entirely if any
+                            // of them are banned. Alternatively, we could
+                            // unsit banned agents....
+
+
+                            // 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)
+                            {
+                                canCross = false;
+                                break;
+                            }
+                            
+                            m_log.DebugFormat("[SCENE OBJECT]: Avatar {0} needs to be crossed to {1}", av.Name, destination.RegionName);
+                        }
+
+                        if (canCross)
+                        {
+                            // We unparent the SP quietly so that it won't
+                            // be made to stand up
+                            foreach (ScenePresence av in m_linkedAvatars)
+                            {
+                                SceneObjectPart parentPart = m_scene.GetSceneObjectPart(av.ParentID);
+                                if (parentPart != null)
+                                    av.ParentUUID = parentPart.UUID;
+
+                                av.ParentID = 0;
+                            }
+
+                            m_scene.CrossPrimGroupIntoNewRegion(val, this, true);
+
+                            // Normalize
+                            if (val.X >= Constants.RegionSize)
+                                val.X -= Constants.RegionSize;
+                            if (val.Y >= Constants.RegionSize)
+                                val.Y -= Constants.RegionSize;
+                            if (val.X < 0)
+                                val.X += Constants.RegionSize;
+                            if (val.Y < 0)
+                                val.Y += Constants.RegionSize;
+
+                            // If it's deleted, crossing was successful
+                            if (IsDeleted)
+                            {
+                                foreach (ScenePresence av in m_linkedAvatars)
+                                {
+                                    m_log.DebugFormat("[SCENE OBJECT]: Crossing avatar {0} to {1}", av.Name, val);
+
+                                    av.IsInTransit = true;
+
+                                    CrossAgentToNewRegionDelegate d = entityTransfer.CrossAgentToNewRegionAsync;
+                                    d.BeginInvoke(av, val, x, y, destination, av.Flying, version, CrossAgentToNewRegionCompleted, d);
+                                }
+
+                                return;
+                            }
+                        }
+
+                        val = AbsolutePosition;
                     }
                 }
 
@@ -524,6 +594,23 @@ namespace OpenSim.Region.Framework.Scenes
             }
         }
 
+        private void CrossAgentToNewRegionCompleted(IAsyncResult iar)
+        {
+            CrossAgentToNewRegionDelegate icon = (CrossAgentToNewRegionDelegate)iar.AsyncState;
+            ScenePresence agent = icon.EndInvoke(iar);
+
+            //// If the cross was successful, this agent is a child agent
+            //if (agent.IsChildAgent)
+            //    agent.Reset();
+            //else // Not successful
+            //    agent.RestoreInCurrentScene();
+
+            // In any case
+            agent.IsInTransit = false;
+
+            m_log.DebugFormat("[SCENE OBJECT]: Crossing agent {0} {1} completed.", agent.Firstname, agent.Lastname);
+        }
+
         public override uint LocalId
         {
             get { return m_rootPart.LocalId; }
diff --git a/OpenSim/Region/Framework/Scenes/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index 9100c29..8a42616 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -233,6 +233,8 @@ namespace OpenSim.Region.Framework.Scenes
         private bool m_collisionEventFlag = false;
         private object m_collisionEventLock = new Object();
 
+        private Vector3 m_prevSitOffset;
+
         protected AvatarAppearance m_appearance;
 
         public AvatarAppearance Appearance
@@ -295,13 +297,10 @@ namespace OpenSim.Region.Framework.Scenes
         /// </summary>
         public PhysicsActor PhysicsActor { get; private set; }
 
-        private byte m_movementflag;
-
-        public byte MovementFlag
-        {
-            set { m_movementflag = value; }
-            get { return m_movementflag; }
-        }
+        /// <summary>
+        /// Record user movement inputs.
+        /// </summary>
+        public byte MovementFlag { get; private set; }
 
         private bool m_updateflag;
 
@@ -647,6 +646,13 @@ namespace OpenSim.Region.Framework.Scenes
         }
         private uint m_parentID;
 
+        public UUID ParentUUID
+        {
+            get { return m_parentUUID; }
+            set { m_parentUUID = value; }
+        }
+        private UUID m_parentUUID = UUID.Zero;
+
         public float Health
         {
             get { return m_health; }
@@ -868,7 +874,26 @@ namespace OpenSim.Region.Framework.Scenes
                 "[SCENE]: Upgrading child to root agent for {0} in {1}",
                 Name, m_scene.RegionInfo.RegionName);
 
-            //m_log.DebugFormat("[SCENE]: known regions in {0}: {1}", Scene.RegionInfo.RegionName, KnownChildRegionHandles.Count);
+            if (ParentUUID != UUID.Zero)
+            {
+                m_log.DebugFormat("[SCENE PRESENCE]: Sitting avatar back on prim {0}", ParentUUID);
+                SceneObjectPart part = m_scene.GetSceneObjectPart(ParentUUID);
+                if (part == null)
+                {
+                    m_log.ErrorFormat("[SCENE PRESENCE]: Can't find prim {0} to sit on", ParentUUID);
+                }
+                else
+                {
+                    part.ParentGroup.AddAvatar(UUID);
+                    if (part.SitTargetPosition != Vector3.Zero)
+                        part.SitTargetAvatar = UUID;
+                    ParentPosition = part.GetWorldPosition();
+                    ParentID = part.LocalId;
+                    m_pos = m_prevSitOffset;
+                    pos = ParentPosition;
+                }
+                ParentUUID = UUID.Zero;
+            }
 
             bool wasChild = IsChildAgent;
             IsChildAgent = false;
@@ -881,62 +906,64 @@ namespace OpenSim.Region.Framework.Scenes
 
             m_scene.EventManager.TriggerSetRootAgentScene(m_uuid, m_scene);
 
-            // Moved this from SendInitialData to ensure that Appearance is initialized
-            // before the inventory is processed in MakeRootAgent. This fixes a race condition
-            // related to the handling of attachments
-            //m_scene.GetAvatarAppearance(ControllingClient, out Appearance);
-            if (m_scene.TestBorderCross(pos, Cardinals.E))
+            if (ParentID == 0)
             {
-                Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.E);
-                pos.X = crossedBorder.BorderLine.Z - 1;
-            }
+                // Moved this from SendInitialData to ensure that Appearance is initialized
+                // before the inventory is processed in MakeRootAgent. This fixes a race condition
+                // related to the handling of attachments
+                //m_scene.GetAvatarAppearance(ControllingClient, out Appearance);
+                if (m_scene.TestBorderCross(pos, Cardinals.E))
+                {
+                    Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.E);
+                    pos.X = crossedBorder.BorderLine.Z - 1;
+                }
 
-            if (m_scene.TestBorderCross(pos, Cardinals.N))
-            {
-                Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.N);
-                pos.Y = crossedBorder.BorderLine.Z - 1;
-            }
+                if (m_scene.TestBorderCross(pos, Cardinals.N))
+                {
+                    Border crossedBorder = m_scene.GetCrossedBorder(pos, Cardinals.N);
+                    pos.Y = crossedBorder.BorderLine.Z - 1;
+                }
 
-            CheckAndAdjustLandingPoint(ref pos);
+                CheckAndAdjustLandingPoint(ref pos);
 
-            if (pos.X < 0f || pos.Y < 0f || pos.Z < 0f)
-            {
-                m_log.WarnFormat(
-                    "[SCENE PRESENCE]: MakeRootAgent() was given an illegal position of {0} for avatar {1}, {2}. Clamping",
-                    pos, Name, UUID);
+                if (pos.X < 0f || pos.Y < 0f || pos.Z < 0f)
+                {
+                    m_log.WarnFormat(
+                        "[SCENE PRESENCE]: MakeRootAgent() was given an illegal position of {0} for avatar {1}, {2}. Clamping",
+                        pos, Name, UUID);
 
-                if (pos.X < 0f) pos.X = 0f;
-                if (pos.Y < 0f) pos.Y = 0f;
-                if (pos.Z < 0f) pos.Z = 0f;
-            }
+                    if (pos.X < 0f) pos.X = 0f;
+                    if (pos.Y < 0f) pos.Y = 0f;
+                    if (pos.Z < 0f) pos.Z = 0f;
+                }
 
-            float localAVHeight = 1.56f;
-            if (Appearance.AvatarHeight > 0)
-                localAVHeight = Appearance.AvatarHeight;
+                float localAVHeight = 1.56f;
+                if (Appearance.AvatarHeight > 0)
+                    localAVHeight = Appearance.AvatarHeight;
 
-            float posZLimit = 0;
+                float posZLimit = 0;
 
-            if (pos.X < Constants.RegionSize && pos.Y < Constants.RegionSize)
-                posZLimit = (float)m_scene.Heightmap[(int)pos.X, (int)pos.Y];
-            
-            float newPosZ = posZLimit + localAVHeight / 2;
-            if (posZLimit >= (pos.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ)))
-            {
-                pos.Z = newPosZ;
-            }
-            AbsolutePosition = pos;
+                if (pos.X < Constants.RegionSize && pos.Y < Constants.RegionSize)
+                    posZLimit = (float)m_scene.Heightmap[(int)pos.X, (int)pos.Y];
+                
+                float newPosZ = posZLimit + localAVHeight / 2;
+                if (posZLimit >= (pos.Z - (localAVHeight / 2)) && !(Single.IsInfinity(newPosZ) || Single.IsNaN(newPosZ)))
+                {
+                    pos.Z = newPosZ;
+                }
+                AbsolutePosition = pos;
 
-            AddToPhysicalScene(isFlying);
+                AddToPhysicalScene(isFlying);
 
-            if (ForceFly)
-            {
-                Flying = true;
-            }
-            else if (FlyDisabled)
-            {
-                Flying = false;
+                if (ForceFly)
+                {
+                    Flying = true;
+                }
+                else if (FlyDisabled)
+                {
+                    Flying = false;
+                }
             }
-
             // Don't send an animation pack here, since on a region crossing this will sometimes cause a flying 
             // avatar to return to the standing position in mid-air.  On login it looks like this is being sent
             // elsewhere anyway
@@ -954,11 +981,13 @@ namespace OpenSim.Region.Framework.Scenes
                 {
                     m_log.DebugFormat("[SCENE PRESENCE]: Restarting scripts in attachments...");
                     // Resume scripts
-                    foreach (SceneObjectGroup sog in m_attachments)
-                    {
-                        sog.RootPart.ParentGroup.CreateScriptInstances(0, false, m_scene.DefaultScriptEngine, GetStateSource());
-                        sog.ResumeScripts();
-                    }
+                    Util.FireAndForget(delegate(object x) {
+                        foreach (SceneObjectGroup sog in m_attachments)
+                        {
+                            sog.RootPart.ParentGroup.CreateScriptInstances(0, false, m_scene.DefaultScriptEngine, GetStateSource());
+                            sog.ResumeScripts();
+                        }
+                    });
                 }
             }
 
@@ -3122,6 +3151,9 @@ namespace OpenSim.Region.Framework.Scenes
             cAgent.AlwaysRun = SetAlwaysRun;
 
             cAgent.Appearance = new AvatarAppearance(Appearance);
+
+            cAgent.ParentPart = ParentUUID;
+            cAgent.SitOffset = m_pos;
             
             lock (scriptedcontrols)
             {
@@ -3181,6 +3213,8 @@ namespace OpenSim.Region.Framework.Scenes
             CameraAtAxis = cAgent.AtAxis;
             CameraLeftAxis = cAgent.LeftAxis;
             m_CameraUpAxis = cAgent.UpAxis;
+            ParentUUID = cAgent.ParentPart;
+            m_prevSitOffset = cAgent.SitOffset;
 
             // When we get to the point of re-computing neighbors everytime this
             // changes, then start using the agent's drawdistance rather than the 
diff --git a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
index ba33122..4b80e37 100644
--- a/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
+++ b/OpenSim/Region/Framework/Scenes/Serialization/SceneObjectSerializer.cs
@@ -1486,7 +1486,7 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
                 m_SOPXmlProcessors,
                 reader,
                 (o, nodeName, e)
-                    => m_log.ErrorFormat(
+                    => m_log.DebugFormat(
                         "[SceneObjectSerializer]: Exception while parsing {0} in object {1} {2}: {3}{4}",
                         ((SceneObjectPart)o).Name, ((SceneObjectPart)o).UUID, nodeName, e.Message, e.StackTrace));
 
@@ -1539,14 +1539,18 @@ namespace OpenSim.Region.Framework.Scenes.Serialization
 
             reader.ReadStartElement(name, String.Empty); // Shape
 
-            ExternalRepresentationUtils.ExecuteReadProcessors(
+            errors = ExternalRepresentationUtils.ExecuteReadProcessors(
                 shape,
                 m_ShapeXmlProcessors,
                 reader,
                 (o, nodeName, e)
-                    => m_log.ErrorFormat(
-                        "[SceneObjectSerializer]: Exception while parsing Shape property {0}: {1}{2}",
-                        nodeName, e.Message, e.StackTrace));
+                    =>
+                    {
+                        m_log.DebugFormat(
+                            "[SceneObjectSerializer]: Exception while parsing Shape property {0}: {1}{2}",
+                            nodeName, e.Message, e.StackTrace);
+                    }
+            );
 
             reader.ReadEndElement(); // Shape
 
diff --git a/OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs b/OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs
index 1b675a6..8af3652 100644
--- a/OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/Voice/FreeSwitchVoice/FreeSwitchVoiceModule.cs
@@ -63,9 +63,9 @@ namespace OpenSim.Region.OptionalModules.Avatar.Voice.FreeSwitchVoice
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         // Capability string prefixes
-        private static readonly string m_parcelVoiceInfoRequestPath = "0007/";
-        private static readonly string m_provisionVoiceAccountRequestPath = "0008/";
-        private static readonly string m_chatSessionRequestPath = "0009/";
+        private static readonly string m_parcelVoiceInfoRequestPath = "0207/";
+        private static readonly string m_provisionVoiceAccountRequestPath = "0208/";
+        private static readonly string m_chatSessionRequestPath = "0209/";
 
         // Control info
         private static bool   m_Enabled  = false;
diff --git a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/SimianGroupsServicesConnectorModule.cs b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/SimianGroupsServicesConnectorModule.cs
index 42008da..130513d 100644
--- a/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/SimianGroupsServicesConnectorModule.cs
+++ b/OpenSim/Region/OptionalModules/Avatar/XmlRpcGroups/SimianGroupsServicesConnectorModule.cs
@@ -30,6 +30,7 @@ using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Reflection;
+using System.Threading;
 
 using Nwc.XmlRpc;
 
@@ -167,6 +168,8 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
         private bool m_debugEnabled = false;
 
+        private Dictionary<string, bool> m_pendingRequests = new Dictionary<string,bool>();
+        
         private ExpiringCache<string, OSDMap> m_memoryCache;
         private int m_cacheTimeout = 30;
 
@@ -1348,6 +1351,7 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             // Immediately forward the request if the cache is disabled.
             if (m_cacheTimeout == 0)
             {
+                m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: cache is disabled");
                 return WebUtil.PostToService(m_groupsServerURI, requestArgs);
             }
 
@@ -1355,6 +1359,8 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
             if (requestArgs["RequestMethod"] == "RemoveGeneric"
                 || requestArgs["RequestMethod"] == "AddGeneric")
             {
+                m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: clearing generics cache");
+                
                 // Any and all updates cause the cache to clear
                 m_memoryCache.Clear();
 
@@ -1366,18 +1372,67 @@ namespace OpenSim.Region.OptionalModules.Avatar.XmlRpcGroups
 
             // Create the cache key for the request and see if we have it cached
             string CacheKey = WebUtil.BuildQueryString(requestArgs);
-            OSDMap response = null;
-            if (!m_memoryCache.TryGetValue(CacheKey, out response))
+
+            // This code uses a leader/follower pattern. On a cache miss, the request is added
+            // to a queue; the first thread to add it to the queue completes the request while
+            // follow on threads busy wait for the results, this situation seems to happen
+            // often when checking permissions
+            while (true)
             {
-                // if it wasn't in the cache, pass the request to the Simian Grid Services
-                response = WebUtil.PostToService(m_groupsServerURI, requestArgs);
+                OSDMap response = null;
+                bool firstRequest = false;
 
-                // and cache the response
-                m_memoryCache.AddOrUpdate(CacheKey, response, TimeSpan.FromSeconds(m_cacheTimeout));
+                lock (m_memoryCache)
+                {
+                    if (m_memoryCache.TryGetValue(CacheKey, out response))
+                        return response;
+                    
+                    if (! m_pendingRequests.ContainsKey(CacheKey))
+                    {
+                        m_pendingRequests.Add(CacheKey,true);
+                        firstRequest = true;
+                    }
+                }
+                
+                if (firstRequest)
+                {
+                    // if it wasn't in the cache, pass the request to the Simian Grid Services
+                    try
+                    {
+                        response = WebUtil.PostToService(m_groupsServerURI, requestArgs);
+                    }
+                    catch (Exception e)
+                    {
+                        m_log.InfoFormat("[SIMIAN GROUPS CONNECTOR] request failed {0}",CacheKey);
+                    }
+                    
+                    // and cache the response
+                    lock (m_memoryCache)
+                    {
+                        m_memoryCache.AddOrUpdate(CacheKey, response, TimeSpan.FromSeconds(m_cacheTimeout));
+                        m_pendingRequests.Remove(CacheKey);
+                    }
+
+                    return response;
+                }
+
+                Thread.Sleep(50); // waiting for a web request to complete, 50msecs is reasonable
             }
 
-            // return cached response
-            return response;
+            // if (!m_memoryCache.TryGetValue(CacheKey, out response))
+            // {
+            //     m_log.WarnFormat("[SIMIAN GROUPS CONNECTOR]: query not in the cache");
+            //     Util.PrintCallStack();
+                
+            //     // if it wasn't in the cache, pass the request to the Simian Grid Services
+            //     response = WebUtil.PostToService(m_groupsServerURI, requestArgs);
+
+            //     // and cache the response
+            //     m_memoryCache.AddOrUpdate(CacheKey, response, TimeSpan.FromSeconds(m_cacheTimeout));
+            // }
+
+            // // return cached response
+            // return response;
         }
         #endregion
 
diff --git a/OpenSim/Region/OptionalModules/World/NPC/NPCModule.cs b/OpenSim/Region/OptionalModules/World/NPC/NPCModule.cs
index 6803644..d395206 100644
--- a/OpenSim/Region/OptionalModules/World/NPC/NPCModule.cs
+++ b/OpenSim/Region/OptionalModules/World/NPC/NPCModule.cs
@@ -96,15 +96,15 @@ namespace OpenSim.Region.OptionalModules.World.NPC
                 if (!m_avatars.ContainsKey(agentId))
                     return false;
 
+            // Delete existing sp attachments
             scene.AttachmentsModule.DeleteAttachmentsFromScene(sp, false);
 
-            AvatarAppearance npcAppearance = new AvatarAppearance(appearance, true);
-            sp.Appearance = npcAppearance;
+            // Set new sp appearance. Also sends to clients.
+            scene.RequestModuleInterface<IAvatarFactoryModule>().SetAppearance(sp, new AvatarAppearance(appearance, true));
+            
+            // Rez needed sp attachments
             scene.AttachmentsModule.RezAttachments(sp);
-
-            IAvatarFactoryModule module = scene.RequestModuleInterface<IAvatarFactoryModule>();
-            module.SendAppearance(sp.UUID);
-
+            
             return true;
         }
 
diff --git a/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs b/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
index 7c1c046..6d1f41d 100644
--- a/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
+++ b/OpenSim/Region/Physics/OdePlugin/ODECharacter.cs
@@ -156,6 +156,22 @@ namespace OpenSim.Region.Physics.OdePlugin
         internal UUID m_uuid { get; private set; }
         internal bool bad = false;
 
+        /// <summary>
+        /// ODE Avatar.
+        /// </summary>
+        /// <param name="avName"></param>
+        /// <param name="parent_scene"></param>
+        /// <param name="pos"></param>
+        /// <param name="size"></param>
+        /// <param name="pid_d"></param>
+        /// <param name="pid_p"></param>
+        /// <param name="capsule_radius"></param>
+        /// <param name="tensor"></param>
+        /// <param name="density">
+        /// Only used right now to return information to LSL.  Not actually used to set mass in ODE!
+        /// </param>
+        /// <param name="walk_divisor"></param>
+        /// <param name="rundivisor"></param>
         public OdeCharacter(
             String avName, OdeScene parent_scene, Vector3 pos, Vector3 size, float pid_d, float pid_p,
             float capsule_radius, float tensor, float density,
@@ -786,6 +802,10 @@ namespace OpenSim.Region.Physics.OdePlugin
             Vector3 vec = Vector3.Zero;
             d.Vector3 vel = d.BodyGetLinearVel(Body);
 
+//            m_log.DebugFormat(
+//                "[ODE CHARACTER]: Current velocity in Move() is <{0},{1},{2}>, target {3} for {4}",
+//                vel.X, vel.Y, vel.Z, _target_velocity, Name);
+
             float movementdivisor = 1f;
 
             if (!m_alwaysRun)
@@ -884,18 +904,20 @@ namespace OpenSim.Region.Physics.OdePlugin
 
                 if (flying)
                 {
+                    // This also acts as anti-gravity so that we hover when flying rather than fall.
                     vec.Z = (_target_velocity.Z - vel.Z) * (PID_D);
                 }
             }
 
             if (flying)
             {
+                // Anti-gravity so that we hover when flying rather than fall.
                 vec.Z += ((-1 * _parent_scene.gravityz) * m_mass);
 
                 //Added for auto fly height. Kitto Flora
                 //d.Vector3 pos = d.BodyGetPosition(Body);
                 float target_altitude = _parent_scene.GetTerrainHeightAtXY(_position.X, _position.Y) + MinimumGroundFlightOffset;
-                
+
                 if (_position.Z < target_altitude)
                 {
                     vec.Z += (target_altitude - _position.Z) * PID_P * 5.0f;
@@ -921,6 +943,25 @@ namespace OpenSim.Region.Physics.OdePlugin
 
                 return;
             }
+
+            d.Vector3 newVel = d.BodyGetLinearVel(Body);
+            if (newVel.X >= 256 || newVel.X <= 256 || newVel.Y >= 256 || newVel.Y <= 256 || newVel.Z >= 256 || newVel.Z <= 256)
+            {
+//                m_log.DebugFormat(
+//                    "[ODE CHARACTER]: Limiting falling velocity from {0} to {1} for {2}", newVel.Z, -9.8, Name);
+
+                newVel.X = Util.Clamp<float>(newVel.X, -255f, 255f);
+                newVel.Y = Util.Clamp<float>(newVel.Y, -255f, 255f);
+
+                if (!flying)
+                    newVel.Z
+                        = Util.Clamp<float>(
+                            newVel.Z, -_parent_scene.AvatarTerminalVelocity, _parent_scene.AvatarTerminalVelocity);
+                else
+                    newVel.Z = Util.Clamp<float>(newVel.Z, -255f, 255f);
+
+                d.BodySetLinearVel(Body, newVel.X, newVel.Y, newVel.Z);
+            }
         }
 
         /// <summary>
diff --git a/OpenSim/Region/Physics/OdePlugin/OdeScene.cs b/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
index 4530c09..598530c 100644
--- a/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
+++ b/OpenSim/Region/Physics/OdePlugin/OdeScene.cs
@@ -144,6 +144,8 @@ namespace OpenSim.Region.Physics.OdePlugin
         public float gravityy = 0f;
         public float gravityz = -9.8f;
 
+        public float AvatarTerminalVelocity { get; set; }
+
         private float contactsurfacelayer = 0.001f;
 
         private int worldHashspaceLow = -4;
@@ -459,6 +461,15 @@ namespace OpenSim.Region.Physics.OdePlugin
                     gravityy = physicsconfig.GetFloat("world_gravityy", 0f);
                     gravityz = physicsconfig.GetFloat("world_gravityz", -9.8f);
 
+                    float avatarTerminalVelocity = physicsconfig.GetFloat("avatar_terminal_velocity", 54f);
+                    AvatarTerminalVelocity = Util.Clamp<float>(avatarTerminalVelocity, 0, 255f);
+                    if (AvatarTerminalVelocity != avatarTerminalVelocity)
+                    {
+                        m_log.WarnFormat(
+                            "[ODE SCENE]: avatar_terminal_velocity of {0} is invalid.  Clamping to {1}",
+                            avatarTerminalVelocity, AvatarTerminalVelocity);
+                    }
+
                     worldHashspaceLow = physicsconfig.GetInt("world_hashspace_size_low", -4);
                     worldHashspaceHigh = physicsconfig.GetInt("world_hashspace_size_high", 128);
 
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
index b0b1b16..1529140 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/LSL_Api.cs
@@ -2188,7 +2188,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
             if (part.ParentGroup.RootPart == part)
             {
                 SceneObjectGroup parent = part.ParentGroup;
-                parent.UpdateGroupPosition(new Vector3((float)toPos.x, (float)toPos.y, (float)toPos.z));
+                Util.FireAndForget(delegate(object x) {
+                    parent.UpdateGroupPosition(new Vector3((float)toPos.x, (float)toPos.y, (float)toPos.z));
+                });
             }
             else
             {
@@ -7973,7 +7975,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                     if (part.ParentGroup.RootPart == part)
                     {
                         SceneObjectGroup parent = part.ParentGroup;
-                        parent.UpdateGroupPosition(new Vector3((float)currentPosition.x, (float)currentPosition.y, (float)currentPosition.z));
+                        Util.FireAndForget(delegate(object x) {
+                            parent.UpdateGroupPosition(new Vector3((float)currentPosition.x, (float)currentPosition.y, (float)currentPosition.z));
+                        });
                     }
                     else
                     {
@@ -7990,7 +7994,9 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api
                 if (part.ParentGroup.RootPart == part)
                 {
                     SceneObjectGroup parent = part.ParentGroup;
-                    parent.UpdateGroupPosition(new Vector3((float)currentPosition.x, (float)currentPosition.y, (float)currentPosition.z));
+                    Util.FireAndForget(delegate(object x) {
+                        parent.UpdateGroupPosition(new Vector3((float)currentPosition.x, (float)currentPosition.y, (float)currentPosition.z));
+                    });
                 }
                 else
                 {
diff --git a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs
index 2a0ce44..5c200d6 100644
--- a/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs
+++ b/OpenSim/Region/ScriptEngine/Shared/Api/Implementation/Plugins/SensorRepeat.cs
@@ -450,17 +450,28 @@ namespace OpenSim.Region.ScriptEngine.Shared.Api.Plugins
             Vector3 toRegionPos;
             double dis;
 
-            Action<ScenePresence> senseEntity = new Action<ScenePresence>(delegate(ScenePresence presence)
+            Action<ScenePresence> senseEntity = new Action<ScenePresence>(presence =>
             {
-                if ((ts.type & NPC) == 0
-                    && presence.PresenceType == PresenceType.Npc
-                    && !npcModule.GetNPC(presence.UUID, presence.Scene).SenseAsAgent)
-                    return;
+                if ((ts.type & NPC) == 0 && presence.PresenceType == PresenceType.Npc)
+                {
+                    INPC npcData = npcModule.GetNPC(presence.UUID, presence.Scene);
+                    if (npcData == null || !npcData.SenseAsAgent)
+                        return;
+                }
 
-                if ((ts.type & AGENT) == 0
-                    && (presence.PresenceType == PresenceType.User
-                        || npcModule.GetNPC(presence.UUID, presence.Scene).SenseAsAgent))
-                    return;
+                if ((ts.type & AGENT) == 0)
+                {
+                    if (presence.PresenceType == PresenceType.User)
+                    {
+                        return;
+                    }
+                    else
+                    {
+                        INPC npcData = npcModule.GetNPC(presence.UUID, presence.Scene);
+                        if (npcData != null && npcData.SenseAsAgent)
+                            return;
+                    }
+                }
 
                 if (presence.IsDeleted || presence.IsChildAgent || presence.GodLevel > 0.0)
                     return;
diff --git a/OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs b/OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs
index 24a23dd..8ab3b64 100644
--- a/OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs
+++ b/OpenSim/Services/Connectors/Simulation/SimulationServiceConnector.cs
@@ -433,11 +433,14 @@ namespace OpenSim.Services.Connectors.Simulation
                 args["destination_name"] = OSD.FromString(destination.RegionName);
                 args["destination_uuid"] = OSD.FromString(destination.RegionID.ToString());
 
-                WebUtil.PostToService(uri, args, 40000);
+                OSDMap response = WebUtil.PostToService(uri, args, 40000);
+                if (response["Success"] == "False")
+                    return false;
             }
             catch (Exception e)
             {
                 m_log.WarnFormat("[REMOTE SIMULATION CONNECTOR] CreateObject failed with exception; {0}",e.ToString());
+                return false;
             }
 
             return true;