Merge branch 'master' into careminster

17 files changed, 906 insertions, 361 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/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/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/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/Scenes/Scene.cs b/OpenSim/Region/Framework/Scenes/Scene.cs
index ec5cf32..bbdf35d 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/ScenePresence.cs b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
index c7c90da..13854c7 100644
--- a/OpenSim/Region/Framework/Scenes/ScenePresence.cs
+++ b/OpenSim/Region/Framework/Scenes/ScenePresence.cs
@@ -295,13 +295,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;
 
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/bin/OpenSim.ini.example b/bin/OpenSim.ini.example
index d45f72b..a820ddf 100755
--- a/bin/OpenSim.ini.example
+++ b/bin/OpenSim.ini.example
@@ -484,7 +484,6 @@
     ;; such as the Meta7 viewer.
     ;; It has no ill effect on viewers which do not support server-side
     ;; windlight settings.
-    ;; Currently we only have support for MySQL databases.
     ; enable_windlight = false
 
 
@@ -573,10 +572,15 @@
     ; DeleteScriptsOnStartup = true
 
     ;; Set this to true (the default) to load each script into a separate
-    ;; AppDomain. Setting this to false will load all script assemblies into the
-    ;; current AppDomain, which will reduce the per-script overhead at the
-    ;; expense of reduced security and the inability to garbage collect the
-    ;; script assemblies
+    ;; AppDomain. 
+    ;;
+    ;; Setting this to false will load all script assemblies into the
+    ;; current AppDomain, which will significantly improve script loading times.
+    ;; It will also reduce initial per-script memory overhead.
+    ;;
+    ;; However, setting this to false will also prevent script DLLs from being unloaded from memory if the script is deleted.
+    ;; This may cause an OutOfMemory problem over time when avatars with scripted attachments move in and out of the region.
+    ;; Some Windows users have also reported script loading problems when AppDomainLoading = false
     ; AppDomainLoading = true
 
     ;# {DefaultCompileLanguage} {Enabled:true} {Default script language?} {lsl vb cs} lsl
diff --git a/bin/OpenSimDefaults.ini b/bin/OpenSimDefaults.ini
index 07e7533..8671e31 100644
--- a/bin/OpenSimDefaults.ini
+++ b/bin/OpenSimDefaults.ini
@@ -655,6 +655,11 @@
     world_gravityy = 0
     world_gravityz = -9.8
 
+    ; Terminal velocity of a falling avatar
+    ; This is the same http://en.wikipedia.org/wiki/Terminal_velocity#Examples
+    ; Max value is 255, min value is 0
+    avatar_terminal_velocity = 54
+
     ; World Step size. (warning these are dangerous.  Changing these will probably cause your scene to explode dramatically)
     ; reference: fps = (0.089/ODE_STEPSIZE) * 1000;
     world_stepsize = 0.0178
@@ -1065,7 +1070,6 @@
 [LightShare]
     ; This enables the transmission of Windlight scenes to supporting clients, such as the Meta7 viewer.
     ; It has no ill effect on viewers which do not support server-side windlight settings.
-    ; Currently we only have support for MySQL databases.
     enable_windlight = false