Merge branch 'master' into DRTVWR-500

# Conflicts:
#	indra/newview/pipeline.cpp

1 files changed, 242 insertions, 465 deletions

diff --git a/indra/newview/llfloatereditsky.cpp b/indra/newview/llfloatereditsky.cpp
index d809211ea7..6bdc5ee823 100644
--- a/indra/newview/llfloatereditsky.cpp
+++ b/indra/newview/llfloatereditsky.cpp
@@ -28,6 +28,8 @@
 
 #include "llfloatereditsky.h"
 
+#include <boost/make_shared.hpp>
+
 // libs
 #include "llbutton.h"
 #include "llcheckboxctrl.h"
@@ -38,6 +40,7 @@
 #include "llsliderctrl.h"
 #include "lltabcontainer.h"
 #include "lltimectrl.h"
+#include "lljoystickbutton.h"
 
 // newview
 #include "llagent.h"
@@ -45,15 +48,18 @@
 #include "llregioninfomodel.h"
 #include "llviewerregion.h"
 
-static const F32 WL_SUN_AMBIENT_SLIDER_SCALE = 3.0f;
-static const F32 WL_BLUE_HORIZON_DENSITY_SCALE = 2.0f;
-static const F32 WL_CLOUD_SLIDER_SCALE = 1.0f;
+#include "v3colorutil.h"
+#include "llenvironment.h"
+#include "llenvadapters.h"
 
-static F32 sun_pos_to_time24(F32 sun_pos)
+namespace
 {
-	return fmodf(sun_pos * 24.0f + 6, 24.0f);
+    const F32 WL_SUN_AMBIENT_SLIDER_SCALE(3.0f);
+    const F32 WL_BLUE_HORIZON_DENSITY_SCALE(2.0f);
+    const F32 WL_CLOUD_SLIDER_SCALE(1.0f);
 }
 
+
 static F32 time24_to_sun_pos(F32 time24)
 {
 	F32 sun_pos = fmodf((time24 - 6) / 24.0f, 1.0f);
@@ -61,12 +67,13 @@ static F32 time24_to_sun_pos(F32 time24)
 	return sun_pos;
 }
 
-LLFloaterEditSky::LLFloaterEditSky(const LLSD &key)
-:	LLFloater(key)
-,	mSkyPresetNameEditor(NULL)
-,	mSkyPresetCombo(NULL)
-,	mMakeDefaultCheckBox(NULL)
-,	mSaveButton(NULL)
+LLFloaterEditSky::LLFloaterEditSky(const LLSD &key):	
+    LLFloater(key),	
+    mSkyPresetNameEditor(NULL),	
+    mSkyPresetCombo(NULL),	
+    mMakeDefaultCheckBox(NULL),	
+    mSaveButton(NULL),
+    mSkyAdapter()
 {
 }
 
@@ -77,11 +84,14 @@ BOOL LLFloaterEditSky::postBuild()
 	mSkyPresetCombo = getChild<LLComboBox>("sky_preset_combo");
 	mMakeDefaultCheckBox = getChild<LLCheckBoxCtrl>("make_default_cb");
 	mSaveButton = getChild<LLButton>("save");
+    mSkyAdapter = boost::make_shared<LLSkySettingsAdapter>();
+
+    LLEnvironment::instance().setSkyListChange(boost::bind(&LLFloaterEditSky::onSkyPresetListChange, this));
 
 	initCallbacks();
 
-	// Create the sun position scrubber on the slider.
-	getChild<LLMultiSliderCtrl>("WLSunPos")->addSlider(12.f);
+// 	// Create the sun position scrubber on the slider.
+// 	getChild<LLMultiSliderCtrl>("WLSunPos")->addSlider(12.f);
 
 	return TRUE;
 }
@@ -115,7 +125,8 @@ void LLFloaterEditSky::onClose(bool app_quitting)
 {
 	if (!app_quitting) // there's no point to change environment if we're quitting
 	{
-		LLEnvManagerNew::instance().usePrefs(); // revert changes made to current environment
+        LLEnvironment::instance().clearEnvironment(LLEnvironment::ENV_EDIT);
+        LLEnvironment::instance().setSelectedEnvironment(LLEnvironment::ENV_LOCAL);
 	}
 }
 
@@ -137,71 +148,47 @@ void LLFloaterEditSky::initCallbacks(void)
 	mSaveButton->setCommitCallback(boost::bind(&LLFloaterEditSky::onBtnSave, this));
 	getChild<LLButton>("cancel")->setCommitCallback(boost::bind(&LLFloaterEditSky::onBtnCancel, this));
 
-	LLEnvManagerNew::instance().setRegionSettingsChangeCallback(boost::bind(&LLFloaterEditSky::onRegionSettingsChange, this));
-	LLWLParamManager::instance().setPresetListChangeCallback(boost::bind(&LLFloaterEditSky::onSkyPresetListChange, this));
-
 	// Connect to region info updates.
 	LLRegionInfoModel::instance().setUpdateCallback(boost::bind(&LLFloaterEditSky::onRegionInfoUpdate, this));
 
-	//-------------------------------------------------------------------------
-
-	LLWLParamManager& param_mgr = LLWLParamManager::instance();
-
-	// blue horizon
-	getChild<LLUICtrl>("WLBlueHorizon")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &param_mgr.mBlueHorizon));
-
-	// haze density, horizon, mult, and altitude
-	getChild<LLUICtrl>("WLHazeDensity")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &param_mgr.mHazeDensity));
-	getChild<LLUICtrl>("WLHazeHorizon")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &param_mgr.mHazeHorizon));
-	getChild<LLUICtrl>("WLDensityMult")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &param_mgr.mDensityMult));
-	getChild<LLUICtrl>("WLMaxAltitude")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &param_mgr.mMaxAlt));
-
-	// blue density
-	getChild<LLUICtrl>("WLBlueDensity")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &param_mgr.mBlueDensity));
-
-	// Lighting
-
 	// sunlight
-	getChild<LLUICtrl>("WLSunlight")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &param_mgr.mSunlight));
+    getChild<LLUICtrl>("WLSunlight")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &mSkyAdapter->mSunlight));
 
 	// glow
