1 files changed, 244 insertions, 114 deletions

diff --git a/linden/indra/newview/lightshare.cpp b/linden/indra/newview/llettherebelight.cpp
index 599a527..7fc2a3d 100644
--- a/linden/indra/newview/lightshare.cpp
+++ b/linden/indra/newview/llettherebelight.cpp
@@ -1,9 +1,10 @@
 /**
- * @file lightshare.cpp
- * @brief Handler for Meta7 Lightshare (region-side Windlight settings).
+ * @file llettherebelight.cpp
+ * @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
@@ -27,7 +28,6 @@
  */
 
 
-#include "lightshare.h"
 
 #include "linden_common.h"
 #include "llviewercontrol.h"
@@ -38,30 +38,26 @@
 #include "message.h"
 #include "meta7windlight.h"
 
+#include "llettherebelight.h"
 
-const std::string WindlightMessage::sWaterPresetName  = "(Region settings)";
-const std::string WindlightMessage::sSkyPresetName    = "(Region settings)";
-const std::string WindlightMessage::sBackupWaterPresetName = "(Backup settings)";
-const std::string WindlightMessage::sBackupSkyPresetName = "(Backup settings)";
+#include "llagent.h"
+#include "llworld.h"
 
-// Backups.
-LLWaterParamSet waterBackup;
-LLWLParamSet skyBackup;
-//LLUUID* waterNormalBackup = NULL;
-bool animatorIsRunning = true;
-bool animatorUseEstateTime = true;
-bool backup = false;
 
-WindlightMessage* WindlightMessage::sMostRecent = NULL;
-LLTimer* WindlightMessage::sIgnoreTimer = new LLTimer();
-bool WindlightMessage::sIgnoreRegion = false;
+const std::string LightShare::sRegionPresetName = "(Region settings)";
+const std::string LightShare::sParcelPresetName = "(Parcel settings)";
+const std::string LightShare::sRLVPresetName = "(RLV settings)";
 
 
-WindlightMessage::WindlightMessage( LLMessageSystem* msg ) :
+LLWaterParamSet* LightShare::mWater = NULL;
+LLWLParamSet* LightShare::mSky = NULL;
+LLUUID* LightShare::mWaterNormal = NULL;
+LLTimer* LightShare::sIgnoreTimer = new LLTimer();
+bool LightShare::sIgnoreRegion = false;
+
+
+LightShare::LightShare( LLMessageSystem* msg ) :
         mPacket(NULL),
-        mWater(NULL),
-        mSky(NULL),
-        mWaterNormal(NULL),
         mIsValid(false)
 {
         std::string method;
@@ -86,10 +82,7 @@ WindlightMessage::WindlightMessage( LLMessageSystem* msg ) :
                                  buf, size, 0, 249);
 
         mWater = new LLWaterParamSet();
-//      mSky = new LLWLParamSet();
-        LLWLParamManager * wl_param_mgr = LLWLParamManager::instance();
-        static LLWLParamSet & sSky = wl_param_mgr->mCurParams;
-        mSky = &sSky;
+        mSky = new LLWLParamSet();
 
         mWaterNormal = new LLUUID();
 
@@ -102,21 +95,21 @@ WindlightMessage::WindlightMessage( LLMessageSystem* msg ) :
 }
 
 
-WindlightMessage::~WindlightMessage()
+LightShare::~LightShare()
 {
         delete mWater;
-//      delete mSky;
+        delete mSky;
         delete mWaterNormal;
 }
 
 
 // static
-void WindlightMessage::processWindlight(LLMessageSystem* msg, void**)
+void LightShare::processWindlight(LLMessageSystem* msg, void**)
 {
         if( gSavedSettings.getU32("LightShareAllowed") <= LIGHTSHARE_NEVER )
                 return;
 
-        WindlightMessage* wl = new WindlightMessage(msg);
+        LightShare* wl = new LightShare(msg);
 
         if (!wl)
                 return;
@@ -127,16 +120,28 @@ void WindlightMessage::processWindlight(LLMessageSystem* msg, void**)
                 return;
         }
 
