Second Life viewer sources 1.19.1.0

1 files changed, 998 insertions, 0 deletions

diff --git a/linden/indra/newview/llfloaterwindlight.cpp b/linden/indra/newview/llfloaterwindlight.cpp
new file mode 100644
index 0000000..2321f5d
--- /dev/null
+++ b/linden/indra/newview/llfloaterwindlight.cpp
@@ -0,0 +1,998 @@
+/** 
+ * @file llfloaterwindlight.cpp
+ * @brief LLFloaterWindLight class definition
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llfloaterwindlight.h"
+
+#include "pipeline.h"
+#include "llsky.h"
+
+#include "llsliderctrl.h"
+#include "llmultislider.h"
+#include "llmultisliderctrl.h"
+#include "llspinctrl.h"
+#include "llcheckboxctrl.h"
+#include "llvieweruictrlfactory.h"
+#include "llviewercamera.h"
+#include "llcombobox.h"
+#include "lllineeditor.h"
+#include "llfloaterdaycycle.h"
+#include "llboost.h"
+
+#include "v4math.h"
+#include "llviewerdisplay.h"
+#include "llviewercontrol.h"
+#include "llviewerwindow.h"
+#include "llsavedsettingsglue.h"
+
+#include "llwlparamset.h"
+#include "llwlparammanager.h"
+#include "llpostprocess.h"
+
+#undef max
+
+LLFloaterWindLight* LLFloaterWindLight::sWindLight = NULL;
+
+std::set<std::string> LLFloaterWindLight::sDefaultPresets;
+
+static const F32 WL_SUN_AMBIENT_SLIDER_SCALE = 3.0f;
+
+LLFloaterWindLight::LLFloaterWindLight() : LLFloater("windlight floater")
+{
+        gUICtrlFactory->buildFloater(this, "floater_windlight_options.xml");
+        
+        // add the combo boxes
+        LLComboBox* comboBox = LLUICtrlFactory::getComboBoxByName(this, "WLPresetsCombo");
+
+        if(comboBox != NULL) {
+                
+                std::map<std::string, LLWLParamSet>::iterator mIt = 
+                        LLWLParamManager::instance()->mParamList.begin();
+                for(; mIt != LLWLParamManager::instance()->mParamList.end(); mIt++) 
+                {
+                        comboBox->add(mIt->first);
+                }
+
+                // entry for when we're in estate time
+                comboBox->add("");
+
+                // set defaults on combo boxes
+                comboBox->selectByValue(LLSD("Default"));
+        }
+
+        // add the list of presets
+        LLString def_days = getString("WLDefaultSkyNames");
+
+        // no editing or deleting of the blank string
+        sDefaultPresets.insert("");
+        boost_tokenizer tokens(def_days, boost::char_separator<char>(":"));
+        for (boost_tokenizer::iterator token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
+        {
+                LLString tok(*token_iter);
+                sDefaultPresets.insert(tok);
+        }
+
+        // load it up
+        initCallbacks();
+}
+
+LLFloaterWindLight::~LLFloaterWindLight()
+{
+}
+
+void LLFloaterWindLight::initCallbacks(void) {
+
+        // help buttons
+        initHelpBtn("WLBlueHorizonHelp", "HelpBlueHorizon");
+        initHelpBtn("WLHazeHorizonHelp", "HelpHazeHorizon");
+        initHelpBtn("WLBlueDensityHelp", "HelpBlueDensity");
+        initHelpBtn("WLHazeDensityHelp", "HelpHazeDensity");
+
+        initHelpBtn("WLDensityMultHelp", "HelpDensityMult");
+        initHelpBtn("WLDistanceMultHelp", "HelpDistanceMult");
+        initHelpBtn("WLMaxAltitudeHelp", "HelpMaxAltitude");
+
+        initHelpBtn("WLSunlightColorHelp", "HelpSunlightColor");
+        initHelpBtn("WLAmbientHelp", "HelpSunAmbient");
+        initHelpBtn("WLSunGlowHelp", "HelpSunGlow");
+        initHelpBtn("WLTimeOfDayHelp", "HelpTimeOfDay");
+        initHelpBtn("WLEastAngleHelp", "HelpEastAngle");
+
+        initHelpBtn("WLSceneGammaHelp", "HelpSceneGamma");
+        initHelpBtn("WLStarBrightnessHelp", "HelpStarBrightness");
+
+        initHelpBtn("WLCloudColorHelp", "HelpCloudColor");
+        initHelpBtn("WLCloudDetailHelp", "HelpCloudDetail");
+        initHelpBtn("WLCloudDensityHelp", "HelpCloudDensity");
+        initHelpBtn("WLCloudCoverageHelp", "HelpCloudCoverage");
+
+        initHelpBtn("WLCloudScaleHelp", "HelpCloudScale");
+        initHelpBtn("WLCloudScrollXHelp", "HelpCloudScrollX");
+        initHelpBtn("WLCloudScrollYHelp", "HelpCloudScrollY");
+
+        initHelpBtn("WLClassicCloudsHelp", "HelpClassicClouds");
+
+        LLWLParamManager * param_mgr = LLWLParamManager::instance();
+
+        // blue horizon
+        childSetCommitCallback("WLBlueHorizonR", onColorControlRMoved, &param_mgr->mBlueHorizon);
+        childSetCommitCallback("WLBlueHorizonG", onColorControlGMoved, &param_mgr->mBlueHorizon);
+        childSetCommitCallback("WLBlueHorizonB", onColorControlBMoved, &param_mgr->mBlueHorizon);
+        childSetCommitCallback("WLBlueHorizonI", onColorControlIMoved, &param_mgr->mBlueHorizon);
+
+        // haze density, horizon, mult, and altitude
+        childSetCommitCallback("WLHazeDensity", onColorControlRMoved, &param_mgr->mHazeDensity);
+        childSetCommitCallback("WLHazeHorizon", onColorControlRMoved, &param_mgr->mHazeHorizon);
+        childSetCommitCallback("WLDensityMult", onFloatControlMoved, &param_mgr->mDensityMult);
+        childSetCommitCallback("WLMaxAltitude", onFloatControlMoved, &param_mgr->mMaxAlt);
+
+        // blue density
+        childSetCommitCallback("WLBlueDensityR", onColorControlRMoved, &param_mgr->mBlueDensity);
+        childSetCommitCallback("WLBlueDensityG", onColorControlGMoved, &param_mgr->mBlueDensity);
+        childSetCommitCallback("WLBlueDensityB", onColorControlBMoved, &param_mgr->mBlueDensity);
+        childSetCommitCallback("WLBlueDensityI", onColorControlIMoved, &param_mgr->mBlueDensity);
+
+        // Lighting
+        
+        // sunlight
+        childSetCommitCallback("WLSunlightR", onColorControlRMoved, &param_mgr->mSunlight);
+        childSetCommitCallback("WLSunlightG", onColorControlGMoved, &param_mgr->mSunlight);
+        childSetCommitCallback("WLSunlightB", onColorControlBMoved, &param_mgr->mSunlight);
+        childSetCommitCallback("WLSunlightI", onColorControlIMoved, &param_mgr->mSunlight);
+
+        // glow
+        childSetCommitCallback("WLGlowR", onGlowRMoved, &param_mgr->mGlow);
+        childSetCommitCallback("WLGlowB", onGlowBMoved, &param_mgr->mGlow);
+
+        // ambient
+        childSetCommitCallback("WLAmbientR", onColorControlRMoved, &param_mgr->mAmbient);
+        childSetCommitCallback("WLAmbientG", onColorControlGMoved, &param_mgr->mAmbient);
+        childSetCommitCallback("WLAmbientB", onColorControlBMoved, &param_mgr->mAmbient);
+        childSetCommitCallback("WLAmbientI", onColorControlIMoved, &param_mgr->mAmbient);
+
+        // time of day
+        childSetCommitCallback("WLSunAngle", onSunMoved, &param_mgr->mLightnorm);
+        childSetCommitCallback("WLEastAngle", onSunMoved, &param_mgr->mLightnorm);
+
+        // Clouds
+
+        // Cloud Color
+        childSetCommitCallback("WLCloudColorR", onColorControlRMoved, &param_mgr->mCloudColor);
+        childSetCommitCallback("WLCloudColorG", onColorControlGMoved, &param_mgr->mCloudColor);
+        childSetCommitCallback("WLCloudColorB", onColorControlBMoved, &param_mgr->mCloudColor);
+        childSetCommitCallback("WLCloudColorI", onColorControlIMoved, &param_mgr->mCloudColor);
+
+        // Cloud
+        childSetCommitCallback("WLCloudX", onColorControlRMoved, &param_mgr->mCloudMain);
+        childSetCommitCallback("WLCloudY", onColorControlGMoved, &param_mgr->mCloudMain);
+        childSetCommitCallback("WLCloudDensity", onColorControlBMoved, &param_mgr->mCloudMain);
+
+        // Cloud Detail
+        childSetCommitCallback("WLCloudDetailX", onColorControlRMoved, &param_mgr->mCloudDetail);
+        childSetCommitCallback("WLCloudDetailY", onColorControlGMoved, &param_mgr->mCloudDetail);
+        childSetCommitCallback("WLCloudDetailDensity", onColorControlBMoved, &param_mgr->mCloudDetail);
+
+        // Cloud extras
+        childSetCommitCallback("WLCloudCoverage", onFloatControlMoved, &param_mgr->mCloudCoverage);
+        childSetCommitCallback("WLCloudScale", onFloatControlMoved, &param_mgr->mCloudScale);
+        childSetCommitCallback("WLCloudLockX", onCloudScrollXToggled, NULL);
+        childSetCommitCallback("WLCloudLockY", onCloudScrollYToggled, NULL);
+        childSetCommitCallback("WLCloudScrollX", onCloudScrollXMoved, NULL);
+        childSetCommitCallback("WLCloudScrollY", onCloudScrollYMoved, NULL);
+        childSetCommitCallback("WLDistanceMult", onFloatControlMoved, &param_mgr->mDistanceMult);
+        childSetCommitCallback("DrawClassicClouds", LLSavedSettingsGlue::setBOOL, (void*)"SkyUseClassicClouds");
+
+        // WL Top
+        childSetAction("WLDayCycleMenuButton", onOpenDayCycle, NULL);
+        // Load/save
+        LLComboBox* comboBox = LLUICtrlFactory::getComboBoxByName(this, "WLPresetsCombo");
+
+        //childSetAction("WLLoadPreset", onLoadPreset, comboBox);
+        childSetAction("WLNewPreset", onNewPreset, comboBox);
+        childSetAction("WLSavePreset", onSavePreset, comboBox);
+        childSetAction("WLDeletePreset", onDeletePreset, comboBox);
+
+        comboBox->setCommitCallback(onChangePresetName);
+
+
+        // Dome
+        childSetCommitCallback("WLGamma", onFloatControlMoved, &param_mgr->mWLGamma);
+        childSetCommitCallback("WLStarAlpha", onStarAlphaMoved, NULL);
+}
+
+void LLFloaterWindLight::onClickHelp(void* data)
+{
+        LLFloaterWindLight* self = LLFloaterWindLight::instance();
+
+        const char* xml_alert = (const char*) data;
+        LLAlertDialog* dialogp = gViewerWindow->alertXml(xml_alert);
+        if (dialogp)
+        {
+                LLFloater* root_floater = gFloaterView->getParentFloater(self);
+                if (root_floater)
+                {
+                        root_floater->addDependentFloater(dialogp);
+                }
+        }               
+        
+}
+
+void LLFloaterWindLight::initHelpBtn(const char* name, const char* xml_alert)
+{
+        childSetAction(name, onClickHelp, (void*)xml_alert);
+}
+
+void LLFloaterWindLight::newPromptCallback(S32 option, const LLString& text, void* userData)
+{
+        if(text == "")
+        {
+                return;
+        }
+
+        if(option == 0) {
+                LLComboBox* comboBox = LLUICtrlFactory::getComboBoxByName(sWindLight, 
+                        "WLPresetsCombo");
+
+                LLFloaterDayCycle* sDayCycle = NULL;
+                LLComboBox* keyCombo = NULL;
+                if(LLFloaterDayCycle::isOpen()) 
+                {
+                        sDayCycle = LLFloaterDayCycle::instance();
+                        keyCombo = LLUICtrlFactory::getComboBoxByName(sDayCycle, 
+                                "WLKeyPresets");
+                }
+
+                // add the current parameters to the list
+                // see if it's there first
+                std::map<std::string, LLWLParamSet>::iterator mIt = 
+                        LLWLParamManager::instance()->mParamList.find(text.c_str());
+
+                // if not there, add a new one
+                if(mIt == LLWLParamManager::instance()->mParamList.end()) 
+                {
+                        LLWLParamManager::instance()->addParamSet(text.c_str(), 
+                                LLWLParamManager::instance()->mCurParams);
+                        comboBox->add(text);
+                        comboBox->sortByName();
+
+                        // add a blank to the bottom
+                        comboBox->selectFirstItem();
+                        if(comboBox->getSimple() == "")
+                        {
+                                comboBox->remove(0);
+                        }
+                        comboBox->add("");
+
+                        comboBox->setSelectedByValue(text, true);
+                        if(LLFloaterDayCycle::isOpen()) 
+                        {
+                                keyCombo->add(text);
+                                keyCombo->sortByName();
+                        }
+                        LLWLParamManager::instance()->savePreset(text);
+
+                // otherwise, send a message to the user
+                } 
+                else 
+                {
+                        gViewerWindow->alertXml("ExistsSkyPresetAlert");
+                }
+        }
+}
+
+void LLFloaterWindLight::syncMenu()
+{
+        bool err;
+
+        LLWLParamManager * param_mgr = LLWLParamManager::instance();
+
+        LLWLParamSet& currentParams = param_mgr->mCurParams;
+        //std::map<std::string, LLVector4> & currentParams = param_mgr->mCurParams.mParamValues;
+
+        // blue horizon
+        param_mgr->mBlueHorizon = currentParams.getVector(param_mgr->mBlueHorizon.name, err);
+        childSetValue("WLBlueHorizonR", param_mgr->mBlueHorizon.r / 2.0);
+        childSetValue("WLBlueHorizonG", param_mgr->mBlueHorizon.g / 2.0);
+        childSetValue("WLBlueHorizonB", param_mgr->mBlueHorizon.b / 2.0);
+        childSetValue("WLBlueHorizonI", 
+                std::max(param_mgr->mBlueHorizon.r / 2.0, 
+                        std::max(param_mgr->mBlueHorizon.g / 2.0, 
+                                param_mgr->mBlueHorizon.b / 2.0)));
+
+        // haze density, horizon, mult, and altitude
+        param_mgr->mHazeDensity = currentParams.getVector(param_mgr->mHazeDensity.name, err);
+        childSetValue("WLHazeDensity", param_mgr->mHazeDensity.r);
+        param_mgr->mHazeHorizon = currentParams.getVector(param_mgr->mHazeHorizon.name, err);
+        childSetValue("WLHazeHorizon", param_mgr->mHazeHorizon.r);
+        param_mgr->mDensityMult = currentParams.getVector(param_mgr->mDensityMult.name, err);
+        childSetValue("WLDensityMult", param_mgr->mDensityMult.x * 
+                param_mgr->mDensityMult.mult);
+        param_mgr->mMaxAlt = currentParams.getVector(param_mgr->mMaxAlt.name, err);
+        childSetValue("WLMaxAltitude", param_mgr->mMaxAlt.x);
+
+        // blue density
+        param_mgr->mBlueDensity = currentParams.getVector(param_mgr->mBlueDensity.name, err);
+        childSetValue("WLBlueDensityR", param_mgr->mBlueDensity.r / 2.0);
+        childSetValue("WLBlueDensityG", param_mgr->mBlueDensity.g / 2.0);
+        childSetValue("WLBlueDensityB", param_mgr->mBlueDensity.b / 2.0);
+        childSetValue("WLBlueDensityI", 
+                std::max(param_mgr->mBlueDensity.r / 2.0, 
+                std::max(param_mgr->mBlueDensity.g / 2.0, param_mgr->mBlueDensity.b / 2.0)));
+
+        // Lighting
+        
+        // sunlight
+        param_mgr->mSunlight = currentParams.getVector(param_mgr->mSunlight.name, err);
+        childSetValue("WLSunlightR", param_mgr->mSunlight.r / WL_SUN_AMBIENT_SLIDER_SCALE);
+        childSetValue("WLSunlightG", param_mgr->mSunlight.g / WL_SUN_AMBIENT_SLIDER_SCALE);
+        childSetValue("WLSunlightB", param_mgr->mSunlight.b / WL_SUN_AMBIENT_SLIDER_SCALE);
+        childSetValue("WLSunlightI", 
+                std::max(param_mgr->mSunlight.r / WL_SUN_AMBIENT_SLIDER_SCALE, 
+                std::max(param_mgr->mSunlight.g / WL_SUN_AMBIENT_SLIDER_SCALE, param_mgr->mSunlight.b / WL_SUN_AMBIENT_SLIDER_SCALE)));
+
+        // glow
+        param_mgr->mGlow = currentParams.getVector(param_mgr->mGlow.name, err);
+        childSetValue("WLGlowR", 2 - param_mgr->mGlow.r / 20.0f);
+        childSetValue("WLGlowB", -param_mgr->mGlow.b / 5.0f);
+                
+        // ambient
+        param_mgr->mAmbient = currentParams.getVector(param_mgr->mAmbient.name, err);
+        childSetValue("WLAmbientR", param_mgr->mAmbient.r / WL_SUN_AMBIENT_SLIDER_SCALE);
+        childSetValue("WLAmbientG", param_mgr->mAmbient.g / WL_SUN_AMBIENT_SLIDER_SCALE);
+        childSetValue("WLAmbientB", param_mgr->mAmbient.b / WL_SUN_AMBIENT_SLIDER_SCALE);
+        childSetValue("WLAmbientI", 
+                std::max(param_mgr->mAmbient.r / WL_SUN_AMBIENT_SLIDER_SCALE, 
+                std::max(param_mgr->mAmbient.g / WL_SUN_AMBIENT_SLIDER_SCALE, param_mgr->mAmbient.b / WL_SUN_AMBIENT_SLIDER_SCALE)));           
+
+        childSetValue("WLSunAngle", param_mgr->mCurParams.getFloat("sun_angle",err) / F_TWO_PI);
+        childSetValue("WLEastAngle", param_mgr->mCurParams.getFloat("east_angle",err) / F_TWO_PI);
+
+        // Clouds
+
+        // Cloud Color
+        param_mgr->mCloudColor = currentParams.getVector(param_mgr->mCloudColor.name, err);
+        childSetValue("WLCloudColorR", param_mgr->mCloudColor.r);
+        childSetValue("WLCloudColorG", param_mgr->mCloudColor.g);
+        childSetValue("WLCloudColorB", param_mgr->mCloudColor.b);
+        childSetValue("WLCloudColorI", 
+                std::max(param_mgr->mCloudColor.r, 
+                std::max(param_mgr->mCloudColor.g, param_mgr->mCloudColor.b)));
+
+        // Cloud
+        param_mgr->mCloudMain = currentParams.getVector(param_mgr->mCloudMain.name, err);
+        childSetValue("WLCloudX", param_mgr->mCloudMain.r);
+        childSetValue("WLCloudY", param_mgr->mCloudMain.g);
+        childSetValue("WLCloudDensity", param_mgr->mCloudMain.b);
+
+        // Cloud Detail
+        param_mgr->mCloudDetail = currentParams.getVector(param_mgr->mCloudDetail.name, err);
+        childSetValue("WLCloudDetailX", param_mgr->mCloudDetail.r);
+        childSetValue("WLCloudDetailY", param_mgr->mCloudDetail.g);
+        childSetValue("WLCloudDetailDensity", param_mgr->mCloudDetail.b);
+
+        // Cloud extras
+        param_mgr->mCloudCoverage = currentParams.getVector(param_mgr->mCloudCoverage.name, err);
+        param_mgr->mCloudScale = currentParams.getVector(param_mgr->mCloudScale.name, err);
+        childSetValue("WLCloudCoverage", param_mgr->mCloudCoverage.x);
+        childSetValue("WLCloudScale", param_mgr->mCloudScale.x);
+
+        // cloud scrolling
+        bool lockX = !param_mgr->mCurParams.getEnableCloudScrollX();
+        bool lockY = !param_mgr->mCurParams.getEnableCloudScrollY();
+        childSetValue("WLCloudLockX", lockX);
+        childSetValue("WLCloudLockY", lockY);
+        childSetValue("DrawClassicClouds", gSavedSettings.getBOOL("SkyUseClassicClouds"));
+        
+        // disable if locked, enable if not
+        if(lockX) 
+        {
+                childDisable("WLCloudScrollX");
+        } else {
+                childEnable("WLCloudScrollX");
+        }
+        if(lockY)
+        {
+                childDisable("WLCloudScrollY");
+        } else {
+                childEnable("WLCloudScrollY");
+        }
+
+        // *HACK cloud scrolling is off my an additive of 10
+        childSetValue("WLCloudScrollX", param_mgr->mCurParams.getCloudScrollX() - 10.0f);
+        childSetValue("WLCloudScrollY", param_mgr->mCurParams.getCloudScrollY() - 10.0f);
+
+        param_mgr->mDistanceMult = currentParams.getVector(param_mgr->mDistanceMult.name, err);
+        childSetValue("WLDistanceMult", param_mgr->mDistanceMult.x);
+
+        // Tweak extras
+
+        param_mgr->mWLGamma = currentParams.getVector(param_mgr->mWLGamma.name, err);
+        childSetValue("WLGamma", param_mgr->mWLGamma.x);
+
+        childSetValue("WLStarAlpha", param_mgr->mCurParams.getStarBrightness());
+}
+
+
+// static
+LLFloaterWindLight* LLFloaterWindLight::instance()
+{
+        if (!sWindLight)
+        {
+                sWindLight = new LLFloaterWindLight();
+                sWindLight->open();
+                sWindLight->setFocus(TRUE);
+        }
+        return sWindLight;
+}
+void LLFloaterWindLight::show()
+{
+        LLFloaterWindLight* windLight = instance();
+        windLight->syncMenu();
+
+        // comment in if you want the menu to rebuild each time
+        //gUICtrlFactory->buildFloater(windLight, "floater_windlight_options.xml");
+        //windLight->initCallbacks();
+
+        windLight->open();
+}
+
+bool LLFloaterWindLight::isOpen()
+{
+        if (sWindLight != NULL) {
+                return true;
+        }
+        return false;
+}
+
+// virtual
+void LLFloaterWindLight::onClose(bool app_quitting)
+{
+        if (sWindLight)
+        {
+                sWindLight->setVisible(FALSE);
+        }
+}
+
+// color control callbacks
+void LLFloaterWindLight::onColorControlRMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
+        WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
+
+        colorControl->r = sldrCtrl->getValueF32();
+        if(colorControl->isSunOrAmbientColor) {
+                colorControl->r *= 3;
+        }
+        if(colorControl->isBlueHorizonOrDensity) {
+                colorControl->r *= 2;
+        }       
+
+        // move i if it's the max
+        if(colorControl->r >= colorControl->g && colorControl->r >= colorControl->b 
+                && colorControl->hasSliderName) {
+                colorControl->i = colorControl->r;
+                std::string name = colorControl->mSliderName;
+                name.append("I");
+                
+                if(colorControl->isSunOrAmbientColor) {
+                        sWindLight->childSetValue(name, colorControl->r / 3);
+                } else if(colorControl->isBlueHorizonOrDensity) {
+                        sWindLight->childSetValue(name, colorControl->r / 2);
+                } else {
+                        sWindLight->childSetValue(name, colorControl->r);
+                }
+        }
+
+        colorControl->update(LLWLParamManager::instance()->mCurParams);
+
+        LLWLParamManager::instance()->propagateParameters();
+}
+
+void LLFloaterWindLight::onColorControlGMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
+        WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
+
+        colorControl->g = sldrCtrl->getValueF32();
+        if(colorControl->isSunOrAmbientColor) {
+                colorControl->g *= 3;
+        }
+        if(colorControl->isBlueHorizonOrDensity) {
+                colorControl->g *= 2;
+        }       
+
+        // move i if it's the max
+        if(colorControl->g >= colorControl->r && colorControl->g >= colorControl->b
+                && colorControl->hasSliderName) {
+                colorControl->i = colorControl->g;
+                std::string name = colorControl->mSliderName;
+                name.append("I");
+
+                if(colorControl->isSunOrAmbientColor) {
+                        sWindLight->childSetValue(name, colorControl->g / 3);
+                } else if(colorControl->isBlueHorizonOrDensity) {
+                        sWindLight->childSetValue(name, colorControl->g / 2);
+                } else {
+                        sWindLight->childSetValue(name, colorControl->g);
+                }
+        }
+
+        colorControl->update(LLWLParamManager::instance()->mCurParams);
+
+        LLWLParamManager::instance()->propagateParameters();
+}
+
+void LLFloaterWindLight::onColorControlBMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
+        WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
+
+        colorControl->b = sldrCtrl->getValueF32();
+        if(colorControl->isSunOrAmbientColor) {
+                colorControl->b *= 3;
+        }
+        if(colorControl->isBlueHorizonOrDensity) {
+                colorControl->b *= 2;
+        }       
+
+        // move i if it's the max
+        if(colorControl->b >= colorControl->r && colorControl->b >= colorControl->g
+                && colorControl->hasSliderName) {
+                colorControl->i = colorControl->b;
+                std::string name = colorControl->mSliderName;
+                name.append("I");
+
+                if(colorControl->isSunOrAmbientColor) {
+                        sWindLight->childSetValue(name, colorControl->b / 3);
+                } else if(colorControl->isBlueHorizonOrDensity) {
+                        sWindLight->childSetValue(name, colorControl->b / 2);
+                } else {
+                        sWindLight->childSetValue(name, colorControl->b);
+                }
+        }
+
+        colorControl->update(LLWLParamManager::instance()->mCurParams);
+
+        LLWLParamManager::instance()->propagateParameters();
+}
+
+void LLFloaterWindLight::onColorControlIMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
+        WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
+
+        colorControl->i = sldrCtrl->getValueF32();
+        
+        // only for sliders where we pass a name
+        if(colorControl->hasSliderName) {
+                
+                // set it to the top
+                F32 maxVal = std::max(std::max(colorControl->r, colorControl->g), colorControl->b);
+                F32 iVal;
+
+                if(colorControl->isSunOrAmbientColor)
+                {
+                        iVal = colorControl->i * 3;
+                } 
+                else if(colorControl->isBlueHorizonOrDensity)
+                {
+                        iVal = colorControl->i * 2;
+                } 
+                else 
+                {
+                        iVal = colorControl->i;
+                }
+
+                // get the names of the other sliders
+                std::string rName = colorControl->mSliderName;
+                rName.append("R");
+                std::string gName = colorControl->mSliderName;
+                gName.append("G");
+                std::string bName = colorControl->mSliderName;
+                bName.append("B");
+
+                // handle if at 0
+                if(iVal == 0) {
+                        colorControl->r = 0;
+                        colorControl->g = 0;
+                        colorControl->b = 0;
+                
+                // if all at the start
+                // set them all to the intensity
+                } else if (maxVal == 0) {
+                        colorControl->r = iVal;
+                        colorControl->g = iVal;
+                        colorControl->b = iVal;
+
+                } else {
+
+                        // add delta amounts to each
+                        F32 delta = (iVal - maxVal) / maxVal;
+                        colorControl->r *= (1.0f + delta);
+                        colorControl->g *= (1.0f + delta);
+                        colorControl->b *= (1.0f + delta);
+                }
+
+                // divide sun color vals by three
+                if(colorControl->isSunOrAmbientColor) 
+                {
+                        sWindLight->childSetValue(rName.c_str(), colorControl->r/3);
+                        sWindLight->childSetValue(gName.c_str(), colorControl->g/3);
+                        sWindLight->childSetValue(bName.c_str(), colorControl->b/3);    
+                
+                } 
+                else if(colorControl->isBlueHorizonOrDensity) 
+                {
+                        sWindLight->childSetValue(rName.c_str(), colorControl->r/2);
+                        sWindLight->childSetValue(gName.c_str(), colorControl->g/2);
+                        sWindLight->childSetValue(bName.c_str(), colorControl->b/2);    
+                
+                } 
+                else 
+                {
+                        // set the sliders to the new vals
+                        sWindLight->childSetValue(rName.c_str(), colorControl->r);
+                        sWindLight->childSetValue(gName.c_str(), colorControl->g);
+                        sWindLight->childSetValue(bName.c_str(), colorControl->b);
+                }
+        }
+
+        // now update the current parameters and send them to shaders
+        colorControl->update(LLWLParamManager::instance()->mCurParams);
+        LLWLParamManager::instance()->propagateParameters();
+}
+
+/// GLOW SPECIFIC CODE
+void LLFloaterWindLight::onGlowRMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
+        WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
+
+        // scaled by 20
+        colorControl->r = (2 - sldrCtrl->getValueF32()) * 20;
+
+        colorControl->update(LLWLParamManager::instance()->mCurParams);
+        LLWLParamManager::instance()->propagateParameters();
+}
+
+/// \NOTE that we want NEGATIVE (-) B
+void LLFloaterWindLight::onGlowBMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
+        WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
+
+        /// \NOTE that we want NEGATIVE (-) B and NOT by 20 as 20 is too big
+        colorControl->b = -sldrCtrl->getValueF32() * 5;
+
+        colorControl->update(LLWLParamManager::instance()->mCurParams);
+        LLWLParamManager::instance()->propagateParameters();
+}
+
+void LLFloaterWindLight::onFloatControlMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
+        WLFloatControl * floatControl = static_cast<WLFloatControl *>(userData);
+
+        floatControl->x = sldrCtrl->getValueF32() / floatControl->mult;
+
+        floatControl->update(LLWLParamManager::instance()->mCurParams);
+        LLWLParamManager::instance()->propagateParameters();
+}
+
+void LLFloaterWindLight::onBoolToggle(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLCheckBoxCtrl* cbCtrl = static_cast<LLCheckBoxCtrl*>(ctrl);
+
+        bool value = cbCtrl->get();
+        (*(static_cast<BOOL *>(userData))) = value;
+}
+
+
+// Lighting callbacks
+
+// time of day
+void LLFloaterWindLight::onSunMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sunSldr = LLUICtrlFactory::getSliderByName(sWindLight, 
+                "WLSunAngle");
+        LLSliderCtrl* eastSldr = LLUICtrlFactory::getSliderByName(sWindLight, 
+                "WLEastAngle");
+
+        WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
+        
+        // get the two angles
+        LLWLParamManager * param_mgr = LLWLParamManager::instance();
+
+        param_mgr->mCurParams.setSunAngle(F_TWO_PI * sunSldr->getValueF32());
+        param_mgr->mCurParams.setEastAngle(F_TWO_PI * eastSldr->getValueF32());
+
+        // set the sun vector
+        colorControl->r = -sin(param_mgr->mCurParams.getEastAngle()) * 
+                cos(param_mgr->mCurParams.getSunAngle());
+        colorControl->g = sin(param_mgr->mCurParams.getSunAngle());
+        colorControl->b = cos(param_mgr->mCurParams.getEastAngle()) * 
+                cos(param_mgr->mCurParams.getSunAngle());
+        colorControl->i = 1.f;
+
+        colorControl->update(param_mgr->mCurParams);
+        param_mgr->propagateParameters();
+}
+
+void LLFloaterWindLight::onFloatTweakMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
+        F32 * tweak = static_cast<F32 *>(userData);
+
+        (*tweak) = sldrCtrl->getValueF32();
+        LLWLParamManager::instance()->propagateParameters();
+}
+
+void LLFloaterWindLight::onStarAlphaMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
+
+        LLWLParamManager::instance()->mCurParams.setStarBrightness(sldrCtrl->getValueF32());
+}
+
+void LLFloaterWindLight::onNewPreset(void* userData)
+{
+        gViewerWindow->alertXmlEditText("NewSkyPreset", LLString::format_map_t(), 
+                NULL, NULL, newPromptCallback, NULL);
+}
+
+void LLFloaterWindLight::onSavePreset(void* userData)
+{
+        // get the name
+        LLComboBox* comboBox = LLUICtrlFactory::getComboBoxByName(sWindLight, 
+                "WLPresetsCombo");
+
+        // don't save the empty name
+        if(comboBox->getSelectedItemLabel() == "")
+        {
+                return;
+        }
+
+        // check to see if it's a default and shouldn't be overwritten
+        std::set<std::string>::iterator sIt = sDefaultPresets.find(
+                comboBox->getSelectedItemLabel().c_str());
+        if(sIt != sDefaultPresets.end() && !gSavedSettings.getBOOL("SkyEditPresets")) 
+        {
+                gViewerWindow->alertXml("WLNoEditDefault");
+                return;
+        }
+
+        LLWLParamManager::instance()->mCurParams.mName = 
+                comboBox->getSelectedItemLabel();
+
+        gViewerWindow->alertXml("WLSavePresetAlert", saveAlertCallback, sWindLight);
+}
+
+void LLFloaterWindLight::saveAlertCallback(S32 option, void* userdata)
+{
+        // if they choose save, do it.  Otherwise, don't do anything
+        if(option == 0) 
+        {
+                LLWLParamManager * param_mgr = LLWLParamManager::instance();
+
+                param_mgr->setParamSet(param_mgr->mCurParams.mName, param_mgr->mCurParams);
+                
+                // comment this back in to save to file
+                param_mgr->savePreset(param_mgr->mCurParams.mName);
+        }
+
+}
+
+void LLFloaterWindLight::onDeletePreset(void* userData)
+{
+        LLComboBox* combo_box = LLUICtrlFactory::getComboBoxByName(sWindLight, 
+                "WLPresetsCombo");
+
+        if(combo_box->getSelectedValue().asString() == "")
+        {
+                return;
+        }
+
+        LLString::format_map_t args;
+        args["[SKY]"] = combo_box->getSelectedValue().asString();
+        gViewerWindow->alertXml("WLDeletePresetAlert", args, deleteAlertCallback, sWindLight);
+}
+
+void LLFloaterWindLight::deleteAlertCallback(S32 option, void* userdata)
+{
+        // if they choose delete, do it.  Otherwise, don't do anything
+        if(option == 0) 
+        {
+                LLComboBox* combo_box = LLUICtrlFactory::getComboBoxByName(sWindLight, 
+                        "WLPresetsCombo");
+                LLFloaterDayCycle* day_cycle = NULL;
+                LLComboBox* key_combo = NULL;
+                LLMultiSliderCtrl* mult_sldr = NULL;
+
+                if(LLFloaterDayCycle::isOpen()) 
+                {
+                        day_cycle = LLFloaterDayCycle::instance();
+                        key_combo = LLUICtrlFactory::getComboBoxByName(day_cycle, 
+                                "WLKeyPresets");
+                        mult_sldr = LLUICtrlFactory::getMultiSliderByName(day_cycle, 
+                                "WLDayCycleKeys");
+                }
+
+                LLString name(combo_box->getSelectedValue().asString());
+
+                // check to see if it's a default and shouldn't be deleted
+                std::set<std::string>::iterator sIt = sDefaultPresets.find(name.c_str());
+                if(sIt != sDefaultPresets.end()) 
+                {
+                        gViewerWindow->alertXml("WLNoEditDefault");
+                        return;
+                }
+
+                LLWLParamManager::instance()->removeParamSet(name, true);
+                
+                // remove and choose another
+                S32 new_index = combo_box->getCurrentIndex();
+
+                combo_box->remove(name);
+                if(key_combo != NULL) 
+                {
+                        key_combo->remove(name);
+
+                        // remove from slider, as well
+                        day_cycle->deletePreset(name);
+                }
+
+                // pick the previously selected index after delete
+                if(new_index > 0) 
+                {
+                        new_index--;
+                }
+                
+                if(combo_box->getItemCount() > 0) 
+                {
+                        combo_box->setCurrentByIndex(new_index);
+                }
+        }
+}
+
+
+void LLFloaterWindLight::onChangePresetName(LLUICtrl* ctrl, void * userData)
+{
+        deactivateAnimator();
+
+        LLComboBox * combo_box = static_cast<LLComboBox*>(ctrl);
+        
+        if(combo_box->getSimple() == "")
+        {
+                return;
+        }
+        
+        LLWLParamManager::instance()->loadPreset(
+                combo_box->getSelectedValue().asString());
+        sWindLight->syncMenu();
+}
+
+void LLFloaterWindLight::onOpenDayCycle(void* userData)
+{
+        LLFloaterDayCycle::show();
+}
+
+// Clouds
+void LLFloaterWindLight::onCloudScrollXMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
+        // *HACK  all cloud scrolling is off by an additive of 10. 
+        LLWLParamManager::instance()->mCurParams.setCloudScrollX(sldrCtrl->getValueF32() + 10.0f);
+}
+
+void LLFloaterWindLight::onCloudScrollYMoved(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
+
+        // *HACK  all cloud scrolling is off by an additive of 10. 
+        LLWLParamManager::instance()->mCurParams.setCloudScrollY(sldrCtrl->getValueF32() + 10.0f);
+}
+
+void LLFloaterWindLight::onCloudScrollXToggled(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLCheckBoxCtrl* cbCtrl = static_cast<LLCheckBoxCtrl*>(ctrl);
+
+        bool lock = cbCtrl->get();
+        LLWLParamManager::instance()->mCurParams.setEnableCloudScrollX(!lock);
+
+        LLSliderCtrl* sldr = LLUICtrlFactory::getSliderByName(sWindLight, 
+                "WLCloudScrollX");
+
+        if(cbCtrl->get()) 
+        {
+                sldr->setEnabled(false);
+        } 
+        else 
+        {
+                sldr->setEnabled(true);
+        }
+
+}
+
+void LLFloaterWindLight::onCloudScrollYToggled(LLUICtrl* ctrl, void* userData)
+{
+        deactivateAnimator();
+
+        LLCheckBoxCtrl* cbCtrl = static_cast<LLCheckBoxCtrl*>(ctrl);
+        bool lock = cbCtrl->get();
+        LLWLParamManager::instance()->mCurParams.setEnableCloudScrollY(!lock);
+
+        LLSliderCtrl* sldr = LLUICtrlFactory::getSliderByName(sWindLight, 
+                "WLCloudScrollY");
+
+        if(cbCtrl->get()) 
+        {
+                sldr->setEnabled(false);
+        } 
+        else 
+        {
+                sldr->setEnabled(true);
+        }
+}
+
+void LLFloaterWindLight::deactivateAnimator()
+{
+        LLWLParamManager::instance()->mAnimator.mIsRunning = false;
+        LLWLParamManager::instance()->mAnimator.mUseLindenTime = false;
+}