-	getChild<LLUICtrl>("WLGlowR")->setCommitCallback(boost::bind(&LLFloaterEditSky::onGlowRMoved, this, _1, &param_mgr.mGlow));
-	getChild<LLUICtrl>("WLGlowB")->setCommitCallback(boost::bind(&LLFloaterEditSky::onGlowBMoved, this, _1, &param_mgr.mGlow));
-
-	// ambient
-	getChild<LLUICtrl>("WLAmbient")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &param_mgr.mAmbient));
+    getChild<LLUICtrl>("WLGlowR")->setCommitCallback(boost::bind(&LLFloaterEditSky::onGlowRMoved, this, _1, &mSkyAdapter->mGlow));
+    getChild<LLUICtrl>("WLGlowB")->setCommitCallback(boost::bind(&LLFloaterEditSky::onGlowBMoved, this, _1, &mSkyAdapter->mGlow));
 
 	// time of day
-	getChild<LLUICtrl>("WLSunPos")->setCommitCallback(boost::bind(&LLFloaterEditSky::onSunMoved, this, _1, &param_mgr.mLightnorm));     // multi-slider
-	getChild<LLTimeCtrl>("WLDayTime")->setCommitCallback(boost::bind(&LLFloaterEditSky::onTimeChanged, this));                          // time ctrl
-	getChild<LLUICtrl>("WLEastAngle")->setCommitCallback(boost::bind(&LLFloaterEditSky::onSunMoved, this, _1, &param_mgr.mLightnorm));
+//     getChild<LLUICtrl>("WLSunPos")->setCommitCallback(boost::bind(&LLFloaterEditSky::onSunMoved, this, _1, &mSkyAdapter->mLightnorm));     // multi-slider
+// 	getChild<LLTimeCtrl>("WLDayTime")->setCommitCallback(boost::bind(&LLFloaterEditSky::onTimeChanged, this));                          // time ctrl
+//     getChild<LLUICtrl>("WLEastAngle")->setCommitCallback(boost::bind(&LLFloaterEditSky::onSunMoved, this, _1, &mSkyAdapter->mLightnorm));
+    getChild<LLJoystickQuaternion>("WLSunRotation")->setCommitCallback(boost::bind(&LLFloaterEditSky::onSunRotationChanged, this));
+    getChild<LLJoystickQuaternion>("WLMoonRotation")->setCommitCallback(boost::bind(&LLFloaterEditSky::onMoonRotationChanged, this));
 
 	// Clouds
 
 	// Cloud Color
-	getChild<LLUICtrl>("WLCloudColor")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &param_mgr.mCloudColor));
+    getChild<LLUICtrl>("WLCloudColor")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &mSkyAdapter->mCloudColor));
 
 	// Cloud
-	getChild<LLUICtrl>("WLCloudX")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlRMoved, this, _1, &param_mgr.mCloudMain));
-	getChild<LLUICtrl>("WLCloudY")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlGMoved, this, _1, &param_mgr.mCloudMain));
-	getChild<LLUICtrl>("WLCloudDensity")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlBMoved, this, _1, &param_mgr.mCloudMain));
+    getChild<LLUICtrl>("WLCloudX")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlRMoved, this, _1, &mSkyAdapter->mCloudMain));
+    getChild<LLUICtrl>("WLCloudY")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlGMoved, this, _1, &mSkyAdapter->mCloudMain));
+    getChild<LLUICtrl>("WLCloudDensity")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlBMoved, this, _1, &mSkyAdapter->mCloudMain));
 
 	// Cloud Detail
-	getChild<LLUICtrl>("WLCloudDetailX")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlRMoved, this, _1, &param_mgr.mCloudDetail));
-	getChild<LLUICtrl>("WLCloudDetailY")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlGMoved, this, _1, &param_mgr.mCloudDetail));
-	getChild<LLUICtrl>("WLCloudDetailDensity")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlBMoved, this, _1, &param_mgr.mCloudDetail));
+    getChild<LLUICtrl>("WLCloudDetailX")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlRMoved, this, _1, &mSkyAdapter->mCloudDetail));
+    getChild<LLUICtrl>("WLCloudDetailY")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlGMoved, this, _1, &mSkyAdapter->mCloudDetail));
+    getChild<LLUICtrl>("WLCloudDetailDensity")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlBMoved, this, _1, &mSkyAdapter->mCloudDetail));
 
 	// Cloud extras
-	getChild<LLUICtrl>("WLCloudCoverage")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &param_mgr.mCloudCoverage));
-	getChild<LLUICtrl>("WLCloudScale")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &param_mgr.mCloudScale));
-	getChild<LLUICtrl>("WLCloudLockX")->setCommitCallback(boost::bind(&LLFloaterEditSky::onCloudScrollXToggled, this, _1));
-	getChild<LLUICtrl>("WLCloudLockY")->setCommitCallback(boost::bind(&LLFloaterEditSky::onCloudScrollYToggled, this, _1));
+    getChild<LLUICtrl>("WLCloudCoverage")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &mSkyAdapter->mCloudCoverage));
+    getChild<LLUICtrl>("WLCloudScale")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &mSkyAdapter->mCloudScale));
 	getChild<LLUICtrl>("WLCloudScrollX")->setCommitCallback(boost::bind(&LLFloaterEditSky::onCloudScrollXMoved, this, _1));
 	getChild<LLUICtrl>("WLCloudScrollY")->setCommitCallback(boost::bind(&LLFloaterEditSky::onCloudScrollYMoved, this, _1));
-	getChild<LLUICtrl>("WLDistanceMult")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &param_mgr.mDistanceMult));
+    
 
 	// Dome
-	getChild<LLUICtrl>("WLGamma")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &param_mgr.mWLGamma));
+    getChild<LLUICtrl>("WLGamma")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &mSkyAdapter->mWLGamma));
 	getChild<LLUICtrl>("WLStarAlpha")->setCommitCallback(boost::bind(&LLFloaterEditSky::onStarAlphaMoved, this, _1));
 }
 