+        applyMaybe(wl->mWater, wl->mWaterNormal, wl->mSky);
+}
+
+
+//static
+void LightShare::applyMaybe(LLWaterParamSet* thisWater, LLUUID* thisWaterNormal, LLWLParamSet* thisSky)
+{
+        if( gSavedSettings.getU32("LightShareAllowed") <= LIGHTSHARE_NEVER )
+                return;
+
         std::string water = LLWaterParamManager::instance()->mCurParams.mName;
         std::string sky = LLWLParamManager::instance()->mCurParams.mName;
 
         // 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 == sSkyPresetName && water == sWaterPresetName) )
+            (sky == sRegionPresetName && water == sRegionPresetName) )
         {
-                wl->apply();
-                delete wl;
+                mSky = thisSky;
+                mWater = thisWater;
+                mWaterNormal = thisWaterNormal;
+                apply(mWater, mWaterNormal, mSky, WL_SCOPE_REGION);
                 return;
         }
 
@@ -145,41 +150,36 @@ void WindlightMessage::processWindlight(LLMessageSystem* msg, void**)
                 // The user recently ignored a windlight message, so ignore
                 // this one too, and restart the timer.
                 restartIgnoreTimer();
-                delete wl;
                 return;
         }
 
         if(sIgnoreRegion)
         {
                 // We are ignoring new settings until user enters a new region.
-                delete wl;
                 return;
         }
 
-        if( gSavedSettings.getU32("LightShareAllowed") == LIGHTSHARE_ASK &&
-            sMostRecent == NULL )
+        if( gSavedSettings.getU32("LightShareAllowed") == LIGHTSHARE_ASK && mSky == NULL && mWater == NULL)
         {
                 // No most recent, so store this and create notification
                 // asking the user whether to apply or not.
-                sMostRecent = wl;
-                LLNotifications::instance().add("ConfirmLightShare", LLSD(), LLSD(), 
+                mSky = thisSky;
+                mWater = thisWater;
+                mWaterNormal = thisWaterNormal;
+                LLNotifications::instance().add("ConfirmLightShare", LLSD(), LLSD(),
                                                 boost::bind(&applyCallback, _1, _2));
-                return;
         }
         else
         {
-                // No new notification (to avoid spamming the user), just
-                // store this as most recent.
-                delete sMostRecent;
-                sMostRecent = wl;
-                return;
+                // No new notification (to avoid spamming the user, we do keep the saves from above)
+                mSky = thisSky;
+                mWater = thisWater;
+                mWaterNormal = thisWaterNormal;
         }
 }
 
-
 // static
