7 files changed, 243 insertions, 141 deletions

diff --git a/linden/indra/newview/lightshare.cpp b/linden/indra/newview/lightshare.cpp
index 378a755..db391f5 100644
--- a/linden/indra/newview/lightshare.cpp
+++ b/linden/indra/newview/lightshare.cpp
@@ -1,9 +1,10 @@
 /**
  * @file lightshare.cpp
- * @brief Handler for Meta7 Lightshare (region-side Windlight settings).
+ * @brief Handler for Meta7 Lightshare (region-side Windlight settings), and other methods of sharing WindLight.
  *
  * Copyright (c) 2010, Tom Grimshaw (Tom Meta)
  * Copyright (c) 2010, Jacek Antonelli
+ * Copyright (c) 2012, David Seikel
  *
  * The source code in this file ("Source Code") is provided to you
  * under the terms of the GNU General Public License, version 2.0
@@ -43,6 +44,10 @@
 #include "llworld.h"
 
 
+const std::string LightShare::sRegionPresetName = "(Region settings)";
+const std::string LightShare::sParcelPresetName = "(Parcel settings)";
+const std::string LightShare::sRLVPresetName = "(RLV settings)";
+
 
 LLWaterParamSet* LightShare::mWater = NULL;
 LLWLParamSet* LightShare::mSky = NULL;
@@ -131,12 +136,12 @@ void LightShare::applyMaybe(LLWaterParamSet* thisWater, LLUUID* thisWaterNormal,
         // If they are using region settings already, or LightShare is
         // always allowed, just apply the new settings, don't bother asking.
         if( gSavedSettings.getU32("LightShareAllowed") == LIGHTSHARE_ALWAYS ||
-            (sky == LLWLParamManager::sSkyPresetName && water == LLWLParamManager::sWaterPresetName) )
+            (sky == sRegionPresetName && water == sRegionPresetName) )
         {
                 mSky = thisSky;
                 mWater = thisWater;
                 mWaterNormal = thisWaterNormal;
-                LLWLParamManager::apply(mWater, mWaterNormal, mSky);
+                apply(mWater, mWaterNormal, mSky, WL_SCOPE_REGION);
                 return;
         }
 
@@ -182,7 +187,7 @@ bool LightShare::applyCallback(const LLSD& notification, const LLSD& response)
         {
                 case 0:{
                         // "Apply"
-                        LLWLParamManager::apply(mWater, mWaterNormal, mSky);
+                        apply(mWater, mWaterNormal, mSky, WL_SCOPE_REGION);
 
                         break;
                 }
@@ -205,7 +210,7 @@ bool LightShare::applyCallback(const LLSD& notification, const LLSD& response)
 void LightShare::resetRegion()
 {
         sIgnoreRegion = false;
-        LLWorld::getInstance()->rebuildClouds(gAgent.getRegion());
+        apply(NULL, NULL, NULL, WL_SCOPE_REGION);
 }
 
 // static
@@ -222,6 +227,201 @@ bool LightShare::ignoreTimerHasExpired()
         return sIgnoreTimer->hasExpired();
 }
 
+// TODO - have regionSet and parcelSet be arrays, so we can deal with height zones.
+static struct WLCombined userSet, regionSet, parcelSet, RLVSet;
+
+// TODO - should spread this merging stuff around,
+//        so that eventually we can get rid of almost identical code for water and sky.
+//        Then one of these two methods goes away.
+
+//static
+void LightShare::mergeWaterSets(LLWaterParamSet* thisSet, LLWaterParamSet* oldSet)
+{
+        for(LLSD::map_const_iterator i = thisSet->mParamValues.beginMap();
+                i != thisSet->mParamValues.endMap();
+                ++i)
+        {
+                const std::string& param = i->first;
+
+                if(i->second.isArray())
+                {
+                        for (int j = 0; j < i->second.size(); j++)
+                        {
+                                oldSet->mParamValues[param][j] = i->second[j].asReal();
+                        }
+                }
+                else if(i->second.isReal())
+                  oldSet->mParamValues[param] = i->second.asReal();
+        }
+}
+
+//static
+void LightShare::mergeWLSets(LLWLParamSet* thisSet, LLWLParamSet* oldSet)
+{
+        for(LLSD::map_const_iterator i = thisSet->mParamValues.beginMap();
+                i != thisSet->mParamValues.endMap();
+                ++i)
+        {
+                const std::string& param = i->first;
+
+                if(i->second.isArray())
+                {
+                        for (int j = 0; j < i->second.size(); j++)
+                        {
+                                oldSet->mParamValues[param][j] = i->second[j].asReal();
+                        }
+                }
+                else if(i->second.isReal())
+                  oldSet->mParamValues[param] = i->second.asReal();
+        }
+}
+
+//static
+void LightShare::apply(LLWaterParamSet * newWater, LLUUID *newWaterNormal, LLWLParamSet *newSky, WLScope scope)
+// TODO - Deal with day cycle stuff.
+{
+        LLWaterParamManager* waterMgr = LLWaterParamManager::instance();
+        LLWLParamManager* skyMgr = LLWLParamManager::instance();
+        LLWaterParamSet oldWaterSet = waterMgr->mCurParams;
+        LLWLParamSet oldWLSet = skyMgr->mCurParams;
+        struct WLCombined* thisSet = &userSet;
+        bool user = true;
+
+        switch(scope)
+        {
+                case WL_SCOPE_USER :
+                {
+                        thisSet = &userSet;
+                        thisSet->water.mName = waterMgr->mCurParams.mName;
+                        thisSet->sky.mName = skyMgr->mCurParams.mName;
+                        thisSet->enabled = true;
+                        // Check if user selected to show the saved region or parcel settings.
+                        if (newSky && (sRegionPresetName == skyMgr->mCurParams.mName))
+                          thisSet->enabled = false;
+                        if (newWater && (sParcelPresetName == skyMgr->mCurParams.mName))
+                          thisSet->enabled = false;
+                        break;
+                }
+                case WL_SCOPE_REGION :
+                {
+                        thisSet = &regionSet;
+                        thisSet->water.mName = sRegionPresetName;
+                        thisSet->sky.mName = sRegionPresetName;
+                        thisSet->enabled = (gSavedSettings.getU32("LightShareAllowed") != LIGHTSHARE_NEVER);
+                        break;
+                }
+                case WL_SCOPE_PARCEL :
+                {
+                        thisSet = &parcelSet;
+                        thisSet->water.mName = sParcelPresetName;
+                        thisSet->sky.mName = sParcelPresetName;
+                        thisSet->enabled = (gSavedSettings.getU32("LightShareAllowed") != LIGHTSHARE_NEVER);
+                        break;
+                }
+                case WL_SCOPE_RLV :
+                {
+                        thisSet = &RLVSet;
+                        thisSet->water.mName = sRLVPresetName;
+                        thisSet->sky.mName = sRLVPresetName;
+                        // TODO set enabled properly.
+                        break;
+                }
+        }
+
+        if (newWater)
+                thisSet->water.setAll(newWater->getAll());
+        if (newWaterNormal)
+                thisSet->water.mParamValues["normalMap"] = *newWaterNormal;
+        if (newSky)
+                thisSet->sky.setAll(newSky->getAll());
+
+        if ((NULL == newWater) && (NULL == newSky))
+                thisSet->enabled = false;
+
+        F32 fade = 0; //Instant
+        bool error;
+        fade = thisSet->sky.getFloat("fade", error);
+
+        if (fade)
+        {
+                // TODO - should copy the original, then set that here.
+                // The fade should delete this copy once it's done fading.
+                // Dunno if we actually need to do any of this anyway.
+                waterMgr->removeParamSet( oldWaterSet.mName, false );
+                waterMgr->addParamSet( oldWaterSet.mName, oldWaterSet );
+                waterMgr->setNormalMapID( *newWaterNormal );
+                waterMgr->getParamSet(oldWaterSet.mName, waterMgr->mCurParams);
+                waterMgr->propagateParameters();
+
+                skyMgr->removeParamSet( oldWLSet.mName, false );
+                skyMgr->addParamSet( oldWLSet.mName, oldWLSet );
+                skyMgr->getParamSet(oldWLSet.mName, skyMgr->mCurParams);
+                skyMgr->propagateParameters();
+        }
+
+        if (regionSet.enabled)
+        {
+                waterMgr->setParamSet( regionSet.water.mName, regionSet.water );
+                skyMgr->setParamSet( regionSet.sky.mName, regionSet.sky );
+                mergeWaterSets(&(regionSet.water), &oldWaterSet);
+                mergeWLSets(&(regionSet.sky), &oldWLSet);
+        }
+        else
+        {
+                waterMgr->removeParamSet( regionSet.water.mName, false );
+                skyMgr->removeParamSet( regionSet.sky.mName, false );
+        }
+        if (parcelSet.enabled)
+        {
+                waterMgr->setParamSet( parcelSet.water.mName, parcelSet.water );
+                skyMgr->setParamSet( parcelSet.sky.mName, parcelSet.sky );
+                mergeWaterSets(&(parcelSet.water), &oldWaterSet);
+                mergeWLSets(&(parcelSet.sky), &oldWLSet);
+        }
+        else
+        {
+                waterMgr->removeParamSet( parcelSet.water.mName, false );
+                skyMgr->removeParamSet( parcelSet.sky.mName, false );
+        }
+        if (userSet.enabled)
+        {
+                mergeWaterSets(&(userSet.water), &oldWaterSet);
+                mergeWLSets(&(userSet.sky), &oldWLSet);
+        }
+        if (RLVSet.enabled)
+        {
+                mergeWaterSets(&(RLVSet.water), &oldWaterSet);
+                mergeWLSets(&(RLVSet.sky), &oldWLSet);
+        }
+
+        skyMgr->mAnimator.mIsRunning = false;
+        skyMgr->mAnimator.mUseLindenTime = false;
+        if (fade)
+        {
+                waterMgr->SetMixTime(&oldWaterSet, fade);
+                skyMgr->SetMixTime(&oldWLSet, fade);
+        }
+        else
+        {
+                if (newWater)
+                {
+                        waterMgr->setParamSet( thisSet->water.mName, oldWaterSet );
+                        waterMgr->setNormalMapID( *newWaterNormal );
+                        waterMgr->getParamSet(thisSet->water.mName, waterMgr->mCurParams);
+                        waterMgr->propagateParameters();
+                }
+
+                if (newSky)
+                {
+                          skyMgr->setParamSet( thisSet->sky.mName, oldWLSet );
+                          skyMgr->getParamSet(thisSet->sky.mName, skyMgr->mCurParams);
+                          skyMgr->propagateParameters();
+                }
+        }
+
+        LLWorld::getInstance()->rebuildClouds(gAgent.getRegion());
+}
+
 bool LightShare::isValid()
 {
         return mIsValid;
diff --git a/linden/indra/newview/lightshare.h b/linden/indra/newview/lightshare.h
index 1df2084..3561a91 100644
--- a/linden/indra/newview/lightshare.h
+++ b/linden/indra/newview/lightshare.h
@@ -37,6 +37,21 @@
 struct Meta7WindlightPacket;
 
 
+typedef enum wl_scope
+{
+        WL_SCOPE_USER,
+        WL_SCOPE_REGION,
+        WL_SCOPE_PARCEL,
+        WL_SCOPE_RLV
+} WLScope;
+
+struct WLCombined
+{
+        LLWaterParamSet water;
+        LLWLParamSet sky;
+        BOOL enabled;
+};
+
 // Encapsulates a "Windlight" (LightShare) message sent from the
 // region, allowing the settings to be applied at a later time.
 //
@@ -51,6 +66,13 @@ public:
                 LIGHTSHARE_ALWAYS = 2,
         };
 
+        // The name of the preset where the region settings are stored.
+        static const std::string sRegionPresetName;
+        // The name of the preset where the parcel settings are stored.
+        static const std::string sParcelPresetName;
+        // The name of the preset where the RLV settings are stored.
+        static const std::string sRLVPresetName;
+
         // Constructs a new LightShare instance from a GenericMessage
         // with the "Windlight" method, such as those sent by a
         // Lightshare-enabled OpenSim region.
@@ -72,6 +94,8 @@ public:
         // (But there's no real validation yet, so this is always true.)
         bool isValid();
 
+        static void apply(LLWaterParamSet * newWater, LLUUID *newWaterNormal, LLWLParamSet *newSky, WLScope scope);
+
 private:
         static LLTimer* sIgnoreTimer;
         static bool sIgnoreRegion;
@@ -100,6 +124,9 @@ private:
         // Returns true if the ignore timer has expired (i.e. new settings
         // should not be ignored anymore).
         static bool ignoreTimerHasExpired();
+
+        static void mergeWaterSets(LLWaterParamSet* thisSet, LLWaterParamSet* oldSet);
+        static void mergeWLSets(LLWLParamSet* thisSet, LLWLParamSet* oldSet);
 };
 
 #endif
diff --git a/linden/indra/newview/llwaterparammanager.cpp b/linden/indra/newview/llwaterparammanager.cpp
index 9d0fd86..6e2b420 100644
--- a/linden/indra/newview/llwaterparammanager.cpp
+++ b/linden/indra/newview/llwaterparammanager.cpp
@@ -69,6 +69,7 @@
 
 #include "llwlparammanager.h"
 #include "llwaterparamset.h"
+#include "lightshare.h"
 #include "llpostprocess.h"
 #include "llfloaterwater.h"
 
@@ -159,7 +160,7 @@ void LLWaterParamManager::loadPreset(const std::string & name,bool propagate)
                 if(propagate)
                 {
                         getParamSet(name, mCurParams);
-                        propagateParameters();
+                        LightShare::apply(&mCurParams, NULL, NULL, WL_SCOPE_USER);
                 }
                 return;
         }
@@ -200,21 +201,21 @@ void LLWaterParamManager::loadPreset(const std::string & name,bool propagate)
         if(propagate)
         {
                 getParamSet(name, mCurParams);
-                propagateParameters();
+                LightShare::apply(&mCurParams, NULL, NULL, WL_SCOPE_USER);
         }
 }
 
 bool LLWaterParamManager::loadPresetXML(const std::string& name, std::istream& preset_stream, bool propagate /* = false */, bool check_if_real /* = false */)
 {
         LLSD paramsData(LLSD::emptyMap());
-        
+
         LLPointer<LLSDParser> parser = new LLSDXMLParser();
-        
+
         if(parser->parse(preset_stream, paramsData, LLSDSerialize::SIZE_UNLIMITED) == LLSDParser::PARSE_FAILURE)
         {
                 return false;
         }
-        
+
         if(check_if_real)
         {
                 static const char* expected_windlight_settings[] = {
diff --git a/linden/indra/newview/llwaterparamset.h b/linden/indra/newview/llwaterparamset.h
index f2667ab..09da42b 100644
--- a/linden/indra/newview/llwaterparamset.h
+++ b/linden/indra/newview/llwaterparamset.h
@@ -48,6 +48,7 @@ class LLWaterParamSet
 {
         friend class LLWaterParamManager;
         friend class LLWLParamManager;
+        friend class LightShare;
 
 public:
         std::string mName;
diff --git a/linden/indra/newview/llwlparammanager.cpp b/linden/indra/newview/llwlparammanager.cpp
index 75592da..b4d999c 100644
--- a/linden/indra/newview/llwlparammanager.cpp
+++ b/linden/indra/newview/llwlparammanager.cpp
@@ -34,6 +34,7 @@
 
 #include "llwlparammanager.h"
 #include "llwaterparammanager.h"
+#include "lightshare.h"
 
 #include "pipeline.h"
 #include "llsky.h"
@@ -77,9 +78,6 @@
 
 #include "curl/curl.h"
 
-const std::string LLWLParamManager::sWaterPresetName = "(Region settings)";
-const std::string LLWLParamManager::sSkyPresetName   = "(Region settings)";
-
 LLWLParamManager * LLWLParamManager::sInstance = NULL;
 std::vector<LLWLPresetsObserver*> LLWLParamManager::sObservers;
 LLFrameTimer wlSmoothTransitionTimer;
@@ -346,7 +344,7 @@ void LLWLParamManager::loadPreset(const std::string & name,bool propagate)
                 if(propagate)
                 {
                         getParamSet(name, mCurParams);
-                        propagateParameters();
+                        LightShare::apply(NULL, NULL, &mCurParams, WL_SCOPE_USER);
                 }
                 return;
         }
@@ -388,7 +386,7 @@ void LLWLParamManager::loadPreset(const std::string & name,bool propagate)
         if(propagate)
         {
                 getParamSet(name, mCurParams);
-                propagateParameters();
+                LightShare::apply(NULL, NULL, &mCurParams, WL_SCOPE_USER);
         }
 
         notifyObservers();
@@ -859,112 +857,3 @@ bool LLWLParamManager::isSettingsNotecard(std::string name)
 {
         return (isSkySettingsNotecard(name) || isWaterSettingsNotecard(name));
 }
-
-
-struct WLCombined userSet, regionSet, parcelSet, RLVSet;
-
-//static
-void LLWLParamManager::apply(LLWaterParamSet * newWater, LLUUID *newWaterNormal, LLWLParamSet *newSky)
-// TODO - Pass in scope and day cycle stuff.
-{
-        LLWaterParamManager* waterMgr = LLWaterParamManager::instance();
-        LLWLParamManager* skyMgr = LLWLParamManager::instance();
-        struct WLCombined* thisSet = &userSet;
-
-//      if (region == scope)
-                thisSet = &regionSet;
-//      if (parcel== scope)
-//              thisSet = &parcelSet;
-//      if (RLV == scope)
-//              thisSet = &RLVSet;
-
-        thisSet->water.setAll(newWater->getAll());
-        thisSet->water.mParamValues["normalMap"] = *newWaterNormal;
-        thisSet->sky.setAll(newSky->getAll());
-
-// TODO - if scope is region or parcel, and not using server settings
-//          return
-
-        thisSet->enabled = true;
-
-        F32 fade = 0; //Instant
-        bool error;
-        fade = newSky->getFloat("fade", error);
-
-        newWater->mName = sWaterPresetName;
-        newSky->mName = sSkyPresetName;
-        LLWaterParamSet oldWaterSet = waterMgr->mCurParams;
-        LLWLParamSet oldWLSet = skyMgr->mCurParams;
-
-        if (fade)
-        {
-                // TODO - should copy the original, then set that here.
-                // The fade should delete this copy once it's done fading.
-                waterMgr->removeParamSet( sWaterPresetName, false );
-                waterMgr->addParamSet( sWaterPresetName, oldWaterSet );
-                waterMgr->loadPreset( sWaterPresetName, true );
-                waterMgr->setNormalMapID( *newWaterNormal );
-
-                skyMgr->removeParamSet( sSkyPresetName, true );
-                skyMgr->addParamSet( sSkyPresetName, oldWLSet );
-                skyMgr->loadPreset( sSkyPresetName, true );
-         }
-
-        for(LLSD::map_const_iterator i = thisSet->water.mParamValues.beginMap();
-                i != thisSet->water.mParamValues.endMap();
-                ++i)
-        {
-                const std::string& param = i->first;
-
-                if(i->second.isArray())
-                {
-                        for (int j = 0; j < i->second.size(); j++)
-                        {
-                                oldWaterSet.mParamValues[param][j] = i->second[j].asReal();
-                        }
-                }
-                else if(i->second.isReal())
-                  oldWaterSet.mParamValues[param] = i->second.asReal();
-        }
-
-        skyMgr->mAnimator.mIsRunning = false;
-        skyMgr->mAnimator.mUseLindenTime = false;
-        for(LLSD::map_const_iterator i = thisSet->sky.mParamValues.beginMap();
-                i != thisSet->sky.mParamValues.endMap();
-                ++i)
-        {
-                const std::string& param = i->first;
-
-                if(i->second.isArray())
-                {
-                        for (int j = 0; j < i->second.size(); j++)
-                        {
-                                oldWLSet.mParamValues[param][j] = i->second[j].asReal();
-                        }
-                }
-                else if(i->second.isReal())
-                  oldWLSet.mParamValues[param] = i->second.asReal();
-        }
-
-// TODO - If RLV enabled
-//          Loop through RLVSet, setting the values into the old one, but keeping old values that are not in RLVSet
-
-        if (fade)
-        {
-                waterMgr->SetMixTime(&oldWaterSet, fade);
-                skyMgr->SetMixTime(&oldWLSet, fade);
-        }
-        else
-        {
-                waterMgr->removeParamSet( sWaterPresetName, false );
-                waterMgr->addParamSet( sWaterPresetName, oldWaterSet );
-                waterMgr->loadPreset( sWaterPresetName, true );
-                waterMgr->setNormalMapID( *newWaterNormal );
-
-                skyMgr->removeParamSet( sSkyPresetName, true );
-                skyMgr->addParamSet( sSkyPresetName, oldWLSet );
-                skyMgr->loadPreset( sSkyPresetName, true );
-        }
-
-        LLWorld::getInstance()->rebuildClouds(gAgent.getRegion());
-}
diff --git a/linden/indra/newview/llwlparammanager.h b/linden/indra/newview/llwlparammanager.h
index 27e7663..034b2e6 100644
--- a/linden/indra/newview/llwlparammanager.h
+++ b/linden/indra/newview/llwlparammanager.h
@@ -230,8 +230,6 @@ public:
         static bool isSkySettingsNotecard(std::string name);
         static bool isSettingsNotecard(std::string name);
 
-        static void apply(LLWaterParamSet * newWater, LLUUID *newWaterNormal, LLWLParamSet *newSky);
-
 public:
 
         // helper variables
@@ -288,12 +286,6 @@ public:
         // list of all the parameters, listed by name
         std::map<std::string, LLWLParamSet> mParamList;
 
-        // The name of the water preset where the region settings are stored.
-        static const std::string sWaterPresetName;
-
-        // The name of the sky preset where the region settings are stored.
-        static const std::string sSkyPresetName;
-
 private:
         // our parameter manager singleton instance
         static LLWLParamManager * sInstance;
@@ -306,7 +298,6 @@ private:
         static std::vector<LLWLPresetsObserver*> sObservers;
 
         static void loadWindlightNotecard(LLVFS *vfs, const LLUUID& asset_id, LLAssetType::EType asset_type, void *user_data, S32 status, LLExtStat ext_status);
-
 };
 
 inline F32 LLWLParamManager::getDomeOffset(void) const
@@ -334,11 +325,4 @@ inline LLVector4 LLWLParamManager::getRotatedLightDir(void) const
         return mRotatedLightDir;
 }
 
-struct WLCombined
-{
-        LLWaterParamSet water;
-        LLWLParamSet sky;
-        BOOL enabled;
-};
-
 #endif
diff --git a/linden/indra/newview/llwlparamset.h b/linden/indra/newview/llwlparamset.h
index 4b6f336..ce01f84 100644
--- a/linden/indra/newview/llwlparamset.h
+++ b/linden/indra/newview/llwlparamset.h
@@ -46,7 +46,7 @@ class LLWLParamSet;
 /// A class representing a set of parameter values for the WindLight shaders.
 class LLWLParamSet {
 
-        friend class LLWLParamManager;
+        friend class LightShare;
 
 public:
         std::string mName;