@@ -209,320 +196,229 @@ void LLFloaterEditSky::initCallbacks(void)
 
 void LLFloaterEditSky::syncControls()
 {
-	bool err;
-
-	LLWLParamManager * param_mgr = LLWLParamManager::getInstance();
-
-	LLWLParamSet& cur_params = param_mgr->mCurParams;
+    LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
+    mEditSettings = psky;
 
-	// blue horizon
-	param_mgr->mBlueHorizon = cur_params.getVector(param_mgr->mBlueHorizon.mName, err);
-	setColorSwatch("WLBlueHorizon", param_mgr->mBlueHorizon, WL_BLUE_HORIZON_DENSITY_SCALE);
+    std::string name = psky->getName();
 
-	// haze density, horizon, mult, and altitude
-	param_mgr->mHazeDensity = cur_params.getFloat(param_mgr->mHazeDensity.mName, err);
-	childSetValue("WLHazeDensity", (F32) param_mgr->mHazeDensity);
-	param_mgr->mHazeHorizon = cur_params.getFloat(param_mgr->mHazeHorizon.mName, err);
-	childSetValue("WLHazeHorizon", (F32) param_mgr->mHazeHorizon);
-	param_mgr->mDensityMult = cur_params.getFloat(param_mgr->mDensityMult.mName, err);
-	childSetValue("WLDensityMult", ((F32) param_mgr->mDensityMult) * param_mgr->mDensityMult.mult);
-	param_mgr->mMaxAlt = cur_params.getFloat(param_mgr->mMaxAlt.mName, err);
-	childSetValue("WLMaxAltitude", (F32) param_mgr->mMaxAlt);
-
-	// blue density
-	param_mgr->mBlueDensity = cur_params.getVector(param_mgr->mBlueDensity.mName, err);
-	setColorSwatch("WLBlueDensity", param_mgr->mBlueDensity, WL_BLUE_HORIZON_DENSITY_SCALE);
+    mSkyPresetNameEditor->setText(name);
+    mSkyPresetCombo->setValue(name);
 
 	// Lighting
 
 	// sunlight
-	param_mgr->mSunlight = cur_params.getVector(param_mgr->mSunlight.mName, err);
-	setColorSwatch("WLSunlight", param_mgr->mSunlight, WL_SUN_AMBIENT_SLIDER_SCALE);
+    mSkyAdapter->mSunlight.setColor3( psky->getSunlightColor() );
+	setColorSwatch("WLSunlight", mSkyAdapter->mSunlight, WL_SUN_AMBIENT_SLIDER_SCALE);
 
 	// glow
-	param_mgr->mGlow = cur_params.getVector(param_mgr->mGlow.mName, err);
-	childSetValue("WLGlowR", 2 - param_mgr->mGlow.r / 20.0f);
-	childSetValue("WLGlowB", -param_mgr->mGlow.b / 5.0f);
-
-	// ambient
-	param_mgr->mAmbient = cur_params.getVector(param_mgr->mAmbient.mName, err);
-	setColorSwatch("WLAmbient", param_mgr->mAmbient, WL_SUN_AMBIENT_SLIDER_SCALE);
-
-	F32 time24 = sun_pos_to_time24(param_mgr->mCurParams.getFloat("sun_angle",err) / F_TWO_PI);
-	getChild<LLMultiSliderCtrl>("WLSunPos")->setCurSliderValue(time24, TRUE);
-	getChild<LLTimeCtrl>("WLDayTime")->setTime24(time24);
-	childSetValue("WLEastAngle", param_mgr->mCurParams.getFloat("east_angle",err) / F_TWO_PI);
+    mSkyAdapter->mGlow.setColor3( psky->getGlow() );
+	childSetValue("WLGlowR", 2 - mSkyAdapter->mGlow.getRed() / 20.0f);
+	childSetValue("WLGlowB", -mSkyAdapter->mGlow.getBlue() / 5.0f);
+
+// LLSettingsSky::azimalt_t azal = psky->getSunRotationAzAl();
+// 
+// 	F32 time24 = sun_pos_to_time24(azal.second / F_TWO_PI);
+// 	getChild<LLMultiSliderCtrl>("WLSunPos")->setCurSliderValue(time24, TRUE);
+// 	getChild<LLTimeCtrl>("WLDayTime")->setTime24(time24);
+// 	childSetValue("WLEastAngle", azal.first / F_TWO_PI);
+    getChild<LLJoystickQuaternion>("WLSunRotation")->setRotation(psky->getSunRotation());
+    getChild<LLJoystickQuaternion>("WLMoonRotation")->setRotation(psky->getMoonRotation());
 
 	// Clouds
 
 	// Cloud Color
-	param_mgr->mCloudColor = cur_params.getVector(param_mgr->mCloudColor.mName, err);
-	setColorSwatch("WLCloudColor", param_mgr->mCloudColor, WL_CLOUD_SLIDER_SCALE);
+    mSkyAdapter->mCloudColor.setColor3( psky->getCloudColor() );
+	setColorSwatch("WLCloudColor", mSkyAdapter->mCloudColor, WL_CLOUD_SLIDER_SCALE);
 
 	// Cloud
-	param_mgr->mCloudMain = cur_params.getVector(param_mgr->mCloudMain.mName, err);
-	childSetValue("WLCloudX", param_mgr->mCloudMain.r);
-	childSetValue("WLCloudY", param_mgr->mCloudMain.g);
-	childSetValue("WLCloudDensity", param_mgr->mCloudMain.b);
+    mSkyAdapter->mCloudMain.setColor3( psky->getCloudPosDensity1() );
+	childSetValue("WLCloudX", mSkyAdapter->mCloudMain.getRed());
+	childSetValue("WLCloudY", mSkyAdapter->mCloudMain.getGreen());
+	childSetValue("WLCloudDensity", mSkyAdapter->mCloudMain.getBlue());
 
 	// Cloud Detail
-	param_mgr->mCloudDetail = cur_params.getVector(param_mgr->mCloudDetail.mName, err);
-	childSetValue("WLCloudDetailX", param_mgr->mCloudDetail.r);
-	childSetValue("WLCloudDetailY", param_mgr->mCloudDetail.g);
-	childSetValue("WLCloudDetailDensity", param_mgr->mCloudDetail.b);
+	mSkyAdapter->mCloudDetail.setColor3( psky->getCloudPosDensity2() );
+	childSetValue("WLCloudDetailX", mSkyAdapter->mCloudDetail.getRed());
+	childSetValue("WLCloudDetailY", mSkyAdapter->mCloudDetail.getGreen());
+	childSetValue("WLCloudDetailDensity", mSkyAdapter->mCloudDetail.getBlue());
 
 	// Cloud extras
-	param_mgr->mCloudCoverage = cur_params.getFloat(param_mgr->mCloudCoverage.mName, err);
-	param_mgr->mCloudScale = cur_params.getFloat(param_mgr->mCloudScale.mName, err);
-	childSetValue("WLCloudCoverage", (F32) param_mgr->mCloudCoverage);
-	childSetValue("WLCloudScale", (F32) param_mgr->mCloudScale);
+    mSkyAdapter->mCloudCoverage = psky->getCloudShadow();
+    mSkyAdapter->mCloudScale = psky->getCloudScale();
+	childSetValue("WLCloudCoverage", (F32) mSkyAdapter->mCloudCoverage);
+	childSetValue("WLCloudScale", (F32) mSkyAdapter->mCloudScale);
 
 	// cloud scrolling
-	bool lockX = !param_mgr->mCurParams.getEnableCloudScrollX();
-	bool lockY = !param_mgr->mCurParams.getEnableCloudScrollY();
-	childSetValue("WLCloudLockX", lockX);
-	childSetValue("WLCloudLockY", lockY);
+    LLVector2 scroll_rate = psky->getCloudScrollRate();
+
+    // LAPRAS: These should go away...
+    childDisable("WLCloudLockX");
+ 	childDisable("WLCloudLockY");
 
 	// disable if locked, enable if not
-	if (lockX)
-	{
-		childDisable("WLCloudScrollX");
-	}
-	else
-	{
-		childEnable("WLCloudScrollX");
-	}
-	if (lockY)
-	{
-		childDisable("WLCloudScrollY");
-	}
-	else
-	{
-		childEnable("WLCloudScrollY");
-	}
+	childEnable("WLCloudScrollX");
+	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 = cur_params.getFloat(param_mgr->mDistanceMult.mName, err);
-	childSetValue("WLDistanceMult", (F32) param_mgr->mDistanceMult);
+	childSetValue("WLCloudScrollX", scroll_rate[0] - 10.0f);
+	childSetValue("WLCloudScrollY", scroll_rate[1] - 10.0f);
 
 	// Tweak extras
 
-	param_mgr->mWLGamma = cur_params.getFloat(param_mgr->mWLGamma.mName, err);
-	childSetValue("WLGamma", (F32) param_mgr->mWLGamma);
+    mSkyAdapter->mWLGamma = psky->getGamma();
+	childSetValue("WLGamma", (F32) mSkyAdapter->mWLGamma);
 
-	childSetValue("WLStarAlpha", param_mgr->mCurParams.getStarBrightness());
+	childSetValue("WLStarAlpha", psky->getStarBrightness());
 }
 
 void LLFloaterEditSky::setColorSwatch(const std::string& name, const WLColorControl& from_ctrl, F32 k)
 {
 	// Set the value, dividing it by <k> first.
-	LLVector4 color_vec = from_ctrl;
-	getChild<LLColorSwatchCtrl>(name)->set(LLColor4(color_vec / k));
+	LLColor4 color = from_ctrl.getColor4();
+	getChild<LLColorSwatchCtrl>(name)->set(color / k);
 }
 
 // color control callbacks
 void LLFloaterEditSky::onColorControlMoved(LLUICtrl* ctrl, WLColorControl* color_ctrl)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