-bool WindlightMessage::applyCallback(const LLSD& notification,
-                                     const LLSD& response)
+bool LightShare::applyCallback(const LLSD& notification, const LLSD& response)
 {
         S32 option = LLNotification::getSelectedOption(notification, response);
 
@@ -187,7 +187,8 @@ bool WindlightMessage::applyCallback(const LLSD& notification,
         {
                 case 0:{
                         // "Apply"
-                        sMostRecent->apply();
+                        apply(mWater, mWaterNormal, mSky, WL_SCOPE_REGION);
+
                         break;
                 }
                 case 1:{
@@ -202,41 +203,18 @@ bool WindlightMessage::applyCallback(const LLSD& notification,
                 }
         }
 
-        delete sMostRecent;
-        sMostRecent = NULL;
-
         return false;
 }
 
-
 // static
-void WindlightMessage::resetRegion()
+void LightShare::resetRegion()
 {
         sIgnoreRegion = false;
-
-// According to Melanie Thielker -
-// The new WindlightReset message from OpenSim is for resetting Windlight presets when leaving a sim that uses Lightshare.
-// Hopefully if you are moving to a sim that has new LightShare data, that gets sent after this reset, or the reset is never sent.
-        if (backup)
-        {
-            LLWaterParamManager* water_mgr = LLWaterParamManager::instance();
-            LLWLParamManager* sky_mgr = LLWLParamManager::instance();
-
-            llinfos << "Restoring WindLight presets " << waterBackup.mName << " and " << skyBackup.mName <<  "." << llendl;
-            water_mgr->loadPreset(waterBackup.mName, true);
-            // Don't think we need to do this.
-            //if (waterNormalBackup)
-                //water_mgr->setNormalMapID(*waterNormalBackup);
-            sky_mgr->mAnimator.mIsRunning = animatorIsRunning;
-            sky_mgr->mAnimator.mUseLindenTime = animatorUseEstateTime;
-            sky_mgr->loadPreset(skyBackup.mName, true);
-            backup = false;
-        }
+        apply(NULL, NULL, NULL, WL_SCOPE_REGION);
 }
 
-
 // static
-void WindlightMessage::restartIgnoreTimer()
+void LightShare::restartIgnoreTimer()
 {
         F32 time = gSavedSettings.getF32("LightShareIgnoreTimer");
         sIgnoreTimer->start();
@@ -244,65 +222,219 @@ void WindlightMessage::restartIgnoreTimer()
 }
 
 // static
-bool WindlightMessage::ignoreTimerHasExpired()
+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;
 
-bool WindlightMessage::apply()
-{
-        LLWaterParamManager* water_mgr = LLWaterParamManager::instance();
-        LLWLParamManager* sky_mgr = LLWLParamManager::instance();
+// 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.
 
-        if (!backup)
+//static
+void LightShare::mergeWaterSets(LLWaterParamSet* thisSet, LLWaterParamSet* oldSet)
+{
+        for(LLSD::map_const_iterator i = thisSet->mParamValues.beginMap();
+                i != thisSet->mParamValues.endMap();
+                ++i)
         {
-            llinfos << "Backing up WindLight presets '" << water_mgr->mCurParams.mName << " and " << sky_mgr->mCurParams.mName << "'." << llendl;
-            waterBackup = water_mgr->mCurParams;
-            //waterNormalBackup = waterBackup->getNormalMapID();
-            skyBackup = sky_mgr->mCurParams;
-            animatorIsRunning = sky_mgr->mAnimator.mIsRunning;
-            animatorUseEstateTime = sky_mgr->mAnimator.mUseLindenTime;
-            backup = true;
+                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();
         }
+}
 
-        mWater->mName = sWaterPresetName;
-        water_mgr->removeParamSet( sWaterPresetName, false );
-        water_mgr->addParamSet( sWaterPresetName, *mWater );
-        // Don't think we need to save it, the load gets the one we added above.
-        //water_mgr->savePreset( sWaterPresetName );
-        water_mgr->loadPreset( sWaterPresetName, true );
-        water_mgr->setNormalMapID( *mWaterNormal );
-
-        mSky->mName = sSkyPresetName;
-        sky_mgr->mAnimator.mIsRunning = false;
-        sky_mgr->mAnimator.mUseLindenTime = false;
-        sky_mgr->removeParamSet( sSkyPresetName, false );
-        sky_mgr->addParamSet( sSkyPresetName, *mSky );
-        // Don't think we need to save it, the load gets the one we added above.
-        //sky_mgr->savePreset( sSkyPresetName );
-        sky_mgr->loadPreset( sSkyPresetName, true );
-
-        return true;
+//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());
 
-// static
-bool WindlightMessage::isValid()
+        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;
 }
 
-
-void WindlightMessage::process_packet( char* buf )
+void LightShare::process_packet( char* buf )
 {
         // *FIXME: Horrible idea, fragile, not byte-order or endian
         //         safe, no validation, etc. etc. -Jacek
         mPacket = (Meta7WindlightPacket*)buf;
 }
 
-
-void WindlightMessage::process_water()
+void LightShare::process_water()
 {
         mWater->set("waterFogColor",
                                                         mPacket->waterColor.red   / 256.f,
@@ -358,7 +490,7 @@ void WindlightMessage::process_water()
 }
 
 
-void WindlightMessage::process_sky()
+void LightShare::process_sky()
 {
         mSky->setSunAngle(F_TWO_PI * mPacket->sunMoonPosiiton);
         mSky->setEastAngle(F_TWO_PI * mPacket->eastAngle);
@@ -453,5 +585,3 @@ void WindlightMessage::process_sky()
 
         mSky->setStarBrightness(mPacket->starBrightness);
 }
-
-