-
 	LLColorSwatchCtrl* swatch = static_cast<LLColorSwatchCtrl*>(ctrl);
-	LLVector4 color_vec(swatch->get().mV);
-
-	// Set intensity to maximum of the RGB values.
-	color_vec.mV[3] = llmax(color_vec.mV[0], llmax(color_vec.mV[1], color_vec.mV[2]));
+	LLColor4 color_vec(swatch->get().mV);
 
 	// Multiply RGB values by the appropriate factor.
 	F32 k = WL_CLOUD_SLIDER_SCALE;
-	if (color_ctrl->isSunOrAmbientColor)
+	if (color_ctrl->getIsSunOrAmbientColor())
 	{
 		k = WL_SUN_AMBIENT_SLIDER_SCALE;
 	}
-	if (color_ctrl->isBlueHorizonOrDensity)
+	else if (color_ctrl->getIsBlueHorizonOrDensity())
 	{
 		k = WL_BLUE_HORIZON_DENSITY_SCALE;
 	}
 
 	color_vec *= k; // intensity isn't affected by the multiplication
 
+    // Set intensity to maximum of the RGB values.
+    color_vec.mV[3] = color_max(color_vec);
+
 	// Apply the new RGBI value.
-	*color_ctrl = color_vec;
-	color_ctrl->update(LLWLParamManager::getInstance()->mCurParams);
-	LLWLParamManager::getInstance()->propagateParameters();
+	color_ctrl->setColor4(color_vec);
+	color_ctrl->update(mEditSettings);
 }
 
 void LLFloaterEditSky::onColorControlRMoved(LLUICtrl* ctrl, void* userdata)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
-
 	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
 	WLColorControl* color_ctrl = static_cast<WLColorControl *>(userdata);
 
-	color_ctrl->r = sldr_ctrl->getValueF32();
-	if (color_ctrl->isSunOrAmbientColor)
-	{
-		color_ctrl->r *= WL_SUN_AMBIENT_SLIDER_SCALE;
-	}
-	if (color_ctrl->isBlueHorizonOrDensity)
+    F32 red_value = sldr_ctrl->getValueF32();
+    F32 k = 1.0f;
+
+	if (color_ctrl->getIsSunOrAmbientColor())
 	{
-		color_ctrl->r *= WL_BLUE_HORIZON_DENSITY_SCALE;
+		k = WL_SUN_AMBIENT_SLIDER_SCALE;
 	}
-
-	// move i if it's the max
-	if (color_ctrl->r >= color_ctrl->g && color_ctrl->r >= color_ctrl->b && color_ctrl->hasSliderName)
+	if (color_ctrl->getIsBlueHorizonOrDensity())
 	{
-		color_ctrl->i = color_ctrl->r;
-		std::string name = color_ctrl->mSliderName;
-		name.append("I");
-
-		if (color_ctrl->isSunOrAmbientColor)
-		{
-			childSetValue(name, color_ctrl->r / WL_SUN_AMBIENT_SLIDER_SCALE);
-		}
-		else if	(color_ctrl->isBlueHorizonOrDensity)
-		{
-			childSetValue(name, color_ctrl->r / WL_BLUE_HORIZON_DENSITY_SCALE);
-		}
-		else
-		{
-			childSetValue(name, color_ctrl->r);
-		}
+		k = WL_BLUE_HORIZON_DENSITY_SCALE;
 	}
+    color_ctrl->setRed(red_value * k);
 
-	color_ctrl->update(LLWLParamManager::getInstance()->mCurParams);
-
-	LLWLParamManager::getInstance()->propagateParameters();
+    adjustIntensity(color_ctrl, red_value, k);
+    color_ctrl->update(mEditSettings);
 }
 
 void LLFloaterEditSky::onColorControlGMoved(LLUICtrl* ctrl, void* userdata)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
+    LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
+    WLColorControl* color_ctrl = static_cast<WLColorControl *>(userdata);
 
-	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
-	WLColorControl* color_ctrl = static_cast<WLColorControl *>(userdata);
+    F32 green_value = sldr_ctrl->getValueF32();
+    F32 k = 1.0f;
 
-	color_ctrl->g = sldr_ctrl->getValueF32();
-	if (color_ctrl->isSunOrAmbientColor)
-	{
-		color_ctrl->g *= WL_SUN_AMBIENT_SLIDER_SCALE;
-	}
-	if (color_ctrl->isBlueHorizonOrDensity)
-	{
-		color_ctrl->g *= WL_BLUE_HORIZON_DENSITY_SCALE;
-	}
+    if (color_ctrl->getIsSunOrAmbientColor())
+    {
+        k = WL_SUN_AMBIENT_SLIDER_SCALE;
+    }
+    if (color_ctrl->getIsBlueHorizonOrDensity())
+    {
+        k = WL_BLUE_HORIZON_DENSITY_SCALE;
+    }
+    color_ctrl->setGreen(green_value * k);
 
-	// move i if it's the max
-	if (color_ctrl->g >= color_ctrl->r && color_ctrl->g >= color_ctrl->b && color_ctrl->hasSliderName)
-	{
-		color_ctrl->i = color_ctrl->g;
-		std::string name = color_ctrl->mSliderName;
-		name.append("I");
-
-		if (color_ctrl->isSunOrAmbientColor)
-		{
-			childSetValue(name, color_ctrl->g / WL_SUN_AMBIENT_SLIDER_SCALE);
-		}
-		else if (color_ctrl->isBlueHorizonOrDensity)
-		{
-			childSetValue(name, color_ctrl->g / WL_BLUE_HORIZON_DENSITY_SCALE);
-		}
-		else
-		{
-			childSetValue(name, color_ctrl->g);
-		}
-	}
-
-	color_ctrl->update(LLWLParamManager::getInstance()->mCurParams);
-
-	LLWLParamManager::getInstance()->propagateParameters();
+    adjustIntensity(color_ctrl, green_value, k);
+    color_ctrl->update(mEditSettings);
 }
 
 void LLFloaterEditSky::onColorControlBMoved(LLUICtrl* ctrl, void* userdata)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
+    LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
+    WLColorControl* color_ctrl = static_cast<WLColorControl *>(userdata);
 
-	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
-	WLColorControl* color_ctrl = static_cast<WLColorControl *>(userdata);
+    F32 blue_value = sldr_ctrl->getValueF32();
+    F32 k = 1.0f;
 
-	color_ctrl->b = sldr_ctrl->getValueF32();
-	if (color_ctrl->isSunOrAmbientColor)
-	{
-		color_ctrl->b *= WL_SUN_AMBIENT_SLIDER_SCALE;
-	}
-	if (color_ctrl->isBlueHorizonOrDensity)
-	{
-		color_ctrl->b *= WL_BLUE_HORIZON_DENSITY_SCALE;
-	}
+    if (color_ctrl->getIsSunOrAmbientColor())
+    {
+        k = WL_SUN_AMBIENT_SLIDER_SCALE;
+    }
+    if (color_ctrl->getIsBlueHorizonOrDensity())
+    {
+        k = WL_BLUE_HORIZON_DENSITY_SCALE;
+    }
+    color_ctrl->setBlue(blue_value * k);
 
-	// move i if it's the max
-	if (color_ctrl->b >= color_ctrl->r && color_ctrl->b >= color_ctrl->g && color_ctrl->hasSliderName)
-	{
-		color_ctrl->i = color_ctrl->b;
-		std::string name = color_ctrl->mSliderName;
-		name.append("I");
-
-		if (color_ctrl->isSunOrAmbientColor)
-		{
-			childSetValue(name, color_ctrl->b / WL_SUN_AMBIENT_SLIDER_SCALE);
-		}
-		else if (color_ctrl->isBlueHorizonOrDensity)
-		{
-			childSetValue(name, color_ctrl->b / WL_BLUE_HORIZON_DENSITY_SCALE);
-		}
-		else
-		{
-			childSetValue(name, color_ctrl->b);
-		}
-	}
+    adjustIntensity(color_ctrl, blue_value, k);
+    color_ctrl->update(mEditSettings);
+}
 
-	color_ctrl->update(LLWLParamManager::getInstance()->mCurParams);
+void LLFloaterEditSky::adjustIntensity(WLColorControl *ctrl, F32 val, F32 scale)
+{
+    if (ctrl->getHasSliderName())
+    {
+        LLColor4 color = ctrl->getColor4();
+        F32 i = color_max(color) / scale;
+        ctrl->setIntensity(i);
+        std::string name = ctrl->getSliderName();
+        name.append("I");
 
-	LLWLParamManager::getInstance()->propagateParameters();
+        childSetValue(name, i);
+    }
 }
 
+
 /// GLOW SPECIFIC CODE
 void LLFloaterEditSky::onGlowRMoved(LLUICtrl* ctrl, void* userdata)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
 
 	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
 	WLColorControl* color_ctrl = static_cast<WLColorControl *>(userdata);
 
 	// scaled by 20
-	color_ctrl->r = (2 - sldr_ctrl->getValueF32()) * 20;
+	color_ctrl->setRed((2 - sldr_ctrl->getValueF32()) * 20);
 
-	color_ctrl->update(LLWLParamManager::getInstance()->mCurParams);
-	LLWLParamManager::getInstance()->propagateParameters();
+	color_ctrl->update(mEditSettings);
 }
 
 /// \NOTE that we want NEGATIVE (-) B
 void LLFloaterEditSky::onGlowBMoved(LLUICtrl* ctrl, void* userdata)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
-
 	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
 	WLColorControl* color_ctrl = static_cast<WLColorControl *>(userdata);
 
 	/// \NOTE that we want NEGATIVE (-) B and NOT by 20 as 20 is too big
-	color_ctrl->b = -sldr_ctrl->getValueF32() * 5;
+	color_ctrl->setBlue(-sldr_ctrl->getValueF32() * 5);
 
-	color_ctrl->update(LLWLParamManager::getInstance()->mCurParams);
-	LLWLParamManager::getInstance()->propagateParameters();
+	color_ctrl->update(mEditSettings);
 }
 
 void LLFloaterEditSky::onFloatControlMoved(LLUICtrl* ctrl, void* userdata)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
-
 	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
 	WLFloatControl * floatControl = static_cast<WLFloatControl *>(userdata);
 
-	floatControl->x = sldr_ctrl->getValueF32() / floatControl->mult;
+	floatControl->setValue(sldr_ctrl->getValueF32() / floatControl->getMult());
 
-	floatControl->update(LLWLParamManager::getInstance()->mCurParams);
-	LLWLParamManager::getInstance()->propagateParameters();
+	floatControl->update(mEditSettings);
 }
 
 
@@ -531,8 +427,6 @@ void LLFloaterEditSky::onFloatControlMoved(LLUICtrl* ctrl, void* userdata)
 // time of day
 void LLFloaterEditSky::onSunMoved(LLUICtrl* ctrl, void* userdata)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
-
 	LLMultiSliderCtrl* sun_msldr = getChild<LLMultiSliderCtrl>("WLSunPos");
 	LLSliderCtrl* east_sldr = getChild<LLSliderCtrl>("WLEastAngle");
 	LLTimeCtrl* time_ctrl = getChild<LLTimeCtrl>("WLDayTime");
@@ -542,99 +436,60 @@ void LLFloaterEditSky::onSunMoved(LLUICtrl* ctrl, void* userdata)
 	time_ctrl->setTime24(time24); // sync the time ctrl with the new sun position
 
 	// get the two angles
-	LLWLParamManager * param_mgr = LLWLParamManager::getInstance();
-
-	param_mgr->mCurParams.setSunAngle(F_TWO_PI * time24_to_sun_pos(time24));
-	param_mgr->mCurParams.setEastAngle(F_TWO_PI * east_sldr->getValueF32());
+    F32 azimuth = F_TWO_PI * east_sldr->getValueF32();
+    F32 altitude = F_TWO_PI * time24_to_sun_pos(time24);
+    mEditSettings->setSunRotation(azimuth, altitude);
+    mEditSettings->setMoonRotation(azimuth + F_PI, -altitude);
 
-	// set the sun vector
-	color_ctrl->r = -sin(param_mgr->mCurParams.getEastAngle()) *
-		cos(param_mgr->mCurParams.getSunAngle());
-	color_ctrl->g = sin(param_mgr->mCurParams.getSunAngle());
-	color_ctrl->b = cos(param_mgr->mCurParams.getEastAngle()) *
-		cos(param_mgr->mCurParams.getSunAngle());
-	color_ctrl->i = 1.f;
+    LLVector4 sunnorm( mEditSettings->getSunDirection(), 1.f );
 
-	color_ctrl->update(param_mgr->mCurParams);
-	param_mgr->propagateParameters();
+	color_ctrl->update(mEditSettings);
 }
 
 void LLFloaterEditSky::onTimeChanged()
 {
 	F32 time24 = getChild<LLTimeCtrl>("WLDayTime")->getTime24();
 	getChild<LLMultiSliderCtrl>("WLSunPos")->setCurSliderValue(time24, TRUE);
-	onSunMoved(getChild<LLUICtrl>("WLSunPos"), &LLWLParamManager::instance().mLightnorm);
+    onSunMoved(getChild<LLUICtrl>("WLSunPos"), &(mSkyAdapter->mLightnorm));
 }
 
-void LLFloaterEditSky::onStarAlphaMoved(LLUICtrl* ctrl)
+void LLFloaterEditSky::onSunRotationChanged()
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
-
-	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
+    LLJoystickQuaternion* sun_spinner = getChild<LLJoystickQuaternion>("WLSunRotation");
+    LLQuaternion sunrot(sun_spinner->getRotation());
 
-	LLWLParamManager::getInstance()->mCurParams.setStarBrightness(sldr_ctrl->getValueF32());
+    mEditSettings->setSunRotation(sunrot);
 }
 
-// Clouds
-void LLFloaterEditSky::onCloudScrollXMoved(LLUICtrl* ctrl)
+void LLFloaterEditSky::onMoonRotationChanged()
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
+    LLJoystickQuaternion* moon_spinner = getChild<LLJoystickQuaternion>("WLMoonRotation");
+    LLQuaternion moonrot(moon_spinner->getRotation());
 
-	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
-	// *HACK  all cloud scrolling is off by an additive of 10.
-	LLWLParamManager::getInstance()->mCurParams.setCloudScrollX(sldr_ctrl->getValueF32() + 10.0f);
+    mEditSettings->setMoonRotation(moonrot);
 }
 
-void LLFloaterEditSky::onCloudScrollYMoved(LLUICtrl* ctrl)
+void LLFloaterEditSky::onStarAlphaMoved(LLUICtrl* ctrl)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
-
 	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
 
-	// *HACK  all cloud scrolling is off by an additive of 10.
-	LLWLParamManager::getInstance()->mCurParams.setCloudScrollY(sldr_ctrl->getValueF32() + 10.0f);
+    mEditSettings->setStarBrightness(sldr_ctrl->getValueF32());
 }
 
-void LLFloaterEditSky::onCloudScrollXToggled(LLUICtrl* ctrl)
+// Clouds
+void LLFloaterEditSky::onCloudScrollXMoved(LLUICtrl* ctrl)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
-
-	LLCheckBoxCtrl* cb_ctrl = static_cast<LLCheckBoxCtrl*>(ctrl);
-
-	bool lock = cb_ctrl->get();
-	LLWLParamManager::getInstance()->mCurParams.setEnableCloudScrollX(!lock);
-
-	LLSliderCtrl* sldr = getChild<LLSliderCtrl>("WLCloudScrollX");
-
-	if (cb_ctrl->get())
-	{
-		sldr->setEnabled(false);
-	}
-	else
-	{
-		sldr->setEnabled(true);
-	}
-
+	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
+	// *HACK  all cloud scrolling is off by an additive of 10.
+    mEditSettings->setCloudScrollRateX(sldr_ctrl->getValueF32() + 10.0f);
 }
 
-void LLFloaterEditSky::onCloudScrollYToggled(LLUICtrl* ctrl)
+void LLFloaterEditSky::onCloudScrollYMoved(LLUICtrl* ctrl)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
-
-	LLCheckBoxCtrl* cb_ctrl = static_cast<LLCheckBoxCtrl*>(ctrl);
-	bool lock = cb_ctrl->get();
-	LLWLParamManager::getInstance()->mCurParams.setEnableCloudScrollY(!lock);
-
-	LLSliderCtrl* sldr = getChild<LLSliderCtrl>("WLCloudScrollY");
+	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
 
-	if (cb_ctrl->get())
-	{
-		sldr->setEnabled(false);
-	}
-	else
-	{
-		sldr->setEnabled(true);
-	}
+	// *HACK  all cloud scrolling is off by an additive of 10.
+    mEditSettings->setCloudScrollRateY(sldr_ctrl->getValueF32() + 10.0f);
 }
 
 //=================================================================================================
@@ -664,38 +519,12 @@ void LLFloaterEditSky::refreshSkyPresetsList()
 {
 	mSkyPresetCombo->removeall();
 
-	LLWLParamManager::preset_name_list_t region_presets, user_presets, sys_presets;
-	LLWLParamManager::instance().getPresetNames(region_presets, user_presets, sys_presets);
+    LLEnvironment::list_name_id_t list = LLEnvironment::instance().getSkyList();
 
-#if 0 // Disable editing region skies until the workflow is clear enough.
-	// Add region presets.
-	std::string region_name = gAgent.getRegion() ? gAgent.getRegion()->getName() : LLTrans::getString("Unknown");
-	for (LLWLParamManager::preset_name_list_t::const_iterator it = region_presets.begin(); it != region_presets.end(); ++it)
-	{
-		std::string item_title = *it + " (" + region_name + ")";
-		mSkyPresetCombo->add(item_title, LLWLParamKey(*it, LLEnvKey::SCOPE_REGION).toLLSD());
-	}
-	if (region_presets.size() > 0)
-	{
-		mSkyPresetCombo->addSeparator();
-	}
-#endif
-
-	// Add user presets.
-	for (LLWLParamManager::preset_name_list_t::const_iterator it = user_presets.begin(); it != user_presets.end(); ++it)
-	{
-		mSkyPresetCombo->add(*it, LLWLParamKey(*it, LLEnvKey::SCOPE_LOCAL).toLLSD());
-	}
-	if (user_presets.size() > 0)
-	{
-		mSkyPresetCombo->addSeparator();
-	}
-
-	// Add system presets.
-	for (LLWLParamManager::preset_name_list_t::const_iterator it = sys_presets.begin(); it != sys_presets.end(); ++it)
-	{
-		mSkyPresetCombo->add(*it, LLWLParamKey(*it, LLEnvKey::SCOPE_LOCAL).toLLSD());
-	}
+    for (LLEnvironment::list_name_id_t::iterator it = list.begin(); it != list.end(); ++it)
+    {
+        mSkyPresetCombo->add((*it).first, LLSDArray((*it).first)((*it).second));
+    }
 
 	mSkyPresetCombo->setLabel(getString("combo_label"));
 }
@@ -718,6 +547,7 @@ void LLFloaterEditSky::enableEditing(bool enable)
 
 void LLFloaterEditSky::saveRegionSky()
 {
+#if 0
 	LLWLParamKey key(getSelectedSkyPreset());
 	llassert(key.scope == LLEnvKey::SCOPE_REGION);
 
@@ -728,61 +558,55 @@ void LLFloaterEditSky::saveRegionSky()
 
 	// *TODO: save to cached region settings.
 	LL_WARNS("Windlight") << "Saving region sky is not fully implemented yet" << LL_ENDL;
+#endif
 }
 
-LLWLParamKey LLFloaterEditSky::getSelectedSkyPreset()
+std::string LLFloaterEditSky::getSelectedPresetName() const
 {
-	LLWLParamKey key;
-
-	if (mSkyPresetNameEditor->getVisible())
-	{
-		key.name = mSkyPresetNameEditor->getText();
-		key.scope = LLEnvKey::SCOPE_LOCAL;
-	}
-	else
-	{
-		LLSD combo_val = mSkyPresetCombo->getValue();
-
-		if (!combo_val.isArray()) // manually typed text
-		{
-			key.name = combo_val.asString();
-			key.scope = LLEnvKey::SCOPE_LOCAL;
-		}
-		else
-		{
-			key.fromLLSD(combo_val);
-		}
-	}
+    std::string name;
+    if (mSkyPresetNameEditor->getVisible())
+    {
+        name = mSkyPresetNameEditor->getText();
+    }
+    else
+    {
+        LLSD combo_val = mSkyPresetCombo->getValue();
+        name = combo_val[0].asString();
+    }
 
-	return key;
+    return name;
 }
 
 void LLFloaterEditSky::onSkyPresetNameEdited()
 {
-	// Disable saving a sky preset having empty name.
-	LLWLParamKey key = getSelectedSkyPreset();
-	mSaveButton->setEnabled(!key.name.empty());
+    std::string name = mSkyPresetNameEditor->getText();
+    LLSettingsWater::ptr_t psky = LLEnvironment::instance().getCurrentWater();
+
+    psky->setName(name);
 }
 
 void LLFloaterEditSky::onSkyPresetSelected()
 {
-	LLWLParamKey key = getSelectedSkyPreset();
-	LLWLParamSet sky_params;
+    std::string name;
 
-	if (!LLWLParamManager::instance().getParamSet(key, sky_params))
-	{
-		// Manually entered string?
-		LL_WARNS("Windlight") << "No sky preset named " << key.toString() << LL_ENDL;
-		return;
-	}
+    name = getSelectedPresetName();
 
-	LLEnvManagerNew::instance().useSkyParams(sky_params.getAll());
-	//syncControls();
+    LLSettingsSky::ptr_t psky = LLEnvironment::instance().findSkyByName(name);
 
-	bool can_edit = (key.scope == LLEnvKey::SCOPE_LOCAL || LLEnvManagerNew::canEditRegionSettings());
-	enableEditing(can_edit);
+    if (!psky)
+    {
+        LL_WARNS("WATEREDIT") << "Could not find water preset" << LL_ENDL;
+        enableEditing(false);
+        return;
+    }
+
+    psky = psky->buildClone();
+    LLEnvironment::instance().setEnvironment(LLEnvironment::ENV_EDIT, psky);
+    mEditSettings = psky;
+
+    syncControls();
+    enableEditing(true);
 
-	mMakeDefaultCheckBox->setEnabled(key.scope == LLEnvKey::SCOPE_LOCAL);
 }
 
 bool LLFloaterEditSky::onSaveAnswer(const LLSD& notification, const LLSD& response)
@@ -800,69 +624,29 @@ bool LLFloaterEditSky::onSaveAnswer(const LLSD& notification, const LLSD& respon
 
 void LLFloaterEditSky::onSaveConfirmed()
 {
-	// Save current params to the selected preset.
-	LLWLParamKey key(getSelectedSkyPreset());
+    // Save currently displayed water params to the selected preset.
+    std::string name = mEditSettings->getName();
 
-	LL_DEBUGS("Windlight") << "Saving sky preset " << key.name << LL_ENDL;
-	LLWLParamManager& wl_mgr = LLWLParamManager::instance();
-	if (wl_mgr.hasParamSet(key))
-	{
-		wl_mgr.setParamSet(key, wl_mgr.mCurParams);
-	}
-	else
-	{
-		wl_mgr.addParamSet(key, wl_mgr.mCurParams);
-	}
+    LL_DEBUGS("Windlight") << "Saving sky preset " << name << LL_ENDL;
 
-	wl_mgr.savePreset(key);
+    LLEnvironment::instance().addSky(mEditSettings);
 
-	// Change preference if requested.
-	if (mMakeDefaultCheckBox->getValue())
-	{
-		LL_DEBUGS("Windlight") << key.name << " is now the new preferred sky preset" << LL_ENDL;
-		LLEnvManagerNew::instance().setUseSkyPreset(key.name);
-	}
+    // Change preference if requested.
+    if (mMakeDefaultCheckBox->getEnabled() && mMakeDefaultCheckBox->getValue())
+    {
+        LL_DEBUGS("Windlight") << name << " is now the new preferred sky preset" << LL_ENDL;
+        LLEnvironment::instance().setEnvironment(LLEnvironment::ENV_LOCAL, mEditSettings);
+    }
 
-	closeFloater();
+    closeFloater();
 }
 
 void LLFloaterEditSky::onBtnSave()
 {
-	LLWLParamKey selected_sky = getSelectedSkyPreset();
-	LLWLParamManager& wl_mgr = LLWLParamManager::instance();
-
-	if (selected_sky.scope == LLEnvKey::SCOPE_REGION)
-	{
-		saveRegionSky();
-		closeFloater();
-		return;
-	}
+    LLEnvironment::instance().addSky(mEditSettings);
+    LLEnvironment::instance().setEnvironment(LLEnvironment::ENV_LOCAL, mEditSettings);
 
-	std::string name = selected_sky.name;
-	if (name.empty())
-	{
-		// *TODO: show an alert
-		LL_WARNS() << "Empty sky preset name" << LL_ENDL;
-		return;
-	}
-
-	// Don't allow overwriting system presets.
-	if (wl_mgr.isSystemPreset(name))
-	{
-		LLNotificationsUtil::add("WLNoEditDefault");
-		return;
-	}
-
-	// Save, ask for confirmation for overwriting an existing preset.
-	if (wl_mgr.hasParamSet(selected_sky))
-	{
-		LLNotificationsUtil::add("WLSavePresetAlert", LLSD(), LLSD(), boost::bind(&LLFloaterEditSky::onSaveAnswer, this, _1, _2));
-	}
-	else
-	{
-		// new preset, hence no confirmation needed
-		onSaveConfirmed();
-	}
+    closeFloater();
 }
 
 void LLFloaterEditSky::onBtnCancel()
@@ -872,22 +656,12 @@ void LLFloaterEditSky::onBtnCancel()
 
 void LLFloaterEditSky::onSkyPresetListChange()
 {
-	LLWLParamKey key = getSelectedSkyPreset(); // preset being edited
-	if (!LLWLParamManager::instance().hasParamSet(key))
-	{
-		// Preset we've been editing doesn't exist anymore. Close the floater.
-		closeFloater(false);
-	}
-	else
-	{
-		// A new preset has been added.
-		// Refresh the presets list, though it may not make sense as the floater is about to be closed.
-		refreshSkyPresetsList();
-	}
+    refreshSkyPresetsList();
 }
 
 void LLFloaterEditSky::onRegionSettingsChange()
 {
+#if 0
 	// If creating a new sky, don't bother.
 	if (isNewPreset())
 	{
@@ -905,10 +679,12 @@ void LLFloaterEditSky::onRegionSettingsChange()
 	{
 		refreshSkyPresetsList();
 	}
+#endif
 }
 
 void LLFloaterEditSky::onRegionInfoUpdate()
 {
+#if 0
 	bool can_edit = true;
 
 	// If we've selected a region sky preset for editing.
@@ -919,4 +695,5 @@ void LLFloaterEditSky::onRegionInfoUpdate()
 	}
 
 	enableEditing(can_edit);
+#endif
 }