From c04ceedbc3e462098eceaa233cd26f6bed79b773 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Tue, 19 Sep 2017 15:50:30 -0700
Subject: Baseline for settings changes

---
 indra/newview/llwlparammanager.cpp | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'indra/newview/llwlparammanager.cpp')

diff --git a/indra/newview/llwlparammanager.cpp b/indra/newview/llwlparammanager.cpp
index 4b4393b07b..980fe96c2b 100644
--- a/indra/newview/llwlparammanager.cpp
+++ b/indra/newview/llwlparammanager.cpp
@@ -317,6 +317,10 @@ bool LLWLParamManager::loadPreset(const std::string& path)
 		addParamSet(key, params_data);
 	}
 
+    //*RIDER temp code testing conversion old preset to new settings.
+    //LLSettingsSky::ptr_t test = LLSettingsSky::buildFromLegacyPreset(name, params_data);
+    //test->exportSettings(name);
+
 	return true;
 }
 
@@ -708,3 +712,4 @@ std::string LLWLParamManager::escapeString(const std::string& str)
 
 	return escaped_str;
 }
+
-- 
cgit v1.3


From d4d0520f38f59c4f60da098da9c2217ca6e45d65 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Wed, 20 Sep 2017 14:29:36 -0700
Subject: Cleanup inside GLSLShader for uniform mapping.

---
 indra/llrender/llglslshader.cpp    | 319 ++++++++++++++-----------------------
 indra/llrender/llglslshader.h      |  29 +++-
 indra/newview/CMakeLists.txt       |   2 +
 indra/newview/llwlparammanager.cpp |   7 +-
 4 files changed, 152 insertions(+), 205 deletions(-)

(limited to 'indra/newview/llwlparammanager.cpp')

diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index 5d669fb955..79421e6bdc 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -154,8 +154,7 @@ void LLGLSLShader::clearStats()
     mSamplesDrawn = 0;
     mDrawCalls = 0;
     mTextureStateFetched = false;
-    mTextureMagFilter.clear();
-    mTextureMinFilter.clear();
+    mTextureMagMinFilter.clear();
 }
 
 void LLGLSLShader::dumpStats()
@@ -168,14 +167,16 @@ void LLGLSLShader::dumpStats()
         {
             LL_INFOS() << mShaderFiles[i].first << LL_ENDL;
         }
-        for (U32 i = 0; i < mTexture.size(); ++i)
+        for (uniforms_index_t::iterator it = mTexture.begin(); it != mTexture.end(); ++it)
         {
-            GLint idx = mTexture[i];
+            S32 i = (*it).first;
+            GLint idx = (*it).second;
             
             if (idx >= 0)
             {
                 GLint uniform_idx = getUniformLocation(i);
-                LL_INFOS() << mUniformNameMap[uniform_idx] << " - " << std::hex << mTextureMagFilter[i] << "/" << mTextureMinFilter[i] << std::dec << LL_ENDL;
+                magmin_filter_t::iterator it = mTextureMagMinFilter.find(i);
+                LL_INFOS() << mUniformNameMap[uniform_idx] << " - " << std::hex << (*it).second.second << "/" << (*it).second.first << std::dec << LL_ENDL;
             }
         }
         LL_INFOS() << "=============================================" << LL_ENDL;
@@ -232,14 +233,13 @@ void LLGLSLShader::placeProfileQuery()
     if (!mTextureStateFetched)
     {
         mTextureStateFetched = true;
-        mTextureMagFilter.resize(mTexture.size());
-        mTextureMinFilter.resize(mTexture.size());
 
         U32 cur_active = gGL.getCurrentTexUnitIndex();
 
-        for (U32 i = 0; i < mTexture.size(); ++i)
+        for (uniforms_index_t::iterator it = mTexture.begin(); it != mTexture.end(); ++it)
         {
-            GLint idx = mTexture[i];
+            S32 i = (*it).first;
+            GLint idx = (*it).second;
 
             if (idx >= 0)
             {
@@ -253,8 +253,7 @@ void LLGLSLShader::placeProfileQuery()
                 glGetTexParameteriv(type, GL_TEXTURE_MAG_FILTER, (GLint*) &mag);
                 glGetTexParameteriv(type, GL_TEXTURE_MIN_FILTER, (GLint*) &min);
 
-                mTextureMagFilter[i] = mag;
-                mTextureMinFilter[i] = min;
+                mTextureMagMinFilter[i] = magmin_values_t(mag, min);
             }
         }
 
@@ -470,13 +469,14 @@ BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString> * attributes,
         }
 
         S32 cur_tex = channel_count; //adjust any texture channels that might have been overwritten
-        for (U32 i = 0; i < mTexture.size(); i++)
+        for (uniforms_index_t::iterator it = mTexture.begin(); it != mTexture.end(); ++it)
         {
-            if (mTexture[i] > -1 && mTexture[i] < channel_count)
+            int i = (*it).first;
+            if (((*it).second >= 0) && ((*it).second < channel_count))
             {
                 llassert(cur_tex < gGLManager.mNumTextureImageUnits);
                 uniform1i(i, cur_tex);
-                mTexture[i] = cur_tex++;
+                (*it).second = cur_tex++;
             }
         }
         unbind();
@@ -655,13 +655,16 @@ void LLGLSLShader::mapUniform(GLint index, const vector<LLStaticHashedString> *
         //find the index of this uniform
         for (S32 i = 0; i < (S32) LLShaderMgr::instance()->mReservedUniforms.size(); i++)
         {
-            if ( (mUniform[i] == -1)
-                && (LLShaderMgr::instance()->mReservedUniforms[i] == name))
+            if (LLShaderMgr::instance()->mReservedUniforms[i] == name)
             {
-                //found it
-                mUniform[i] = location;
-                mTexture[i] = mapUniformTextureChannel(location, type);
-                return;
+                std::pair<uniforms_index_t::iterator, bool> result;
+
+                result = mUniform.insert(uniforms_index_t::value_type(i, location));
+                if (result.second)
+                {
+                    mTexture[i] = mapUniformTextureChannel(location, type);
+                    return;
+                }
             }
         }
 
@@ -669,13 +672,17 @@ void LLGLSLShader::mapUniform(GLint index, const vector<LLStaticHashedString> *
         {
             for (U32 i = 0; i < uniforms->size(); i++)
             {
-                if ( (mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] == -1)
-                    && ((*uniforms)[i].String() == name))
+                std::pair<uniforms_index_t::iterator, bool> result;
+                S32 index = i + LLShaderMgr::instance()->mReservedUniforms.size();
+
+                if ((*uniforms)[i].String() == name)
                 {
-                    //found it
-                    mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] = location;
-                    mTexture[i+LLShaderMgr::instance()->mReservedUniforms.size()] = mapUniformTextureChannel(location, type);
-                    return;
+                    result = mUniform.insert(uniforms_index_t::value_type(index, location));
+                    if (result.second)
+                    {
+                        mTexture[index] = mapUniformTextureChannel(location, type);
+                        return;
+                    }
                 }
             }
         }
@@ -715,10 +722,6 @@ BOOL LLGLSLShader::mapUniforms(const vector<LLStaticHashedString> * uniforms)
 	mUniformNameMap.clear();
 	mTexture.clear();
 	mValue.clear();
-	//initialize arrays
-	U32 numUniforms = (uniforms == NULL) ? 0 : uniforms->size();
-	mUniform.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
-	mTexture.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
 
 	bind();
 
@@ -910,20 +913,14 @@ S32 LLGLSLShader::bindTexture(const std::string &uniform, LLTexture *texture, LL
 
 S32 LLGLSLShader::bindTexture(S32 uniform, LLTexture *texture, LLTexUnit::eTextureType mode)
 {
-    if (uniform < 0 || uniform >= (S32)mTexture.size())
-    {
-        UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
-        return -1;
-    }
-    
-    uniform = mTexture[uniform];
+    GLint channel = getTexChannelForIndex(uniform);
     
-    if (uniform > -1)
+    if (channel > -1)
     {
-        gGL.getTexUnit(uniform)->bind(texture, mode);
+        gGL.getTexUnit(channel)->bind(texture, mode);
     }
     
-    return uniform;
+    return channel;
 }
 
 S32 LLGLSLShader::unbindTexture(const std::string &uniform, LLTexUnit::eTextureType mode)
@@ -936,82 +933,64 @@ S32 LLGLSLShader::unbindTexture(const std::string &uniform, LLTexUnit::eTextureT
 
 S32 LLGLSLShader::unbindTexture(S32 uniform, LLTexUnit::eTextureType mode)
 {
-    if (uniform < 0 || uniform >= (S32)mTexture.size())
-    {
-        UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
-        return -1;
-    }
-    
-    uniform = mTexture[uniform];
-    
-    if (uniform > -1)
+    GLint channel = getTexChannelForIndex(uniform);
+
+    if (channel > -1)
     {
-        gGL.getTexUnit(uniform)->unbind(mode);
+        gGL.getTexUnit(channel)->unbind(mode);
     }
     
-    return uniform;
+    return channel;
 }
 
 S32 LLGLSLShader::enableTexture(S32 uniform, LLTexUnit::eTextureType mode)
 {
-    if (uniform < 0 || uniform >= (S32)mTexture.size())
-    {
-        UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
-        return -1;
-    }
-    S32 index = mTexture[uniform];
-    if (index != -1)
+    GLint channel = getTexChannelForIndex(uniform);
+
+    if (channel != -1)
     {
-        gGL.getTexUnit(index)->activate();
-        gGL.getTexUnit(index)->enable(mode);
+        gGL.getTexUnit(channel)->activate();
+        gGL.getTexUnit(channel)->enable(mode);
     }
-    return index;
+    return channel;
 }
 
 S32 LLGLSLShader::disableTexture(S32 uniform, LLTexUnit::eTextureType mode)
 {
-    if (uniform < 0 || uniform >= (S32)mTexture.size())
-    {
-        UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
-        return -1;
-    }
-    S32 index = mTexture[uniform];
-    if (index != -1 && gGL.getTexUnit(index)->getCurrType() != LLTexUnit::TT_NONE)
+    GLint channel = getTexChannelForIndex(uniform);
+
+    if (channel != -1 && gGL.getTexUnit(channel)->getCurrType() != LLTexUnit::TT_NONE)
     {
-        if (gDebugGL && gGL.getTexUnit(index)->getCurrType() != mode)
+        if (gDebugGL && gGL.getTexUnit(channel)->getCurrType() != mode)
         {
             if (gDebugSession)
             {
-                gFailLog << "Texture channel " << index << " texture type corrupted." << std::endl;
+                gFailLog << "Texture channel " << channel << " texture type corrupted." << std::endl;
                 ll_fail("LLGLSLShader::disableTexture failed");
             }
             else
             {
-                LL_ERRS() << "Texture channel " << index << " texture type corrupted." << LL_ENDL;
+                LL_ERRS() << "Texture channel " << channel << " texture type corrupted." << LL_ENDL;
             }
         }
-        gGL.getTexUnit(index)->disable();
+        gGL.getTexUnit(channel)->disable();
     }
-    return index;
+    return channel;
 }
 
 void LLGLSLShader::uniform1i(U32 index, GLint x)
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
             if (iter == mValue.end() || iter->second.mV[0] != x)
             {
-                glUniform1iARB(mUniform[index], x);
-                mValue[mUniform[index]] = LLVector4(x,0.f,0.f,0.f);
+                glUniform1iARB(location, x);
+                mValue[location] = LLVector4(x,0.f,0.f,0.f);
             }
         }
     }
@@ -1021,19 +1000,15 @@ void LLGLSLShader::uniform1f(U32 index, GLfloat x)
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
             if (iter == mValue.end() || iter->second.mV[0] != x)
             {
-                glUniform1fARB(mUniform[index], x);
-                mValue[mUniform[index]] = LLVector4(x,0.f,0.f,0.f);
+                glUniform1fARB(location, x);
+                mValue[location] = LLVector4(x,0.f,0.f,0.f);
             }
         }
     }
@@ -1043,20 +1018,16 @@ void LLGLSLShader::uniform2f(U32 index, GLfloat x, GLfloat y)
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
             LLVector4 vec(x,y,0.f,0.f);
             if (iter == mValue.end() || shouldChange(iter->second,vec))
             {
-                glUniform2fARB(mUniform[index], x, y);
-                mValue[mUniform[index]] = vec;
+                glUniform2fARB(location, x, y);
+                mValue[location] = vec;
             }
         }
     }
@@ -1066,20 +1037,16 @@ void LLGLSLShader::uniform3f(U32 index, GLfloat x, GLfloat y, GLfloat z)
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
             LLVector4 vec(x,y,z,0.f);
             if (iter == mValue.end() || shouldChange(iter->second,vec))
             {
-                glUniform3fARB(mUniform[index], x, y, z);
-                mValue[mUniform[index]] = vec;
+                glUniform3fARB(location, x, y, z);
+                mValue[location] = vec;
             }
         }
     }
@@ -1089,20 +1056,16 @@ void LLGLSLShader::uniform4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
             LLVector4 vec(x,y,z,w);
             if (iter == mValue.end() || shouldChange(iter->second,vec))
             {
-                glUniform4fARB(mUniform[index], x, y, z, w);
-                mValue[mUniform[index]] = vec;
+                glUniform4fARB(location, x, y, z, w);
+                mValue[location] = vec;
             }
         }
     }
@@ -1112,20 +1075,16 @@ void LLGLSLShader::uniform1iv(U32 index, U32 count, const GLint* v)
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
             LLVector4 vec(v[0],0.f,0.f,0.f);
             if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
             {
-                glUniform1ivARB(mUniform[index], count, v);
-                mValue[mUniform[index]] = vec;
+                glUniform1ivARB(location, count, v);
+                mValue[location] = vec;
             }
         }
     }
@@ -1135,20 +1094,16 @@ void LLGLSLShader::uniform1fv(U32 index, U32 count, const GLfloat* v)
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
             LLVector4 vec(v[0],0.f,0.f,0.f);
             if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
             {
-                glUniform1fvARB(mUniform[index], count, v);
-                mValue[mUniform[index]] = vec;
+                glUniform1fvARB(location, count, v);
+                mValue[location] = vec;
             }
         }
     }
@@ -1158,20 +1113,16 @@ void LLGLSLShader::uniform2fv(U32 index, U32 count, const GLfloat* v)
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
             LLVector4 vec(v[0],v[1],0.f,0.f);
             if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
             {
-                glUniform2fvARB(mUniform[index], count, v);
-                mValue[mUniform[index]] = vec;
+                glUniform2fvARB(location, count, v);
+                mValue[location] = vec;
             }
         }
     }
@@ -1181,20 +1132,16 @@ void LLGLSLShader::uniform3fv(U32 index, U32 count, const GLfloat* v)
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
             LLVector4 vec(v[0],v[1],v[2],0.f);
             if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
             {
-                glUniform3fvARB(mUniform[index], count, v);
-                mValue[mUniform[index]] = vec;
+                glUniform3fvARB(location, count, v);
+                mValue[location] = vec;
             }
         }
     }
@@ -1204,20 +1151,16 @@ void LLGLSLShader::uniform4fv(U32 index, U32 count, const GLfloat* v)
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+            std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
             LLVector4 vec(v[0],v[1],v[2],v[3]);
             if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
             {
-                glUniform4fvARB(mUniform[index], count, v);
-                mValue[mUniform[index]] = vec;
+                glUniform4fvARB(location, count, v);
+                mValue[location] = vec;
             }
         }
     }
@@ -1227,15 +1170,11 @@ void LLGLSLShader::uniformMatrix2fv(U32 index, U32 count, GLboolean transpose, c
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            glUniformMatrix2fvARB(mUniform[index], count, transpose, v);
+            glUniformMatrix2fvARB(location, count, transpose, v);
         }
     }
 }
@@ -1244,15 +1183,11 @@ void LLGLSLShader::uniformMatrix3fv(U32 index, U32 count, GLboolean transpose, c
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            glUniformMatrix3fvARB(mUniform[index], count, transpose, v);
+            glUniformMatrix3fvARB(location, count, transpose, v);
         }
     }
 }
@@ -1261,15 +1196,11 @@ void LLGLSLShader::uniformMatrix3x4fv(U32 index, U32 count, GLboolean transpose,
 {
 	if (mProgramObject > 0)
 	{	
-		if (mUniform.size() <= index)
-		{
-			UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-			return;
-		}
+        GLint location = getLocationForIndex(index);
 
-		if (mUniform[index] >= 0)
+		if (location >= 0)
 		{
-			glUniformMatrix3x4fv(mUniform[index], count, transpose, v);
+			glUniformMatrix3x4fv(location, count, transpose, v);
 		}
 	}
 }
@@ -1278,15 +1209,11 @@ void LLGLSLShader::uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, c
 {
     if (mProgramObject > 0)
     {   
-        if (mUniform.size() <= index)
-        {
-            UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
-            return;
-        }
+        GLint location = getLocationForIndex(index);
 
-        if (mUniform[index] >= 0)
+        if (location >= 0)
         {
-            glUniformMatrix4fvARB(mUniform[index], count, transpose, v);
+            glUniformMatrix4fvARB(location, count, transpose, v);
         }
     }
 }
@@ -1317,14 +1244,8 @@ GLint LLGLSLShader::getUniformLocation(const LLStaticHashedString& uniform)
 
 GLint LLGLSLShader::getUniformLocation(U32 index)
 {
-    GLint ret = -1;
-    if (mProgramObject > 0)
-    {
-        llassert(index < mUniform.size());
-        return mUniform[index];
-    }
-
-    return ret;
+    /*TODO: flatten this... change calls to gUL(U32) */
+    return getLocationForIndex(index);
 }
 
 GLint LLGLSLShader::getAttribLocation(U32 attrib)
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index 6f10d122cb..75cb6cf757 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -166,14 +166,20 @@ public:
 	U32 mMatHash[LLRender::NUM_MATRIX_MODES];
 	U32 mLightHash;
 
+    typedef std::map<S32, GLint> uniforms_index_t;
+    typedef std::pair<U32, U32>  magmin_values_t;
+
+    typedef std::map < S32, magmin_values_t> magmin_filter_t;
+
 	GLhandleARB mProgramObject;
 	std::vector<GLint> mAttribute; //lookup table of attribute enum to attribute channel
 	U32 mAttributeMask;  //mask of which reserved attributes are set (lines up with LLVertexBuffer::getTypeMask())
-	std::vector<GLint> mUniform;   //lookup table of uniform enum to uniform location
+    uniforms_index_t mUniform;
+    uniforms_index_t mTexture;
+
 	LLStaticStringTable<GLint> mUniformMap; //lookup map of uniform name to uniform location
 	std::map<GLint, std::string> mUniformNameMap; //lookup map of uniform location to uniform name
 	std::map<GLint, LLVector4> mValue; //lookup map of uniform location to last known value
-	std::vector<GLint> mTexture;
 	S32 mTotalUniformSize;
 	S32 mActiveTextureChannels;
 	S32 mShaderLevel;
@@ -197,11 +203,26 @@ public:
 	static U32 sTotalDrawCalls;
 
 	bool mTextureStateFetched;
-	std::vector<U32> mTextureMagFilter;
-	std::vector<U32> mTextureMinFilter;
+    magmin_filter_t mTextureMagMinFilter;
 
 private:
 	void unloadInternal();
+
+    inline GLint getLocationForIndex(S32 index)
+    {
+        uniforms_index_t::iterator it = mUniform.find(index);
+        if (it == mUniform.end())
+            return -1;
+        return (*it).second;
+    }
+
+    inline GLint getTexChannelForIndex(S32 index)
+    {
+        uniforms_index_t::iterator it = mTexture.find(index);
+        if (it == mTexture.end())
+            return -1;
+        return (*it).second;
+    }
 };
 
 //UI shader (declared here so llui_libtest will link properly)
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index f3811fffe7..72339b2f51 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -181,6 +181,7 @@ set(viewer_SOURCE_FILES
     lldrawpoolwlsky.cpp
     lldynamictexture.cpp
     llemote.cpp
+    llenvironment.cpp
     llenvmanager.cpp
     llestateinfomodel.cpp
     lleventnotifier.cpp
@@ -803,6 +804,7 @@ set(viewer_HEADER_FILES
     lldrawpoolwlsky.h
     lldynamictexture.h
     llemote.h
+    llenvironment.h
     llenvmanager.h
     llestateinfomodel.h
     lleventnotifier.h
diff --git a/indra/newview/llwlparammanager.cpp b/indra/newview/llwlparammanager.cpp
index 980fe96c2b..41783c8667 100644
--- a/indra/newview/llwlparammanager.cpp
+++ b/indra/newview/llwlparammanager.cpp
@@ -59,6 +59,8 @@
 #include "curl/curl.h"
 #include "llstreamtools.h"
 
+#include "llenvironment.h"
+
 LLWLParamManager::LLWLParamManager() :
 
 	//set the defaults for the controls
@@ -317,8 +319,9 @@ bool LLWLParamManager::loadPreset(const std::string& path)
 		addParamSet(key, params_data);
 	}
 
-    //*RIDER temp code testing conversion old preset to new settings.
-    //LLSettingsSky::ptr_t test = LLSettingsSky::buildFromLegacyPreset(name, params_data);
+    //*LAPRAS temp code testing conversion old preset to new settings.
+    LLSettingsSky::ptr_t test = LLSettingsSky::buildFromLegacyPreset(name, params_data);
+    LLEnvironment::instance().addSky(test);
     //test->exportSettings(name);
 
 	return true;
-- 
cgit v1.3


From 150fba7c5cd24ad9ab343e762bfd15032e6a9462 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Thu, 21 Sep 2017 15:58:13 -0700
Subject: Still not working.  Black Sky.

---
 indra/newview/lldrawpoolwlsky.cpp  |  10 +-
 indra/newview/llenvironment.cpp    | 271 +++++++++++++++++++++++++++++++++++++
 indra/newview/llenvironment.h      |  81 +++++++++++
 indra/newview/llsettingsbase.h     |   5 +
 indra/newview/llsettingssky.cpp    |  69 +++++++---
 indra/newview/llsettingssky.h      |  15 +-
 indra/newview/llvosky.cpp          |  50 +++----
 indra/newview/llwlparammanager.cpp |   3 +-
 indra/newview/llwlparamset.cpp     |  20 ++-
 9 files changed, 468 insertions(+), 56 deletions(-)
 create mode 100644 indra/newview/llenvironment.cpp
 create mode 100644 indra/newview/llenvironment.h

(limited to 'indra/newview/llwlparammanager.cpp')

diff --git a/indra/newview/lldrawpoolwlsky.cpp b/indra/newview/lldrawpoolwlsky.cpp
index 309f535c39..e10bc10bc2 100644
--- a/indra/newview/lldrawpoolwlsky.cpp
+++ b/indra/newview/lldrawpoolwlsky.cpp
@@ -42,6 +42,8 @@
 #include "llface.h"
 #include "llrender.h"
 
+#include "llenvironment.h" 
+
 LLPointer<LLViewerTexture> LLDrawPoolWLSky::sCloudNoiseTexture = NULL;
 
 LLPointer<LLImageRaw> LLDrawPoolWLSky::sCloudNoiseRawImage = NULL;
@@ -190,14 +192,14 @@ void LLDrawPoolWLSky::renderStars(void) const
 	
 	// *NOTE: we divide by two here and GL_ALPHA_SCALE by two below to avoid
 	// clamping and allow the star_alpha param to brighten the stars.
-	bool error;
 	LLColor4 star_alpha(LLColor4::black);
-	star_alpha.mV[3] = LLWLParamManager::getInstance()->mCurParams.getFloat("star_brightness", error) / 2.f;
+    // *LAPRAS
+    star_alpha.mV[3] = LLEnvironment::instance().getCurrentSky()->getStarBrightness() / 2.f;
 
 	// If start_brightness is not set, exit
-	if( error )
+	if( star_alpha.mV[3] < 0.001 )
 	{
-		LL_WARNS() << "star_brightness missing in mCurParams" << LL_ENDL;
+		LL_DEBUGS("SKY") << "star_brightness below threshold." << LL_ENDL;
 		return;
 	}
 
diff --git a/indra/newview/llenvironment.cpp b/indra/newview/llenvironment.cpp
new file mode 100644
index 0000000000..dec2930970
--- /dev/null
+++ b/indra/newview/llenvironment.cpp
@@ -0,0 +1,271 @@
+/**
+ * @file llenvmanager.cpp
+ * @brief Implementation of classes managing WindLight and water settings.
+ *
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2011, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "llenvironment.h"
+
+#include "llagent.h"
+#include "lldaycyclemanager.h"
+#include "llviewercontrol.h" // for gSavedSettings
+#include "llviewerregion.h"
+#include "llwaterparammanager.h"
+#include "llwlhandlers.h"
+#include "llwlparammanager.h"
+#include "lltrans.h"
+#include "lltrace.h"
+#include "llfasttimer.h"
+#include "llviewercamera.h"
+#include "pipeline.h"
+
+//=========================================================================
+const F32 LLEnvironment::SUN_DELTA_YAW(F_PI);   // 180deg 
+
+namespace
+{
+    LLTrace::BlockTimerStatHandle   FTM_ENVIRONMENT_UPDATE("Update Environment Tick");
+    LLTrace::BlockTimerStatHandle   FTM_SHADER_PARAM_UPDATE("Update Shader Parameters");
+}
+
+//-------------------------------------------------------------------------
+LLEnvironment::LLEnvironment():
+    mCurrentSky(),
+    mSkysById(),
+    mSkysByName()
+{
+    LLSettingsSky::ptr_t p_default_sky = LLSettingsSky::buildDefaultSky();
+    addSky(p_default_sky);
+    mCurrentSky = p_default_sky;
+}
+
+LLEnvironment::~LLEnvironment()
+{
+}
+
+//-------------------------------------------------------------------------
+void LLEnvironment::update(const LLViewerCamera * cam)
+{
+    LL_RECORD_BLOCK_TIME(FTM_ENVIRONMENT_UPDATE);
+
+    // update clouds, sun, and general
+    updateCloudScroll();
+    mCurrentSky->update();
+
+//     // update only if running
+//     if (mAnimator.getIsRunning())
+//     {
+//         mAnimator.update(mCurParams);
+//     }
+
+    LLVector3 lightdir = mCurrentSky->getLightDirection();
+    // update the shaders and the menu
+
+    F32 camYaw = cam->getYaw();
+
+    stop_glerror();
+
+    // *TODO: potential optimization - this block may only need to be
+    // executed some of the time.  For example for water shaders only.
+    {
+        LLVector3 lightNorm3(mCurrentSky->getLightDirection());
+
+        lightNorm3 *= LLQuaternion(-(camYaw + SUN_DELTA_YAW), LLVector3(0.f, 1.f, 0.f));
+        mRotatedLight = LLVector4(lightNorm3, 0.f);
+
+        LLViewerShaderMgr::shader_iter shaders_iter, end_shaders;
+        end_shaders = LLViewerShaderMgr::instance()->endShaders();
+        for (shaders_iter = LLViewerShaderMgr::instance()->beginShaders(); shaders_iter != end_shaders; ++shaders_iter)
+        {
+            if ((shaders_iter->mProgramObject != 0)
+                && (gPipeline.canUseWindLightShaders()
+                || shaders_iter->mShaderGroup == LLGLSLShader::SG_WATER))
+            {
+                shaders_iter->mUniformsDirty = TRUE;
+            }
+        }
+    }
+}
+
+void LLEnvironment::updateCloudScroll()
+{
+    // This is a function of the environment rather than the sky, since it should 
+    // persist through sky transitions.
+    static LLTimer s_cloud_timer;
+
+    F64 delta_t = s_cloud_timer.getElapsedTimeAndResetF64();
+    
+    LLVector2 cloud_delta = static_cast<F32>(delta_t) * (mCurrentSky->getCloudScrollRate() - LLVector2(10.0, 10.0)) / 100.0;
+
+    mCloudScroll += cloud_delta;
+
+}
+
+void LLEnvironment::updateGLVariablesForSettings(LLGLSLShader *shader, const LLSettingsBase::ptr_t &psetting)
+{
+    LL_RECORD_BLOCK_TIME(FTM_SHADER_PARAM_UPDATE);
+
+    //_WARNS("RIDER") << "----------------------------------------------------------------" << LL_ENDL;
+    LLSettingsBase::parammapping_t params = psetting->getParameterMap();
+    for (LLSettingsBase::parammapping_t::iterator it = params.begin(); it != params.end(); ++it)
+    {
+        if (!psetting->mSettings.has((*it).first))
+            continue;
+
+        LLSD value = psetting->mSettings[(*it).first];
+        LLSD::Type setting_type = value.type();
+
+        stop_glerror();
+        switch (setting_type)
+        {
+        case LLSD::TypeInteger:
+            shader->uniform1i((*it).second, value.asInteger());
+            //_WARNS("RIDER") << "pushing '" << (*it).first << "' as " << value << LL_ENDL;
+            break;
+        case LLSD::TypeReal:
+            shader->uniform1f((*it).second, value.asReal());
+            //_WARNS("RIDER") << "pushing '" << (*it).first << "' as " << value << LL_ENDL;
+            break;
+
+        case LLSD::TypeBoolean:
+            shader->uniform1i((*it).second, value.asBoolean() ? 1 : 0);
+            //_WARNS("RIDER") << "pushing '" << (*it).first << "' as " << value << LL_ENDL;
+            break;
+
+        case LLSD::TypeArray:
+        {
+            LLVector4 vect4(value);
+            //_WARNS("RIDER") << "pushing '" << (*it).first << "' as " << vect4 << LL_ENDL;
+            shader->uniform4fv((*it).second, 4, vect4.mV);
+
+            break;
+        }
+
+        //  case LLSD::TypeMap:
+        //  case LLSD::TypeString:
+        //  case LLSD::TypeUUID:
+        //  case LLSD::TypeURI:
+        //  case LLSD::TypeBinary:
+        //  case LLSD::TypeDate:
+        default:
+            break;
+        }
+        stop_glerror();
+    }
+    //_WARNS("RIDER") << "----------------------------------------------------------------" << LL_ENDL;
+
+//    psetting->applySpecial(shader);
+
+    if (LLPipeline::sRenderDeferred && !LLPipeline::sReflectionRender && !LLPipeline::sUnderWaterRender)
+    {
+        shader->uniform1f(LLShaderMgr::GLOBAL_GAMMA, 2.2);
+    }
+    else 
+    {
+        shader->uniform1f(LLShaderMgr::GLOBAL_GAMMA, 1.0);
+    }
+
+}
+
+void LLEnvironment::updateShaderUniforms(LLGLSLShader *shader)
+{
+
+    if (gPipeline.canUseWindLightShaders())
+    {
+        updateGLVariablesForSettings(shader, mCurrentSky);
+    }
+
+    if (shader->mShaderGroup == LLGLSLShader::SG_DEFAULT)
+    {
+        stop_glerror();
+        shader->uniform4fv(LLShaderMgr::LIGHTNORM, 1, mRotatedLight.mV);
+        shader->uniform3fv(LLShaderMgr::WL_CAMPOSLOCAL, 1, LLViewerCamera::getInstance()->getOrigin().mV);
+        stop_glerror();
+    }
+    else if (shader->mShaderGroup == LLGLSLShader::SG_SKY)
+    {
+        stop_glerror();
+        shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, mCurrentSky->getLightDirectionClamped().mV);
+        stop_glerror();
+    }
+
+    shader->uniform1f(LLShaderMgr::SCENE_LIGHT_STRENGTH, mCurrentSky->getSceneLightStrength());
+
+    {
+        LLVector4 cloud_scroll(mCloudScroll[0], mCloudScroll[1], 0.0, 0.0);
+//         val.mV[0] = F32(i->second[0].asReal()) + mCloudScrollXOffset;
+//         val.mV[1] = F32(i->second[1].asReal()) + mCloudScrollYOffset;
+//         val.mV[2] = (F32)i->second[2].asReal();
+//         val.mV[3] = (F32)i->second[3].asReal();
+
+        stop_glerror();
+        shader->uniform4fv(LLSettingsSky::SETTING_CLOUD_POS_DENSITY1, 1, cloud_scroll.mV);
+        stop_glerror();
+    }
+
+
+}
+//--------------------------------------------------------------------------
+
+void LLEnvironment::addSky(const LLSettingsSky::ptr_t &sky)
+{
+    std::string name = sky->getValue(LLSettingsSky::SETTING_NAME).asString();
+
+    std::pair<NamedSkyMap_t::iterator, bool> result;
+    result = mSkysByName.insert(NamedSkyMap_t::value_type(name, sky));
+
+    if (!result.second)
+        (*(result.first)).second = sky;
+}
+
+void LLEnvironment::addSky(const LLUUID &id, const LLSettingsSky::ptr_t &sky)
+{
+    //     std::string name = sky->getValue(LLSettingsSky::SETTING_NAME).asString();
+    // 
+    //     std::pair<NamedSkyMap_t::iterator, bool> result;
+    //     result = mSkysByName.insert(NamedSkyMap_t::value_type(name, sky));
+    // 
+    //     if (!result.second)
+    //         (*(result.first)).second = sky;
+}
+
+void LLEnvironment::removeSky(const std::string &name)
+{
+    NamedSkyMap_t::iterator it = mSkysByName.find(name);
+    if (it != mSkysByName.end())
+        mSkysByName.erase(it);
+}
+
+void LLEnvironment::removeSky(const LLUUID &id)
+{
+
+}
+
+void LLEnvironment::clearAllSkys()
+{
+    mSkysByName.clear();
+    mSkysById.clear();
+}
+
diff --git a/indra/newview/llenvironment.h b/indra/newview/llenvironment.h
new file mode 100644
index 0000000000..bbb5f45ad9
--- /dev/null
+++ b/indra/newview/llenvironment.h
@@ -0,0 +1,81 @@
+/**
+ * @file llenvmanager.h
+ * @brief Declaration of classes managing WindLight and water settings.
+ *
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2011, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_ENVIRONMENT_H
+#define LL_ENVIRONMENT_H
+
+#include "llmemory.h"
+#include "llsd.h"
+
+#include "llsettingssky.h"
+
+class LLViewerCamera;
+class LLGLSLShader;
+
+//-------------------------------------------------------------------------
+class LLEnvironment : public LLSingleton<LLEnvironment>
+{
+    LLSINGLETON(LLEnvironment);
+    LOG_CLASS(LLEnvironment);
+
+public:
+    virtual ~LLEnvironment();
+
+    LLSettingsSky::ptr_t    getCurrentSky() const { return mCurrentSky; }
+
+    void                    update(const LLViewerCamera * cam);
+
+    LLVector4               getRotatedLightDir() const { return mRotatedLight; }
+
+    void                    updateGLVariablesForSettings(LLGLSLShader *shader, const LLSettingsBase::ptr_t &psetting);
+    void                    updateShaderUniforms(LLGLSLShader *shader);
+
+    void                    addSky(const LLSettingsSky::ptr_t &sky);
+private:
+    static const F32        SUN_DELTA_YAW;
+
+    typedef std::map<std::string, LLSettingsSky::ptr_t> NamedSkyMap_t;
+    typedef std::map<LLUUID, LLSettingsSky::ptr_t> AssetSkyMap_t;
+
+    LLVector4               mRotatedLight;
+    LLVector2               mCloudScroll;
+
+    LLSettingsSky::ptr_t    mCurrentSky;
+
+    NamedSkyMap_t           mSkysByName;
+    AssetSkyMap_t           mSkysById;
+
+    void addSky(const LLUUID &id, const LLSettingsSky::ptr_t &sky);
+    void removeSky(const std::string &name);
+    void removeSky(const LLUUID &id);
+    void clearAllSkys();
+
+    void updateCloudScroll();
+};
+
+
+#endif // LL_ENVIRONMENT_H
+
diff --git a/indra/newview/llsettingsbase.h b/indra/newview/llsettingsbase.h
index 01a19c8734..cd5098cbb6 100644
--- a/indra/newview/llsettingsbase.h
+++ b/indra/newview/llsettingsbase.h
@@ -45,6 +45,8 @@ class LLSettingsBase: private boost::noncopyable
     friend class LLEnvironment;
 
 public:
+    typedef std::map<std::string, S32>  parammapping_t;
+
     typedef boost::shared_ptr<LLSettingsBase> ptr_t;
 
     virtual ~LLSettingsBase() { };
@@ -122,6 +124,7 @@ protected:
 
     typedef std::set<std::string>   stringset_t;
 
+
     // combining settings objects. Customize for specific setting types
     virtual void lerpSettings(const LLSettingsBase &other, F32 mix);
 
@@ -141,6 +144,8 @@ protected:
     // Apply any settings that need special handling. 
     virtual void applySpecial(void *) { };
 
+    virtual parammapping_t getParameterMap() const { return parammapping_t(); }
+
     LLSD    mSettings;
 
 private:
diff --git a/indra/newview/llsettingssky.cpp b/indra/newview/llsettingssky.cpp
index 364c211344..26ed719b3b 100644
--- a/indra/newview/llsettingssky.cpp
+++ b/indra/newview/llsettingssky.cpp
@@ -117,17 +117,17 @@ LLSettingsSky::ptr_t LLSettingsSky::buildFromLegacyPreset(const std::string &nam
 
     if (oldsettings.has(SETTING_AMBIENT))
     {
-        newsettings[SETTING_AMBIENT] = LLColor3(oldsettings[SETTING_AMBIENT]).getValue();
+        newsettings[SETTING_AMBIENT] = LLColor4(oldsettings[SETTING_AMBIENT]).getValue();
     }
 
     if (oldsettings.has(SETTING_BLUE_DENSITY))
     {
-        newsettings[SETTING_BLUE_DENSITY] = LLColor3(oldsettings[SETTING_BLUE_DENSITY]).getValue();
+        newsettings[SETTING_BLUE_DENSITY] = LLColor4(oldsettings[SETTING_BLUE_DENSITY]).getValue();
     }
 
     if (oldsettings.has(SETTING_BLUE_HORIZON))
     {
-        newsettings[SETTING_BLUE_HORIZON] = LLColor3(oldsettings[SETTING_BLUE_HORIZON]).getValue();
+        newsettings[SETTING_BLUE_HORIZON] = LLColor4(oldsettings[SETTING_BLUE_HORIZON]).getValue();
     }
 
     if (oldsettings.has(SETTING_CLOUD_COLOR))
@@ -188,12 +188,12 @@ LLSettingsSky::ptr_t LLSettingsSky::buildFromLegacyPreset(const std::string &nam
 
     if (oldsettings.has(SETTING_GLOW))
     {
-        newsettings[SETTING_GLOW] = LLColor3(oldsettings[SETTING_GLOW]).getValue();
+        newsettings[SETTING_GLOW] = LLColor4(oldsettings[SETTING_GLOW]).getValue();
     }
 
     if (oldsettings.has(SETTING_GAMMA))
     {
-        newsettings[SETTING_GAMMA] = LLSD::Real(oldsettings[SETTING_GAMMA][0].asReal());
+        newsettings[SETTING_GAMMA] = LLVector4(oldsettings[SETTING_GAMMA]).getValue();
     }
 
     if (oldsettings.has(SETTING_CLOUD_SCROLL_RATE))
@@ -283,21 +283,21 @@ LLSD LLSettingsSky::defaults()
     LLQuaternion moonquat = ~sunquat;
 
     // Magic constants copied form dfltsetting.xml 
-    dfltsetting[SETTING_AMBIENT]            = LLColor3::white.getValue();
-    dfltsetting[SETTING_BLUE_DENSITY]       = LLColor3(0.2447, 0.4487, 0.7599).getValue();
-    dfltsetting[SETTING_BLUE_HORIZON]       = LLColor3(0.4954, 0.4954, 0.6399).getValue();
-    dfltsetting[SETTING_CLOUD_COLOR]        = LLColor3(0.4099, 0.4099, 0.4099).getValue();
-    dfltsetting[SETTING_CLOUD_POS_DENSITY1] = LLColor3(1.0000, 0.5260, 1.0000).getValue();
-    dfltsetting[SETTING_CLOUD_POS_DENSITY2] = LLColor3(1.0000, 0.5260, 1.0000).getValue();
+    dfltsetting[SETTING_AMBIENT]            = LLColor4::white.getValue();
+    dfltsetting[SETTING_BLUE_DENSITY]       = LLColor4(0.2447, 0.4487, 0.7599, 1.0).getValue();
+    dfltsetting[SETTING_BLUE_HORIZON]       = LLColor4(0.4954, 0.4954, 0.6399, 1.0).getValue();
+    dfltsetting[SETTING_CLOUD_COLOR]        = LLColor4(0.4099, 0.4099, 0.4099, 1.0).getValue();
+    dfltsetting[SETTING_CLOUD_POS_DENSITY1] = LLColor4(1.0000, 0.5260, 1.0000, 1.0).getValue();
+    dfltsetting[SETTING_CLOUD_POS_DENSITY2] = LLColor4(1.0000, 0.5260, 1.0000, 1.0).getValue();
     dfltsetting[SETTING_CLOUD_SCALE]        = LLSD::Real(0.4199);
     dfltsetting[SETTING_CLOUD_SCROLL_RATE]  = LLSDArray(10.1999)(10.0109);
-    dfltsetting[SETTING_CLOUD_SHADOW]       = LLColor3(0.2699, 0.0000, 0.0000).getValue();
+    dfltsetting[SETTING_CLOUD_SHADOW]       = LLSD::Real(0.2699);
     dfltsetting[SETTING_DENSITY_MULTIPLIER] = LLSD::Real(0.0001);
     dfltsetting[SETTING_DISTANCE_MULTIPLIER] = LLSD::Real(0.8000);
-    dfltsetting[SETTING_DOME_OFFSET]        = LLSD::Real(1.0);
-    dfltsetting[SETTING_DOME_RADIUS]        = LLSD::Real(0.0);
-    dfltsetting[SETTING_GAMMA]              = LLSD::Real(1.0000);
-    dfltsetting[SETTING_GLOW]               = LLColor3(5.000, 0.0010, -0.4799).getValue();   // *RIDER: This is really weird for a color... TODO: check if right.
+    dfltsetting[SETTING_DOME_OFFSET]        = LLSD::Real(0.96f);
+    dfltsetting[SETTING_DOME_RADIUS]        = LLSD::Real(15000.f);
+    dfltsetting[SETTING_GAMMA]              = LLVector4(1.0, 0.0, 0.0, 1.0).getValue();
+    dfltsetting[SETTING_GLOW]               = LLColor4(5.000, 0.0010, -0.4799, 1.0).getValue();   // *RIDER: This is really weird for a color... TODO: check if right.
     dfltsetting[SETTING_HAZE_DENSITY]       = LLSD::Real(0.6999);
     dfltsetting[SETTING_HAZE_HORIZON]       = LLSD::Real(0.1899);
     dfltsetting[SETTING_LIGHT_NORMAL]       = LLVector4(0.0000, 0.9126, -0.4086, 0.0000).getValue();
@@ -305,7 +305,7 @@ LLSD LLSettingsSky::defaults()
     dfltsetting[SETTING_MOON_ROTATION]      = moonquat.getValue();
     dfltsetting[SETTING_NAME]               = std::string("_default_");
     dfltsetting[SETTING_STAR_BRIGHTNESS]    = LLSD::Real(0.0000);
-    dfltsetting[SETTING_SUNLIGHT_COLOR]     = LLColor3(0.7342, 0.7815, 0.8999).getValue();
+    dfltsetting[SETTING_SUNLIGHT_COLOR]     = LLColor4(0.7342, 0.7815, 0.8999, 1.0).getValue();
     dfltsetting[SETTING_SUN_ROTATION]       = sunquat.getValue();
 
     dfltsetting[SETTING_BLOOM_TEXTUREID]    = LLUUID::null;
@@ -468,10 +468,37 @@ void LLSettingsSky::calculateLightSettings()
     mTotalAmbient.setAlpha(1);
 
     mFadeColor = mTotalAmbient + (mSunDiffuse + mMoonDiffuse) * 0.5f;
-    mFadeColor.setAlpha(0);
+    mFadeColor.setAlpha(1);
 
 }
 
+LLSettingsSky::parammapping_t LLSettingsSky::getParameterMap() const
+{
+    static parammapping_t param_map;
+
+    if (param_map.empty())
+    {
+        param_map[SETTING_AMBIENT] = LLShaderMgr::AMBIENT;
+        param_map[SETTING_BLUE_DENSITY] = LLShaderMgr::BLUE_DENSITY;
+        param_map[SETTING_BLUE_HORIZON] = LLShaderMgr::BLUE_HORIZON;
+        param_map[SETTING_CLOUD_COLOR] = LLShaderMgr::CLOUD_COLOR;
+        param_map[SETTING_CLOUD_POS_DENSITY1] = LLShaderMgr::CLOUD_POS_DENSITY1;
+        param_map[SETTING_CLOUD_POS_DENSITY2] = LLShaderMgr::CLOUD_POS_DENSITY2;
+        param_map[SETTING_CLOUD_SCALE] = LLShaderMgr::CLOUD_SCALE;
+        param_map[SETTING_CLOUD_SHADOW] = LLShaderMgr::CLOUD_SHADOW;
+        param_map[SETTING_DENSITY_MULTIPLIER] = LLShaderMgr::DENSITY_MULTIPLIER;
+        param_map[SETTING_DISTANCE_MULTIPLIER] = LLShaderMgr::DISTANCE_MULTIPLIER;
+        param_map[SETTING_GAMMA] = LLShaderMgr::GAMMA;
+        param_map[SETTING_GLOW] = LLShaderMgr::GLOW;
+        param_map[SETTING_HAZE_DENSITY] = LLShaderMgr::HAZE_DENSITY;
+        param_map[SETTING_HAZE_HORIZON] = LLShaderMgr::HAZE_HORIZON;
+        param_map[SETTING_MAX_Y] = LLShaderMgr::MAX_Y;
+        param_map[SETTING_SUNLIGHT_COLOR] = LLShaderMgr::SUNLIGHT_COLOR;
+    }
+
+    return param_map;
+}
+
 
 LLSettingsSky::stringset_t LLSettingsSky::getSkipApplyKeys() const
 {
@@ -480,14 +507,14 @@ LLSettingsSky::stringset_t LLSettingsSky::getSkipApplyKeys() const
 
     if (skip_apply_set.empty())
     {
-        skip_apply_set.insert(SETTING_GAMMA);
         skip_apply_set.insert(SETTING_MOON_ROTATION);
         skip_apply_set.insert(SETTING_SUN_ROTATION);
         skip_apply_set.insert(SETTING_NAME);
         skip_apply_set.insert(SETTING_STAR_BRIGHTNESS);
         skip_apply_set.insert(SETTING_CLOUD_SCROLL_RATE);
         skip_apply_set.insert(SETTING_LIGHT_NORMAL);
-        skip_apply_set.insert(SETTING_CLOUD_POS_DENSITY1);
+        skip_apply_set.insert(SETTING_DOME_OFFSET);
+        skip_apply_set.insert(SETTING_DOME_RADIUS);
     }
 
     return skip_apply_set;
@@ -505,6 +532,8 @@ void LLSettingsSky::applySpecial(void *ptarget)
     shader->uniform1f(LLShaderMgr::SCENE_LIGHT_STRENGTH, mSceneLightStrength);
     
     shader->uniform4f(LLShaderMgr::GAMMA, getGama(), 0.0, 0.0, 1.0);
+
+
 }
 
 //-------------------------------------------------------------------------
diff --git a/indra/newview/llsettingssky.h b/indra/newview/llsettingssky.h
index 5b8691fa8b..2fb9ff3887 100644
--- a/indra/newview/llsettingssky.h
+++ b/indra/newview/llsettingssky.h
@@ -161,12 +161,12 @@ public:
 
     F32 getGama() const
     {
-        return mSettings[SETTING_GAMMA].asReal();
+        return mSettings[SETTING_GAMMA][0].asReal();
     }
 
     LLColor3 getGlow() const
     {
-        return mSettings[SETTING_GLOW].asReal();
+        return LLColor3(mSettings[SETTING_GLOW]);
     }
 
     F32 getHazeDensity() const
@@ -179,6 +179,11 @@ public:
         return mSettings[SETTING_HAZE_HORIZON].asReal();
     }
 
+    LLVector3 getLightNormal() const
+    {
+        return LLVector3(mSettings[SETTING_LIGHT_NORMAL]);
+    }
+
     F32 getMaxY() const
     {
         return mSettings[SETTING_MAX_Y].asReal();
@@ -289,6 +294,8 @@ protected:
 
     virtual void        updateSettings();
 
+    virtual parammapping_t getParameterMap() const;
+
     virtual stringset_t getSkipApplyKeys() const;
     virtual void        applySpecial(void *);
 
@@ -309,6 +316,10 @@ private:
     
     LLColor4    mTotalAmbient;
     LLColor4    mFadeColor;
+
+    typedef std::map<std::string, S32> mapNameToUniformId_t;
+
+    static mapNameToUniformId_t sNameToUniformMapping;
 };
 
 #endif
diff --git a/indra/newview/llvosky.cpp b/indra/newview/llvosky.cpp
index 03dfdf92fa..ce956b7fda 100644
--- a/indra/newview/llvosky.cpp
+++ b/indra/newview/llvosky.cpp
@@ -52,6 +52,9 @@
 #include "llwaterparammanager.h"
 #include "v3colorutil.h"
 
+#include "llsettingssky.h"
+#include "llenvironment.h"
+
 #undef min
 #undef max
 
@@ -327,8 +330,6 @@ LLVOSky::LLVOSky(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
 	mWorldScale(1.f),
 	mBumpSunDir(0.f, 0.f, 1.f)
 {
-	bool error = false;
-	
 	/// WL PARAMS
 	dome_radius = 1.f;
 	dome_offset_ratio = 0.f;
@@ -367,7 +368,9 @@ LLVOSky::LLVOSky(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
 	mAtmHeight = ATM_HEIGHT;
 	mEarthCenter = LLVector3(mCameraPosAgent.mV[0], mCameraPosAgent.mV[1], -EARTH_RADIUS);
 
-	mSunDefaultPosition = LLVector3(LLWLParamManager::getInstance()->mCurParams.getVector("lightnorm", error));
+    // *LAPRAS
+    mSunDefaultPosition = LLEnvironment::instance().getCurrentSky()->getLightNormal();
+
 	if (gSavedSettings.getBOOL("SkyOverrideSimSunPosition"))
 	{
 		initSunDirection(mSunDefaultPosition, LLVector3(0, 0, 0));
@@ -563,27 +566,28 @@ void LLVOSky::createSkyTexture(const S32 side, const S32 tile)
 
 void LLVOSky::initAtmospherics(void)
 {	
-	bool error;
 	
-	// uniform parameters for convenience
-	dome_radius = LLWLParamManager::getInstance()->getDomeRadius();
-	dome_offset_ratio = LLWLParamManager::getInstance()->getDomeOffset();
-	sunlight_color = LLColor3(LLWLParamManager::getInstance()->mCurParams.getVector("sunlight_color", error));
-	ambient = LLColor3(LLWLParamManager::getInstance()->mCurParams.getVector("ambient", error));
-	//lightnorm = LLWLParamManager::getInstance()->mCurParams.getVector("lightnorm", error);
-	gamma = LLWLParamManager::getInstance()->mCurParams.getFloat("gamma", error);
-	blue_density = LLColor3(LLWLParamManager::getInstance()->mCurParams.getVector("blue_density", error));
-	blue_horizon = LLColor3(LLWLParamManager::getInstance()->mCurParams.getVector("blue_horizon", error));
-	haze_density = LLWLParamManager::getInstance()->mCurParams.getFloat("haze_density", error);
-	haze_horizon = LLWLParamManager::getInstance()->mCurParams.getFloat("haze_horizon", error);
-	density_multiplier = LLWLParamManager::getInstance()->mCurParams.getFloat("density_multiplier", error);
-	max_y = LLWLParamManager::getInstance()->mCurParams.getFloat("max_y", error);
-	glow = LLColor3(LLWLParamManager::getInstance()->mCurParams.getVector("glow", error));
-	cloud_shadow = LLWLParamManager::getInstance()->mCurParams.getFloat("cloud_shadow", error);
-	cloud_color = LLColor3(LLWLParamManager::getInstance()->mCurParams.getVector("cloud_color", error));
-	cloud_scale = LLWLParamManager::getInstance()->mCurParams.getFloat("cloud_scale", error);
-	cloud_pos_density1 = LLColor3(LLWLParamManager::getInstance()->mCurParams.getVector("cloud_pos_density1", error));
-	cloud_pos_density2 = LLColor3(LLWLParamManager::getInstance()->mCurParams.getVector("cloud_pos_density2", error));
+    // *LAPRAS
+    // uniform parameters for convenience
+    LLSettingsSky::ptr_t sky = LLEnvironment::instance().getCurrentSky();
+
+    dome_radius = sky->getDomeRadius();
+    dome_offset_ratio = sky->getDomeOffset();
+    sunlight_color = sky->getSunlightColor();
+    ambient = sky->getAmbientColor();
+    gamma = sky->getGama();
+    blue_density = sky->getBlueDensity();
+    blue_horizon = sky->getBlueHorizon();
+    haze_density = sky->getHazeDensity();
+    haze_horizon = sky->getHazeHorizon();
+    density_multiplier = sky->getDensityMultiplier();
+    max_y = sky->getMaxY();
+    glow = sky->getGlow();
+    cloud_shadow = sky->getCloudShadow();
+    cloud_color = sky->getCloudColor();
+    cloud_scale = sky->getCloudScale();
+    cloud_pos_density1 = sky->getCloudPosDensity1();
+    cloud_pos_density2 = sky->getCloudPosDensity2();
 
 	// light norm is different.  We need the sun's direction, not the light direction
 	// which could be from the moon.  And we need to clamp it
diff --git a/indra/newview/llwlparammanager.cpp b/indra/newview/llwlparammanager.cpp
index 41783c8667..de2d3bc41d 100644
--- a/indra/newview/llwlparammanager.cpp
+++ b/indra/newview/llwlparammanager.cpp
@@ -351,7 +351,8 @@ void LLWLParamManager::updateShaderUniforms(LLGLSLShader * shader)
 {
 	if (gPipeline.canUseWindLightShaders())
 	{
-		mCurParams.update(shader);
+        LLEnvironment::instance().updateGLVariablesForSettings(shader, LLEnvironment::instance().getCurrentSky());
+		//mCurParams.update(shader);
 	}
 
 	if (shader->mShaderGroup == LLGLSLShader::SG_DEFAULT)
diff --git a/indra/newview/llwlparamset.cpp b/indra/newview/llwlparamset.cpp
index 066cb9a0ac..a2ff2c0c95 100644
--- a/indra/newview/llwlparamset.cpp
+++ b/indra/newview/llwlparamset.cpp
@@ -65,6 +65,8 @@ static LLTrace::BlockTimerStatHandle FTM_WL_PARAM_UPDATE("WL Param Update");
 void LLWLParamSet::update(LLGLSLShader * shader) const 
 {	
 	LL_RECORD_BLOCK_TIME(FTM_WL_PARAM_UPDATE);
+    //_WARNS("RIDER") << "----------------------------------------------------------------" << LL_ENDL;
+
 	LLSD::map_const_iterator i = mParamValues.beginMap();
 	std::vector<LLStaticHashedString>::const_iterator n = mParamHashedNames.begin();
 	for(;(i != mParamValues.endMap()) && (n != mParamHashedNames.end());++i, n++)
@@ -91,7 +93,8 @@ void LLWLParamSet::update(LLGLSLShader * shader) const
 			val.mV[3] = (F32) i->second[3].asReal();
 
 			stop_glerror();
-			shader->uniform4fv(param, 1, val.mV);
+            //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
+            shader->uniform4fv(param, 1, val.mV);
 			stop_glerror();
 		}
 		else if (param == sCloudScale || param == sCloudShadow ||
@@ -102,7 +105,8 @@ void LLWLParamSet::update(LLGLSLShader * shader) const
 			F32 val = (F32) i->second[0].asReal();
 
 			stop_glerror();
-			shader->uniform1f(param, val);
+            //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
+            shader->uniform1f(param, val);
 			stop_glerror();
 		}
 		else // param is the uniform name
@@ -118,7 +122,8 @@ void LLWLParamSet::update(LLGLSLShader * shader) const
 				val.mV[3] = (F32) i->second[3].asReal();															
 
 				stop_glerror();
-				shader->uniform4fv(param, 1, val.mV);
+                //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
+                shader->uniform4fv(param, 1, val.mV);
 				stop_glerror();
 			} 
 			else if (i->second.isReal())
@@ -126,7 +131,8 @@ void LLWLParamSet::update(LLGLSLShader * shader) const
 				F32 val = (F32) i->second.asReal();
 
 				stop_glerror();
-				shader->uniform1f(param, val);
+                //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
+                shader->uniform1f(param, val);
 				stop_glerror();
 			} 
 			else if (i->second.isInteger())
@@ -134,7 +140,8 @@ void LLWLParamSet::update(LLGLSLShader * shader) const
 				S32 val = (S32) i->second.asInteger();
 
 				stop_glerror();
-				shader->uniform1i(param, val);
+                //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
+                shader->uniform1i(param, val);
 				stop_glerror();
 			} 
 			else if (i->second.isBoolean())
@@ -142,7 +149,8 @@ void LLWLParamSet::update(LLGLSLShader * shader) const
 				S32 val = (i->second.asBoolean() ? 1 : 0);
 
 				stop_glerror();
-				shader->uniform1i(param, val);
+                //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
+                shader->uniform1i(param, val);
 				stop_glerror();
 			}
 		}
-- 
cgit v1.3


From 0d414c1fb579dffc122c4d021a84cd126c612e54 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Tue, 26 Sep 2017 09:19:20 -0700
Subject: Clouds still funky but better.

---
 indra/llmath/v4math.h               | 19 +++++++++++++
 indra/llrender/llglslshader.cpp     |  2 +-
 indra/llrender/llshadermgr.cpp      |  3 +-
 indra/newview/llenvironment.cpp     | 41 +++++++++++++++++----------
 indra/newview/llenvironment.h       |  5 +++-
 indra/newview/llsettingsbase.h      |  1 -
 indra/newview/llsettingssky.cpp     | 56 +++++++++++++++++--------------------
 indra/newview/llsettingssky.h       |  5 ++--
 indra/newview/llviewerdisplay.cpp   |  6 +++-
 indra/newview/llviewershadermgr.cpp |  4 ++-
 indra/newview/llwlparammanager.cpp  |  4 +--
 11 files changed, 89 insertions(+), 57 deletions(-)

(limited to 'indra/newview/llwlparammanager.cpp')

diff --git a/indra/llmath/v4math.h b/indra/llmath/v4math.h
index 293005a627..3f6d480ed9 100644
--- a/indra/llmath/v4math.h
+++ b/indra/llmath/v4math.h
@@ -30,6 +30,7 @@
 #include "llerror.h"
 #include "llmath.h"
 #include "v3math.h"
+#include "v2math.h"
 
 class LLMatrix3;
 class LLMatrix4;
@@ -46,6 +47,8 @@ class LLVector4
 		LLVector4();						// Initializes LLVector4 to (0, 0, 0, 1)
 		explicit LLVector4(const F32 *vec);			// Initializes LLVector4 to (vec[0]. vec[1], vec[2], vec[3])
 		explicit LLVector4(const F64 *vec);			// Initialized LLVector4 to ((F32) vec[0], (F32) vec[1], (F32) vec[3], (F32) vec[4]);
+        explicit LLVector4(const LLVector2 &vec);
+        explicit LLVector4(const LLVector2 &vec, F32 z, F32 w);
 		explicit LLVector4(const LLVector3 &vec);			// Initializes LLVector4 to (vec, 1)
 		explicit LLVector4(const LLVector3 &vec, F32 w);	// Initializes LLVector4 to (vec, w)
         explicit LLVector4(const LLSD &sd);
@@ -185,6 +188,22 @@ inline LLVector4::LLVector4(const F64 *vec)
 	mV[VW] = (F32) vec[VW];
 }
 
+inline LLVector4::LLVector4(const LLVector2 &vec)
+{
+    mV[VX] = vec[VX];
+    mV[VY] = vec[VY];
+    mV[VZ] = 0.f;
+    mV[VW] = 0.f;
+}
+
+inline LLVector4::LLVector4(const LLVector2 &vec, F32 z, F32 w)
+{
+    mV[VX] = vec[VX];
+    mV[VY] = vec[VY];
+    mV[VZ] = z;
+    mV[VW] = w;
+}
+
 inline LLVector4::LLVector4(const LLVector3 &vec)
 {
 	mV[VX] = vec.mV[VX];
diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index e7457826a3..bba94a976f 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -406,7 +406,7 @@ BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString> * attributes,
     for ( ; fileIter != mShaderFiles.end(); fileIter++ )
     {
         GLhandleARB shaderhandle = LLShaderMgr::instance()->loadShaderFile((*fileIter).first, mShaderLevel, (*fileIter).second, &mDefines, mFeatures.mIndexedTextureChannels);
-        LL_DEBUGS("ShaderLoading") << "SHADER FILE: " << (*fileIter).first << " mShaderLevel=" << mShaderLevel << LL_ENDL;
+        LL_DEBUGS("ShaderLoading") << "SHADER FILE: " << (*fileIter).first << " mShaderLevel=" << mShaderLevel << " shaderhandle=" << shaderhandle << LL_ENDL;
         if (shaderhandle)
         {
             attachObject(shaderhandle);
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index e721ad93fa..4e9a1f5de5 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -953,7 +953,8 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 		// Add shader file to map
 		mShaderObjects[filename] = ret;
 		shader_level = try_gpu_class;
-	}
+        LL_WARNS("RIDER") << "Shader '" << filename << "' loaded with handle=" << ret << LL_ENDL;
+    }
 	else
 	{
 		if (shader_level > 1)
diff --git a/indra/newview/llenvironment.cpp b/indra/newview/llenvironment.cpp
index dec2930970..84a1f2c1ab 100644
--- a/indra/newview/llenvironment.cpp
+++ b/indra/newview/llenvironment.cpp
@@ -117,9 +117,20 @@ void LLEnvironment::updateCloudScroll()
 
     F64 delta_t = s_cloud_timer.getElapsedTimeAndResetF64();
     
-    LLVector2 cloud_delta = static_cast<F32>(delta_t) * (mCurrentSky->getCloudScrollRate() - LLVector2(10.0, 10.0)) / 100.0;
+    LLVector2 cloud_delta = static_cast<F32>(delta_t)* (mCurrentSky->getCloudScrollRate() - LLVector2(10.0, 10.0)) / 100.0;
+    mCloudScrollDelta += cloud_delta;
+
+//     {
+//         LLVector2 v2(mCurrentSky->getCloudScrollRate());
+//         static F32 xoffset(0.f);
+//         static F32 yoffset(0.f);
+// 
+//         xoffset += F32(delta_t * (v2[0] - 10.f) / 100.f);
+//         yoffset += F32(delta_t * (v2[1] - 10.f) / 100.f);
+// 
+//         LL_WARNS("RIDER") << "offset " << mCloudScrollDelta << " vs (" << xoffset << ", " << yoffset << ")" << LL_ENDL;
+//     }
 
-    mCloudScroll += cloud_delta;
 
 }
 
@@ -158,7 +169,7 @@ void LLEnvironment::updateGLVariablesForSettings(LLGLSLShader *shader, const LLS
         {
             LLVector4 vect4(value);
             //_WARNS("RIDER") << "pushing '" << (*it).first << "' as " << vect4 << LL_ENDL;
-            shader->uniform4fv((*it).second, 4, vect4.mV);
+            shader->uniform4fv((*it).second, 1, vect4.mV);
 
             break;
         }
@@ -176,7 +187,7 @@ void LLEnvironment::updateGLVariablesForSettings(LLGLSLShader *shader, const LLS
     }
     //_WARNS("RIDER") << "----------------------------------------------------------------" << LL_ENDL;
 
-//    psetting->applySpecial(shader);
+    psetting->applySpecial(shader);
 
     if (LLPipeline::sRenderDeferred && !LLPipeline::sReflectionRender && !LLPipeline::sUnderWaterRender)
     {
@@ -213,17 +224,17 @@ void LLEnvironment::updateShaderUniforms(LLGLSLShader *shader)
 
     shader->uniform1f(LLShaderMgr::SCENE_LIGHT_STRENGTH, mCurrentSky->getSceneLightStrength());
 
-    {
-        LLVector4 cloud_scroll(mCloudScroll[0], mCloudScroll[1], 0.0, 0.0);
-//         val.mV[0] = F32(i->second[0].asReal()) + mCloudScrollXOffset;
-//         val.mV[1] = F32(i->second[1].asReal()) + mCloudScrollYOffset;
-//         val.mV[2] = (F32)i->second[2].asReal();
-//         val.mV[3] = (F32)i->second[3].asReal();
-
-        stop_glerror();
-        shader->uniform4fv(LLSettingsSky::SETTING_CLOUD_POS_DENSITY1, 1, cloud_scroll.mV);
-        stop_glerror();
-    }
+//     {
+//         LLVector4 cloud_scroll(mCloudScroll[0], mCloudScroll[1], 0.0, 0.0);
+// //         val.mV[0] = F32(i->second[0].asReal()) + mCloudScrollXOffset;
+// //         val.mV[1] = F32(i->second[1].asReal()) + mCloudScrollYOffset;
+// //         val.mV[2] = (F32)i->second[2].asReal();
+// //         val.mV[3] = (F32)i->second[3].asReal();
+// 
+//         stop_glerror();
+//         shader->uniform4fv(LLSettingsSky::SETTING_CLOUD_POS_DENSITY1, 1, cloud_scroll.mV);
+//         stop_glerror();
+//     }
 
 
 }
diff --git a/indra/newview/llenvironment.h b/indra/newview/llenvironment.h
index bbb5f45ad9..3a834963f3 100644
--- a/indra/newview/llenvironment.h
+++ b/indra/newview/llenvironment.h
@@ -54,6 +54,9 @@ public:
     void                    updateShaderUniforms(LLGLSLShader *shader);
 
     void                    addSky(const LLSettingsSky::ptr_t &sky);
+
+    inline LLVector2        getCloudScrollDelta() const { return mCloudScrollDelta; }
+
 private:
     static const F32        SUN_DELTA_YAW;
 
@@ -61,7 +64,7 @@ private:
     typedef std::map<LLUUID, LLSettingsSky::ptr_t> AssetSkyMap_t;
 
     LLVector4               mRotatedLight;
-    LLVector2               mCloudScroll;
+    LLVector2               mCloudScrollDelta;  // cumulative cloud delta
 
     LLSettingsSky::ptr_t    mCurrentSky;
 
diff --git a/indra/newview/llsettingsbase.h b/indra/newview/llsettingsbase.h
index cd5098cbb6..142b74caf9 100644
--- a/indra/newview/llsettingsbase.h
+++ b/indra/newview/llsettingsbase.h
@@ -140,7 +140,6 @@ protected:
     // Calculate any custom settings that may need to be cached.
     virtual void updateSettings() { mDirty = false; };
 
-    virtual stringset_t getSkipApplyKeys() const { return stringset_t(); }
     // Apply any settings that need special handling. 
     virtual void applySpecial(void *) { };
 
diff --git a/indra/newview/llsettingssky.cpp b/indra/newview/llsettingssky.cpp
index 26ed719b3b..1d71140430 100644
--- a/indra/newview/llsettingssky.cpp
+++ b/indra/newview/llsettingssky.cpp
@@ -37,6 +37,7 @@
 #include "llglslshader.h"
 #include "llviewershadermgr.h"
 
+#include "llenvironment.h"
 #include "llsky.h"
 
 //=========================================================================
@@ -482,7 +483,7 @@ LLSettingsSky::parammapping_t LLSettingsSky::getParameterMap() const
         param_map[SETTING_BLUE_DENSITY] = LLShaderMgr::BLUE_DENSITY;
         param_map[SETTING_BLUE_HORIZON] = LLShaderMgr::BLUE_HORIZON;
         param_map[SETTING_CLOUD_COLOR] = LLShaderMgr::CLOUD_COLOR;
-        param_map[SETTING_CLOUD_POS_DENSITY1] = LLShaderMgr::CLOUD_POS_DENSITY1;
+
         param_map[SETTING_CLOUD_POS_DENSITY2] = LLShaderMgr::CLOUD_POS_DENSITY2;
         param_map[SETTING_CLOUD_SCALE] = LLShaderMgr::CLOUD_SCALE;
         param_map[SETTING_CLOUD_SHADOW] = LLShaderMgr::CLOUD_SHADOW;
@@ -499,44 +500,37 @@ LLSettingsSky::parammapping_t LLSettingsSky::getParameterMap() const
     return param_map;
 }
 
-
-LLSettingsSky::stringset_t LLSettingsSky::getSkipApplyKeys() const
-{
-
-    static stringset_t skip_apply_set;
-
-    if (skip_apply_set.empty())
-    {
-        skip_apply_set.insert(SETTING_MOON_ROTATION);
-        skip_apply_set.insert(SETTING_SUN_ROTATION);
-        skip_apply_set.insert(SETTING_NAME);
-        skip_apply_set.insert(SETTING_STAR_BRIGHTNESS);
-        skip_apply_set.insert(SETTING_CLOUD_SCROLL_RATE);
-        skip_apply_set.insert(SETTING_LIGHT_NORMAL);
-        skip_apply_set.insert(SETTING_DOME_OFFSET);
-        skip_apply_set.insert(SETTING_DOME_RADIUS);
-    }
-
-    return skip_apply_set;
-}
-
 void LLSettingsSky::applySpecial(void *ptarget)
 {
     LLGLSLShader *shader = (LLGLSLShader *)ptarget;
 
-    if (shader->mShaderGroup == LLGLSLShader::SG_SKY)
-    {
-        shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, mLightDirectionClamped.mV);
-    }
+    shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, mLightDirectionClamped.mV);
 
     shader->uniform1f(LLShaderMgr::SCENE_LIGHT_STRENGTH, mSceneLightStrength);
     
     shader->uniform4f(LLShaderMgr::GAMMA, getGama(), 0.0, 0.0, 1.0);
 
+    {
+        //LLEnvironment::instance().getCloudDelta();
+        LLVector4 vect_c_p_d1(mSettings[SETTING_CLOUD_POS_DENSITY1]);
+        vect_c_p_d1 += LLVector4(LLEnvironment::instance().getCloudScrollDelta());
+        shader->uniform4fv(LLShaderMgr::CLOUD_POS_DENSITY1, 1, vect_c_p_d1.mV);
+    }
 
-}
+//     {
+//         LLVector4 val(mSettings[ ];
+//         val.mV[0] = F32(i->second[0].asReal()) + mCloudScrollXOffset;
+//         val.mV[1] = F32(i->second[1].asReal()) + mCloudScrollYOffset;
+//         val.mV[2] = (F32)i->second[2].asReal();
+//         val.mV[3] = (F32)i->second[3].asReal();
+// 
+//         stop_glerror();
+//         //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
+//         shader->uniform4fv(param, 1, val.mV);
+//         stop_glerror();
+// 
+//     }
 
-//-------------------------------------------------------------------------
-// const std::string LLSettingsSky::SETTING_DENSITY_MULTIPLIER("density_multiplier");
-// const std::string LLSettingsSky::SETTING_LIGHT_NORMAL("lightnorm");
-// const std::string LLSettingsSky::SETTING_NAME("name");
+    //param_map[SETTING_CLOUD_POS_DENSITY1] = LLShaderMgr::CLOUD_POS_DENSITY1;
+
+}
diff --git a/indra/newview/llsettingssky.h b/indra/newview/llsettingssky.h
index 2fb9ff3887..4e333f0584 100644
--- a/indra/newview/llsettingssky.h
+++ b/indra/newview/llsettingssky.h
@@ -116,12 +116,12 @@ public:
 
     LLColor3 getCloudPosDensity1() const
     {
-        return mSettings[SETTING_CLOUD_POS_DENSITY1].asReal();
+        return LLColor3(mSettings[SETTING_CLOUD_POS_DENSITY1]);
     }
 
     LLColor3 getCloudPosDensity2() const
     {
-        return mSettings[SETTING_CLOUD_POS_DENSITY2].asReal();
+        return LLColor3(mSettings[SETTING_CLOUD_POS_DENSITY2]);
     }
 
     F32 getCloudScale() const
@@ -296,7 +296,6 @@ protected:
 
     virtual parammapping_t getParameterMap() const;
 
-    virtual stringset_t getSkipApplyKeys() const;
     virtual void        applySpecial(void *);
 
 private:
diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index e53db403e1..d810d7077b 100644
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -79,6 +79,8 @@
 #include "llpostprocess.h"
 #include "llscenemonitor.h"
 
+#include "llenvironment.h"
+
 extern LLPointer<LLViewerTexture> gStartTexture;
 extern bool gShiftFrame;
 
@@ -200,7 +202,9 @@ void display_update_camera()
 	gViewerWindow->setup3DRender();
 	
 	// update all the sky/atmospheric/water settings
-	LLWLParamManager::getInstance()->update(LLViewerCamera::getInstance());
+	// *LAPRAS
+	//LLWLParamManager::getInstance()->update(LLViewerCamera::getInstance());
+    LLEnvironment::instance().update(LLViewerCamera::getInstance());
 	LLWaterParamManager::getInstance()->update(LLViewerCamera::getInstance());
 
 	// Update land visibility too
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index 8adc86b423..313cdaa500 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -45,6 +45,7 @@
 #include "llrender.h"
 #include "lljoint.h"
 #include "llskinningutil.h"
+#include "llenvironment.h"
 
 #ifdef LL_RELEASE_FOR_DOWNLOAD
 #define UNIFORM_ERRS LL_WARNS_ONCE("Shader")
@@ -3430,7 +3431,8 @@ std::string LLViewerShaderMgr::getShaderDirPrefix(void)
 void LLViewerShaderMgr::updateShaderUniforms(LLGLSLShader * shader)
 {
     //*LAPRAS*/
-	LLWLParamManager::getInstance()->updateShaderUniforms(shader);
+    LLEnvironment::instance().updateShaderUniforms(shader);
+	//LLWLParamManager::getInstance()->updateShaderUniforms(shader);
 	LLWaterParamManager::getInstance()->updateShaderUniforms(shader);
 }
 
diff --git a/indra/newview/llwlparammanager.cpp b/indra/newview/llwlparammanager.cpp
index de2d3bc41d..b6e1c36a33 100644
--- a/indra/newview/llwlparammanager.cpp
+++ b/indra/newview/llwlparammanager.cpp
@@ -351,8 +351,8 @@ void LLWLParamManager::updateShaderUniforms(LLGLSLShader * shader)
 {
 	if (gPipeline.canUseWindLightShaders())
 	{
-        LLEnvironment::instance().updateGLVariablesForSettings(shader, LLEnvironment::instance().getCurrentSky());
-		//mCurParams.update(shader);
+        //LLEnvironment::instance().updateGLVariablesForSettings(shader, LLEnvironment::instance().getCurrentSky());
+		mCurParams.update(shader);
 	}
 
 	if (shader->mShaderGroup == LLGLSLShader::SG_DEFAULT)
-- 
cgit v1.3


From e4b035d0cd3eaa76fd82643c17e3631c67387a54 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Thu, 5 Oct 2017 15:40:48 -0700
Subject: Skys settings object active.

---
 indra/llmath/v4color.h             |  11 +
 indra/llrender/llshadermgr.h       |   7 +-
 indra/newview/CMakeLists.txt       |   2 +
 indra/newview/llenvadapters.cpp    |  55 ++++
 indra/newview/llenvadapters.h      | 225 ++++++++++++++++
 indra/newview/llfloatereditsky.cpp | 539 +++++++++++++++----------------------
 indra/newview/llfloatereditsky.h   |  17 +-
 indra/newview/llsettingsbase.cpp   |  21 ++
 indra/newview/llsettingsbase.h     |   3 +-
 indra/newview/llsettingssky.cpp    | 176 +++++++-----
 indra/newview/llsettingssky.h      | 199 ++++++++++----
 indra/newview/llvosky.cpp          | 205 ++++----------
 indra/newview/llvosky.h            |  49 +---
 indra/newview/llwlparammanager.cpp |  34 +--
 indra/newview/llwlparammanager.h   |   9 +-
 15 files changed, 894 insertions(+), 658 deletions(-)
 create mode 100644 indra/newview/llenvadapters.cpp
 create mode 100644 indra/newview/llenvadapters.h

(limited to 'indra/newview/llwlparammanager.cpp')

diff --git a/indra/llmath/v4color.h b/indra/llmath/v4color.h
index 8f353ead5a..614cdc9f3e 100644
--- a/indra/llmath/v4color.h
+++ b/indra/llmath/v4color.h
@@ -114,9 +114,11 @@ class LLColor4
 		friend LLColor4 operator-(const LLColor4 &a, const LLColor4 &b);	// Return vector a minus b
 		friend LLColor4 operator*(const LLColor4 &a, const LLColor4 &b);	// Return component wise a * b
 		friend LLColor4 operator*(const LLColor4 &a, F32 k);				// Return rgb times scaler k (no alpha change)
+        friend LLColor4 operator/(const LLColor4 &a, F32 k);                // Return rgb divided by scalar k (no alpha change)
 		friend LLColor4 operator*(F32 k, const LLColor4 &a);				// Return rgb times scaler k (no alpha change)
 		friend LLColor4 operator%(const LLColor4 &a, F32 k);				// Return alpha times scaler k (no rgb change)
 		friend LLColor4 operator%(F32 k, const LLColor4 &a);				// Return alpha times scaler k (no rgb change)
+
 		friend bool operator==(const LLColor4 &a, const LLColor4 &b);		// Return a == b
 		friend bool operator!=(const LLColor4 &a, const LLColor4 &b);		// Return a != b
 		
@@ -477,6 +479,15 @@ inline LLColor4 operator*(const LLColor4 &a, F32 k)
 		a.mV[VW]);
 }
 
+inline LLColor4 operator/(const LLColor4 &a, F32 k)
+{
+    return LLColor4(
+        a.mV[VX] / k,
+        a.mV[VY] / k,
+        a.mV[VZ] / k,
+        a.mV[VW]);
+}
+
 inline LLColor4 operator*(F32 k, const LLColor4 &a)
 {
 	// only affects rgb (not a!)
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index 394b38f832..7bdd97200d 100644
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -30,6 +30,11 @@
 #include "llgl.h"
 #include "llglslshader.h"
 
+/*RIDER: TODO:
+ * This should use the LL Singleton<> template... but not a quick conversion.
+ * (llviewershadermgr derives from this)
+ */
+
 class LLShaderMgr
 {
 public:
@@ -215,7 +220,7 @@ public:
 		TERRAIN_ALPHARAMP,
 		
 		SHINY_ORIGIN,
-DISPLAY_GAMMA,
+        DISPLAY_GAMMA,
 		END_RESERVED_UNIFORMS
 	} eGLSLReservedUniforms;
 
diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 72339b2f51..d8d1c0b51e 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -181,6 +181,7 @@ set(viewer_SOURCE_FILES
     lldrawpoolwlsky.cpp
     lldynamictexture.cpp
     llemote.cpp
+    llenvadapters.cpp
     llenvironment.cpp
     llenvmanager.cpp
     llestateinfomodel.cpp
@@ -804,6 +805,7 @@ set(viewer_HEADER_FILES
     lldrawpoolwlsky.h
     lldynamictexture.h
     llemote.h
+    llenvadapters.h
     llenvironment.h
     llenvmanager.h
     llestateinfomodel.h
diff --git a/indra/newview/llenvadapters.cpp b/indra/newview/llenvadapters.cpp
new file mode 100644
index 0000000000..8bed0737dd
--- /dev/null
+++ b/indra/newview/llenvadapters.cpp
@@ -0,0 +1,55 @@
+/**
+ * @file llenvadapters.cpp
+ * @brief Declaration of classes managing WindLight and water settings.
+ *
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2011, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llviewerprecompiledheaders.h"
+#include "llenvadapters.h"
+
+#include "llsettingssky.h"
+//=========================================================================
+
+LLSkySettingsAdapter::LLSkySettingsAdapter():
+    mWLGamma(1.0f, LLSettingsSky::SETTING_GAMMA),
+    mBlueHorizon(LLColor4(0.25f, 0.25f, 1.0f, 1.0f), LLSettingsSky::SETTING_BLUE_HORIZON, "WLBlueHorizon"),
+    mHazeDensity(1.0f, LLSettingsSky::SETTING_HAZE_DENSITY),
+    mBlueDensity(LLColor4(0.25f, 0.25f, 0.25f, 1.0f), LLSettingsSky::SETTING_BLUE_DENSITY, "WLBlueDensity"),
+    mDensityMult(1.0f, LLSettingsSky::SETTING_DENSITY_MULTIPLIER, 1000),
+    mHazeHorizon(1.0f, LLSettingsSky::SETTING_HAZE_HORIZON),
+    mMaxAlt(4000.0f, LLSettingsSky::SETTING_MAX_Y),
+    // Lighting
+    mLightnorm(LLColor4(0.f, 0.707f, -0.707f, 1.f), LLSettingsSky::SETTING_LIGHT_NORMAL),
+    mSunlight(LLColor4(0.5f, 0.5f, 0.5f, 1.0f), LLSettingsSky::SETTING_SUNLIGHT_COLOR, "WLSunlight"),
+    mAmbient(LLColor4(0.5f, 0.75f, 1.0f, 1.19f), LLSettingsSky::SETTING_AMBIENT, "WLAmbient"),
+    mGlow(LLColor4(18.0f, 0.0f, -0.01f, 1.0f), LLSettingsSky::SETTING_GLOW),
+    // Clouds
+    mCloudColor(LLColor4(0.5f, 0.5f, 0.5f, 1.0f), LLSettingsSky::SETTING_CLOUD_COLOR, "WLCloudColor"),
+    mCloudMain(LLColor4(0.5f, 0.5f, 0.125f, 1.0f), LLSettingsSky::SETTING_CLOUD_POS_DENSITY1),
+    mCloudCoverage(0.0f, LLSettingsSky::SETTING_CLOUD_SHADOW),
+    mCloudDetail(LLColor4(0.0f, 0.0f, 0.0f, 1.0f), LLSettingsSky::SETTING_CLOUD_POS_DENSITY2),
+    mDistanceMult(1.0f, LLSettingsSky::SETTING_DISTANCE_MULTIPLIER),
+    mCloudScale(0.42f, LLSettingsSky::SETTING_CLOUD_SCALE)
+{
+
+}
diff --git a/indra/newview/llenvadapters.h b/indra/newview/llenvadapters.h
new file mode 100644
index 0000000000..fc7a47be1b
--- /dev/null
+++ b/indra/newview/llenvadapters.h
@@ -0,0 +1,225 @@
+/**
+ * @file llenvadapters.h
+ * @brief Declaration of classes managing WindLight and water settings.
+ *
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2011, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_ENVADAPTERS_H
+#define LL_ENVADAPTERS_H
+
+#include "v3math.h"
+#include "v3color.h"
+#include "v4math.h"
+#include "llsettingsbase.h"
+
+class WLColorControl 
+{
+public:
+    inline WLColorControl(LLColor4 color, const std::string& n, const std::string& slider_name = std::string()):
+        mColor(color), 
+        mName(n), 
+        mSliderName(slider_name),
+        mHasSliderName(false),
+        mIsSunOrAmbientColor(false),
+        mIsBlueHorizonOrDensity(false)
+    {
+        // if there's a slider name, say we have one
+        mHasSliderName = !mSliderName.empty();
+
+        // if it's the sun controller
+        mIsSunOrAmbientColor = (mSliderName == "WLSunlight" || mSliderName == "WLAmbient");
+        mIsBlueHorizonOrDensity = (mSliderName == "WLBlueHorizon" || mSliderName == "WLBlueDensity");
+    }
+
+    inline WLColorControl & operator = (const LLColor4 & val)
+    {
+        mColor = val;
+        return *this;
+    }
+
+    inline operator LLColor4 (void) const 
+    {
+        return mColor;
+    }
+
+    inline operator LLColor3 (void) const 
+    {
+        return vec4to3(mColor);
+    }
+
+    inline void update(const LLSettingsBase::ptr_t &psetting) const 
+    {
+        psetting->setValue(mName, mColor);
+    }
+
+    inline bool getHasSliderName() const
+    {
+        return mHasSliderName;
+    }
+
+    inline std::string getSliderName() const
+    {
+        return mSliderName;
+    }
+
+    inline bool getIsSunOrAmbientColor() const
+    {
+        return mIsSunOrAmbientColor;
+    }
+
+    inline bool getIsBlueHorizonOrDensity() const
+    {
+        return mIsBlueHorizonOrDensity;
+    }
+
+    inline F32 getRed() const
+    {
+        return mColor[0];
+    }
+
+    inline F32 getGreen() const
+    {
+        return mColor[1];
+    }
+
+    inline F32 getBlue() const
+    {
+        return mColor[2];
+    }
+
+    inline F32 getIntensity() const
+    {
+        return mColor[3];
+    }
+
+    inline void setRed(F32 red)
+    {
+        mColor[0] = red;
+    }
+
+    inline void setGreen(F32 green)
+    {
+        mColor[1] = green;
+    }
+
+    inline void setBlue(F32 blue)
+    {
+        mColor[2] = blue;
+    }
+
+    inline void setIntensity(F32 intensity)
+    {
+        mColor[3] = intensity;
+    }
+
+private:
+    LLColor4    mColor;         /// [3] is intensity, not alpha
+    std::string mName;			/// name to use to dereference params
+    std::string mSliderName;	/// name of the slider in menu
+    bool        mHasSliderName;			/// only set slider name for true color types
+    bool        mIsSunOrAmbientColor;			/// flag for if it's the sun or ambient color controller
+    bool        mIsBlueHorizonOrDensity;		/// flag for if it's the Blue Horizon or Density color controller
+
+};
+
+// float slider control
+class WLFloatControl 
+{
+public:
+    inline WLFloatControl(F32 val, const std::string& n, F32 m = 1.0f):
+        x(val), 
+        mName(n), 
+        mult(m)
+    {
+    }
+
+    inline WLFloatControl &operator = (F32 val) 
+    {
+        x = val;
+        return *this;
+    }
+
+    inline operator F32 (void) const 
+    {
+        return x;
+    }
+
+    inline void update(const LLSettingsBase::ptr_t &psetting) const 
+    {
+        psetting->setValue(mName, x);
+    }
+
+    inline F32 getMult() const
+    {
+        return mult;
+    }
+
+    inline void setValue(F32 val)
+    {
+        x = val;
+    }
+
+private:
+    F32 x;
+    std::string mName;
+    F32 mult;
+};
+
+
+//-------------------------------------------------------------------------
+class LLSkySettingsAdapter
+{
+public:
+    typedef std::shared_ptr<LLSkySettingsAdapter> ptr_t;
+    
+    LLSkySettingsAdapter();
+
+    WLFloatControl mWLGamma;
+
+    /// Atmospherics
+    WLColorControl mBlueHorizon;
+    WLFloatControl mHazeDensity;
+    WLColorControl mBlueDensity;
+    WLFloatControl mDensityMult;
+    WLFloatControl mHazeHorizon;
+    WLFloatControl mMaxAlt;
+
+    /// Lighting
+    WLColorControl mLightnorm;
+    WLColorControl mSunlight;
+    WLColorControl mAmbient;
+    WLColorControl mGlow;
+
+    /// Clouds
+    WLColorControl mCloudColor;
+    WLColorControl mCloudMain;
+    WLFloatControl mCloudCoverage;
+    WLColorControl mCloudDetail;
+    WLFloatControl mDistanceMult;
+    WLFloatControl mCloudScale;
+
+
+};
+
+#endif // LL_ENVIRONMENT_H
+
diff --git a/indra/newview/llfloatereditsky.cpp b/indra/newview/llfloatereditsky.cpp
index d809211ea7..1ca61e758f 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"
@@ -45,6 +47,10 @@
 #include "llregioninfomodel.h"
 #include "llviewerregion.h"
 
+#include "v3colorutil.h"
+#include "llenvironment.h"
+#include "llenvadapters.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;
@@ -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,6 +84,7 @@ BOOL LLFloaterEditSky::postBuild()
 	mSkyPresetCombo = getChild<LLComboBox>("sky_preset_combo");
 	mMakeDefaultCheckBox = getChild<LLCheckBoxCtrl>("make_default_cb");
 	mSaveButton = getChild<LLButton>("save");
+    mSkyAdapter = boost::make_shared<LLSkySettingsAdapter>();
 
 	initCallbacks();
 
@@ -115,7 +123,7 @@ 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
+//		LLEnvManagerNew::instance().usePrefs(); // revert changes made to current environment
 	}
 }
 
@@ -137,71 +145,69 @@ 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));
+    // *LAPRAS
+    // TODO:
+// 	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));
+	getChild<LLUICtrl>("WLBlueHorizon")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &mSkyAdapter->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));
+    getChild<LLUICtrl>("WLHazeDensity")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &mSkyAdapter->mHazeDensity));
+    getChild<LLUICtrl>("WLHazeHorizon")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &mSkyAdapter->mHazeHorizon));
+    getChild<LLUICtrl>("WLDensityMult")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &mSkyAdapter->mDensityMult));
+    getChild<LLUICtrl>("WLMaxAltitude")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &mSkyAdapter->mMaxAlt));
 
 	// blue density
-	getChild<LLUICtrl>("WLBlueDensity")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &param_mgr.mBlueDensity));
+    getChild<LLUICtrl>("WLBlueDensity")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &mSkyAdapter->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));
+    getChild<LLUICtrl>("WLGlowR")->setCommitCallback(boost::bind(&LLFloaterEditSky::onGlowRMoved, this, _1, &mSkyAdapter->mGlow));
+    getChild<LLUICtrl>("WLGlowB")->setCommitCallback(boost::bind(&LLFloaterEditSky::onGlowBMoved, this, _1, &mSkyAdapter->mGlow));
 
 	// ambient
-	getChild<LLUICtrl>("WLAmbient")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &param_mgr.mAmbient));
+    getChild<LLUICtrl>("WLAmbient")->setCommitCallback(boost::bind(&LLFloaterEditSky::onColorControlMoved, this, _1, &mSkyAdapter->mAmbient));
 
 	// time of day
-	getChild<LLUICtrl>("WLSunPos")->setCommitCallback(boost::bind(&LLFloaterEditSky::onSunMoved, this, _1, &param_mgr.mLightnorm));     // multi-slider
+    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, &param_mgr.mLightnorm));
+    getChild<LLUICtrl>("WLEastAngle")->setCommitCallback(boost::bind(&LLFloaterEditSky::onSunMoved, this, _1, &mSkyAdapter->mLightnorm));
 
 	// 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));
+    getChild<LLUICtrl>("WLDistanceMult")->setCommitCallback(boost::bind(&LLFloaterEditSky::onFloatControlMoved, this, _1, &mSkyAdapter->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 +215,250 @@ void LLFloaterEditSky::initCallbacks(void)
 
 void LLFloaterEditSky::syncControls()
 {
-	bool err;
+    LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
+    mEditSettings = psky;
 
-	LLWLParamManager * param_mgr = LLWLParamManager::getInstance();
-
-	LLWLParamSet& cur_params = param_mgr->mCurParams;
 
 	// blue horizon
-	param_mgr->mBlueHorizon = cur_params.getVector(param_mgr->mBlueHorizon.mName, err);
-	setColorSwatch("WLBlueHorizon", param_mgr->mBlueHorizon, WL_BLUE_HORIZON_DENSITY_SCALE);
+	mSkyAdapter->mBlueHorizon = psky->getBlueHorizon();
+	setColorSwatch("WLBlueHorizon", mSkyAdapter->mBlueHorizon, WL_BLUE_HORIZON_DENSITY_SCALE);
 
 	// 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);
+    mSkyAdapter->mHazeDensity = psky->getHazeDensity();
+	childSetValue("WLHazeDensity", (F32) mSkyAdapter->mHazeDensity);
+    mSkyAdapter->mHazeHorizon = psky->getHazeHorizon();
+	childSetValue("WLHazeHorizon", (F32) mSkyAdapter->mHazeHorizon);
+    mSkyAdapter->mDensityMult = psky->getDensityMultiplier();
+	childSetValue("WLDensityMult", ((F32) mSkyAdapter->mDensityMult) * mSkyAdapter->mDensityMult.getMult());
+    mSkyAdapter->mMaxAlt = psky->getMaxY();
+	childSetValue("WLMaxAltitude", (F32) mSkyAdapter->mMaxAlt);
 
 	// blue density
-	param_mgr->mBlueDensity = cur_params.getVector(param_mgr->mBlueDensity.mName, err);
-	setColorSwatch("WLBlueDensity", param_mgr->mBlueDensity, WL_BLUE_HORIZON_DENSITY_SCALE);
+    mSkyAdapter->mBlueDensity = psky->getBlueDensity();
+	setColorSwatch("WLBlueDensity", mSkyAdapter->mBlueDensity, WL_BLUE_HORIZON_DENSITY_SCALE);
 
 	// 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 = 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);
+    mSkyAdapter->mGlow = psky->getGlow();
+	childSetValue("WLGlowR", 2 - mSkyAdapter->mGlow.getRed() / 20.0f);
+	childSetValue("WLGlowB", -mSkyAdapter->mGlow.getBlue() / 5.0f);
 
 	// ambient
-	param_mgr->mAmbient = cur_params.getVector(param_mgr->mAmbient.mName, err);
-	setColorSwatch("WLAmbient", param_mgr->mAmbient, WL_SUN_AMBIENT_SLIDER_SCALE);
+    mSkyAdapter->mAmbient = psky->getAmbientColor();
+	setColorSwatch("WLAmbient", mSkyAdapter->mAmbient, WL_SUN_AMBIENT_SLIDER_SCALE);
+
+    LLSettingsSky::azimalt_t azal = psky->getSunRotationAzAl();
 
-	F32 time24 = sun_pos_to_time24(param_mgr->mCurParams.getFloat("sun_angle",err) / F_TWO_PI);
+	F32 time24 = sun_pos_to_time24(azal.second / 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);
+	childSetValue("WLEastAngle", azal.first / F_TWO_PI);
 
 	// 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 = 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 = 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 = 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);
+	childSetValue("WLCloudScrollX", scroll_rate[0] - 10.0f);
+	childSetValue("WLCloudScrollY", scroll_rate[1] - 10.0f);
 
-	param_mgr->mDistanceMult = cur_params.getFloat(param_mgr->mDistanceMult.mName, err);
-	childSetValue("WLDistanceMult", (F32) param_mgr->mDistanceMult);
+    mSkyAdapter->mDistanceMult = psky->getDistanceMultiplier();
+	childSetValue("WLDistanceMult", (F32) mSkyAdapter->mDistanceMult);
 
 	// 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;
+	getChild<LLColorSwatchCtrl>(name)->set(color / k);
 }
 
 // color control callbacks
 void LLFloaterEditSky::onColorControlMoved(LLUICtrl* ctrl, WLColorControl* color_ctrl)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
+	//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->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);
-
-	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;
-	}
+    LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
+    WLColorControl* color_ctrl = static_cast<WLColorControl *>(userdata);
 
-	// 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);
-		}
-	}
+    F32 green_value = sldr_ctrl->getValueF32();
+    F32 k = 1.0f;
 
-	color_ctrl->update(LLWLParamManager::getInstance()->mCurParams);
+    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);
 
-	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 = static_cast<LLColor4>(*ctrl);
+        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 +467,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 +476,44 @@ 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)
 {
-	LLWLParamManager::getInstance()->mAnimator.deactivate();
-
 	LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
 
-	LLWLParamManager::getInstance()->mCurParams.setStarBrightness(sldr_ctrl->getValueF32());
+    mEditSettings->setStarBrightness(sldr_ctrl->getValueF32());
 }
 
 // Clouds
 void LLFloaterEditSky::onCloudScrollXMoved(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.setCloudScrollX(sldr_ctrl->getValueF32() + 10.0f);
+    mEditSettings->setCloudScrollRateX(sldr_ctrl->getValueF32() + 10.0f);
 }
 
 void LLFloaterEditSky::onCloudScrollYMoved(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);
-}
-
-void LLFloaterEditSky::onCloudScrollXToggled(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);
-	}
-
-}
-
-void LLFloaterEditSky::onCloudScrollYToggled(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");
-
-	if (cb_ctrl->get())
-	{
-		sldr->setEnabled(false);
-	}
-	else
-	{
-		sldr->setEnabled(true);
-	}
+    mEditSettings->setCloudScrollRateY(sldr_ctrl->getValueF32() + 10.0f);
 }
 
 //=================================================================================================
@@ -662,6 +541,7 @@ bool LLFloaterEditSky::isNewPreset() const
 
 void LLFloaterEditSky::refreshSkyPresetsList()
 {
+#if 0
 	mSkyPresetCombo->removeall();
 
 	LLWLParamManager::preset_name_list_t region_presets, user_presets, sys_presets;
@@ -698,6 +578,7 @@ void LLFloaterEditSky::refreshSkyPresetsList()
 	}
 
 	mSkyPresetCombo->setLabel(getString("combo_label"));
+#endif
 }
 
 void LLFloaterEditSky::enableEditing(bool enable)
@@ -718,6 +599,7 @@ void LLFloaterEditSky::enableEditing(bool enable)
 
 void LLFloaterEditSky::saveRegionSky()
 {
+#if 0
 	LLWLParamKey key(getSelectedSkyPreset());
 	llassert(key.scope == LLEnvKey::SCOPE_REGION);
 
@@ -728,44 +610,48 @@ 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()
-{
-	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);
-		}
-	}
-
-	return key;
-}
+// LLWLParamKey LLFloaterEditSky::getSelectedSkyPreset()
+// {
+// 	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);
+// 		}
+// 	}
+// 
+// 	return key;
+// }
 
 void LLFloaterEditSky::onSkyPresetNameEdited()
 {
+#if 0
 	// Disable saving a sky preset having empty name.
 	LLWLParamKey key = getSelectedSkyPreset();
 	mSaveButton->setEnabled(!key.name.empty());
+#endif
 }
 
 void LLFloaterEditSky::onSkyPresetSelected()
 {
+#if 0
 	LLWLParamKey key = getSelectedSkyPreset();
 	LLWLParamSet sky_params;
 
@@ -783,6 +669,7 @@ void LLFloaterEditSky::onSkyPresetSelected()
 	enableEditing(can_edit);
 
 	mMakeDefaultCheckBox->setEnabled(key.scope == LLEnvKey::SCOPE_LOCAL);
+#endif
 }
 
 bool LLFloaterEditSky::onSaveAnswer(const LLSD& notification, const LLSD& response)
@@ -800,6 +687,7 @@ bool LLFloaterEditSky::onSaveAnswer(const LLSD& notification, const LLSD& respon
 
 void LLFloaterEditSky::onSaveConfirmed()
 {
+#if 0
 	// Save current params to the selected preset.
 	LLWLParamKey key(getSelectedSkyPreset());
 
@@ -824,10 +712,12 @@ void LLFloaterEditSky::onSaveConfirmed()
 	}
 
 	closeFloater();
+#endif
 }
 
 void LLFloaterEditSky::onBtnSave()
 {
+#if 0
 	LLWLParamKey selected_sky = getSelectedSkyPreset();
 	LLWLParamManager& wl_mgr = LLWLParamManager::instance();
 
@@ -863,6 +753,7 @@ void LLFloaterEditSky::onBtnSave()
 		// new preset, hence no confirmation needed
 		onSaveConfirmed();
 	}
+#endif
 }
 
 void LLFloaterEditSky::onBtnCancel()
@@ -872,6 +763,7 @@ void LLFloaterEditSky::onBtnCancel()
 
 void LLFloaterEditSky::onSkyPresetListChange()
 {
+#if 0
 	LLWLParamKey key = getSelectedSkyPreset(); // preset being edited
 	if (!LLWLParamManager::instance().hasParamSet(key))
 	{
@@ -884,10 +776,12 @@ void LLFloaterEditSky::onSkyPresetListChange()
 		// Refresh the presets list, though it may not make sense as the floater is about to be closed.
 		refreshSkyPresetsList();
 	}
+#endif
 }
 
 void LLFloaterEditSky::onRegionSettingsChange()
 {
+#if 0
 	// If creating a new sky, don't bother.
 	if (isNewPreset())
 	{
@@ -905,10 +799,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 +815,5 @@ void LLFloaterEditSky::onRegionInfoUpdate()
 	}
 
 	enableEditing(can_edit);
+#endif
 }
diff --git a/indra/newview/llfloatereditsky.h b/indra/newview/llfloatereditsky.h
index a06c4fc5fa..6aec87014d 100644
--- a/indra/newview/llfloatereditsky.h
+++ b/indra/newview/llfloatereditsky.h
@@ -28,12 +28,17 @@
 #define LL_LLFLOATEREDITSKY_H
 
 #include "llfloater.h"
-#include "llwlparammanager.h"
+#include "llsettingssky.h"
 
 class LLButton;
 class LLCheckBoxCtrl;
 class LLComboBox;
 class LLLineEditor;
+class WLColorControl;
+class LLSkySettingsAdapter;
+
+typedef boost::shared_ptr<LLSkySettingsAdapter> LLSkySettingsAdapterPtr;
+
 
 /**
  * Floater for creating or editing a sky preset.
@@ -66,6 +71,8 @@ private:
 	void onColorControlBMoved(LLUICtrl* ctrl, void* userdata);
 	void onFloatControlMoved(LLUICtrl* ctrl, void* userdata);
 
+    void adjustIntensity(WLColorControl *ctrl, F32 color, F32 scale);
+
 	// lighting callbacks for glow
 	void onGlowRMoved(LLUICtrl* ctrl, void* userdata);
 	void onGlowBMoved(LLUICtrl* ctrl, void* userdata);
@@ -80,8 +87,6 @@ private:
 	// handle cloud scrolling
 	void onCloudScrollXMoved(LLUICtrl* ctrl);
 	void onCloudScrollYMoved(LLUICtrl* ctrl);
-	void onCloudScrollXToggled(LLUICtrl* ctrl);
-	void onCloudScrollYToggled(LLUICtrl* ctrl);
 
 	//-- WL stuff ends --------------------------------------------------------
 
@@ -90,7 +95,7 @@ private:
 	void refreshSkyPresetsList();
 	void enableEditing(bool enable);
 	void saveRegionSky();
-	LLWLParamKey getSelectedSkyPreset();
+//	LLWLParamKey getSelectedSkyPreset();
 
 	void onSkyPresetNameEdited();
 	void onSkyPresetSelected();
@@ -104,10 +109,14 @@ private:
 	void onRegionSettingsChange();
 	void onRegionInfoUpdate();
 
+    LLSettingsSky::ptr_t mEditSettings;
+
 	LLLineEditor*	mSkyPresetNameEditor;
 	LLComboBox*		mSkyPresetCombo;
 	LLCheckBoxCtrl*	mMakeDefaultCheckBox;
 	LLButton*		mSaveButton;
+    LLSkySettingsAdapterPtr mSkyAdapter;
+
 };
 
 #endif // LL_LLFLOATEREDITSKY_H
diff --git a/indra/newview/llsettingsbase.cpp b/indra/newview/llsettingsbase.cpp
index 1aafacae45..71ec240214 100644
--- a/indra/newview/llsettingsbase.cpp
+++ b/indra/newview/llsettingsbase.cpp
@@ -80,6 +80,14 @@ LLSD LLSettingsBase::combineSDMaps(const LLSD &settings, const LLSD &other) cons
                 newSettings[key_name].append(*ita);
             }
             break;
+        //case LLSD::TypeInteger:
+        //case LLSD::TypeReal:
+        //case LLSD::TypeBoolean:
+        //case LLSD::TypeString:
+        //case LLSD::TypeUUID:
+        //case LLSD::TypeURI:
+        //case LLSD::TypeDate:
+        //case LLSD::TypeBinary:
         default:
             newSettings[key_name] = value;
             break;
@@ -106,6 +114,14 @@ LLSD LLSettingsBase::combineSDMaps(const LLSD &settings, const LLSD &other) cons
                     newSettings[key_name].append(*ita);
                 }
                 break;
+            //case LLSD::TypeInteger:
+            //case LLSD::TypeReal:
+            //case LLSD::TypeBoolean:
+            //case LLSD::TypeString:
+            //case LLSD::TypeUUID:
+            //case LLSD::TypeURI:
+            //case LLSD::TypeDate:
+            //case LLSD::TypeBinary:
             default:
                 newSettings[key_name] = value;
                 break;
@@ -219,6 +235,11 @@ LLSD LLSettingsBase::interpolateSDMap(const LLSD &settings, const LLSD &other, F
     return newSettings;
 }
 
+LLSD LLSettingsBase::cloneSettings() const
+{
+    return combineSDMaps(mSettings, LLSD());
+}
+
 
 void LLSettingsBase::exportSettings(std::string name) const
 {
diff --git a/indra/newview/llsettingsbase.h b/indra/newview/llsettingsbase.h
index 142b74caf9..02f5ffc8af 100644
--- a/indra/newview/llsettingsbase.h
+++ b/indra/newview/llsettingsbase.h
@@ -124,7 +124,6 @@ protected:
 
     typedef std::set<std::string>   stringset_t;
 
-
     // combining settings objects. Customize for specific setting types
     virtual void lerpSettings(const LLSettingsBase &other, F32 mix);
 
@@ -147,6 +146,8 @@ protected:
 
     LLSD    mSettings;
 
+    LLSD    cloneSettings() const;
+
 private:
     bool    mDirty;
 
diff --git a/indra/newview/llsettingssky.cpp b/indra/newview/llsettingssky.cpp
index d4d9172a75..898cdad7be 100644
--- a/indra/newview/llsettingssky.cpp
+++ b/indra/newview/llsettingssky.cpp
@@ -44,12 +44,14 @@
 namespace
 {
     const LLVector3 DUE_EAST(0.0f, 0.0f, 1.0);
+    const LLVector3 VECT_ZENITH(0.f, 1.f, 0.f);
+    const LLVector3 VECT_NORTHSOUTH(1.f, 0.f, 0.f);
 
     LLTrace::BlockTimerStatHandle FTM_BLEND_ENVIRONMENT("Blending Environment Params");
     LLTrace::BlockTimerStatHandle FTM_UPDATE_ENVIRONMENT("Update Environment Params");
 
     LLQuaternion body_position_from_angles(F32 azimuth, F32 altitude);
-
+    void angles_from_rotation(LLQuaternion quat, F32 &azimuth, F32 &altitude);
 }
 
 const F32 LLSettingsSky::DOME_OFFSET(0.96f);
@@ -101,6 +103,32 @@ LLSettingsSky::LLSettingsSky():
 {
 }
 
+void LLSettingsSky::setMoonRotation(F32 azimuth, F32 altitude)
+{
+    setValue(SETTING_MOON_ROTATION, ::body_position_from_angles(azimuth, altitude));
+}
+
+LLSettingsSky::azimalt_t LLSettingsSky::getMoonRotationAzAl() const
+{
+    azimalt_t res;
+    ::angles_from_rotation(getMoonRotation(), res.first, res.second);
+
+    return res;
+}
+
+void LLSettingsSky::setSunRotation(F32 azimuth, F32 altitude)
+{
+    setValue(SETTING_SUN_ROTATION, ::body_position_from_angles(azimuth, altitude));
+}
+
+LLSettingsSky::azimalt_t LLSettingsSky::getSunRotationAzAl() const
+{
+    azimalt_t res;
+    ::angles_from_rotation(getSunRotation(), res.first, res.second);
+
+    return res;
+}
+
 LLSettingsSky::stringset_t LLSettingsSky::getSlerpKeys() const 
 { 
     static stringset_t slepSet;
@@ -124,27 +152,27 @@ LLSettingsSky::ptr_t LLSettingsSky::buildFromLegacyPreset(const std::string &nam
 
     if (oldsettings.has(SETTING_AMBIENT))
     {
-        newsettings[SETTING_AMBIENT] = LLColor4(oldsettings[SETTING_AMBIENT]).getValue();
+        newsettings[SETTING_AMBIENT] = LLColor3(oldsettings[SETTING_AMBIENT]).getValue();
     }
     if (oldsettings.has(SETTING_BLUE_DENSITY))
     {
-        newsettings[SETTING_BLUE_DENSITY] = LLColor4(oldsettings[SETTING_BLUE_DENSITY]).getValue();
+        newsettings[SETTING_BLUE_DENSITY] = LLColor3(oldsettings[SETTING_BLUE_DENSITY]).getValue();
     }
     if (oldsettings.has(SETTING_BLUE_HORIZON))
     {
-        newsettings[SETTING_BLUE_HORIZON] = LLColor4(oldsettings[SETTING_BLUE_HORIZON]).getValue();
+        newsettings[SETTING_BLUE_HORIZON] = LLColor3(oldsettings[SETTING_BLUE_HORIZON]).getValue();
     }
     if (oldsettings.has(SETTING_CLOUD_COLOR))
     {
-        newsettings[SETTING_CLOUD_COLOR] = LLColor4(oldsettings[SETTING_CLOUD_COLOR]).getValue();
+        newsettings[SETTING_CLOUD_COLOR] = LLColor3(oldsettings[SETTING_CLOUD_COLOR]).getValue();
     }
     if (oldsettings.has(SETTING_CLOUD_POS_DENSITY1))
     {
-        newsettings[SETTING_CLOUD_POS_DENSITY1] = LLColor4(oldsettings[SETTING_CLOUD_POS_DENSITY1]).getValue();
+        newsettings[SETTING_CLOUD_POS_DENSITY1] = LLColor3(oldsettings[SETTING_CLOUD_POS_DENSITY1]).getValue();
     }
     if (oldsettings.has(SETTING_CLOUD_POS_DENSITY2))
     {
-        newsettings[SETTING_CLOUD_POS_DENSITY2] = LLColor4(oldsettings[SETTING_CLOUD_POS_DENSITY2]).getValue();
+        newsettings[SETTING_CLOUD_POS_DENSITY2] = LLColor3(oldsettings[SETTING_CLOUD_POS_DENSITY2]).getValue();
     }
     if (oldsettings.has(SETTING_CLOUD_SCALE))
     {
@@ -179,11 +207,11 @@ LLSettingsSky::ptr_t LLSettingsSky::buildFromLegacyPreset(const std::string &nam
     }
     if (oldsettings.has(SETTING_GAMMA))
     {
-        newsettings[SETTING_GAMMA] = LLVector4(oldsettings[SETTING_GAMMA]).getValue();
+        newsettings[SETTING_GAMMA] = oldsettings[SETTING_GAMMA][0].asReal();
     }
     if (oldsettings.has(SETTING_GLOW))
     {
-        newsettings[SETTING_GLOW] = LLColor4(oldsettings[SETTING_GLOW]).getValue();
+        newsettings[SETTING_GLOW] = LLColor3(oldsettings[SETTING_GLOW]).getValue();
     }
     if (oldsettings.has(SETTING_HAZE_DENSITY))
     {
@@ -230,6 +258,9 @@ LLSettingsSky::ptr_t LLSettingsSky::buildFromLegacyPreset(const std::string &nam
         LLQuaternion sunquat = ::body_position_from_angles(azimuth, altitude);
         LLQuaternion moonquat = ::body_position_from_angles(azimuth + F_PI, -altitude);
 
+        F32 az(0), al(0);
+        ::angles_from_rotation(sunquat, az, al);
+
         newsettings[SETTING_SUN_ROTATION] = sunquat.getValue();
         newsettings[SETTING_MOON_ROTATION] = moonquat.getValue();
     }
@@ -245,11 +276,18 @@ LLSettingsSky::ptr_t LLSettingsSky::buildDefaultSky()
     LLSD settings = LLSettingsSky::defaults();
 
     LLSettingsSky::ptr_t skyp = boost::make_shared<LLSettingsSky>(settings);
-    //skyp->update();
 
     return skyp;
 }
 
+LLSettingsSky::ptr_t LLSettingsSky::buildClone()
+{
+    LLSD settings = cloneSettings();
+
+    LLSettingsSky::ptr_t skyp = boost::make_shared<LLSettingsSky>(settings);
+
+    return skyp;
+}
 
 // Settings status 
 
@@ -278,11 +316,11 @@ LLSD LLSettingsSky::defaults()
 
     // Magic constants copied form dfltsetting.xml 
     dfltsetting[SETTING_AMBIENT]            = LLColor4::white.getValue();
-    dfltsetting[SETTING_BLUE_DENSITY]       = LLColor4(0.2447, 0.4487, 0.7599, 1.0).getValue();
-    dfltsetting[SETTING_BLUE_HORIZON]       = LLColor4(0.4954, 0.4954, 0.6399, 1.0).getValue();
-    dfltsetting[SETTING_CLOUD_COLOR]        = LLColor4(0.4099, 0.4099, 0.4099, 1.0).getValue();
-    dfltsetting[SETTING_CLOUD_POS_DENSITY1] = LLColor4(1.0000, 0.5260, 1.0000, 1.0).getValue();
-    dfltsetting[SETTING_CLOUD_POS_DENSITY2] = LLColor4(1.0000, 0.5260, 1.0000, 1.0).getValue();
+    dfltsetting[SETTING_BLUE_DENSITY]       = LLColor4(0.2447, 0.4487, 0.7599, 0.0).getValue();
+    dfltsetting[SETTING_BLUE_HORIZON]       = LLColor4(0.4954, 0.4954, 0.6399, 0.0).getValue();
+    dfltsetting[SETTING_CLOUD_COLOR]        = LLColor4(0.4099, 0.4099, 0.4099, 0.0).getValue();
+    dfltsetting[SETTING_CLOUD_POS_DENSITY1] = LLColor4(1.0000, 0.5260, 1.0000, 0.0).getValue();
+    dfltsetting[SETTING_CLOUD_POS_DENSITY2] = LLColor4(1.0000, 0.5260, 1.0000, 0.0).getValue();
     dfltsetting[SETTING_CLOUD_SCALE]        = LLSD::Real(0.4199);
     dfltsetting[SETTING_CLOUD_SCROLL_RATE]  = LLSDArray(10.1999)(10.0109);
     dfltsetting[SETTING_CLOUD_SHADOW]       = LLSD::Real(0.2699);
@@ -290,7 +328,7 @@ LLSD LLSettingsSky::defaults()
     dfltsetting[SETTING_DISTANCE_MULTIPLIER] = LLSD::Real(0.8000);
     dfltsetting[SETTING_DOME_OFFSET]        = LLSD::Real(0.96f);
     dfltsetting[SETTING_DOME_RADIUS]        = LLSD::Real(15000.f);
-    dfltsetting[SETTING_GAMMA]              = LLVector4(1.0, 0.0, 0.0, 1.0).getValue();
+    dfltsetting[SETTING_GAMMA]              = LLSD::Real(1.0);
     dfltsetting[SETTING_GLOW]               = LLColor4(5.000, 0.0010, -0.4799, 1.0).getValue();   // *RIDER: This is really weird for a color... TODO: check if right.
     dfltsetting[SETTING_HAZE_DENSITY]       = LLSD::Real(0.6999);
     dfltsetting[SETTING_HAZE_HORIZON]       = LLSD::Real(0.1899);
@@ -299,7 +337,7 @@ LLSD LLSettingsSky::defaults()
     dfltsetting[SETTING_MOON_ROTATION]      = moonquat.getValue();
     dfltsetting[SETTING_NAME]               = std::string("_default_");
     dfltsetting[SETTING_STAR_BRIGHTNESS]    = LLSD::Real(0.0000);
-    dfltsetting[SETTING_SUNLIGHT_COLOR]     = LLColor4(0.7342, 0.7815, 0.8999, 1.0).getValue();
+    dfltsetting[SETTING_SUNLIGHT_COLOR]     = LLColor4(0.7342, 0.7815, 0.8999, 0.0).getValue();
     dfltsetting[SETTING_SUN_ROTATION]       = sunquat.getValue();
 
     dfltsetting[SETTING_BLOOM_TEXTUREID]    = LLUUID::null;
@@ -367,29 +405,26 @@ void LLSettingsSky::calculateHeavnlyBodyPositions()
 
 void LLSettingsSky::calculateLightSettings()
 {
-#if 0
     LLColor3 vary_HazeColor;
     LLColor3 vary_SunlightColor;
     LLColor3 vary_AmbientColor;
     {
         // Initialize temp variables
-        LLColor3 sunlight = getSunlightColor();
-
-        // Fetch these once...
-        F32 haze_density = getHazeDensity();
-        F32 haze_horizon = getHazeHorizon();
-        F32 density_multiplier = getDensityMultiplier();
-        F32 max_y = getMaxY();
-        F32 gamma = getGama();
-        F32 cloud_shadow = getCloudShadow();
-        LLColor3 blue_density = getBlueDensity();
-        LLColor3 blue_horizon = getBlueHorizon();
-        LLColor3 ambient = getAmbientColor();
-
+        LLColor3    sunlight = getSunlightColor();
+        LLColor3    ambient = getAmbientColor();
+        F32         gamma = getGamma();
+        LLColor3    blue_density = getBlueDensity();
+        LLColor3    blue_horizon = getBlueHorizon();
+        F32         haze_density = getHazeDensity();
+        F32         haze_horizon = getHazeHorizon();
+        F32         density_multiplier = getDensityMultiplier();
+        F32         max_y = getMaxY();
+        F32         cloud_shadow = getCloudShadow();
+        LLVector3   lightnorm = getLightDirection();
 
         // Sunlight attenuation effect (hue and brightness) due to atmosphere
         // this is used later for sunlight modulation at various altitudes
-        LLColor3 light_atten =  
+        LLColor3 light_atten =
             (blue_density * 1.0 + smear(haze_density * 0.25f)) * (density_multiplier * max_y);
 
         // Calculate relative weights
@@ -403,14 +438,14 @@ void LLSettingsSky::calculateLightSettings()
         // temp2[1] = llmax(0.f, llmax(0.f, Pn[1]) * 1.0f + lightnorm[1] );
 
         // and vary_sunlight will work properly with moon light
-        F32 lighty = mLightDirection[1];
+        F32 lighty = lightnorm[1];
         if (lighty < LLSky::NIGHTTIME_ELEVATION_COS)
         {
             lighty = -lighty;
         }
 
         temp2.mV[1] = llmax(0.f, lighty);
-        if (temp2.mV[1] > 0.f)
+        if(temp2.mV[1] > 0.f)
         {
             temp2.mV[1] = 1.f / temp2.mV[1];
         }
@@ -429,9 +464,9 @@ void LLSettingsSky::calculateLightSettings()
 
         //haze color
         vary_HazeColor =
-            (blue_horizon * blue_weight * (sunlight*(1.f - cloud_shadow) + tmpAmbient)
+            (blue_horizon * blue_weight * (sunlight*(1.f - cloud_shadow) + tmpAmbient)	
             + componentMult(haze_horizon * haze_weight, sunlight*(1.f - cloud_shadow) * temp2.mV[0] + tmpAmbient)
-            );
+            );	
 
         //brightness of surface both sunlight and ambient
         vary_SunlightColor = componentMult(sunlight, temp1) * 1.f;
@@ -449,7 +484,16 @@ void LLSettingsSky::calculateLightSettings()
 
     }
 
-    float dp = getSunDirection() * LLVector3(0, 0, 1.f); // a dot b
+#if 0
+    mSun.setColor(vary_SunlightColor);
+    mMoon.setColor(LLColor3(1.0f, 1.0f, 1.0f));
+
+    mSun.renewDirection();
+    mSun.renewColor();
+    mMoon.renewDirection();
+    mMoon.renewColor();
+
+    float dp = getToSunLast() * LLVector3(0,0,1.f);
     if (dp < 0)
     {
         dp = 0;
@@ -457,21 +501,19 @@ void LLSettingsSky::calculateLightSettings()
 
     // Since WL scales everything by 2, there should always be at least a 2:1 brightness ratio
     // between sunlight and point lights in windlight to normalize point lights.
-    F32 sun_dynamic_range = std::max(gSavedSettings.getF32("RenderSunDynamicRange"), 0.0001f);
-    
+    F32 sun_dynamic_range = llmax(gSavedSettings.getF32("RenderSunDynamicRange"), 0.0001f);
     LLEnvironment::instance().setSceneLightStrength(2.0f * (1.0f + sun_dynamic_range * dp));
+#endif
 
     mSunDiffuse = vary_SunlightColor;
     mSunAmbient = vary_AmbientColor;
     mMoonDiffuse = vary_SunlightColor;
     mMoonAmbient = vary_AmbientColor;
 
-    mTotalAmbient = vary_AmbientColor;
-    mTotalAmbient.setAlpha(1);
+    mTotalAmbient = LLColor4(vary_AmbientColor, 1.0f);
 
     mFadeColor = mTotalAmbient + (mSunDiffuse + mMoonDiffuse) * 0.5f;
-    mFadeColor.setAlpha(1);
-#endif
+    mFadeColor.setAlpha(0);
 }
 
 LLSettingsSky::parammapping_t LLSettingsSky::getParameterMap() const
@@ -490,7 +532,6 @@ LLSettingsSky::parammapping_t LLSettingsSky::getParameterMap() const
         param_map[SETTING_CLOUD_SHADOW] = LLShaderMgr::CLOUD_SHADOW;
         param_map[SETTING_DENSITY_MULTIPLIER] = LLShaderMgr::DENSITY_MULTIPLIER;
         param_map[SETTING_DISTANCE_MULTIPLIER] = LLShaderMgr::DISTANCE_MULTIPLIER;
-        param_map[SETTING_GAMMA] = LLShaderMgr::GAMMA;
         param_map[SETTING_GLOW] = LLShaderMgr::GLOW;
         param_map[SETTING_HAZE_DENSITY] = LLShaderMgr::HAZE_DENSITY;
         param_map[SETTING_HAZE_HORIZON] = LLShaderMgr::HAZE_HORIZON;
@@ -507,7 +548,7 @@ void LLSettingsSky::applySpecial(void *ptarget)
 
     shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, mClampedLightDirection.mV);
 
-    shader->uniform4f(LLShaderMgr::GAMMA, getGama(), 0.0, 0.0, 1.0);
+    shader->uniform4f(LLShaderMgr::GAMMA, getGamma(), 0.0, 0.0, 1.0);
 
     {
         //LLEnvironment::instance().getCloudDelta();
@@ -515,23 +556,6 @@ void LLSettingsSky::applySpecial(void *ptarget)
         vect_c_p_d1 += LLVector4(LLEnvironment::instance().getCloudScrollDelta());
         shader->uniform4fv(LLShaderMgr::CLOUD_POS_DENSITY1, 1, vect_c_p_d1.mV);
     }
-
-//     {
-//         LLVector4 val(mSettings[ ];
-//         val.mV[0] = F32(i->second[0].asReal()) + mCloudScrollXOffset;
-//         val.mV[1] = F32(i->second[1].asReal()) + mCloudScrollYOffset;
-//         val.mV[2] = (F32)i->second[2].asReal();
-//         val.mV[3] = (F32)i->second[3].asReal();
-// 
-//         stop_glerror();
-//         //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
-//         shader->uniform4fv(param, 1, val.mV);
-//         stop_glerror();
-// 
-//     }
-
-    //param_map[SETTING_CLOUD_POS_DENSITY1] = LLShaderMgr::CLOUD_POS_DENSITY1;
-
 }
 
 //=========================================================================
@@ -539,9 +563,6 @@ namespace
 {
     LLQuaternion body_position_from_angles(F32 azimuth, F32 altitude)
     {
-        static const LLVector3 VECT_ZENITH(0.f, 1.f, 0.f);
-        static const LLVector3 VECT_NORTHSOUTH(1.f, 0.f, 0.f);
-
         // Azimuth is traditionally calculated from North, we are going from East.
         LLQuaternion rot_azi;
         LLQuaternion rot_alt;
@@ -552,11 +573,26 @@ namespace
         LLQuaternion body_quat = rot_alt * rot_azi;
         body_quat.normalize();
 
-        LLVector3 sun_vector = (DUE_EAST * body_quat);
-
-
-        LL_WARNS("RIDER") << "Azimuth=" << azimuth << " Altitude=" << altitude << " Body Vector=" << sun_vector.getValue() << LL_ENDL;
-
+        //LLVector3 sun_vector = (DUE_EAST * body_quat);
+        //_WARNS("RIDER") << "Azimuth=" << azimuth << " Altitude=" << altitude << " Body Vector=" << sun_vector.getValue() << LL_ENDL;
         return body_quat;
     }
+
+    void angles_from_rotation(LLQuaternion quat, F32 &azimuth, F32 &altitude)
+    {
+        LLVector3 body_vector = (DUE_EAST * quat);
+
+        LLVector3 body_az(body_vector[0], 0.f, body_vector[2]);
+        LLVector3 body_al(0.f, body_vector[1], body_vector[2]);
+        
+        if (fabs(body_az.normalize()) > 0.001)
+            azimuth = angle_between(DUE_EAST, body_az);
+        else
+            azimuth = 0.0f;
+
+        if (fabs(body_al.normalize()) > 0.001)
+            altitude = angle_between(DUE_EAST, body_al);
+        else
+            altitude = 0.0f;
+    }
 }
diff --git a/indra/newview/llsettingssky.h b/indra/newview/llsettingssky.h
index 0274661643..012244d1f9 100644
--- a/indra/newview/llsettingssky.h
+++ b/indra/newview/llsettingssky.h
@@ -67,13 +67,15 @@ public:
     static const std::string SETTING_LEGACY_SUN_ANGLE;
 
     typedef boost::shared_ptr<LLSettingsSky> ptr_t;
+    typedef std::pair<F32, F32> azimalt_t;
 
     //---------------------------------------------------------------------
     LLSettingsSky(const LLSD &data);
     virtual ~LLSettingsSky() { };
 
-    static ptr_t buildFromLegacyPreset(const std::string &name, const LLSD &oldsettings);
-    static ptr_t buildDefaultSky();
+    static ptr_t    buildFromLegacyPreset(const std::string &name, const LLSD &oldsettings);
+    static ptr_t    buildDefaultSky();
+    ptr_t           buildClone();
 
     //---------------------------------------------------------------------
     virtual std::string getSettingType() const { return std::string("sky"); }
@@ -89,6 +91,11 @@ public:
         return LLColor3(mSettings[SETTING_AMBIENT]);
     }
 
+    void setAmbientColor(const LLColor3 &val)
+    {
+        setValue(SETTING_AMBIENT, val);
+    }
+
     LLUUID getBloomTextureId() const
     {
         return mSettings[SETTING_BLOOM_TEXTUREID].asUUID();
@@ -99,16 +106,31 @@ public:
         return LLColor3(mSettings[SETTING_BLUE_DENSITY]);
     }
 
+    void setBlueDensity(const LLColor3 &val)
+    {
+        setValue(SETTING_BLUE_DENSITY, val);
+    }
+
     LLColor3 getBlueHorizon() const
     {
         return LLColor3(mSettings[SETTING_BLUE_HORIZON]);
     }
 
+    void setBlueHorizon(const LLColor3 &val)
+    {
+        setValue(SETTING_BLUE_HORIZON, val);
+    }
+
     LLColor3 getCloudColor() const
     {
         return LLColor3(mSettings[SETTING_CLOUD_COLOR]);
     }
 
+    void setCloudColor(const LLColor3 &val)
+    {
+        setValue(SETTING_CLOUD_COLOR, val);
+    }
+
     LLUUID getCloudNoiseTextureId() const
     {
         return mSettings[SETTING_CLOUD_TEXTUREID].asUUID();
@@ -119,36 +141,83 @@ public:
         return LLColor3(mSettings[SETTING_CLOUD_POS_DENSITY1]);
     }
 
+    void setCloudPosDensity1(const LLColor3 &val)
+    {
+        setValue(SETTING_CLOUD_POS_DENSITY1, val);
+    }
+
     LLColor3 getCloudPosDensity2() const
     {
         return LLColor3(mSettings[SETTING_CLOUD_POS_DENSITY2]);
     }
 
+    void setCloudPosDensity2(const LLColor3 &val)
+    {
+        setValue(SETTING_CLOUD_POS_DENSITY2, val);
+    }
+
     F32 getCloudScale() const
     {
         return mSettings[SETTING_CLOUD_SCALE].asReal();
     }
 
+    void setCloudScale(F32 val)
+    {
+        setValue(SETTING_CLOUD_SCALE, val);
+    }
+
     LLVector2 getCloudScrollRate() const
     {
         return LLVector2(mSettings[SETTING_CLOUD_SCROLL_RATE]);
     }
 
+    void setCloudScrollRate(const LLVector2 &val)
+    {
+        setValue(SETTING_CLOUD_SCROLL_RATE, val);
+    }
+
+    void setCloudScrollRateX(F32 val)
+    {
+        mSettings[SETTING_CLOUD_SCROLL_RATE][0] = val;
+        setDirtyFlag(true);
+    }
+
+    void setCloudScrollRateY(F32 val)
+    {
+        mSettings[SETTING_CLOUD_SCROLL_RATE][1] = val;
+        setDirtyFlag(true);
+    }
+
     F32 getCloudShadow() const
     {
         return mSettings[SETTING_CLOUD_SHADOW].asReal();
     }
 
+    void setCloudShadow(F32 val)
+    {
+        setValue(SETTING_CLOUD_SHADOW, val);
+    }
+
     F32 getDensityMultiplier() const
     {
         return mSettings[SETTING_DENSITY_MULTIPLIER].asReal();
     }
 
+    void setDensityMultiplier(F32 val)
+    {
+        setValue(SETTING_DENSITY_MULTIPLIER, val);
+    }
+
     F32 getDistanceMultiplier() const
     {
         return mSettings[SETTING_DISTANCE_MULTIPLIER].asReal();
     }
 
+    void setDistanceMultiplier(F32 val)
+    {
+        setValue(SETTING_DISTANCE_MULTIPLIER, val);
+    }
+
     F32 getDomeOffset() const
     {
         return DOME_OFFSET;
@@ -161,9 +230,15 @@ public:
         //return mSettings[SETTING_DOME_RADIUS].asReal();
     }
 
-    F32 getGama() const
+    F32 getGamma() const
+    {
+        return mSettings[SETTING_GAMMA].asReal();
+    }
+
+    void setGamma(F32 val)
     {
-        return mSettings[SETTING_GAMMA][0].asReal();
+        mSettings[SETTING_GAMMA] = LLSD::Real(val);
+        setDirtyFlag(true);
     }
 
     LLColor3 getGlow() const
@@ -171,21 +246,41 @@ public:
         return LLColor3(mSettings[SETTING_GLOW]);
     }
 
+    void setGlow(const LLColor3 &val)
+    {
+        setValue(SETTING_GLOW, val);
+    }
+
     F32 getHazeDensity() const
     {
         return mSettings[SETTING_HAZE_DENSITY].asReal();
     }
 
+    void setHazeDensity(F32 val)
+    {
+        setValue(SETTING_HAZE_DENSITY, val);
+    }
+
     F32 getHazeHorizon() const
     {
         return mSettings[SETTING_HAZE_HORIZON].asReal();
     }
 
+    void setHazeHorizon(F32 val)
+    {
+        setValue(SETTING_HAZE_HORIZON, val);
+    }
+
     LLVector3 getLightNormal() const
     {
         return LLVector3(mSettings[SETTING_LIGHT_NORMAL]);
     }
 
+    void setLightNormal(const LLVector3 &val) 
+    {
+        setValue(SETTING_LIGHT_NORMAL, val);
+    }
+
     F32 getMaxY() const
     {
         return mSettings[SETTING_MAX_Y].asReal();
@@ -196,6 +291,20 @@ public:
         return LLQuaternion(mSettings[SETTING_MOON_ROTATION]);
     }
 
+    void setMoonRotation(const LLQuaternion &val)
+    {
+        setValue(SETTING_MOON_ROTATION, val);
+    }
+
+    azimalt_t getMoonRotationAzAl() const;
+
+    void setMoonRotation(F32 azimuth, F32 altitude);
+
+    void setMoonRotation(const azimalt_t &azialt)
+    {
+        setMoonRotation(azialt.first, azialt.second);
+    }
+
     LLUUID getMoonTextureId() const
     {
         return mSettings[SETTING_MOON_TEXTUREID].asUUID();
@@ -206,58 +315,56 @@ public:
         return mSettings[SETTING_STAR_BRIGHTNESS].asReal();
     }
 
+    void setStarBrightness(F32 val)
+    {
+        setValue(SETTING_STAR_BRIGHTNESS, val);
+    }
+
     LLColor3 getSunlightColor() const
     {
         return LLColor3(mSettings[SETTING_SUNLIGHT_COLOR]);
     }
 
-    LLQuaternion getSunRotation() const
+    void setSunlightColor(const LLColor3 &val)
     {
-        return LLQuaternion(mSettings[SETTING_SUN_ROTATION]);
+        setValue(SETTING_SUNLIGHT_COLOR, val);
     }
 
-    LLUUID getSunTextureId() const
+    LLQuaternion getSunRotation() const
     {
-        return mSettings[SETTING_SUN_TEXUTUREID].asUUID();
+        return LLQuaternion(mSettings[SETTING_SUN_ROTATION]);
     }
 
-    // Internal/calculated settings
-    LLVector3 getLightDirection() const
-    {
-        update();
-        return mLightDirection;
-    };
+    azimalt_t getSunRotationAzAl() const;
 
-    LLVector3 getClampedLightDirection() const
+    void setSunRotation(const LLQuaternion &val) 
     {
-        update();
-        return mClampedLightDirection;
-    };
+        setValue(SETTING_SUN_ROTATION, val);
+    }
 
-    LLVector3   getSunDirection() const
+    void setSunRotation(F32 azimuth, F32 altitude);
+
+    void setSunRotation(const azimalt_t & azimalt)
     {
-        update();
-        return mSunDirection;
+        setSunRotation(azimalt.first, azimalt.second);
     }
 
-    LLVector3   getMoonDirection() const
+    LLUUID getSunTextureId() const
     {
-        update();
-        return mMoonDirection;
+        return mSettings[SETTING_SUN_TEXUTUREID].asUUID();
     }
 
-
-#if 0
+    // Internal/calculated settings
     LLVector3 getLightDirection() const
     {
         update();
         return mLightDirection;
     };
 
-    LLVector3 getLightDirectionClamped() const
+    LLVector3 getClampedLightDirection() const
     {
         update();
-        return mLightDirectionClamped;
+        return mClampedLightDirection;
     };
 
     LLVector3   getSunDirection() const
@@ -272,16 +379,16 @@ public:
         return mMoonDirection;
     }
 
-    LLColor3    getSunDiffuse() const
+    LLColor4U   getFadeColor() const
     {
         update();
-        return mSunDiffuse;
+        return mFadeColor;
     }
 
-    LLColor3    getSunAmbient() const
+    LLColor4    getMoonAmbient() const
     {
         update();
-        return mSunAmbient;
+        return mMoonAmbient;
     }
 
     LLColor3    getMoonDiffuse() const
@@ -290,24 +397,23 @@ public:
         return mMoonDiffuse;
     }
 
-    LLColor3    getMoonAmbient() const
+    LLColor4    getSunAmbient() const
     {
         update();
-        return mMoonAmbient;
+        return mSunAmbient;
     }
 
-    LLColor4    getTotalAmbient() const
+    LLColor3    getSunDiffuse() const
     {
         update();
-        return mTotalAmbient;
+        return mSunDiffuse;
     }
 
-    LLColor4    getFadeColor() const
+    LLColor4    getTotalAmbient() const
     {
         update();
-        return mFadeColor;
+        return mTotalAmbient;
     }
-#endif
 
 protected:
     LLSettingsSky();
@@ -320,6 +426,7 @@ protected:
 
     virtual void        applySpecial(void *);
 
+
 private:
     void        calculateHeavnlyBodyPositions();
     void        calculateLightSettings();
@@ -332,13 +439,13 @@ private:
     static const F32 DOME_RADIUS;
     static const F32 DOME_OFFSET;
 
-//     LLColor3    mSunDiffuse;
-//     LLColor3    mSunAmbient;
-//     LLColor3    mMoonDiffuse;
-//     LLColor3    mMoonAmbient;        
-//     
-//     LLColor4    mTotalAmbient;
-//     LLColor4    mFadeColor;
+    LLColor4U   mFadeColor;
+    LLColor4    mMoonAmbient;
+    LLColor3    mMoonDiffuse;
+    LLColor4    mSunAmbient;
+    LLColor3    mSunDiffuse;
+
+    LLColor4    mTotalAmbient;
 
     typedef std::map<std::string, S32> mapNameToUniformId_t;
 
diff --git a/indra/newview/llvosky.cpp b/indra/newview/llvosky.cpp
index 71abad79b6..93ca7945ba 100644
--- a/indra/newview/llvosky.cpp
+++ b/indra/newview/llvosky.cpp
@@ -331,24 +331,6 @@ LLVOSky::LLVOSky(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
 	mBumpSunDir(0.f, 0.f, 1.f)
 {
 	/// WL PARAMS
-//	dome_radius = 1.f;
-//	dome_offset_ratio = 0.f;
-//	sunlight_color = LLColor3();
-//	ambient = LLColor3();
-//	gamma = 1.f;
-//	lightnorm = LLVector4();
-//	blue_density = LLColor3();
-//	blue_horizon = LLColor3();
-//	haze_density = 0.f;
-//	haze_horizon = 1.f;
-//	density_multiplier = 0.f;
-//	max_y = 0.f;
-//	glow = LLColor3();
-//	cloud_shadow = 0.f;
-//	cloud_color = LLColor3();
-//	cloud_scale = 0.f;
-//	cloud_pos_density1 = LLColor3();
-//	cloud_pos_density2 = LLColor3();
 
 	mInitialized = FALSE;
 	mbCanSelect = FALSE;
@@ -565,48 +547,6 @@ void LLVOSky::createSkyTexture(const S32 side, const S32 tile)
 	}
 }
 
-void LLVOSky::initAtmospherics(void)
-{	
-	
-    // *LAPRAS
-    // uniform parameters for convenience
-    LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
-
-//    dome_radius = psky->getDomeRadius();
-//    dome_offset_ratio = psky->getDomeOffset();
-//    sunlight_color = psky->getSunlightColor();
-//    ambient = psky->getAmbientColor();
-//    gamma = psky->getGama();
-//    blue_density = psky->getBlueDensity();
-//    blue_horizon = psky->getBlueHorizon();
-//    haze_density = psky->getHazeDensity();
-//    haze_horizon = psky->getHazeHorizon();
-//    density_multiplier = psky->getDensityMultiplier();
-//    max_y = psky->getMaxY();
-//    glow = psky->getGlow();
-//    cloud_shadow = psky->getCloudShadow();
-//    cloud_color = psky->getCloudColor();
-//    cloud_scale = psky->getCloudScale();
-//    cloud_pos_density1 = psky->getCloudPosDensity1();
-//    cloud_pos_density2 = psky->getCloudPosDensity2();
-
-	// light norm is different.  We need the sun's direction, not the light direction
-	// which could be from the moon.  And we need to clamp it
-	// just like for the gpu
-//	LLVector3 sunDir = gSky.getSunDirection();
-    LLVector3 sunDir = psky->getSunDirection();
-
-	// CFR_TO_OGL
-//	lightnorm = LLVector4(sunDir.mV[1], sunDir.mV[2], sunDir.mV[0], 0);
-    lightnorm = LLVector4(sunDir, 0);
-	unclamped_lightnorm = lightnorm;
-	if(lightnorm.mV[1] < -0.1f)
-	{
-		lightnorm.mV[1] = -0.1f;
-	}
-	
-}
-
 LLColor4 LLVOSky::calcSkyColorInDir(const LLVector3 &dir, bool isShiny)
 {
 	F32 saturation = 0.3f;
@@ -681,8 +621,9 @@ void LLVOSky::calcSkyColorWLVert(LLVector3 & Pn, LLColor3 & vary_HazeColor, LLCo
 {
     LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
 
-    LLColor3 blue_density = psky->getBlueDensity();
-    F32      max_y = psky->getMaxY();
+    LLColor3    blue_density = psky->getBlueDensity();
+    F32         max_y = psky->getMaxY();
+    LLVector3   lightnorm = psky->getLightNormal();
 
 	// project the direction ray onto the sky dome.
 	F32 phi = acos(Pn[1]);
@@ -692,7 +633,6 @@ void LLVOSky::calcSkyColorWLVert(LLVector3 & Pn, LLColor3 & vary_HazeColor, LLCo
 		sinA = 0.01f;
 	}
 
-//	F32 Plen = dome_radius * sin(F_PI + phi + asin(dome_offset_ratio * sinA)) / sinA;
 	F32 Plen = psky->getDomeRadius() * sin(F_PI + phi + asin(psky->getDomeOffset() * sinA)) / sinA;
 
 	Pn *= Plen;
@@ -748,7 +688,7 @@ void LLVOSky::calcSkyColorWLVert(LLVector3 & Pn, LLColor3 & vary_HazeColor, LLCo
 
 
 	// Compute haze glow
-	temp2.mV[0] = Pn * LLVector3(lightnorm);
+	temp2.mV[0] = Pn * lightnorm;
 
 	temp2.mV[0] = 1.f - temp2.mV[0];
 		// temp2.x is 0 at the sun and increases away from sun
@@ -824,7 +764,7 @@ LLColor3 LLVOSky::calcSkyColorWLFrag(LLVector3 & Pn, LLColor3 & vary_HazeColor,
 							LLVector2 vary_HorizontalProjection[2])
 {
     LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
-    F32 gamma = psky->getGama();
+    F32 gamma = psky->getGamma();
 
 	LLColor3 res;
 	LLColor3 color0 = vary_HazeColor;
@@ -893,87 +833,8 @@ LLColor3 LLVOSky::createAmbientFromWL(LLColor3 ambient, LLColor3 sundiffuse, LLC
 void LLVOSky::calcAtmospherics(void)
 {
     LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
-	initAtmospherics();
-
-	LLColor3 vary_HazeColor;
-	LLColor3 vary_SunlightColor;
-	LLColor3 vary_AmbientColor;
-	{
-		// Initialize temp variables
-		LLColor3 sunlight = psky->getSunlightColor();
-        LLColor3 ambient = psky->getAmbientColor();
-        F32      gamma = psky->getGama();
-        LLColor3 blue_density = psky->getBlueDensity();
-        LLColor3 blue_horizon = psky->getBlueHorizon();
-        F32      haze_density = psky->getHazeDensity();
-        F32      haze_horizon = psky->getHazeHorizon();
-        F32      density_multiplier = psky->getDensityMultiplier();
-        F32      max_y = psky->getMaxY();
-        F32      cloud_shadow = psky->getCloudShadow();
-
-		// Sunlight attenuation effect (hue and brightness) due to atmosphere
-		// this is used later for sunlight modulation at various altitudes
-		LLColor3 light_atten =
-			(blue_density * 1.0 + smear(haze_density * 0.25f)) * (density_multiplier * max_y);
-
-		// Calculate relative weights
-		LLColor3 temp2(0.f, 0.f, 0.f);
-		LLColor3 temp1 = blue_density + smear(haze_density);
-		LLColor3 blue_weight = componentDiv(blue_density, temp1);
-		LLColor3 haze_weight = componentDiv(smear(haze_density), temp1);
-
-		// Compute sunlight from P & lightnorm (for long rays like sky)
-		/// USE only lightnorm.
-		// temp2[1] = llmax(0.f, llmax(0.f, Pn[1]) * 1.0f + lightnorm[1] );
-		
-		// and vary_sunlight will work properly with moon light
-		F32 lighty = unclamped_lightnorm[1];
-		if(lighty < LLSky::NIGHTTIME_ELEVATION_COS)
-		{
-			lighty = -lighty;
-		}
-
-		temp2.mV[1] = llmax(0.f, lighty);
-		if(temp2.mV[1] > 0.f)
-		{
-			temp2.mV[1] = 1.f / temp2.mV[1];
-		}
-		componentMultBy(sunlight, componentExp((light_atten * -1.f) * temp2.mV[1]));
-
-		// Distance
-		temp2.mV[2] = density_multiplier;
-
-		// Transparency (-> temp1)
-		temp1 = componentExp((temp1 * -1.f) * temp2.mV[2]);
-
-		// vary_AtmosAttenuation = temp1; 
-
-		//increase ambient when there are more clouds
-		LLColor3 tmpAmbient = ambient + (smear(1.f) - ambient) * cloud_shadow * 0.5f;
-
-		//haze color
-		vary_HazeColor =
-			(blue_horizon * blue_weight * (sunlight*(1.f - cloud_shadow) + tmpAmbient)	
-			+ componentMult(haze_horizon * haze_weight, sunlight*(1.f - cloud_shadow) * temp2.mV[0] + tmpAmbient)
-				 );	
-
-		//brightness of surface both sunlight and ambient
-		vary_SunlightColor = componentMult(sunlight, temp1) * 1.f;
-		vary_SunlightColor.clamp();
-		vary_SunlightColor = smear(1.0f) - vary_SunlightColor;
-		vary_SunlightColor = componentPow(vary_SunlightColor, gamma);
-		vary_SunlightColor = smear(1.0f) - vary_SunlightColor;
-		vary_AmbientColor = componentMult(tmpAmbient, temp1) * 0.5;
-		vary_AmbientColor.clamp();
-		vary_AmbientColor = smear(1.0f) - vary_AmbientColor;
-		vary_AmbientColor = componentPow(vary_AmbientColor, gamma);
-		vary_AmbientColor = smear(1.0f) - vary_AmbientColor;
-
-		componentMultBy(vary_HazeColor, LLColor3(1.f, 1.f, 1.f) - temp1);
 
-	}
-
-	mSun.setColor(vary_SunlightColor);
+    mSun.setColor(psky->getSunlightColor());
 	mMoon.setColor(LLColor3(1.0f, 1.0f, 1.0f));
 
 	mSun.renewDirection();
@@ -992,16 +853,6 @@ void LLVOSky::calcAtmospherics(void)
 	F32 sun_dynamic_range = llmax(gSavedSettings.getF32("RenderSunDynamicRange"), 0.0001f);
     LLEnvironment::instance().setSceneLightStrength(2.0f * (1.0f + sun_dynamic_range * dp));
 
-	mSunDiffuse = vary_SunlightColor;
-	mSunAmbient = vary_AmbientColor;
-	mMoonDiffuse = vary_SunlightColor;
-	mMoonAmbient = vary_AmbientColor;
-
-	mTotalAmbient = vary_AmbientColor;
-	mTotalAmbient.setAlpha(1);
-	
-	mFadeColor = mTotalAmbient + (mSunDiffuse + mMoonDiffuse) * 0.5f;
-	mFadeColor.setAlpha(0);
 }
 
 void LLVOSky::idleUpdate(LLAgent &agent, const F64 &time)
@@ -1010,6 +861,10 @@ void LLVOSky::idleUpdate(LLAgent &agent, const F64 &time)
 
 BOOL LLVOSky::updateSky()
 {
+    LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
+
+    LLColor4 total_ambient = psky->getTotalAmbient();
+
 	if (mDead || !(gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY)))
 	{
 		return TRUE;
@@ -1055,9 +910,9 @@ BOOL LLVOSky::updateSky()
 			const F32 dot_lighting = direction * mLastLightingDirection;
 
 			LLColor3 delta_color;
-			delta_color.setVec(mLastTotalAmbient.mV[0] - mTotalAmbient.mV[0],
-							   mLastTotalAmbient.mV[1] - mTotalAmbient.mV[1],
-							   mLastTotalAmbient.mV[2] - mTotalAmbient.mV[2]);
+			delta_color.setVec(mLastTotalAmbient.mV[0] - total_ambient.mV[0],
+							   mLastTotalAmbient.mV[1] - total_ambient.mV[1],
+                               mLastTotalAmbient.mV[2] - total_ambient.mV[2]);
 
 			if ( mForceUpdate 
 				 || (((dot_lighting < LIGHT_DIRECTION_THRESHOLD)
@@ -1066,7 +921,7 @@ BOOL LLVOSky::updateSky()
 				&& !direction.isExactlyZero()))
 			{
 				mLastLightingDirection = direction;
-				mLastTotalAmbient = mTotalAmbient;
+                mLastTotalAmbient = total_ambient;
 				mInitialized = TRUE;
 
 				if (mCubeMap)
@@ -2039,7 +1894,6 @@ void LLVOSky::updateFog(const F32 distance)
 	tosun_45.normalize();
 
 	// Sky colors, just slightly above the horizon in the direction of the sun, perpendicular to the sun, and at a 45 degree angle to the sun.
-	initAtmospherics();
 	res_color[0] = calcSkyColorInDir(tosun);
 	res_color[1] = calcSkyColorInDir(perp_tosun);
 	res_color[2] = calcSkyColorInDir(tosun_45);
@@ -2240,3 +2094,34 @@ void LLVOSky::setSunDirection(const LLVector3 &sun_dir, const LLVector3 &sun_ang
 		mForceUpdate = TRUE;
 	}
 }
+
+
+LLColor4U LLVOSky::getFadeColor() const
+{ 
+    return LLEnvironment::instance().getCurrentSky()->getFadeColor(); 
+}
+
+LLColor3 LLVOSky::getSunDiffuseColor() const 
+{
+    return LLEnvironment::instance().getCurrentSky()->getSunDiffuse();
+}
+
+LLColor3 LLVOSky::getMoonDiffuseColor() const 
+{ 
+    return LLEnvironment::instance().getCurrentSky()->getMoonDiffuse();
+}
+
+LLColor4 LLVOSky::getSunAmbientColor() const 
+{ 
+    return LLEnvironment::instance().getCurrentSky()->getSunAmbient();
+}
+
+LLColor4 LLVOSky::getMoonAmbientColor() const 
+{ 
+    return LLEnvironment::instance().getCurrentSky()->getMoonAmbient();
+}
+
+LLColor4 LLVOSky::getTotalAmbientColor() const 
+{ 
+    return LLEnvironment::instance().getCurrentSky()->getTotalAmbient();
+}
diff --git a/indra/newview/llvosky.h b/indra/newview/llvosky.h
index 32b5a7eba8..fe2d85df02 100644
--- a/indra/newview/llvosky.h
+++ b/indra/newview/llvosky.h
@@ -379,30 +379,8 @@ class LLCubeMap;
 
 class LLVOSky : public LLStaticViewerObject
 {
-public:
-	/// WL PARAMS
-//	F32 dome_radius;
-//	F32 dome_offset_ratio;
-//	LLColor3 sunlight_color;
-//	LLColor3 ambient;
-//	F32 gamma;
-	LLVector4 lightnorm;
-	LLVector4 unclamped_lightnorm;
-//	LLColor3 blue_density;
-//	LLColor3 blue_horizon;
-//	F32 haze_density;
-//	F32 haze_horizon;
-//	F32 density_multiplier;
-//	F32 max_y;
-//	LLColor3 glow;
-//	F32 cloud_shadow;
-//	LLColor3 cloud_color;
-//	F32 cloud_scale;
-//	LLColor3 cloud_pos_density1;
-//	LLColor3 cloud_pos_density2;
 	
 public:
-	void initAtmospherics(void);
 	void calcAtmospherics(void);
 	LLColor3 createDiffuseFromWL(LLColor3 diffuse, LLColor3 ambient, LLColor3 sundiffuse, LLColor3 sunambient);
 	LLColor3 createAmbientFromWL(LLColor3 ambient, LLColor3 sundiffuse, LLColor3 sunambient);
@@ -470,13 +448,12 @@ public:
 	const LLVector3& getToMoon() const						{ return mMoon.getDirection(); }
 	const LLVector3& getToMoonLast() const					{ return mMoon.getDirectionCached(); }
 	BOOL isSunUp() const									{ return mSun.getDirectionCached().mV[2] > -0.05f; }
-	void calculateColors();
 
-	LLColor3 getSunDiffuseColor() const						{ return mSunDiffuse; }
-	LLColor3 getMoonDiffuseColor() const					{ return mMoonDiffuse; }
-	LLColor4 getSunAmbientColor() const						{ return mSunAmbient; }
-	LLColor4 getMoonAmbientColor() const					{ return mMoonAmbient; }
-	const LLColor4& getTotalAmbientColor() const			{ return mTotalAmbient; }
+    LLColor3 getSunDiffuseColor() const;
+    LLColor3 getMoonDiffuseColor() const;
+    LLColor4 getSunAmbientColor() const;
+    LLColor4 getMoonAmbientColor() const;
+    LLColor4 getTotalAmbientColor() const;
 	LLColor4 getFogColor() const							{ return mFogColor; }
 	LLColor4 getGLFogColor() const							{ return mGLFogCol; }
 	
@@ -508,8 +485,8 @@ public:
 	void setWorldScale(const F32 s)						{ mWorldScale = s; }
 	void updateFog(const F32 distance);
 	void setFogRatio(const F32 fog_ratio)				{ mFogRatio = fog_ratio; }
-	LLColor4U getFadeColor() const						{ return mFadeColor; }
-	F32 getFogRatio() const								{ return mFogRatio; }
+    LLColor4U getFadeColor() const;
+    F32 getFogRatio() const								{ return mFogRatio; }
 	void setCloudDensity(F32 cloud_density)				{ mCloudDensity = cloud_density; }
 	void setWind ( const LLVector3& wind )				{ mWind = wind.length(); }
 
@@ -576,12 +553,12 @@ protected:
 	F32					mFogRatio;
 	F32					mWorldScale;
 
-	LLColor4			mSunAmbient;
-	LLColor4			mMoonAmbient;
-	LLColor4			mTotalAmbient;
-	LLColor3			mSunDiffuse;
-	LLColor3			mMoonDiffuse;
-	LLColor4U			mFadeColor;					// Color to fade in from	
+// 	LLColor4			mSunAmbient;
+// 	LLColor4			mMoonAmbient;
+// 	LLColor4			mTotalAmbient;
+// 	LLColor3			mSunDiffuse;
+// 	LLColor3			mMoonDiffuse;
+// 	LLColor4U			mFadeColor;					// Color to fade in from	
 
 	LLPointer<LLCubeMap>	mCubeMap;					// Cube map for the environment
 	S32					mDrawRefl;
diff --git a/indra/newview/llwlparammanager.cpp b/indra/newview/llwlparammanager.cpp
index b6e1c36a33..a6dc2b343b 100644
--- a/indra/newview/llwlparammanager.cpp
+++ b/indra/newview/llwlparammanager.cpp
@@ -68,28 +68,28 @@ LLWLParamManager::LLWLParamManager() :
 	/// Sun Delta Terrain tweak variables.
 	mSunDeltaYaw(180.0f),
 	mSceneLightStrength(2.0f),
-	mWLGamma(1.0f, "gamma"),
+//	mWLGamma(1.0f, "gamma"),
 
-	mBlueHorizon(0.25f, 0.25f, 1.0f, 1.0f, "blue_horizon", "WLBlueHorizon"),
-	mHazeDensity(1.0f, "haze_density"),
-	mBlueDensity(0.25f, 0.25f, 0.25f, 1.0f, "blue_density", "WLBlueDensity"),
-	mDensityMult(1.0f, "density_multiplier", 1000),
-	mHazeHorizon(1.0f, "haze_horizon"),
-	mMaxAlt(4000.0f, "max_y"),
+// 	mBlueHorizon(0.25f, 0.25f, 1.0f, 1.0f, "blue_horizon", "WLBlueHorizon"),
+// 	mHazeDensity(1.0f, "haze_density"),
+// 	mBlueDensity(0.25f, 0.25f, 0.25f, 1.0f, "blue_density", "WLBlueDensity"),
+// 	mDensityMult(1.0f, "density_multiplier", 1000),
+// 	mHazeHorizon(1.0f, "haze_horizon"),
+// 	mMaxAlt(4000.0f, "max_y"),
 
 	// Lighting
-	mLightnorm(0.f, 0.707f, -0.707f, 1.f, "lightnorm"),
-	mSunlight(0.5f, 0.5f, 0.5f, 1.0f, "sunlight_color", "WLSunlight"),
-	mAmbient(0.5f, 0.75f, 1.0f, 1.19f, "ambient", "WLAmbient"),
-	mGlow(18.0f, 0.0f, -0.01f, 1.0f, "glow"),
+// 	mLightnorm(0.f, 0.707f, -0.707f, 1.f, "lightnorm"),
+// 	mSunlight(0.5f, 0.5f, 0.5f, 1.0f, "sunlight_color", "WLSunlight"),
+// 	mAmbient(0.5f, 0.75f, 1.0f, 1.19f, "ambient", "WLAmbient"),
+// 	mGlow(18.0f, 0.0f, -0.01f, 1.0f, "glow"),
 
 	// Clouds
-	mCloudColor(0.5f, 0.5f, 0.5f, 1.0f, "cloud_color", "WLCloudColor"),
-	mCloudMain(0.5f, 0.5f, 0.125f, 1.0f, "cloud_pos_density1"),
-	mCloudCoverage(0.0f, "cloud_shadow"),
-	mCloudDetail(0.0f, 0.0f, 0.0f, 1.0f, "cloud_pos_density2"),
-	mDistanceMult(1.0f, "distance_multiplier"),
-	mCloudScale(0.42f, "cloud_scale"),
+// 	mCloudColor(0.5f, 0.5f, 0.5f, 1.0f, "cloud_color", "WLCloudColor"),
+// 	mCloudMain(0.5f, 0.5f, 0.125f, 1.0f, "cloud_pos_density1"),
+// 	mCloudCoverage(0.0f, "cloud_shadow"),
+// 	mCloudDetail(0.0f, 0.0f, 0.0f, 1.0f, "cloud_pos_density2"),
+// 	mDistanceMult(1.0f, "distance_multiplier"),
+// 	mCloudScale(0.42f, "cloud_scale"),
 
 	// sky dome
 	mDomeOffset(0.96f),
diff --git a/indra/newview/llwlparammanager.h b/indra/newview/llwlparammanager.h
index 61f86b747f..f7f4baee12 100644
--- a/indra/newview/llwlparammanager.h
+++ b/indra/newview/llwlparammanager.h
@@ -37,6 +37,7 @@
 
 class LLGLSLShader;
  
+#if 0
 // color control
 struct WLColorControl {
 	
@@ -115,6 +116,8 @@ struct WLFloatControl {
 	}
 };
 
+#endif
+
 /// WindLight parameter manager class - what controls all the wind light shaders
 class LLWLParamManager : public LLSingleton<LLWLParamManager>
 {
@@ -245,10 +248,12 @@ public:
 
 	/// Sun Delta Terrain tweak variables.
 	F32 mSunDeltaYaw;
+#if 0
 	WLFloatControl mWLGamma;
-
+#endif
 	F32 mSceneLightStrength;
 	
+#if 0
 	/// Atmospherics
 	WLColorControl mBlueHorizon;
 	WLFloatControl mHazeDensity;
@@ -270,7 +275,7 @@ public:
 	WLColorControl mCloudDetail;
 	WLFloatControl mDistanceMult;
 	WLFloatControl mCloudScale;
-
+#endif
 	/// sky dome
 	F32 mDomeOffset;
 	F32 mDomeRadius;
-- 
cgit v1.3


From 61e6632a713041e8e4ccebf72874767238bf8a48 Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Fri, 3 Nov 2017 11:28:08 -0700
Subject: Initial day cycle impl.

---
 indra/newview/lldaycyclemanager.cpp            |   3 +
 indra/newview/llenvironment.cpp                | 469 +++++++++++++++++++++++--
 indra/newview/llenvironment.h                  | 146 +++++---
 indra/newview/llenvmanager.h                   |   1 +
 indra/newview/llfloatereditdaycycle.cpp        |   1 +
 indra/newview/llfloatereditsky.cpp             | 167 +++------
 indra/newview/llfloatereditsky.h               |   2 +-
 indra/newview/llfloatereditwater.cpp           | 164 ++-------
 indra/newview/llfloatereditwater.h             |   1 +
 indra/newview/llfloaterenvironmentsettings.cpp | 112 +++---
 indra/newview/llfloaterenvironmentsettings.h   |   1 +
 indra/newview/llsettingsbase.cpp               |  24 +-
 indra/newview/llsettingsbase.h                 |  34 +-
 indra/newview/llsettingsdaycycle.cpp           | 179 +++++++---
 indra/newview/llsettingsdaycycle.h             |  28 +-
 indra/newview/llsettingssky.cpp                |  31 +-
 indra/newview/llsettingssky.h                  |   4 +-
 indra/newview/llsettingswater.cpp              |   9 +-
 indra/newview/llsettingswater.h                |   3 +-
 indra/newview/llwaterparammanager.cpp          |   4 -
 indra/newview/llwlparammanager.cpp             |   5 -
 21 files changed, 875 insertions(+), 513 deletions(-)

(limited to 'indra/newview/llwlparammanager.cpp')

diff --git a/indra/newview/lldaycyclemanager.cpp b/indra/newview/lldaycyclemanager.cpp
index 803e2b2fb2..23d442f3b6 100644
--- a/indra/newview/lldaycyclemanager.cpp
+++ b/indra/newview/lldaycyclemanager.cpp
@@ -30,6 +30,9 @@
 
 #include "lldiriterator.h"
 
+#include "llenvironment.h"
+#include "llsettingsdaycycle.h"
+
 void LLDayCycleManager::getPresetNames(preset_name_list_t& names) const
 {
 	names.clear();
diff --git a/indra/newview/llenvironment.cpp b/indra/newview/llenvironment.cpp
index fbb713c6d8..9c654bbeb5 100644
--- a/indra/newview/llenvironment.cpp
+++ b/indra/newview/llenvironment.cpp
@@ -29,7 +29,6 @@
 #include "llenvironment.h"
 
 #include "llagent.h"
-#include "lldaycyclemanager.h"
 #include "llviewercontrol.h" // for gSavedSettings
 #include "llviewerregion.h"
 #include "llwlhandlers.h"
@@ -40,6 +39,10 @@
 #include "pipeline.h"
 #include "llsky.h"
 
+#include "llviewershadermgr.h"
+
+#include "llsdserialize.h"
+#include "lldiriterator.h"
 //=========================================================================
 namespace
 {
@@ -53,21 +56,37 @@ const F32 LLEnvironment::NIGHTTIME_ELEVATION_COS(LLSky::NIGHTTIME_ELEVATION_COS)
 
 //-------------------------------------------------------------------------
 LLEnvironment::LLEnvironment():
-    mCurrentSky(),
-    mCurrentWater(),
+    mSelectedSky(),
+    mSelectedWater(),
+    mSelectedDayCycle(),
     mSkysById(),
     mSkysByName(),
     mWaterByName(),
     mWaterById(),
+    mDayCycleByName(),
+    mDayCycleById(),
     mUserPrefs()
+{
+}
+
+void LLEnvironment::initSingleton()
 {
     LLSettingsSky::ptr_t p_default_sky = LLSettingsSky::buildDefaultSky();
     addSky(p_default_sky);
-    mCurrentSky = p_default_sky;
+    mSelectedSky = p_default_sky;
 
     LLSettingsWater::ptr_t p_default_water = LLSettingsWater::buildDefaultWater();
     addWater(p_default_water);
-    mCurrentWater = p_default_water;
+    mSelectedWater = p_default_water;
+
+    LLSettingsDayCycle::ptr_t p_default_day = LLSettingsDayCycle::buildDefaultDayCycle();
+    addDayCycle(p_default_day);
+    mSelectedDayCycle.reset();
+
+    applyAllSelected();
+
+    // LEGACY!
+    legacyLoadAllPresets();
 }
 
 LLEnvironment::~LLEnvironment()
@@ -79,10 +98,25 @@ void LLEnvironment::loadPreferences()
     mUserPrefs.load();
 }
 
+LLEnvironment::connection_t LLEnvironment::setSkyListChange(const LLEnvironment::change_signal_t::slot_type& cb)
+{
+    return mSkyListChange.connect(cb);
+}
+
+LLEnvironment::connection_t LLEnvironment::setWaterListChange(const LLEnvironment::change_signal_t::slot_type& cb)
+{
+    return mWaterListChange.connect(cb);
+}
+
+LLEnvironment::connection_t LLEnvironment::setDayCycleListChange(const LLEnvironment::change_signal_t::slot_type& cb)
+{
+    return mDayCycleListChange.connect(cb);
+}
+
 //-------------------------------------------------------------------------
 F32 LLEnvironment::getCamHeight() const
 {
-    return (mCurrentSky->getDomeOffset() * mCurrentSky->getDomeRadius());
+    return (mSelectedSky->getDomeOffset() * mSelectedSky->getDomeRadius());
 }
 
 F32 LLEnvironment::getWaterHeight() const
@@ -92,7 +126,7 @@ F32 LLEnvironment::getWaterHeight() const
 
 bool LLEnvironment::getIsDayTime() const
 {
-    return mCurrentSky->getSunDirection().mV[2] > NIGHTTIME_ELEVATION_COS;
+    return mSelectedSky->getSunDirection().mV[2] > NIGHTTIME_ELEVATION_COS;
 }
 
 //-------------------------------------------------------------------------
@@ -102,7 +136,13 @@ void LLEnvironment::update(const LLViewerCamera * cam)
 
     // update clouds, sun, and general
     updateCloudScroll();
-    mCurrentSky->update();
+    if (mSelectedDayCycle)
+        mSelectedDayCycle->update();
+
+    if (mSelectedSky)
+        mSelectedSky->update();
+    if (mSelectedWater)
+        mSelectedWater->update();
 
 //     // update only if running
 //     if (mAnimator.getIsRunning())
@@ -139,6 +179,11 @@ void LLEnvironment::update(const LLViewerCamera * cam)
     }
 }
 
+void advanceDay(F32 delta)
+{
+
+}
+
 void LLEnvironment::updateCloudScroll()
 {
     // This is a function of the environment rather than the sky, since it should 
@@ -147,7 +192,7 @@ void LLEnvironment::updateCloudScroll()
 
     F64 delta_t = s_cloud_timer.getElapsedTimeAndResetF64();
     
-    LLVector2 cloud_delta = static_cast<F32>(delta_t)* (mCurrentSky->getCloudScrollRate() - LLVector2(10.0, 10.0)) / 100.0;
+    LLVector2 cloud_delta = static_cast<F32>(delta_t)* (mSelectedSky->getCloudScrollRate() - LLVector2(10.0, 10.0)) / 100.0;
     mCloudScrollDelta += cloud_delta;
 
 
@@ -225,8 +270,8 @@ void LLEnvironment::updateShaderUniforms(LLGLSLShader *shader)
 
     if (gPipeline.canUseWindLightShaders())
     {
-        updateGLVariablesForSettings(shader, mCurrentSky);
-        updateGLVariablesForSettings(shader, mCurrentWater);
+        updateGLVariablesForSettings(shader, mSelectedSky);
+        updateGLVariablesForSettings(shader, mSelectedWater);
     }
 
     if (shader->mShaderGroup == LLGLSLShader::SG_DEFAULT)
@@ -248,6 +293,176 @@ void LLEnvironment::updateShaderUniforms(LLGLSLShader *shader)
 
 }
 //--------------------------------------------------------------------------
+void LLEnvironment::selectSky(const std::string &name)
+{
+    LLSettingsSky::ptr_t next_sky = findSkyByName(name);
+    if (!next_sky)
+    {
+        LL_WARNS("ENVIRONMENT") << "Unable to select sky with unknown name '" << name << "'" << LL_ENDL;
+        return;
+    }
+
+    selectSky(next_sky);
+}
+
+void LLEnvironment::selectSky(const LLSettingsSky::ptr_t &sky)
+{
+    if (!sky)
+    {
+        mSelectedSky = mCurrentSky;
+        return;
+    }
+    mSelectedSky = sky;
+    mSelectedSky->setDirtyFlag(true);
+}
+
+void LLEnvironment::applySky(const LLSettingsSky::ptr_t &sky)
+{
+    if (sky)
+    {
+        mCurrentSky = sky;
+    }
+    else
+    {
+        mCurrentSky = mSelectedSky;
+    }
+}
+
+void LLEnvironment::selectWater(const std::string &name)
+{
+    LLSettingsWater::ptr_t next_water = findWaterByName(name);
+
+    if (!next_water)
+    {
+        LL_WARNS("ENVIRONMENT") << "Unable to select water with unknown name '" << name << "'" << LL_ENDL;
+        return;
+    }
+
+    selectWater(next_water);
+}
+
+void LLEnvironment::selectWater(const LLSettingsWater::ptr_t &water)
+{
+    if (!water)
+    {
+        mSelectedWater = mCurrentWater;
+        return;
+    }
+    mSelectedWater = water;
+    mSelectedWater->setDirtyFlag(true);
+}
+
+void LLEnvironment::applyWater(const LLSettingsWater::ptr_t water)
+{
+    if (water)
+    {
+        mCurrentWater = water;
+    }
+    else
+    {
+        mCurrentWater = mSelectedWater;
+    }
+}
+
+void LLEnvironment::selectDayCycle(const std::string &name)
+{
+    LLSettingsDayCycle::ptr_t next_daycycle = findDayCycleByName(name);
+
+    if (!next_daycycle)
+    {
+        LL_WARNS("ENVIRONMENT") << "Unable to select daycycle with unknown name '" << name << "'" << LL_ENDL;
+        return;
+    }
+
+    mSelectedDayCycle = next_daycycle;
+    mSelectedDayCycle->setDirtyFlag(true);
+}
+
+void LLEnvironment::selectDayCycle(const LLSettingsDayCycle::ptr_t &daycycle)
+{
+    if (!daycycle)
+    {
+        mSelectedDayCycle = mCurrentDayCycle;
+        return;
+    }
+
+    mSelectedDayCycle = daycycle;
+    mSelectedDayCycle->setDirtyFlag(true);
+}
+
+void LLEnvironment::applyDayCycle(const LLSettingsDayCycle::ptr_t &daycycle)
+{
+    if (daycycle)
+    {
+        mCurrentDayCycle = daycycle;
+    }
+    else
+    {
+        mCurrentDayCycle = mSelectedDayCycle;
+    }
+}
+
+void LLEnvironment::clearAllSelected()
+{
+    if (mSelectedSky != mCurrentSky)
+        selectSky();
+    if (mSelectedWater != mCurrentWater)
+        selectWater();
+    if (mSelectedDayCycle != mCurrentDayCycle)
+        selectDayCycle();
+}
+
+void LLEnvironment::applyAllSelected()
+{
+    if (mSelectedSky != mCurrentSky)
+        applySky();
+    if (mSelectedWater != mCurrentWater)
+        applyWater();
+    if (mSelectedDayCycle != mCurrentDayCycle)
+        applyDayCycle();
+}
+
+LLEnvironment::list_name_id_t LLEnvironment::getSkyList() const
+{
+    list_name_id_t list;
+
+    list.reserve(mSkysByName.size());
+
+    for (NamedSettingMap_t::const_iterator it = mSkysByName.begin(); it != mSkysByName.end(); ++it)
+    {
+        list.push_back(std::vector<name_id_t>::value_type((*it).second->getName(), (*it).second->getId()));
+    }
+
+    return list;
+}
+
+LLEnvironment::list_name_id_t LLEnvironment::getWaterList() const
+{
+    list_name_id_t list;
+
+    list.reserve(mWaterByName.size());
+
+    for (NamedSettingMap_t::const_iterator it = mWaterByName.begin(); it != mWaterByName.end(); ++it)
+    {
+        list.push_back(std::vector<name_id_t>::value_type((*it).second->getName(), (*it).second->getId()));
+    }
+
+    return list;
+}
+
+LLEnvironment::list_name_id_t LLEnvironment::getDayCycleList() const
+{
+    list_name_id_t list;
+
+    list.reserve(mDayCycleByName.size());
+
+    for (NamedSettingMap_t::const_iterator it = mDayCycleByName.begin(); it != mDayCycleByName.end(); ++it)
+    {
+        list.push_back(std::vector<name_id_t>::value_type((*it).second->getName(), (*it).second->getId()));
+    }
+
+    return list;
+}
 
 void LLEnvironment::addSky(const LLSettingsSky::ptr_t &sky)
 {
@@ -260,6 +475,7 @@ void LLEnvironment::addSky(const LLSettingsSky::ptr_t &sky)
 
     if (!result.second)
         (*(result.first)).second = sky;
+    mSkyListChange();
 }
 
 // void LLEnvironment::addSky(const LLUUID &id, const LLSettingsSky::ptr_t &sky)
@@ -278,6 +494,7 @@ void LLEnvironment::removeSky(const std::string &name)
     NamedSettingMap_t::iterator it = mSkysByName.find(name);
     if (it != mSkysByName.end())
         mSkysByName.erase(it);
+    mSkyListChange();
 }
 
 // void LLEnvironment::removeSky(const LLUUID &id)
@@ -289,19 +506,7 @@ void LLEnvironment::clearAllSkys()
 {
     mSkysByName.clear();
     mSkysById.clear();
-}
-
-void LLEnvironment::selectSky(const std::string &name)
-{
-    LLSettingsSky::ptr_t next_sky = findSkyByName(name);
-    if (!next_sky)
-    {
-        LL_WARNS("ENVIRONMENT") << "Unable to select sky with unknown name '" << name << "'" << LL_ENDL;
-        return;
-    }
-
-    mCurrentSky = next_sky;
-    mCurrentSky->setDirtyFlag(true);
+    mSkyListChange();
 }
 
 void LLEnvironment::addWater(const LLSettingsWater::ptr_t &water)
@@ -315,29 +520,17 @@ void LLEnvironment::addWater(const LLSettingsWater::ptr_t &water)
 
     if (!result.second)
         (*(result.first)).second = water;
+    mWaterListChange();
 }
 
 //void LLEnvironment::addWater(const LLUUID &id, const LLSettingsSky::ptr_t &sky);
 
-void LLEnvironment::selectWater(const std::string &name)
-{
-    LLSettingsWater::ptr_t next_water = findWaterByName(name);
-
-    if (!next_water)
-    {
-        LL_WARNS("ENVIRONMENT") << "Unable to select water with unknown name '" << name << "'" << LL_ENDL;
-        return;
-    }
-
-    mCurrentWater = next_water;
-    mCurrentWater->setDirtyFlag(true);
-}
-
 void LLEnvironment::removeWater(const std::string &name)
 {
     NamedSettingMap_t::iterator it = mWaterByName.find(name);
     if (it != mWaterByName.end())
         mWaterByName.erase(it);
+    mWaterListChange();
 }
 
 //void LLEnvironment::removeWater(const LLUUID &id);
@@ -345,6 +538,39 @@ void LLEnvironment::clearAllWater()
 {
     mWaterByName.clear();
     mWaterById.clear();
+    mWaterListChange();
+}
+
+void LLEnvironment::addDayCycle(const LLSettingsDayCycle::ptr_t &daycycle)
+{
+    std::string name = daycycle->getValue(LLSettingsDayCycle::SETTING_NAME).asString();
+
+    LL_WARNS("RIDER") << "Adding daycycle as '" << name << "'" << LL_ENDL;
+
+    std::pair<NamedSettingMap_t::iterator, bool> result;
+    result = mDayCycleByName.insert(NamedSettingMap_t::value_type(name, daycycle));
+
+    if (!result.second)
+        (*(result.first)).second = daycycle;
+    mDayCycleListChange();
+}
+
+//void LLEnvironment::addDayCycle(const LLUUID &id, const LLSettingsSky::ptr_t &sky);
+
+void LLEnvironment::removeDayCycle(const std::string &name)
+{
+    NamedSettingMap_t::iterator it = mDayCycleByName.find(name);
+    if (it != mDayCycleByName.end())
+        mDayCycleByName.erase(it);
+    mDayCycleListChange();
+}
+
+//void LLEnvironment::removeDayCycle(const LLUUID &id);
+void LLEnvironment::clearAllDayCycles()
+{
+    mDayCycleByName.clear();
+    mWaterById.clear();
+    mDayCycleListChange();
 }
 
 LLSettingsSky::ptr_t LLEnvironment::findSkyByName(std::string name) const
@@ -373,6 +599,19 @@ LLSettingsWater::ptr_t LLEnvironment::findWaterByName(std::string name) const
     return boost::static_pointer_cast<LLSettingsWater>((*it).second);
 }
 
+LLSettingsDayCycle::ptr_t LLEnvironment::findDayCycleByName(std::string name) const
+{
+    NamedSettingMap_t::const_iterator it = mDayCycleByName.find(name);
+
+    if (it == mDayCycleByName.end())
+    {
+        LL_WARNS("ENVIRONMENT") << "Unable to find daycycle with unknown name '" << name << "'" << LL_ENDL;
+        return LLSettingsDayCycle::ptr_t();
+    }
+
+    return boost::static_pointer_cast<LLSettingsDayCycle>((*it).second);
+}
+
 //=========================================================================
 LLEnvironment::UserPrefs::UserPrefs():
     mUseRegionSettings(true),
@@ -409,3 +648,157 @@ void LLEnvironment::UserPrefs::store()
         gSavedSettings.setBOOL("UseDayCycle", getUseDayCycle());
     }
 }
+
+
+//=========================================================================
+// Transitional Code.
+// static
+std::string LLEnvironment::getSysDir(const std::string &subdir)
+{
+    return gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight\\"+subdir, "");
+}
+
+// static
+std::string LLEnvironment::getUserDir(const std::string &subdir)
+{
+    return gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, "windlight\\"+subdir, "");
+}
+
+LLSD LLEnvironment::legacyLoadPreset(const std::string& path)
+{
+    llifstream xml_file;
+    std::string name(gDirUtilp->getBaseFileName(LLURI::unescape(path), /*strip_exten = */ true));
+
+    xml_file.open(path.c_str());
+    if (!xml_file)
+    {
+        return LLSD();
+    }
+
+    LLSD params_data;
+    LLPointer<LLSDParser> parser = new LLSDXMLParser();
+    parser->parse(xml_file, params_data, LLSDSerialize::SIZE_UNLIMITED);
+    xml_file.close();
+
+    return params_data;
+}
+
+void LLEnvironment::legacyLoadAllPresets()
+{
+    std::string dir;
+    std::string file;
+
+    // System skies
+    {
+        dir = getSysDir("skies");
+        LLDirIterator dir_iter(dir, "*.xml");
+        while (dir_iter.next(file))
+        {
+            std::string path = gDirUtilp->add(dir, file);
+
+            LLSD data = legacyLoadPreset(path);
+            if (data)
+            {
+                std::string name(gDirUtilp->getBaseFileName(LLURI::unescape(path), true));
+
+                LLSettingsSky::ptr_t sky = LLSettingsSky::buildFromLegacyPreset(name, data);
+                LLEnvironment::instance().addSky(sky);
+            }
+        }
+    }
+
+    // User skies
+    {
+        dir = getUserDir("skies");
+        LLDirIterator dir_iter(dir, "*.xml");
+        while (dir_iter.next(file))
+        {
+            std::string path = gDirUtilp->add(dir, file);
+
+            LLSD data = legacyLoadPreset(path);
+            if (data)
+            {
+                std::string name(gDirUtilp->getBaseFileName(LLURI::unescape(path), true));
+
+                LLSettingsSky::ptr_t sky = LLSettingsSky::buildFromLegacyPreset(name, data);
+                LLEnvironment::instance().addSky(sky);
+            }
+        }
+    }
+
+    // System water
+    {
+        dir = getSysDir("water");
+        LLDirIterator dir_iter(dir, "*.xml");
+        while (dir_iter.next(file))
+        {
+            std::string path = gDirUtilp->add(dir, file);
+
+            LLSD data = legacyLoadPreset(path);
+            if (data)
+            {
+                std::string name(gDirUtilp->getBaseFileName(LLURI::unescape(path), true));
+
+                LLSettingsWater::ptr_t water = LLSettingsWater::buildFromLegacyPreset(name, data);
+                LLEnvironment::instance().addWater(water);
+            }
+        }
+    }
+
+    // User water
+    {
+        dir = getUserDir("water");
+        LLDirIterator dir_iter(dir, "*.xml");
+        while (dir_iter.next(file))
+        {
+            std::string path = gDirUtilp->add(dir, file);
+
+            LLSD data = legacyLoadPreset(path);
+            if (data)
+            {
+                std::string name(gDirUtilp->getBaseFileName(LLURI::unescape(path), true));
+
+                LLSettingsWater::ptr_t water = LLSettingsWater::buildFromLegacyPreset(name, data);
+                LLEnvironment::instance().addWater(water);
+            }
+        }
+    }
+
+    // System water
+    {
+        dir = getSysDir("days");
+        LLDirIterator dir_iter(dir, "*.xml");
+        while (dir_iter.next(file))
+        {
+            std::string path = gDirUtilp->add(dir, file);
+
+            LLSD data = legacyLoadPreset(path);
+            if (data)
+            {
+                std::string name(gDirUtilp->getBaseFileName(LLURI::unescape(path), true));
+
+                LLSettingsDayCycle::ptr_t day = LLSettingsDayCycle::buildFromLegacyPreset(name, data);
+                LLEnvironment::instance().addDayCycle(day);
+            }
+        }
+    }
+
+    // User water
+    {
+        dir = getUserDir("days");
+        LLDirIterator dir_iter(dir, "*.xml");
+        while (dir_iter.next(file))
+        {
+            std::string path = gDirUtilp->add(dir, file);
+
+            LLSD data = legacyLoadPreset(path);
+            if (data)
+            {
+                std::string name(gDirUtilp->getBaseFileName(LLURI::unescape(path), true));
+
+                LLSettingsDayCycle::ptr_t day = LLSettingsDayCycle::buildFromLegacyPreset(name, data);
+                LLEnvironment::instance().addDayCycle(day);
+            }
+        }
+    }
+}
diff --git a/indra/newview/llenvironment.h b/indra/newview/llenvironment.h
index 493fff1769..a3fc9eef66 100644
--- a/indra/newview/llenvironment.h
+++ b/indra/newview/llenvironment.h
@@ -32,6 +32,7 @@
 
 #include "llsettingssky.h"
 #include "llsettingswater.h"
+#include "llsettingsdaycycle.h"
 
 class LLViewerCamera;
 class LLGLSLShader;
@@ -52,22 +53,22 @@ public:
     public:
         UserPrefs();
 
-        bool        getUseRegionSettings() const { return mUseRegionSettings; }
-        bool        getUseDayCycle() const { return mUseDayCycle; }
-        bool        getUseFixedSky() const { return !getUseDayCycle(); }
+        bool            getUseRegionSettings() const { return mUseRegionSettings; }
+        bool            getUseDayCycle() const { return mUseDayCycle; }
+        bool            getUseFixedSky() const { return !getUseDayCycle(); }
 
-        std::string getWaterPresetName() const { return mWaterPresetName; }
-        std::string getSkyPresetName() const { return mSkyPresetName; }
-        std::string getDayCycleName() const { return mDayCycleName; }
+        std::string     getWaterPresetName() const { return mWaterPresetName; }
+        std::string     getSkyPresetName() const { return mSkyPresetName; }
+        std::string     getDayCycleName() const { return mDayCycleName; }
 
-        void setUseRegionSettings(bool val);
-        void setUseWaterPreset(const std::string& name);
-        void setUseSkyPreset(const std::string& name);
-        void setUseDayCycle(const std::string& name);
+        void            setUseRegionSettings(bool val);
+        void            setUseWaterPreset(const std::string& name);
+        void            setUseSkyPreset(const std::string& name);
+        void            setUseDayCycle(const std::string& name);
 
     private:
-        void load();
-        void store();
+        void            load();
+        void            store();
 
         bool			mUseRegionSettings;
         bool			mUseDayCycle;
@@ -77,66 +78,104 @@ public:
         std::string		mDayCycleName;
     };
 
+    typedef std::pair<std::string, LLUUID>  name_id_t;
+    typedef std::vector<name_id_t>          list_name_id_t;
+    typedef boost::signals2::signal<void()> change_signal_t;
+    typedef boost::signals2::connection     connection_t;
+
     virtual ~LLEnvironment();
 
-    void                    loadPreferences();
-    const UserPrefs &       getPreferences() const { return mUserPrefs; }
+    void                        loadPreferences();
+    const UserPrefs &           getPreferences() const { return mUserPrefs; }
+
+    LLSettingsSky::ptr_t        getCurrentSky() const { return mSelectedSky; }
+    LLSettingsWater::ptr_t      getCurrentWater() const { return mSelectedWater; }
 
-    LLSettingsSky::ptr_t    getCurrentSky() const { return mCurrentSky; }
-    LLSettingsWater::ptr_t  getCurrentWater() const { return mCurrentWater; }
+    void                        update(const LLViewerCamera * cam);
 
+    void                        updateGLVariablesForSettings(LLGLSLShader *shader, const LLSettingsBase::ptr_t &psetting);
+    void                        updateShaderUniforms(LLGLSLShader *shader);
 
+    void                        addSky(const LLSettingsSky::ptr_t &sky);
+    void                        addWater(const LLSettingsWater::ptr_t &sky);
+    void                        addDayCycle(const LLSettingsDayCycle::ptr_t &day);
 
-    void                    update(const LLViewerCamera * cam);
+    void                        selectSky(const std::string &name);
+    void                        selectSky(const LLSettingsSky::ptr_t &sky = LLSettingsSky::ptr_t());
+    void                        applySky(const LLSettingsSky::ptr_t &sky = LLSettingsSky::ptr_t());
+    void                        selectWater(const std::string &name);
+    void                        selectWater(const LLSettingsWater::ptr_t &water = LLSettingsWater::ptr_t());
+    void                        applyWater(const LLSettingsWater::ptr_t water = LLSettingsWater::ptr_t());
+    void                        selectDayCycle(const std::string &name);
+    void                        selectDayCycle(const LLSettingsDayCycle::ptr_t &daycycle = LLSettingsDayCycle::ptr_t());
+    void                        applyDayCycle(const LLSettingsDayCycle::ptr_t &daycycle = LLSettingsDayCycle::ptr_t());
+    void                        clearAllSelected();
+    void                        applyAllSelected();
 
-    void                    updateGLVariablesForSettings(LLGLSLShader *shader, const LLSettingsBase::ptr_t &psetting);
-    void                    updateShaderUniforms(LLGLSLShader *shader);
+    list_name_id_t              getSkyList() const;
+    list_name_id_t              getWaterList() const;
+    list_name_id_t              getDayCycleList() const;
 
-    void                    addSky(const LLSettingsSky::ptr_t &sky);
-    void                    selectSky(const std::string &name);
-    LLSettingsSky::ptr_t    findSkyByName(std::string name) const;
-    LLSettingsWater::ptr_t  findWaterByName(std::string name) const;
+    LLSettingsSky::ptr_t        findSkyByName(std::string name) const;
+    LLSettingsWater::ptr_t      findWaterByName(std::string name) const;
+    LLSettingsDayCycle::ptr_t   findDayCycleByName(std::string name) const;
 
-    void                    addWater(const LLSettingsWater::ptr_t &sky);
-    void                    selectWater(const std::string &name);
+    inline LLVector2            getCloudScrollDelta() const { return mCloudScrollDelta; }
 
-    inline LLVector2        getCloudScrollDelta() const { return mCloudScrollDelta; }
+    F32                         getCamHeight() const;
+    F32                         getWaterHeight() const;
+    bool                        getIsDayTime() const;   // "Day Time" is defined as the sun above the horizon.
+    bool                        getIsNightTime() const { return !getIsDayTime(); } // "Not Day Time" 
 
-    F32                     getCamHeight() const;
-    F32                     getWaterHeight() const;
-    bool                    getIsDayTime() const;   // "Day Time" is defined as the sun above the horizon.
-    bool                    getIsNightTime() const { return !getIsDayTime(); } // "Not Day Time" 
+    inline F32                  getSceneLightStrength() const { return mSceneLightStrength; }
+    inline void                 setSceneLightStrength(F32 light_strength) { mSceneLightStrength = light_strength; }
 
-    inline F32              getSceneLightStrength() const { return mSceneLightStrength; }
-    inline void             setSceneLightStrength(F32 light_strength) { mSceneLightStrength = light_strength; }
+    inline LLVector4            getLightDirection() const { return LLVector4(mSelectedSky->getLightDirection(), 0.0f); }
+    inline LLVector4            getClampedLightDirection() const { return LLVector4(mSelectedSky->getClampedLightDirection(), 0.0f); }
+    inline LLVector4            getRotatedLight() const { return mRotatedLight; }
 
-    inline LLVector4        getLightDirection() const { return LLVector4(mCurrentSky->getLightDirection(), 0.0f); }
-    inline LLVector4        getClampedLightDirection() const { return LLVector4(mCurrentSky->getClampedLightDirection(), 0.0f); }
-    inline LLVector4        getRotatedLight() const { return mRotatedLight; }
+    //-------------------------------------------
+    connection_t                setSkyListChange(const change_signal_t::slot_type& cb);
+    connection_t                setWaterListChange(const change_signal_t::slot_type& cb);
+    connection_t                setDayCycleListChange(const change_signal_t::slot_type& cb);
 
+protected:
+    virtual void                initSingleton();
 
 private:
-    static const F32        SUN_DELTA_YAW;
-    static const F32        NIGHTTIME_ELEVATION_COS;
+    static const F32            SUN_DELTA_YAW;
+    static const F32            NIGHTTIME_ELEVATION_COS;
 
     typedef std::map<std::string, LLSettingsBase::ptr_t> NamedSettingMap_t;
     typedef std::map<LLUUID, LLSettingsBase::ptr_t> AssetSettingMap_t;
 
-    LLVector2               mCloudScrollDelta;  // cumulative cloud delta
+    LLVector2                   mCloudScrollDelta;  // cumulative cloud delta
+
+    LLSettingsSky::ptr_t        mSelectedSky;
+    LLSettingsWater::ptr_t      mSelectedWater;
+    LLSettingsDayCycle::ptr_t   mSelectedDayCycle;
+
+    LLSettingsSky::ptr_t        mCurrentSky;
+    LLSettingsWater::ptr_t      mCurrentWater;
+    LLSettingsDayCycle::ptr_t   mCurrentDayCycle;
+
+    NamedSettingMap_t           mSkysByName;
+    AssetSettingMap_t           mSkysById;
 
-    LLSettingsSky::ptr_t    mCurrentSky;
-    LLSettingsWater::ptr_t  mCurrentWater;
+    NamedSettingMap_t           mWaterByName;
+    AssetSettingMap_t           mWaterById;
 
-    NamedSettingMap_t       mSkysByName;
-    AssetSettingMap_t       mSkysById;
+    NamedSettingMap_t           mDayCycleByName;
+    AssetSettingMap_t           mDayCycleById;
 
-    NamedSettingMap_t       mWaterByName;
-    AssetSettingMap_t       mWaterById;
+    F32                         mSceneLightStrength;
+    LLVector4                   mRotatedLight;
 
-    F32                     mSceneLightStrength;
-    LLVector4               mRotatedLight;
+    UserPrefs                   mUserPrefs;
 
-    UserPrefs               mUserPrefs;
+    change_signal_t             mSkyListChange;
+    change_signal_t             mWaterListChange;
+    change_signal_t             mDayCycleListChange;
 
     //void addSky(const LLUUID &id, const LLSettingsSky::ptr_t &sky);
     void removeSky(const std::string &name);
@@ -148,7 +187,20 @@ private:
     //void removeWater(const LLUUID &id);
     void clearAllWater();
 
+    //void addDayCycle(const LLUUID &id, const LLSettingsSky::ptr_t &sky);
+    void removeDayCycle(const std::string &name);
+    //void removeDayCycle(const LLUUID &id);
+    void clearAllDayCycles();
+
+
     void updateCloudScroll();
+
+    //=========================================================================
+    void                        legacyLoadAllPresets();
+    LLSD                        legacyLoadPreset(const std::string& path);
+    static std::string          getSysDir(const std::string &subdir);
+    static std::string          getUserDir(const std::string &subdir);
+
 };
 
 
diff --git a/indra/newview/llenvmanager.h b/indra/newview/llenvmanager.h
index 54bbf85e86..31a093ad5d 100644
--- a/indra/newview/llenvmanager.h
+++ b/indra/newview/llenvmanager.h
@@ -328,6 +328,7 @@ private:
 
 	void onRegionChange();
 
+
 	/// Emitted when user environment preferences change.
 	prefs_change_signal_t mUsePrefsChangeSignal;
 
diff --git a/indra/newview/llfloatereditdaycycle.cpp b/indra/newview/llfloatereditdaycycle.cpp
index 5c0991b0b3..97d87ee13e 100644
--- a/indra/newview/llfloatereditdaycycle.cpp
+++ b/indra/newview/llfloatereditdaycycle.cpp
@@ -691,6 +691,7 @@ void LLFloaterEditDayCycle::onDayCycleNameEdited()
 
 void LLFloaterEditDayCycle::onDayCycleSelected()
 {
+
 	LLSD day_data;
 	LLWLParamKey dc_key = getSelectedDayCycle();
 	bool can_edit = true;
diff --git a/indra/newview/llfloatereditsky.cpp b/indra/newview/llfloatereditsky.cpp
index 5fd559c060..23744e5b07 100644
--- a/indra/newview/llfloatereditsky.cpp
+++ b/indra/newview/llfloatereditsky.cpp
@@ -87,6 +87,8 @@ BOOL LLFloaterEditSky::postBuild()
 	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.
@@ -124,7 +126,7 @@ 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().clearAllSelected();
 	}
 }
 
@@ -216,6 +218,10 @@ void LLFloaterEditSky::syncControls()
     LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
     mEditSettings = psky;
 
+    std::string name = psky->getName();
+
+    mSkyPresetNameEditor->setText(name);
+    mSkyPresetCombo->setValue(name);
 
 	// blue horizon
 	mSkyAdapter->mBlueHorizon.setColor3( psky->getBlueHorizon() );
@@ -557,44 +563,16 @@ bool LLFloaterEditSky::isNewPreset() const
 
 void LLFloaterEditSky::refreshSkyPresetsList()
 {
-#if 0
 	mSkyPresetCombo->removeall();
 
-	LLWLParamManager::preset_name_list_t region_presets, user_presets, sys_presets;
-	LLWLParamManager::instance().getPresetNames(region_presets, user_presets, sys_presets);
-
-#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
+    LLEnvironment::list_name_id_t list = LLEnvironment::instance().getSkyList();
 
-	// 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"));
-#endif
 }
 
 void LLFloaterEditSky::enableEditing(bool enable)
@@ -629,63 +607,51 @@ void LLFloaterEditSky::saveRegionSky()
 #endif
 }
 
-// LLWLParamKey LLFloaterEditSky::getSelectedSkyPreset()
-// {
-// 	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);
-// 		}
-// 	}
-// 
-// 	return key;
-// }
+std::string LLFloaterEditSky::getSelectedPresetName() const
+{
+    std::string name;
+    if (mSkyPresetNameEditor->getVisible())
+    {
+        name = mSkyPresetNameEditor->getText();
+    }
+    else
+    {
+        LLSD combo_val = mSkyPresetCombo->getValue();
+        name = combo_val[0].asString();
+    }
+
+    return name;
+}
 
 void LLFloaterEditSky::onSkyPresetNameEdited()
 {
-#if 0
-	// Disable saving a sky preset having empty name.
-	LLWLParamKey key = getSelectedSkyPreset();
-	mSaveButton->setEnabled(!key.name.empty());
-#endif
+    std::string name = mSkyPresetNameEditor->getText();
+    LLSettingsWater::ptr_t psky = LLEnvironment::instance().getCurrentWater();
+
+    psky->setName(name);
 }
 
 void LLFloaterEditSky::onSkyPresetSelected()
 {
-#if 0
-	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().selectSky(psky);
+
+    syncControls();
+    enableEditing(true);
 
-	mMakeDefaultCheckBox->setEnabled(key.scope == LLEnvKey::SCOPE_LOCAL);
-#endif
 }
 
 bool LLFloaterEditSky::onSaveAnswer(const LLSD& notification, const LLSD& response)
@@ -733,43 +699,11 @@ void LLFloaterEditSky::onSaveConfirmed()
 
 void LLFloaterEditSky::onBtnSave()
 {
-#if 0
-	LLWLParamKey selected_sky = getSelectedSkyPreset();
-	LLWLParamManager& wl_mgr = LLWLParamManager::instance();
-
-	if (selected_sky.scope == LLEnvKey::SCOPE_REGION)
-	{
-		saveRegionSky();
-		closeFloater();
-		return;
-	}
-
-	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;
-	}
+    LLSettingsSky::ptr_t psky = LLEnvironment::instance().getCurrentSky();
+    LLEnvironment::instance().addSky(psky);
 
-	// 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();
-	}
-#endif
+    LLEnvironment::instance().applySky();
+    closeFloater();
 }
 
 void LLFloaterEditSky::onBtnCancel()
@@ -779,6 +713,7 @@ void LLFloaterEditSky::onBtnCancel()
 
 void LLFloaterEditSky::onSkyPresetListChange()
 {
+    refreshSkyPresetsList();
 #if 0
 	LLWLParamKey key = getSelectedSkyPreset(); // preset being edited
 	if (!LLWLParamManager::instance().hasParamSet(key))
diff --git a/indra/newview/llfloatereditsky.h b/indra/newview/llfloatereditsky.h
index 51be50a481..36438becce 100644
--- a/indra/newview/llfloatereditsky.h
+++ b/indra/newview/llfloatereditsky.h
@@ -98,7 +98,7 @@ private:
 	void refreshSkyPresetsList();
 	void enableEditing(bool enable);
 	void saveRegionSky();
-//	LLWLParamKey getSelectedSkyPreset();
+	std::string getSelectedPresetName() const;
 
 	void onSkyPresetNameEdited();
 	void onSkyPresetSelected();
diff --git a/indra/newview/llfloatereditwater.cpp b/indra/newview/llfloatereditwater.cpp
index b025680da1..2868a0609a 100644
--- a/indra/newview/llfloatereditwater.cpp
+++ b/indra/newview/llfloatereditwater.cpp
@@ -73,6 +73,8 @@ BOOL LLFloaterEditWater::postBuild()
 
     mWaterAdapter = boost::make_shared<LLWatterSettingsAdapter>();
 
+    LLEnvironment::instance().setWaterListChange(boost::bind(&LLFloaterEditWater::onWaterPresetListChange, this));
+
 	initCallbacks();
 	refreshWaterPresetsList();
 	syncControls();
@@ -109,7 +111,7 @@ void LLFloaterEditWater::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().clearAllSelected();
 	}
 }
 
@@ -176,6 +178,10 @@ void LLFloaterEditWater::syncControls()
     LLSettingsWater::ptr_t pwater = LLEnvironment::instance().getCurrentWater();
     mEditSettings = pwater;
 
+    std::string name = pwater->getName();
+    mWaterPresetNameEditor->setText(name);
+    mWaterPresetCombo->setValue(name);
+
 	//getChild<LLUICtrl>("WaterGlow")->setValue(col.mV[3]);
     getChild<LLColorSwatchCtrl>("WaterFogColor")->set(LLColor4(pwater->getFogColor()));
 
@@ -322,44 +328,16 @@ bool LLFloaterEditWater::isNewPreset() const
 
 void LLFloaterEditWater::refreshWaterPresetsList()
 {
-#if 0
 	mWaterPresetCombo->removeall();
 
-#if 0 // *TODO: enable when we have a clear workflow to edit existing region environment
-	// If the region already has water params, add them to the list.
-	const LLEnvironmentSettings& region_settings = LLEnvManagerNew::instance().getRegionSettings();
-	if (region_settings.getWaterParams().size() != 0)
-	{
-		const std::string& region_name = gAgent.getRegion()->getName();
-		mWaterPresetCombo->add(region_name, LLSD().with(0, region_name).with(1, LLEnvKey::SCOPE_REGION));
-		mWaterPresetCombo->addSeparator();
-	}
-#endif
-
-	std::list<std::string> user_presets, system_presets;
-	LLWaterParamManager::instance().getPresetNames(user_presets, system_presets);
+    LLEnvironment::list_name_id_t list = LLEnvironment::instance().getWaterList();
 
-	// Add local user presets first.
-	for (std::list<std::string>::const_iterator it = user_presets.begin(); it != user_presets.end(); ++it)
-	{
-		const std::string& name = *it;
-		mWaterPresetCombo->add(name, LLSD().with(0, name).with(1, LLEnvKey::SCOPE_LOCAL)); // [<name>, <scope>]
-	}
-
-	if (user_presets.size() > 0)
-	{
-		mWaterPresetCombo->addSeparator();
-	}
-
-	// Add local system presets.
-	for (std::list<std::string>::const_iterator it = system_presets.begin(); it != system_presets.end(); ++it)
-	{
-		const std::string& name = *it;
-		mWaterPresetCombo->add(name, LLSD().with(0, name).with(1, LLEnvKey::SCOPE_LOCAL)); // [<name>, <scope>]
-	}
+    for (LLEnvironment::list_name_id_t::iterator it = list.begin(); it != list.end(); ++it)
+    {
+        mWaterPresetCombo->add((*it).first, LLSDArray((*it).first)((*it).second));
+    }
 
 	mWaterPresetCombo->setLabel(getString("combo_label"));
-#endif
 }
 
 void LLFloaterEditWater::enableEditing(bool enable)
@@ -406,36 +384,28 @@ LLEnvKey::EScope LLFloaterEditWater::getCurrentScope() const
 }
 #endif
 
-#if 0
-void LLFloaterEditWater::getSelectedPreset(std::string& name, LLEnvKey::EScope& scope) const
+std::string LLFloaterEditWater::getSelectedPresetName() const
 {
-
+    std::string name;
 	if (mWaterPresetNameEditor->getVisible())
 	{
 		name = mWaterPresetNameEditor->getText();
-		scope = LLEnvKey::SCOPE_LOCAL;
 	}
 	else
 	{
 		LLSD combo_val = mWaterPresetCombo->getValue();
-
-		if (!combo_val.isArray()) // manually typed text
-		{
-			name = combo_val.asString();
-			scope = LLEnvKey::SCOPE_LOCAL;
-		}
-		else
-		{
-			name = combo_val[0].asString();
-			scope = (LLEnvKey::EScope) combo_val[1].asInteger();
-		}
+		name = combo_val[0].asString();
 	}
 
+    return name;
 }
-#endif
 
 void LLFloaterEditWater::onWaterPresetNameEdited()
 {
+    std::string name = mWaterPresetNameEditor->getText();
+    LLSettingsWater::ptr_t pwater = LLEnvironment::instance().getCurrentWater();
+
+    pwater->setName(name);
 #if 0
 	// Disable saving a water preset having empty name.
 	mSaveButton->setEnabled(!getCurrentPresetName().empty());
@@ -444,35 +414,24 @@ void LLFloaterEditWater::onWaterPresetNameEdited()
 
 void LLFloaterEditWater::onWaterPresetSelected()
 {
-#if 0
-	LLWaterParamSet water_params;
 	std::string name;
-	LLEnvKey::EScope scope;
 
-	getSelectedPreset(name, scope);
+	name = getSelectedPresetName();
 
-	// Display selected preset.
-	if (scope == LLEnvKey::SCOPE_REGION)
-	{
-		water_params.setAll(LLEnvManagerNew::instance().getRegionSettings().getWaterParams());
-	}
-	else // local preset selected
-	{
-		if (!LLWaterParamManager::instance().getParamSet(name, water_params))
-		{
-			// Manually entered string?
-			LL_WARNS("Windlight") << "No water preset named " << name << LL_ENDL;
-			return;
-		}
-	}
+    LLSettingsWater::ptr_t pwater = LLEnvironment::instance().findWaterByName(name);
 
-	LLEnvManagerNew::instance().useWaterParams(water_params.getAll());
+    if (!pwater)
+    {
+        LL_WARNS("WATEREDIT") << "Could not find water preset" << LL_ENDL;
+        enableEditing(false);
+        return;
+    }
 
-	bool can_edit = (scope == LLEnvKey::SCOPE_LOCAL || LLEnvManagerNew::canEditRegionSettings());
-	enableEditing(can_edit);
+    pwater = pwater->buildClone();
+    LLEnvironment::instance().selectWater(pwater);
 
-	mMakeDefaultCheckBox->setEnabled(scope == LLEnvKey::SCOPE_LOCAL);
-#endif
+    syncControls();
+    enableEditing(true);
 }
 
 bool LLFloaterEditWater::onSaveAnswer(const LLSD& notification, const LLSD& response)
@@ -521,44 +480,11 @@ void LLFloaterEditWater::onSaveConfirmed()
 
 void LLFloaterEditWater::onBtnSave()
 {
-#if 0
-	LLEnvKey::EScope scope;
-	std::string name;
-	getSelectedPreset(name, scope);
-
-	if (scope == LLEnvKey::SCOPE_REGION)
-	{
-		saveRegionWater();
-		closeFloater();
-		return;
-	}
-
-	if (name.empty())
-	{
-		// *TODO: show an alert
-		LL_WARNS() << "Empty water preset name" << LL_ENDL;
-		return;
-	}
-
-	// Don't allow overwriting system presets.
-	LLWaterParamManager& water_mgr = LLWaterParamManager::instance();
-	if (water_mgr.isSystemPreset(name))
-	{
-		LLNotificationsUtil::add("WLNoEditDefault");
-		return;
-	}
+    LLSettingsWater::ptr_t pwater = LLEnvironment::instance().getCurrentWater();
+    LLEnvironment::instance().addWater(pwater);
 
-	// Save, ask for confirmation for overwriting an existing preset.
-	if (water_mgr.hasParamSet(name))
-	{
-		LLNotificationsUtil::add("WLSavePresetAlert", LLSD(), LLSD(), boost::bind(&LLFloaterEditWater::onSaveAnswer, this, _1, _2));
-	}
-	else
-	{
-		// new preset, hence no confirmation needed
-		onSaveConfirmed();
-	}
-#endif
+    LLEnvironment::instance().applyWater();
+    closeFloater();
 }
 
 void LLFloaterEditWater::onBtnCancel()
@@ -568,23 +494,7 @@ void LLFloaterEditWater::onBtnCancel()
 
 void LLFloaterEditWater::onWaterPresetListChange()
 {
-#if 0
-	std::string name;
-	LLEnvKey::EScope scope;
-	getSelectedPreset(name, scope); // preset being edited
-
-	if (scope == LLEnvKey::SCOPE_LOCAL && !LLWaterParamManager::instance().hasParamSet(name))
-	{
-		// 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.
-		refreshWaterPresetsList();
-	}
-#endif
+    refreshWaterPresetsList();
 }
 
 void LLFloaterEditWater::onRegionSettingsChange()
diff --git a/indra/newview/llfloatereditwater.h b/indra/newview/llfloatereditwater.h
index 7d9e493ac2..081b939039 100644
--- a/indra/newview/llfloatereditwater.h
+++ b/indra/newview/llfloatereditwater.h
@@ -87,6 +87,7 @@ private:
 	void enableEditing(bool enable);
 	void saveRegionWater();
 
+    std::string getSelectedPresetName() const;
 //	std::string			getCurrentPresetName() const;
 // 	LLEnvKey::EScope	getCurrentScope() const;
 //	void				getSelectedPreset(std::string& name, LLEnvKey::EScope& scope) const;
diff --git a/indra/newview/llfloaterenvironmentsettings.cpp b/indra/newview/llfloaterenvironmentsettings.cpp
index 39907b19a3..e25c5cedbf 100644
--- a/indra/newview/llfloaterenvironmentsettings.cpp
+++ b/indra/newview/llfloaterenvironmentsettings.cpp
@@ -70,10 +70,10 @@ BOOL LLFloaterEnvironmentSettings::postBuild()
 
 	setCloseCallback(boost::bind(&LLFloaterEnvironmentSettings::cancel, this));
 
+    LLEnvironment::instance().setSkyListChange(boost::bind(&LLFloaterEnvironmentSettings::populateSkyPresetsList, this));
+    LLEnvironment::instance().setWaterListChange(boost::bind(&LLFloaterEnvironmentSettings::populateWaterPresetsList, this));
+    LLEnvironment::instance().setDayCycleListChange(boost::bind(&LLFloaterEnvironmentSettings::populateDayCyclePresetsList, this));
 // 	LLEnvManagerNew::instance().setPreferencesChangeCallback(boost::bind(&LLFloaterEnvironmentSettings::refresh, this));
-//	LLDayCycleManager::instance().setModifyCallback(boost::bind(&LLFloaterEnvironmentSettings::populateDayCyclePresetsList, this));
-// 	LLWLParamManager::instance().setPresetListChangeCallback(boost::bind(&LLFloaterEnvironmentSettings::populateSkyPresetsList, this));
-// 	LLWaterParamManager::instance().setPresetListChangeCallback(boost::bind(&LLFloaterEnvironmentSettings::populateWaterPresetsList, this));
 
 	return TRUE;
 }
@@ -84,6 +84,14 @@ void LLFloaterEnvironmentSettings::onOpen(const LLSD& key)
 	refresh();
 }
 
+//virtual
+void LLFloaterEnvironmentSettings::onClose(bool app_quitting)
+{
+    if (!app_quitting)
+        LLEnvironment::instance().clearAllSelected();
+}
+
+
 void LLFloaterEnvironmentSettings::onSwitchRegionSettings()
 {
 	getChild<LLView>("user_environment_settings")->setEnabled(mRegionSettingsRadioGroup->getSelectedIndex() != 0);
@@ -133,6 +141,7 @@ void LLFloaterEnvironmentSettings::onBtnOK()
 		use_region_settings);
 
 	// *TODO: This triggers applying user preferences again, which is suboptimal.
+    LLEnvironment::instance().applyAllSelected();
 	closeFloater();
 }
 
@@ -173,9 +182,9 @@ void LLFloaterEnvironmentSettings::apply()
 	// Update environment with the user choice.
 	bool use_region_settings	= mRegionSettingsRadioGroup->getSelectedIndex() == 0;
 	bool use_fixed_sky			= mDayCycleSettingsRadioGroup->getSelectedIndex() == 0;
-	std::string water_preset	= mWaterPresetCombo->getValue().asString();
-	std::string sky_preset		= mSkyPresetCombo->getValue().asString();
-	std::string day_cycle		= mDayCyclePresetCombo->getValue().asString();
+    std::string water_preset   = mWaterPresetCombo->getValue()[0].asString();
+    std::string sky_preset     = mSkyPresetCombo->getValue()[0].asString();
+	std::string day_cycle		= mDayCyclePresetCombo->getValue()[0].asString();
 
 	LLEnvManagerNew& env_mgr = LLEnvManagerNew::instance();
 	if (use_region_settings)
@@ -186,18 +195,23 @@ void LLFloaterEnvironmentSettings::apply()
 	{
 		if (use_fixed_sky)
 		{
-            /* LAPRAS */
-			//env_mgr.useSkyPreset(sky_preset);
-            LLEnvironment::instance().selectSky(sky_preset);
+            LLSettingsSky::ptr_t psky = LLEnvironment::instance().findSkyByName(sky_preset);
+            if (psky)
+                LLEnvironment::instance().selectSky(psky);
 		}
 		else
 		{
-			env_mgr.useDayCycle(day_cycle, LLEnvKey::SCOPE_LOCAL);
+            LLSettingsDayCycle::ptr_t pday = LLEnvironment::instance().findDayCycleByName(day_cycle);
+            if (pday)
+                LLEnvironment::instance().selectDayCycle(pday);
+
+//             LLEnvironment::instance().selectDayCycle(day_cycle);
+// 			env_mgr.useDayCycle(day_cycle, LLEnvKey::SCOPE_LOCAL);
 		}
 
-        /* LAPRAS */
-        //env_mgr.useWaterPreset(water_preset);
-        LLEnvironment::instance().selectWater(water_preset);
+        LLSettingsWater::ptr_t pwater = LLEnvironment::instance().findWaterByName(water_preset);
+        if (pwater)
+            LLEnvironment::instance().selectWater(pwater);
 	}
 }
 
@@ -209,76 +223,36 @@ void LLFloaterEnvironmentSettings::cancel()
 
 void LLFloaterEnvironmentSettings::populateWaterPresetsList()
 {
-	mWaterPresetCombo->removeall();
+    mWaterPresetCombo->removeall();
 
-	std::list<std::string> user_presets, system_presets;
-	//LLWaterParamManager::instance().getPresetNames(user_presets, system_presets);
+    LLEnvironment::list_name_id_t list = LLEnvironment::instance().getWaterList();
 
-	// Add user presets first.
-	for (std::list<std::string>::const_iterator it = user_presets.begin(); it != user_presets.end(); ++it)
-	{
-		mWaterPresetCombo->add(*it);
-	}
-
-	if (user_presets.size() > 0)
-	{
-		mWaterPresetCombo->addSeparator();
-	}
-
-	// Add system presets.
-	for (std::list<std::string>::const_iterator it = system_presets.begin(); it != system_presets.end(); ++it)
-	{
-		mWaterPresetCombo->add(*it);
-	}
+    for (LLEnvironment::list_name_id_t::iterator it = list.begin(); it != list.end(); ++it)
+    {
+        mWaterPresetCombo->add((*it).first, LLSDArray((*it).first)((*it).second));
+    }
 }
 
 void LLFloaterEnvironmentSettings::populateSkyPresetsList()
 {
 	mSkyPresetCombo->removeall();
 
-	LLWLParamManager::preset_name_list_t region_presets; // unused as we don't list region presets here
-	LLWLParamManager::preset_name_list_t user_presets, sys_presets;
-	LLWLParamManager::instance().getPresetNames(region_presets, user_presets, sys_presets);
+    LLEnvironment::list_name_id_t list = LLEnvironment::instance().getSkyList();
 
-	// Add user presets.
-	for (LLWLParamManager::preset_name_list_t::const_iterator it = user_presets.begin(); it != user_presets.end(); ++it)
-	{
-		mSkyPresetCombo->add(*it);
-	}
-
-	if (!user_presets.empty())
-	{
-		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);
-	}
+    for (LLEnvironment::list_name_id_t::iterator it = list.begin(); it != list.end(); ++it)
+    {
+        mSkyPresetCombo->add((*it).first, LLSDArray((*it).first)((*it).second));
+    }
 }
 
 void LLFloaterEnvironmentSettings::populateDayCyclePresetsList()
 {
 	mDayCyclePresetCombo->removeall();
 
-	LLDayCycleManager::preset_name_list_t user_days, sys_days;
-	LLDayCycleManager::instance().getPresetNames(user_days, sys_days);
+    LLEnvironment::list_name_id_t list = LLEnvironment::instance().getDayCycleList();
 
-	// Add user days.
-	for (LLDayCycleManager::preset_name_list_t::const_iterator it = user_days.begin(); it != user_days.end(); ++it)
-	{
-		mDayCyclePresetCombo->add(*it);
-	}
-
-	if (user_days.size() > 0)
-	{
-		mDayCyclePresetCombo->addSeparator();
-	}
-
-	// Add system days.
-	for (LLDayCycleManager::preset_name_list_t::const_iterator it = sys_days.begin(); it != sys_days.end(); ++it)
-	{
-		mDayCyclePresetCombo->add(*it);
-	}
+    for (LLEnvironment::list_name_id_t::iterator it = list.begin(); it != list.end(); ++it)
+    {
+        mDayCyclePresetCombo->add((*it).first, LLSDArray((*it).first)((*it).second));
+    }
 }
diff --git a/indra/newview/llfloaterenvironmentsettings.h b/indra/newview/llfloaterenvironmentsettings.h
index 0ab458a0f6..2236d57ff4 100644
--- a/indra/newview/llfloaterenvironmentsettings.h
+++ b/indra/newview/llfloaterenvironmentsettings.h
@@ -40,6 +40,7 @@ public:
 	LLFloaterEnvironmentSettings(const LLSD &key);
 	/*virtual*/	BOOL	postBuild();	
 	/*virtual*/ void	onOpen(const LLSD& key);
+    /*virtual*/ void    onClose(bool app_quitting);
 
 private:
 	void onSwitchRegionSettings();
diff --git a/indra/newview/llsettingsbase.cpp b/indra/newview/llsettingsbase.cpp
index 1f155776bf..a2e705d1fa 100644
--- a/indra/newview/llsettingsbase.cpp
+++ b/indra/newview/llsettingsbase.cpp
@@ -33,11 +33,16 @@
 
 #include "llsdserialize.h"
 
+//=========================================================================
 namespace
 {
     const F32 BREAK_POINT = 0.5;
 }
 
+//=========================================================================
+const std::string LLSettingsBase::SETTING_ID("id");
+const std::string LLSettingsBase::SETTING_NAME("name");
+
 //=========================================================================
 LLSettingsBase::LLSettingsBase():
     mSettings(LLSD::emptyMap()),
@@ -242,15 +247,16 @@ LLSD LLSettingsBase::cloneSettings() const
 
 LLSettingsBase::ptr_t LLSettingsBase::buildBlend(const ptr_t &begin, const ptr_t &end, F32 blendf)
 {
-    if (begin->getSettingType() != end->getSettingType())
-    {
-        LL_WARNS("SETTINGS") << "Attempt to blend settings of different types! " << 
-            begin->getSettingType() << "<->" << end->getSettingType() << LL_ENDL;
-
-        return LLSettingsBase::ptr_t();
-    }
-
-    return begin->blend(end, blendf);
+//     if (begin->getSettingType() != end->getSettingType())
+//     {
+//         LL_WARNS("SETTINGS") << "Attempt to blend settings of different types! " << 
+//             begin->getSettingType() << "<->" << end->getSettingType() << LL_ENDL;
+// 
+//         return LLSettingsBase::ptr_t();
+//     }
+
+//    return begin->blend(end, blendf);
+    return LLSettingsBase::ptr_t();
 }
 
 void LLSettingsBase::exportSettings(std::string name) const
diff --git a/indra/newview/llsettingsbase.h b/indra/newview/llsettingsbase.h
index f7015fb12b..205351c401 100644
--- a/indra/newview/llsettingsbase.h
+++ b/indra/newview/llsettingsbase.h
@@ -46,6 +46,9 @@ class LLSettingsBase: private boost::noncopyable
     friend class LLSettingsDayCycle;
 
 public:
+    static const std::string SETTING_ID;
+    static const std::string SETTING_NAME;
+
     typedef std::map<std::string, S32>  parammapping_t;
 
     typedef boost::shared_ptr<LLSettingsBase> ptr_t;
@@ -63,6 +66,32 @@ public:
     inline bool isDirty() const { return mDirty; }
     inline void setDirtyFlag(bool dirty) { mDirty = dirty; }
 
+    inline LLUUID getId() const
+    {
+        return getValue(SETTING_ID).asUUID();
+    }
+
+    inline std::string getName() const
+    {
+        return getValue(SETTING_NAME).asString();
+    }
+
+    inline void setName(std::string val)
+    {
+        setValue(SETTING_NAME, val);
+    }
+
+    inline void replaceSettings(LLSD settings)
+    {
+        mSettings = settings;
+        setDirtyFlag(true);
+    }
+
+    inline LLSD getSettings() const
+    {
+        return mSettings;
+    }
+
     //---------------------------------------------------------------------
     // 
     inline void setValue(const std::string &name, const LLSD &value)
@@ -71,7 +100,7 @@ public:
         mDirty = true;
     }
 
-    inline LLSD getValue(const std::string &name, const LLSD &deflt = LLSD())
+    inline LLSD getValue(const std::string &name, const LLSD &deflt = LLSD()) const
     {
         if (!mSettings.has(name))
             return deflt;
@@ -121,13 +150,14 @@ public:
     // TODO: This is temporary 
     virtual void exportSettings(std::string name) const;
 
+    virtual void blend(const ptr_t &end, F32 blendf) = 0;
+
 protected:
     LLSettingsBase();
     LLSettingsBase(const LLSD setting);
 
     typedef std::set<std::string>   stringset_t;
 
-    virtual ptr_t blend(const ptr_t &end, F32 blendf) const = 0;
 
     // combining settings objects. Customize for specific setting types
     virtual void lerpSettings(const LLSettingsBase &other, F32 mix);
diff --git a/indra/newview/llsettingsdaycycle.cpp b/indra/newview/llsettingsdaycycle.cpp
index bda3c7c138..2d97ea865f 100644
--- a/indra/newview/llsettingsdaycycle.cpp
+++ b/indra/newview/llsettingsdaycycle.cpp
@@ -47,6 +47,8 @@
 
 #include "llenvironment.h"
 
+#include "llworld.h"
+
 //=========================================================================
 namespace
 {
@@ -55,7 +57,16 @@ namespace
 
     inline F32 get_wrapping_distance(F32 begin, F32 end)
     {
-        return 1.0 - fabs((begin + 1.0) - end);
+        if (begin < end)
+        {
+            return end - begin;
+        }
+        else if (begin > end)
+        {
+            return 1.0 - (begin - end);
+        }
+
+        return 0;
     }
 
     LLSettingsDayCycle::CycleTrack_t::iterator get_wrapping_atafter(LLSettingsDayCycle::CycleTrack_t &collection, F32 key)
@@ -81,11 +92,11 @@ namespace
         LLSettingsDayCycle::CycleTrack_t::iterator it = collection.lower_bound(key);
 
         if (it == collection.end())
-        {   // all offsets are lower, take the last one.
+        {   // all keyframes are lower, take the last one.
             --it; // we know the range is not empty
         }
         else if ((*it).first > key)
-        {   // the offset we are interested in is smaller than the found.
+        {   // the keyframe we are interested in is smaller than the found.
             if (it == collection.begin())
                 it = collection.end();
             --it;
@@ -101,11 +112,13 @@ namespace
 const std::string LLSettingsDayCycle::SETTING_DAYLENGTH("day_length");
 const std::string LLSettingsDayCycle::SETTING_KEYID("key_id");
 const std::string LLSettingsDayCycle::SETTING_KEYNAME("key_name");
-const std::string LLSettingsDayCycle::SETTING_KEYOFFSET("key_offset");
+const std::string LLSettingsDayCycle::SETTING_KEYKFRAME("key_keyframe");
 const std::string LLSettingsDayCycle::SETTING_NAME("name");
 const std::string LLSettingsDayCycle::SETTING_TRACKS("tracks");
 
-const S32 LLSettingsDayCycle::MINIMUM_DAYLENGTH( 14400); // 4 hours
+const S32 LLSettingsDayCycle::MINIMUM_DAYLENGTH(  300); // 5 mins
+
+//const S32 LLSettingsDayCycle::MINIMUM_DAYLENGTH( 14400); // 4 hours
 const S32 LLSettingsDayCycle::MAXIMUM_DAYLENGTH(604800); // 7 days
 
 const S32 LLSettingsDayCycle::TRACK_WATER(0);   // water track is 0
@@ -113,13 +126,15 @@ const S32 LLSettingsDayCycle::TRACK_MAX(5);     // 5 tracks, 4 skys, 1 water
 
 //=========================================================================
 LLSettingsDayCycle::LLSettingsDayCycle(const LLSD &data) :
-    LLSettingsBase(data)
+    LLSettingsBase(data),
+    mHasParsed(false)
 {
     mDayTracks.resize(TRACK_MAX);
 }
 
 LLSettingsDayCycle::LLSettingsDayCycle() :
-    LLSettingsBase()
+    LLSettingsBase(),
+    mHasParsed(false)
 {
     mDayTracks.resize(TRACK_MAX);
 }
@@ -132,8 +147,8 @@ LLSD LLSettingsDayCycle::defaults()
     dfltsetting[SETTING_NAME] = "_default_";
     dfltsetting[SETTING_DAYLENGTH] = MINIMUM_DAYLENGTH;
     dfltsetting[SETTING_TRACKS] = LLSDArray(
-        LLSDArray(LLSDMap(SETTING_KEYOFFSET, LLSD::Real(0.0f))(SETTING_KEYNAME, "_default_"))
-        (LLSDMap(SETTING_KEYOFFSET, LLSD::Real(0.0f))(SETTING_KEYNAME, "_default_")));
+        LLSDArray(LLSDMap(SETTING_KEYKFRAME, LLSD::Real(0.0f))(SETTING_KEYNAME, "_default_"))
+        (LLSDMap(SETTING_KEYKFRAME, LLSD::Real(0.0f))(SETTING_KEYNAME, "_default_")));
     
     return dfltsetting;
 }
@@ -146,14 +161,14 @@ LLSettingsDayCycle::ptr_t LLSettingsDayCycle::buildFromLegacyPreset(const std::s
     newsettings[SETTING_DAYLENGTH] = MINIMUM_DAYLENGTH;
 
     LLSD watertrack = LLSDArray( 
-        LLSDMap ( SETTING_KEYOFFSET, LLSD::Real(0.0f) )
+        LLSDMap ( SETTING_KEYKFRAME, LLSD::Real(0.0f) )
                 ( SETTING_KEYNAME, "Default" ));
 
     LLSD skytrack = LLSD::emptyArray();
 
     for (LLSD::array_const_iterator it = oldsettings.beginArray(); it != oldsettings.endArray(); ++it)
     {
-        LLSD entry = LLSDMap(SETTING_KEYOFFSET, (*it)[0].asReal())
+        LLSD entry = LLSDMap(SETTING_KEYKFRAME, (*it)[0].asReal())
             (SETTING_KEYNAME, (*it)[1].asString());
         skytrack.append(entry);
     }
@@ -185,7 +200,7 @@ void LLSettingsDayCycle::parseFromLLSD(LLSD &data)
         LLSD curtrack = tracks[i];
         for (LLSD::array_const_iterator it = curtrack.beginArray(); it != curtrack.endArray(); ++it)
         {
-            F32 offset = (*it)[SETTING_KEYOFFSET].asReal();
+            F32 keyframe = (*it)[SETTING_KEYKFRAME].asReal();
             LLSettingsBase::ptr_t setting;
 
             if ((*it).has(SETTING_KEYNAME))
@@ -201,9 +216,10 @@ void LLSettingsDayCycle::parseFromLLSD(LLSD &data)
             }
 
             if (setting)
-                mDayTracks[i][offset] = setting;
+                mDayTracks[i][keyframe] = setting;
         }
     }
+    mHasParsed = true;
 }
 
 
@@ -216,31 +232,85 @@ LLSettingsDayCycle::ptr_t LLSettingsDayCycle::buildClone()
     return dayp;
 }
 
-LLSettingsBase::ptr_t LLSettingsDayCycle::blend(const LLSettingsBase::ptr_t &other, F32 mix) const
+void LLSettingsDayCycle::blend(const LLSettingsBase::ptr_t &other, F32 mix)
 {
     LL_ERRS("DAYCYCLE") << "Day cycles are not blendable!" << LL_ENDL;
-    return LLSettingsBase::ptr_t();
 }
 
 //=========================================================================
-F32 LLSettingsDayCycle::secondsToOffset(S32 seconds)
+F32 LLSettingsDayCycle::secondsToKeyframe(S32 seconds)
 {
     S32 daylength = getDayLength();
 
     return static_cast<F32>(seconds % daylength) / static_cast<F32>(daylength);
 }
 
-S32 LLSettingsDayCycle::offsetToSeconds(F32 offset)
+S32 LLSettingsDayCycle::keyframeToSeconds(F32 keyframe)
 {
     S32 daylength = getDayLength();
 
-    return static_cast<S32>(offset * static_cast<F32>(daylength));
+    return static_cast<S32>(keyframe * static_cast<F32>(daylength));
 }
 
 //=========================================================================
 void LLSettingsDayCycle::updateSettings()
 {
+    if (!mHasParsed)
+        parseFromLLSD(mSettings);
+    //F64Seconds time_now(LLWorld::instance().getSpaceTimeUSec());
+    F64Seconds time_now(LLDate::now().secondsSinceEpoch());
+
+    // base class clears dirty flag so as to not trigger recursive update
+    LLSettingsBase::updateSettings();
+
+    if (!mBlendedWater)
+    {
+        mBlendedWater = LLEnvironment::instance().getCurrentWater()->buildClone();
+        LLEnvironment::instance().selectWater(mBlendedWater);
+    }
+
+    if (!mBlendedSky)
+    {
+        mBlendedSky = LLEnvironment::instance().getCurrentSky()->buildClone();
+        LLEnvironment::instance().selectSky(mBlendedSky);
+    }
+
+
+    if ((time_now < mLastUpdateTime) || ((time_now - mLastUpdateTime) > static_cast<F64Seconds>(0.1)))
+    {
+        F64Seconds daylength = static_cast<F64Seconds>(getDayLength());
+        F32 frame = fmod(time_now.value(), daylength.value()) / daylength.value();
+
+        CycleList_t::iterator itTrack = mDayTracks.begin();
+        TrackBound_t bounds = getBoundingEntries(*itTrack, frame);
+
+        mBlendedWater->replaceSettings((*bounds.first).second->getSettings());
+        if (bounds.first != bounds.second)
+        {
+            F32 blendf = get_wrapping_distance((*bounds.first).first, frame) / get_wrapping_distance((*bounds.first).first, (*bounds.second).first);
 
+            mBlendedWater->blend((*bounds.second).second, blendf);
+        }
+
+        ++itTrack;
+        bounds = getBoundingEntries(*itTrack, frame);
+
+        //_WARNS("RIDER") << "Sky blending: frame=" << frame << " start=" << F64Seconds((*bounds.first).first) << " end=" << F64Seconds((*bounds.second).first) << LL_ENDL;
+
+        mBlendedSky->replaceSettings((*bounds.first).second->getSettings());
+        if (bounds.first != bounds.second)
+        {
+            F32 blendf = get_wrapping_distance((*bounds.first).first, frame) / get_wrapping_distance((*bounds.first).first, (*bounds.second).first);
+            //_WARNS("RIDER") << "Distance=" << get_wrapping_distance((*bounds.first).first, frame) << "/" << get_wrapping_distance((*bounds.first).first, (*bounds.second).first) << " Blend factor=" << blendf << LL_ENDL;
+
+            mBlendedSky->blend((*bounds.second).second, blendf);
+        }
+
+        mLastUpdateTime = time_now;
+    }
+
+    // Always mark the day cycle as dirty.So that the blend check can be handled.
+    setDirtyFlag(true);
 }
 
 //=========================================================================
@@ -251,40 +321,40 @@ void LLSettingsDayCycle::setDayLength(S32 seconds)
     setValue(SETTING_DAYLENGTH, seconds);
 }
 
-LLSettingsDayCycle::OffsetList_t LLSettingsDayCycle::getTrackOffsets(S32 trackno)
+LLSettingsDayCycle::KeyframeList_t LLSettingsDayCycle::getTrackKeyframes(S32 trackno)
 {
     if ((trackno < 1) || (trackno >= TRACK_MAX))
     {
         LL_WARNS("DAYCYCLE") << "Attempt get track (#" << trackno << ") out of range!" << LL_ENDL;
-        return OffsetList_t();
+        return KeyframeList_t();
     }
 
-    OffsetList_t offsets;
+    KeyframeList_t keyframes;
     CycleTrack_t &track = mDayTracks[trackno];
 
-    offsets.reserve(track.size());
+    keyframes.reserve(track.size());
 
     for (CycleTrack_t::iterator it = track.begin(); it != track.end(); ++it)
     {
-        offsets.push_back((*it).first);
+        keyframes.push_back((*it).first);
     }
 
-    return offsets;
+    return keyframes;
 }
 
 LLSettingsDayCycle::TimeList_t LLSettingsDayCycle::getTrackTimes(S32 trackno)
 {
-    OffsetList_t offsets = getTrackOffsets(trackno);
+    KeyframeList_t keyframes = getTrackKeyframes(trackno);
 
-    if (offsets.empty())
+    if (keyframes.empty())
         return TimeList_t();
 
     TimeList_t times;
 
-    times.reserve(offsets.size());
-    for (OffsetList_t::iterator it = offsets.begin(); it != offsets.end(); ++it)
+    times.reserve(keyframes.size());
+    for (KeyframeList_t::iterator it = keyframes.begin(); it != keyframes.end(); ++it)
     {
-        times.push_back(offsetToSeconds(*it));
+        times.push_back(keyframeToSeconds(*it));
     }
 
     return times;
@@ -292,13 +362,13 @@ LLSettingsDayCycle::TimeList_t LLSettingsDayCycle::getTrackTimes(S32 trackno)
 
 void LLSettingsDayCycle::setWaterAtTime(const LLSettingsWaterPtr_t &water, S32 seconds)
 {
-    F32 offset = secondsToOffset(seconds);
-    setWaterAtOffset(water, offset);
+    F32 keyframe = secondsToKeyframe(seconds);
+    setWaterAtKeyframe(water, keyframe);
 }
 
-void LLSettingsDayCycle::setWaterAtOffset(const LLSettingsWaterPtr_t &water, F32 offset)
+void LLSettingsDayCycle::setWaterAtKeyframe(const LLSettingsWaterPtr_t &water, F32 keyframe)
 {
-    mDayTracks[TRACK_WATER][offset] = water;
+    mDayTracks[TRACK_WATER][keyframe] = water;
     setDirtyFlag(true);
 }
 
@@ -310,34 +380,33 @@ void LLSettingsDayCycle::setSkyAtOnTrack(const LLSettingsSkyPtr_t &sky, S32 seco
         LL_WARNS("DAYCYCLE") << "Attempt to set sky track (#" << track << ") out of range!" << LL_ENDL;
         return;
     }
-    F32 offset = secondsToOffset(seconds);
+    F32 keyframe = secondsToKeyframe(seconds);
 
-    mDayTracks[track][offset] = sky;
+    mDayTracks[track][keyframe] = sky;
     setDirtyFlag(true);
-
 }
 
-LLSettingsDayCycle::TrackBound_t LLSettingsDayCycle::getBoundingEntries(CycleTrack_t &track, F32 offset)
+LLSettingsDayCycle::TrackBound_t LLSettingsDayCycle::getBoundingEntries(CycleTrack_t &track, F32 keyframe) 
 {
-    return TrackBound_t(get_wrapping_atbefore(track, offset), get_wrapping_atafter(track, offset));
+    return TrackBound_t(get_wrapping_atbefore(track, keyframe), get_wrapping_atafter(track, keyframe));
 }
 
-LLSettingsBase::ptr_t LLSettingsDayCycle::getBlendedEntry(CycleTrack_t &track, F32 offset)
-{
-    TrackBound_t bounds = getBoundingEntries(track, offset);
-
-    if (bounds.first == track.end())
-        return LLSettingsBase::ptr_t(); // Track is empty nothing to blend.
-
-    if (bounds.first == bounds.second)
-    {   // Single entry.  Nothing to blend
-        return (*bounds.first).second;
-    }
-
-    F32 blendf = get_wrapping_distance((*bounds.first).first, offset) / get_wrapping_distance((*bounds.first).first, (*bounds.second).first);
-
-    LLSettingsBase::ptr_t base = (*bounds.first).second;
-    return base->blend((*bounds.second).second, blendf);
-}
+// LLSettingsBase::ptr_t LLSettingsDayCycle::getBlendedEntry(CycleTrack_t &track, F32 keyframe) 
+// {
+//     TrackBound_t bounds = getBoundingEntries(track, keyframe);
+// 
+//     if (bounds.first == track.end())
+//         return LLSettingsBase::ptr_t(); // Track is empty nothing to blend.
+// 
+//     if (bounds.first == bounds.second)
+//     {   // Single entry.  Nothing to blend
+//         return (*bounds.first).second;
+//     }
+// 
+//     F32 blendf = get_wrapping_distance((*bounds.first).first, keyframe) / get_wrapping_distance((*bounds.first).first, (*bounds.second).first);
+// 
+//     LLSettingsBase::ptr_t base = (*bounds.first).second;
+//     return base->blend((*bounds.second).second, blendf);
+// }
 
 //=========================================================================
diff --git a/indra/newview/llsettingsdaycycle.h b/indra/newview/llsettingsdaycycle.h
index 5eb704cdb7..f332b85dee 100644
--- a/indra/newview/llsettingsdaycycle.h
+++ b/indra/newview/llsettingsdaycycle.h
@@ -42,7 +42,7 @@ public:
     static const std::string    SETTING_DAYLENGTH;
     static const std::string    SETTING_KEYID;
     static const std::string    SETTING_KEYNAME;
-    static const std::string    SETTING_KEYOFFSET;
+    static const std::string    SETTING_KEYKFRAME;
     static const std::string    SETTING_NAME;
     static const std::string    SETTING_TRACKS;
 
@@ -56,7 +56,7 @@ public:
     typedef std::vector<CycleTrack_t>               CycleList_t;
     typedef boost::shared_ptr<LLSettingsDayCycle>   ptr_t;
     typedef std::vector<S32>                        TimeList_t;
-    typedef std::vector<F32>                        OffsetList_t;
+    typedef std::vector<F32>                        KeyframeList_t;
     typedef std::pair<CycleTrack_t::iterator, CycleTrack_t::iterator> TrackBound_t;
 
     //---------------------------------------------------------------------
@@ -71,7 +71,7 @@ public:
     virtual std::string getSettingType() const { return std::string("daycycle"); }
 
     // Settings status 
-    virtual LLSettingsBase::ptr_t blend(const LLSettingsBase::ptr_t &other, F32 mix) const;
+    virtual void blend(const LLSettingsBase::ptr_t &other, F32 mix);
 
     static LLSD defaults();
 
@@ -83,11 +83,11 @@ public:
 
     void setDayLength(S32 seconds);
 
-    OffsetList_t  getTrackOffsets(S32 track);
+    KeyframeList_t  getTrackKeyframes(S32 track);
     TimeList_t    getTrackTimes(S32 track);
 
     void setWaterAtTime(const LLSettingsWaterPtr_t &water, S32 seconds);
-    void setWaterAtOffset(const LLSettingsWaterPtr_t &water, F32 offset);
+    void setWaterAtKeyframe(const LLSettingsWaterPtr_t &water, F32 keyframe);
     LLSettingsSkyPtr_t getBlendedWaterAt(S32 seconds);
 
     void setSkyAtOnTrack(const LLSettingsSkyPtr_t &sky, S32 seconds, S32 track);
@@ -98,23 +98,27 @@ protected:
 
     virtual void        updateSettings();
 
+    LLSettingsSkyPtr_t    mBlendedSky;
+    LLSettingsWaterPtr_t  mBlendedWater;
 
     CycleList_t mDayTracks;
 
-    F32 secondsToOffset(S32 seconds);
-    S32 offsetToSeconds(F32 offset);
+    bool                mHasParsed;
 
-    LLSettingsBase::ptr_t getBlendedEntry(CycleTrack_t &track, F32 offset);
+    F32 secondsToKeyframe(S32 seconds);
+    S32 keyframeToSeconds(F32 keyframe);
+
+    //LLSettingsBase::ptr_t getBlendedEntry(const CycleTrack_t &track, F32 keyframe);
 
     void parseFromLLSD(LLSD &data);
 //     CycleList_t &           getTrackRef(S32 trackno);
 
-    static CycleTrack_t::iterator   getEntryAtOrBefore(CycleTrack_t &track, F32 offset);
-    static CycleTrack_t::iterator   getEntryAtOrAfter(CycleTrack_t &track, F32 offset);
-
-    static TrackBound_t getBoundingEntries(CycleTrack_t &track, F32 offset);
+    static CycleTrack_t::iterator   getEntryAtOrBefore(CycleTrack_t &track, F32 keyframe);
+    static CycleTrack_t::iterator   getEntryAtOrAfter(CycleTrack_t &track, F32 keyframe);
 
+    static TrackBound_t getBoundingEntries(CycleTrack_t &track, F32 keyframe);
 
+    F32Seconds  mLastUpdateTime;
 private:
     
 };
diff --git a/indra/newview/llsettingssky.cpp b/indra/newview/llsettingssky.cpp
index 782703c7f7..c420ebca1e 100644
--- a/indra/newview/llsettingssky.cpp
+++ b/indra/newview/llsettingssky.cpp
@@ -81,7 +81,6 @@ const std::string LLSettingsSky::SETTING_LIGHT_NORMAL("lightnorm");
 const std::string LLSettingsSky::SETTING_MAX_Y("max_y");
 const std::string LLSettingsSky::SETTING_MOON_ROTATION("moon_rotation");
 const std::string LLSettingsSky::SETTING_MOON_TEXTUREID("moon_id");
-const std::string LLSettingsSky::SETTING_NAME("name");
 const std::string LLSettingsSky::SETTING_STAR_BRIGHTNESS("star_brightness");
 const std::string LLSettingsSky::SETTING_SUNLIGHT_COLOR("sunlight_color");
 const std::string LLSettingsSky::SETTING_SUN_ROTATION("sun_rotation");
@@ -103,14 +102,12 @@ LLSettingsSky::LLSettingsSky():
 {
 }
 
-LLSettingsBase::ptr_t LLSettingsSky::blend(const LLSettingsBase::ptr_t &end, F32 blendf) const
+void LLSettingsSky::blend(const LLSettingsBase::ptr_t &end, F32 blendf) 
 {
     LLSettingsSky::ptr_t other = boost::static_pointer_cast<LLSettingsSky>(end);
     LLSD blenddata = interpolateSDMap(mSettings, other->mSettings, blendf);
 
-    LLSettingsSky::ptr_t skyp = boost::make_shared<LLSettingsSky>(blenddata);
-
-    return skyp;
+    replaceSettings(blenddata);
 }
 
 
@@ -301,18 +298,18 @@ LLSettingsSky::ptr_t LLSettingsSky::buildClone()
 
 // Settings status 
 
-LLSettingsSky::ptr_t LLSettingsSky::blend(const LLSettingsSky::ptr_t &other, F32 mix) const
-{
-    LL_RECORD_BLOCK_TIME(FTM_BLEND_SKYVALUES);
-    LL_INFOS("WINDLIGHT", "SKY", "EEP") << "Blending new sky settings object." << LL_ENDL;
-
-    LLSettingsSky::ptr_t skyp = boost::make_shared<LLSettingsSky>(mSettings);
-    // the settings in the initial constructor are references to this' settings block.  
-    // They will be replaced in the following lerp
-    skyp->lerpSettings(*other, mix);
-
-    return skyp;
-}
+// LLSettingsSky::ptr_t LLSettingsSky::blend(const LLSettingsSky::ptr_t &other, F32 mix) const
+// {
+//     LL_RECORD_BLOCK_TIME(FTM_BLEND_SKYVALUES);
+//     LL_INFOS("WINDLIGHT", "SKY", "EEP") << "Blending new sky settings object." << LL_ENDL;
+// 
+//     LLSettingsSky::ptr_t skyp = boost::make_shared<LLSettingsSky>(mSettings);
+//     // the settings in the initial constructor are references to this' settings block.  
+//     // They will be replaced in the following lerp
+//     skyp->lerpSettings(*other, mix);
+// 
+//     return skyp;
+// }
 
 
 LLSD LLSettingsSky::defaults()
diff --git a/indra/newview/llsettingssky.h b/indra/newview/llsettingssky.h
index 977ab5141e..ade5a06553 100644
--- a/indra/newview/llsettingssky.h
+++ b/indra/newview/llsettingssky.h
@@ -56,7 +56,6 @@ public:
     static const std::string SETTING_MAX_Y;
     static const std::string SETTING_MOON_ROTATION;
     static const std::string SETTING_MOON_TEXTUREID;
-    static const std::string SETTING_NAME;
     static const std::string SETTING_STAR_BRIGHTNESS;
     static const std::string SETTING_SUNLIGHT_COLOR;
     static const std::string SETTING_SUN_ROTATION;
@@ -77,7 +76,7 @@ public:
     virtual std::string getSettingType() const { return std::string("sky"); }
 
     // Settings status 
-    ptr_t blend(const ptr_t &other, F32 mix) const;
+    virtual void blend(const LLSettingsBase::ptr_t &end, F32 blendf);
     
     static LLSD defaults();
 
@@ -414,7 +413,6 @@ public:
 protected:
     LLSettingsSky();
 
-    virtual LLSettingsBase::ptr_t blend(const LLSettingsBase::ptr_t &end, F32 blendf) const;
 
     virtual stringset_t getSlerpKeys() const;
 
diff --git a/indra/newview/llsettingswater.cpp b/indra/newview/llsettingswater.cpp
index 52448bd4af..9a6dfc15fd 100644
--- a/indra/newview/llsettingswater.cpp
+++ b/indra/newview/llsettingswater.cpp
@@ -56,7 +56,6 @@ const std::string LLSettingsWater::SETTING_FOG_DENSITY("water_fog_density");
 const std::string LLSettingsWater::SETTING_FOG_MOD("underwater_fog_mod");
 const std::string LLSettingsWater::SETTING_FRESNEL_OFFSET("fresnel_offset");
 const std::string LLSettingsWater::SETTING_FRESNEL_SCALE("fresnel_scale");
-const std::string LLSettingsWater::SETTING_NAME("name");
 const std::string LLSettingsWater::SETTING_NORMAL_MAP("normal_map");
 const std::string LLSettingsWater::SETTING_NORMAL_SCALE("normal_scale");
 const std::string LLSettingsWater::SETTING_SCALE_ABOVE("scale_above");
@@ -195,14 +194,12 @@ LLSettingsWater::ptr_t LLSettingsWater::buildClone()
     return skyp;
 }
 
-LLSettingsBase::ptr_t LLSettingsWater::blend(const LLSettingsBase::ptr_t &end, F32 blendf) const
+void LLSettingsWater::blend(const LLSettingsBase::ptr_t &end, F32 blendf) 
 {
     LLSettingsWater::ptr_t other = boost::static_pointer_cast<LLSettingsWater>(end);
     LLSD blenddata = interpolateSDMap(mSettings, other->mSettings, blendf);
-
-    LLSettingsWater::ptr_t waterp = boost::make_shared<LLSettingsWater>(blenddata);
-
-    return waterp;
+    
+    replaceSettings(blenddata);
 }
 
 
diff --git a/indra/newview/llsettingswater.h b/indra/newview/llsettingswater.h
index 6a7e692c25..1550ba4004 100644
--- a/indra/newview/llsettingswater.h
+++ b/indra/newview/llsettingswater.h
@@ -39,7 +39,6 @@ public:
     static const std::string SETTING_FOG_MOD;
     static const std::string SETTING_FRESNEL_OFFSET;
     static const std::string SETTING_FRESNEL_SCALE;
-    static const std::string SETTING_NAME;
     static const std::string SETTING_NORMAL_MAP;
     static const std::string SETTING_NORMAL_SCALE;
     static const std::string SETTING_SCALE_ABOVE;
@@ -63,7 +62,7 @@ public:
     virtual std::string getSettingType() const { return std::string("water"); }
 
     // Settings status 
-    virtual LLSettingsBase::ptr_t blend(const LLSettingsBase::ptr_t &end, F32 blendf) const;
+    virtual void blend(const LLSettingsBase::ptr_t &end, F32 blendf);
 
     static LLSD defaults();
 
diff --git a/indra/newview/llwaterparammanager.cpp b/indra/newview/llwaterparammanager.cpp
index eb21f3c4b4..9e275fd108 100644
--- a/indra/newview/llwaterparammanager.cpp
+++ b/indra/newview/llwaterparammanager.cpp
@@ -135,10 +135,6 @@ bool LLWaterParamManager::loadPreset(const std::string& path)
 		addParamSet(name, params_data);
 	}
 
-    //*LAPRAS temp code testing conversion old preset to new settings.
-    LLSettingsWater::ptr_t test = LLSettingsWater::buildFromLegacyPreset(name, params_data);
-    LLEnvironment::instance().addWater(test);
-
 	return true;
 }
 
diff --git a/indra/newview/llwlparammanager.cpp b/indra/newview/llwlparammanager.cpp
index a6dc2b343b..966a7840cf 100644
--- a/indra/newview/llwlparammanager.cpp
+++ b/indra/newview/llwlparammanager.cpp
@@ -319,11 +319,6 @@ bool LLWLParamManager::loadPreset(const std::string& path)
 		addParamSet(key, params_data);
 	}
 
-    //*LAPRAS temp code testing conversion old preset to new settings.
-    LLSettingsSky::ptr_t test = LLSettingsSky::buildFromLegacyPreset(name, params_data);
-    LLEnvironment::instance().addSky(test);
-    //test->exportSettings(name);
-
 	return true;
 }
 
-- 
cgit v1.3


From b227c86b450134f17ec0624655e1e4c5cb5ba89d Mon Sep 17 00:00:00 2001
From: Rider Linden <rider@lindenlab.com>
Date: Mon, 13 Nov 2017 14:40:54 -0800
Subject: Remove the old wl environment code.

---
 indra/newview/CMakeLists.txt                   |  17 -
 indra/newview/lldaycyclemanager.h              |   5 +-
 indra/newview/lldrawpoolwlsky.cpp              |   3 -
 indra/newview/llenvmanager.cpp                 | 720 -------------------------
 indra/newview/llenvmanager.h                   | 350 ------------
 indra/newview/llfloatereditdaycycle.cpp        |  87 ++-
 indra/newview/llfloatereditdaycycle.h          |  26 +-
 indra/newview/llfloatereditsky.cpp             |  16 -
 indra/newview/llfloaterenvironmentsettings.cpp |   4 +-
 indra/newview/llfloaterregioninfo.cpp          |  38 +-
 indra/newview/llfloaterregioninfo.h            |   5 -
 indra/newview/llstartup.cpp                    |   1 -
 indra/newview/llviewerdisplay.cpp              |   1 -
 indra/newview/llviewermenu.cpp                 |  29 +-
 indra/newview/llviewershadermgr.cpp            |   1 -
 indra/newview/llvosky.cpp                      |   1 -
 indra/newview/llwaterparammanager.cpp          | 448 ---------------
 indra/newview/llwaterparammanager.h            | 413 --------------
 indra/newview/llwaterparamset.cpp              | 266 ---------
 indra/newview/llwaterparamset.h                | 165 ------
 indra/newview/llwlanimator.cpp                 | 324 -----------
 indra/newview/llwlanimator.h                   | 140 -----
 indra/newview/llwldaycycle.cpp                 | 114 ++--
 indra/newview/llwldaycycle.h                   |   7 +-
 indra/newview/llwlparammanager.cpp             | 714 ------------------------
 indra/newview/llwlparammanager.h               | 329 -----------
 indra/newview/llwlparamset.cpp                 | 426 ---------------
 indra/newview/llwlparamset.h                   | 246 ---------
 indra/newview/pipeline.cpp                     |   1 -
 29 files changed, 156 insertions(+), 4741 deletions(-)
 delete mode 100644 indra/newview/llenvmanager.cpp
 delete mode 100644 indra/newview/llenvmanager.h
 delete mode 100644 indra/newview/llwaterparammanager.cpp
 delete mode 100644 indra/newview/llwaterparammanager.h
 delete mode 100644 indra/newview/llwaterparamset.cpp
 delete mode 100644 indra/newview/llwaterparamset.h
 delete mode 100644 indra/newview/llwlanimator.cpp
 delete mode 100644 indra/newview/llwlanimator.h
 delete mode 100644 indra/newview/llwlparammanager.cpp
 delete mode 100644 indra/newview/llwlparammanager.h
 delete mode 100644 indra/newview/llwlparamset.cpp
 delete mode 100644 indra/newview/llwlparamset.h

(limited to 'indra/newview/llwlparammanager.cpp')

diff --git a/indra/newview/CMakeLists.txt b/indra/newview/CMakeLists.txt
index 369ce6f24e..bbe32866f6 100644
--- a/indra/newview/CMakeLists.txt
+++ b/indra/newview/CMakeLists.txt
@@ -158,7 +158,6 @@ set(viewer_SOURCE_FILES
     llcurrencyuimanager.cpp
     llcylinder.cpp
     lldateutil.cpp
-    lldaycyclemanager.cpp
     lldebugmessagebox.cpp
     lldebugview.cpp
     lldeferredsounds.cpp
@@ -183,7 +182,6 @@ set(viewer_SOURCE_FILES
     llemote.cpp
     llenvadapters.cpp
     llenvironment.cpp
-    llenvmanager.cpp
     llestateinfomodel.cpp
     lleventnotifier.cpp
     lleventpoll.cpp
@@ -692,19 +690,13 @@ set(viewer_SOURCE_FILES
     llvowater.cpp
     llvowlsky.cpp
     llwatchdog.cpp
-    llwaterparammanager.cpp
-    llwaterparamset.cpp
     llwearableitemslist.cpp
     llwearablelist.cpp
     llweb.cpp
     llwebprofile.cpp
     llwind.cpp
     llwindowlistener.cpp
-    llwlanimator.cpp
-    llwldaycycle.cpp
     llwlhandlers.cpp
-    llwlparammanager.cpp
-    llwlparamset.cpp
     llworld.cpp
     llworldmap.cpp
     llworldmapmessage.cpp
@@ -783,7 +775,6 @@ set(viewer_HEADER_FILES
     llcurrencyuimanager.h
     llcylinder.h
     lldateutil.h
-    lldaycyclemanager.h
     lldebugmessagebox.h
     lldebugview.h
     lldeferredsounds.h
@@ -808,7 +799,6 @@ set(viewer_HEADER_FILES
     llemote.h
     llenvadapters.h
     llenvironment.h
-    llenvmanager.h
     llestateinfomodel.h
     lleventnotifier.h
     lleventpoll.h
@@ -1311,19 +1301,13 @@ set(viewer_HEADER_FILES
     llvowater.h
     llvowlsky.h
     llwatchdog.h
-    llwaterparammanager.h
-    llwaterparamset.h
     llwearableitemslist.h
     llwearablelist.h
     llweb.h
     llwebprofile.h
     llwind.h
     llwindowlistener.h
-    llwlanimator.h
-    llwldaycycle.h
     llwlhandlers.h
-    llwlparammanager.h
-    llwlparamset.h
     llworld.h
     llworldmap.h
     llworldmapmessage.h
@@ -2369,7 +2353,6 @@ if (LL_TESTS)
 include(LLAddBuildTest)
 SET(viewer_TEST_SOURCE_FILES
   llagentaccess.cpp
-  llwlparammanager.cpp
   )
 set_source_files_properties(
   ${viewer_TEST_SOURCE_FILES}
diff --git a/indra/newview/lldaycyclemanager.h b/indra/newview/lldaycyclemanager.h
index 04db9d5dac..810212c92a 100644
--- a/indra/newview/lldaycyclemanager.h
+++ b/indra/newview/lldaycyclemanager.h
@@ -30,7 +30,6 @@
 #include <map>
 #include <string>
 
-#include "llwldaycycle.h"
 #include "llwlparammanager.h"
 
 /**
@@ -46,14 +45,14 @@ class LLDayCycleManager : public LLSingleton<LLDayCycleManager>
 public:
 	typedef std::list<std::string> preset_name_list_t;
 
-	typedef std::map<std::string, LLWLDayCycle> dc_map_t;
+// 	typedef std::map<std::string, LLWLDayCycle> dc_map_t;
 	typedef boost::signals2::signal<void()> modify_signal_t;
 
 	void getPresetNames(preset_name_list_t& names) const;
 	void getPresetNames(preset_name_list_t& user, preset_name_list_t& sys) const;
 	void getUserPresetNames(preset_name_list_t& user) const;
 
-	bool getPreset(const std::string name, LLWLDayCycle& day_cycle) const;
+//	bool getPreset(const std::string name, LLWLDayCycle& day_cycle) const;
 	bool getPreset(const std::string name, LLSD& day_cycle) const;
 	bool presetExists(const std::string name) const;
 	bool isSystemPreset(const std::string& name) const;
diff --git a/indra/newview/lldrawpoolwlsky.cpp b/indra/newview/lldrawpoolwlsky.cpp
index 2ff4edabe3..f10c116555 100644
--- a/indra/newview/lldrawpoolwlsky.cpp
+++ b/indra/newview/lldrawpoolwlsky.cpp
@@ -81,9 +81,6 @@ LLDrawPoolWLSky::LLDrawPoolWLSky(void) :
 			sCloudNoiseRawImage = NULL ;
 		}
 	}
-
-    /* *LAPRAS */
-//	LLWLParamManager::getInstance()->propagateParameters();
 }
 
 LLDrawPoolWLSky::~LLDrawPoolWLSky()
diff --git a/indra/newview/llenvmanager.cpp b/indra/newview/llenvmanager.cpp
deleted file mode 100644
index 5fc9231506..0000000000
--- a/indra/newview/llenvmanager.cpp
+++ /dev/null
@@ -1,720 +0,0 @@
-/**
- * @file llenvmanager.cpp
- * @brief Implementation of classes managing WindLight and water settings.
- *
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2011, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "llviewerprecompiledheaders.h"
-
-#include "llagent.h"
-#include "lldaycyclemanager.h"
-#include "llviewercontrol.h" // for gSavedSettings
-#include "llviewerregion.h"
-#include "llwaterparammanager.h"
-#include "llwlhandlers.h"
-#include "llwlparammanager.h"
-#include "lltrans.h"
-#include "llenvmanager.h"
-
-std::string LLWLParamKey::toString() const
-{
-	switch (scope)
-	{
-	case SCOPE_LOCAL:
-		return name + std::string(" (") + LLTrans::getString("Local") + std::string(")");
-		break;
-	case SCOPE_REGION:
-		return name + std::string(" (") + LLTrans::getString("Region") + std::string(")");
-		break;
-	default:
-		return name + " (?)";
-	}
-}
-
-std::string LLEnvPrefs::getWaterPresetName() const
-{
-	if (mWaterPresetName.empty())
-	{
-		LL_WARNS() << "Water preset name is empty" << LL_ENDL;
-	}
-
-	return mWaterPresetName;
-}
-
-std::string LLEnvPrefs::getSkyPresetName() const
-{
-	if (mSkyPresetName.empty())
-	{
-		LL_WARNS() << "Sky preset name is empty" << LL_ENDL;
-	}
-
-	return mSkyPresetName;
-}
-
-std::string LLEnvPrefs::getDayCycleName() const
-{
-	if (mDayCycleName.empty())
-	{
-		LL_WARNS() << "Day cycle name is empty" << LL_ENDL;
-	}
-
-	return mDayCycleName;
-}
-
-void LLEnvPrefs::setUseRegionSettings(bool val)
-{
-	mUseRegionSettings = val;
-}
-
-void LLEnvPrefs::setUseWaterPreset(const std::string& name)
-{
-	mUseRegionSettings = false;
-	mWaterPresetName = name;
-}
-
-void LLEnvPrefs::setUseSkyPreset(const std::string& name)
-{
-	mUseRegionSettings = false;
-	mUseDayCycle = false;
-	mSkyPresetName = name;
-}
-
-void LLEnvPrefs::setUseDayCycle(const std::string& name)
-{
-	mUseRegionSettings = false;
-	mUseDayCycle = true;
-	mDayCycleName = name;
-}
-
-//=============================================================================
-LLEnvManagerNew::LLEnvManagerNew():
-	mInterpNextChangeMessage(true),
-	mCurRegionUUID(LLUUID::null),
-	mLastReceivedID(LLUUID::null)
-{
-
-	// Set default environment settings.
-	mUserPrefs.mUseRegionSettings = true;
-	mUserPrefs.mUseDayCycle = true;
-	mUserPrefs.mWaterPresetName = "Default";
-	mUserPrefs.mSkyPresetName = "Default";
-	mUserPrefs.mDayCycleName = "Default";
-
-	LL_DEBUGS("Windlight")<<LL_ENDL;
-	gAgent.addRegionChangedCallback(boost::bind(&LLEnvManagerNew::onRegionChange, this));
-}
-
-bool LLEnvManagerNew::getUseRegionSettings() const
-{
-	return mUserPrefs.getUseRegionSettings();
-}
-
-bool LLEnvManagerNew::getUseDayCycle() const
-{
-	return mUserPrefs.getUseDayCycle();
-}
-
-bool LLEnvManagerNew::getUseFixedSky() const
-{
-	return mUserPrefs.getUseFixedSky();
-}
-
-std::string LLEnvManagerNew::getWaterPresetName() const
-{
-	return mUserPrefs.getWaterPresetName();
-}
-
-std::string LLEnvManagerNew::getSkyPresetName() const
-{
-	return mUserPrefs.getSkyPresetName();
-}
-
-std::string LLEnvManagerNew::getDayCycleName() const
-{
-	return mUserPrefs.getDayCycleName();
-}
-
-const LLEnvironmentSettings& LLEnvManagerNew::getRegionSettings() const
-{
-	return !mNewRegionPrefs.isEmpty() ? mNewRegionPrefs : mCachedRegionPrefs;
-}
-
-void LLEnvManagerNew::setRegionSettings(const LLEnvironmentSettings& new_settings)
-{
-	// Set region settings override that will be used locally
-	// until user either uploads the changes or goes to another region.
-	mNewRegionPrefs = new_settings;
-}
-
-bool LLEnvManagerNew::usePrefs()
-{
-	LL_DEBUGS("Windlight") << "Displaying preferred environment" << LL_ENDL;
-	updateManagersFromPrefs(false);
-	return true;
-}
-
-bool LLEnvManagerNew::useDefaults()
-{
-	bool rslt;
-
-	rslt  = useDefaultWater();
-	rslt &= useDefaultSky();
-
-	return rslt;
-}
-
-bool LLEnvManagerNew::useRegionSettings()
-{
-	bool rslt;
-
-	rslt  = useRegionSky();
-	rslt &= useRegionWater();
-
-	return rslt;
-}
-
-bool LLEnvManagerNew::useWaterPreset(const std::string& name)
-{
-	LL_DEBUGS("Windlight") << "Displaying water preset " << name << LL_ENDL;
-	LLWaterParamManager& water_mgr = LLWaterParamManager::instance();
-	bool rslt = water_mgr.getParamSet(name, water_mgr.mCurParams);
-	llassert(rslt == true);
-	return rslt;
-}
-
-bool LLEnvManagerNew::useWaterParams(const LLSD& params)
-{
-	LL_DEBUGS("Windlight") << "Displaying water params" << LL_ENDL;
-	LLWaterParamManager::instance().mCurParams.setAll(params);
-	return true;
-}
-
-bool LLEnvManagerNew::useSkyPreset(const std::string& name)
-{
-	LLWLParamManager& sky_mgr = LLWLParamManager::instance();
-	LLWLParamSet param_set;
-
-	if (!sky_mgr.getParamSet(LLWLParamKey(name, LLEnvKey::SCOPE_LOCAL), param_set))
-	{
-		LL_WARNS() << "No sky preset named " << name << LL_ENDL;
-		return false;
-	}
-
-	LL_DEBUGS("Windlight") << "Displaying sky preset " << name << LL_ENDL;
-	sky_mgr.applySkyParams(param_set.getAll());
-	return true;
-}
-
-bool LLEnvManagerNew::useSkyParams(const LLSD& params)
-{
-	LL_DEBUGS("Windlight") << "Displaying sky params" << LL_ENDL;
-	LLWLParamManager::instance().applySkyParams(params);
-	return true;
-}
-
-bool LLEnvManagerNew::useDayCycle(const std::string& name, LLEnvKey::EScope scope)
-{
-	LLSD params;
-
-	if (scope == LLEnvKey::SCOPE_REGION)
-	{
-		LL_DEBUGS("Windlight") << "Displaying region day cycle " << name << LL_ENDL;
-		params = getRegionSettings().getWLDayCycle();
-	}
-	else
-	{
-		LL_DEBUGS("Windlight") << "Displaying local day cycle " << name << LL_ENDL;
-
-		if (!LLDayCycleManager::instance().getPreset(name, params))
-		{
-			LL_WARNS() << "No day cycle named " << name << LL_ENDL;
-			return false;
-		}
-	}
-
-	bool rslt = LLWLParamManager::instance().applyDayCycleParams(params, scope);
-	llassert(rslt == true);
-	return rslt;
-}
-
-bool LLEnvManagerNew::useDayCycleParams(const LLSD& params, LLEnvKey::EScope scope, F32 time /* = 0.5*/)
-{
-	LL_DEBUGS("Windlight") << "Displaying day cycle params" << LL_ENDL;
-	return LLWLParamManager::instance().applyDayCycleParams(params, scope);
-}
-
-void LLEnvManagerNew::setUseRegionSettings(bool val)
-{
-	mUserPrefs.setUseRegionSettings(val);
-	saveUserPrefs();
-	updateManagersFromPrefs(false);
-}
-
-void LLEnvManagerNew::setUseWaterPreset(const std::string& name)
-{
-	// *TODO: make sure the preset exists.
-	if (name.empty())
-	{
-		LL_WARNS() << "Empty water preset name passed" << LL_ENDL;
-		return;
-	}
-
-	mUserPrefs.setUseWaterPreset(name);
-	saveUserPrefs();
-	updateManagersFromPrefs(false);
-}
-
-void LLEnvManagerNew::setUseSkyPreset(const std::string& name)
-{
-	// *TODO: make sure the preset exists.
-	if (name.empty())
-	{
-		LL_WARNS() << "Empty sky preset name passed" << LL_ENDL;
-		return;
-	}
-
-	mUserPrefs.setUseSkyPreset(name);
-	saveUserPrefs();
-	updateManagersFromPrefs(false);
-}
-
-void LLEnvManagerNew::setUseDayCycle(const std::string& name)
-{
-	if (!LLDayCycleManager::instance().presetExists(name))
-	{
-		LL_WARNS() << "Invalid day cycle name passed" << LL_ENDL;
-		return;
-	}
-
-	mUserPrefs.setUseDayCycle(name);
-	saveUserPrefs();
-	updateManagersFromPrefs(false);
-}
-
-void LLEnvManagerNew::loadUserPrefs()
-{
-	// operate on members directly to avoid side effects
-	mUserPrefs.mWaterPresetName	= gSavedSettings.getString("WaterPresetName");
-	mUserPrefs.mSkyPresetName	= gSavedSettings.getString("SkyPresetName");
-	mUserPrefs.mDayCycleName	= gSavedSettings.getString("DayCycleName");
-
-	bool use_region_settings = gSavedSettings.getBOOL("EnvironmentPersistAcrossLogin") ? gSavedSettings.getBOOL("UseEnvironmentFromRegion") : true;
-	mUserPrefs.mUseRegionSettings	= use_region_settings;
-	mUserPrefs.mUseDayCycle			= gSavedSettings.getBOOL("UseDayCycle");
-
-	if (mUserPrefs.mUseRegionSettings)
-	{
-		requestRegionSettings();
-	}
-}
-
-void LLEnvManagerNew::saveUserPrefs()
-{
-	gSavedSettings.setString("WaterPresetName",			getWaterPresetName());
-	gSavedSettings.setString("SkyPresetName",			getSkyPresetName());
-	gSavedSettings.setString("DayCycleName",			getDayCycleName());
-
-	gSavedSettings.setBOOL("UseEnvironmentFromRegion",	getUseRegionSettings());
-	gSavedSettings.setBOOL("UseDayCycle",				getUseDayCycle());
-
-	mUsePrefsChangeSignal();
-}
-
-void LLEnvManagerNew::setUserPrefs(
-	const std::string& water_preset,
-	const std::string& sky_preset,
-	const std::string& day_cycle_preset,
-	bool use_fixed_sky,
-	bool use_region_settings)
-{
-	// operate on members directly to avoid side effects
-	mUserPrefs.mWaterPresetName	= water_preset;
-	mUserPrefs.mSkyPresetName	= sky_preset;
-	mUserPrefs.mDayCycleName	= day_cycle_preset;
-
-	mUserPrefs.mUseRegionSettings	= use_region_settings;
-	mUserPrefs.mUseDayCycle			= !use_fixed_sky;
-
-	saveUserPrefs();
-	updateManagersFromPrefs(false);
-}
-
-void LLEnvManagerNew::dumpUserPrefs()
-{
-	LL_DEBUGS("Windlight") << "WaterPresetName: "	<< gSavedSettings.getString("WaterPresetName") << LL_ENDL;
-	LL_DEBUGS("Windlight") << "SkyPresetName: "		<< gSavedSettings.getString("SkyPresetName") << LL_ENDL;
-	LL_DEBUGS("Windlight") << "DayCycleName: "		<< gSavedSettings.getString("DayCycleName") << LL_ENDL;
-
-	LL_DEBUGS("Windlight") << "UseEnvironmentFromRegion: "	<< gSavedSettings.getBOOL("UseEnvironmentFromRegion") << LL_ENDL;
-	LL_DEBUGS("Windlight") << "UseDayCycle: "				<< gSavedSettings.getBOOL("UseDayCycle") << LL_ENDL;
-}
-
-void LLEnvManagerNew::dumpPresets()
-{
-	const LLEnvironmentSettings& region_settings = getRegionSettings();
-	std::string region_name = gAgent.getRegion() ? gAgent.getRegion()->getName() : "Unknown region";
-
-	// Dump water presets.
-	LL_DEBUGS("Windlight") << "Waters:" << LL_ENDL;
-	if (region_settings.getWaterParams().size() != 0)
-	{
-		LL_DEBUGS("Windlight") << " - " << region_name << LL_ENDL;
-	}
-	LLWaterParamManager::preset_name_list_t water_presets;
-	LLWaterParamManager::instance().getPresetNames(water_presets);
-	for (LLWaterParamManager::preset_name_list_t::const_iterator it = water_presets.begin(); it != water_presets.end(); ++it)
-	{
-		LL_DEBUGS("Windlight") << " - " << *it << LL_ENDL;
-	}
-
-	// Dump sky presets.
-	LL_DEBUGS("Windlight") << "Skies:" << LL_ENDL;
-	LLWLParamManager::preset_key_list_t sky_preset_keys;
-	LLWLParamManager::instance().getPresetKeys(sky_preset_keys);
-	for (LLWLParamManager::preset_key_list_t::const_iterator it = sky_preset_keys.begin(); it != sky_preset_keys.end(); ++it)
-	{
-		std::string preset_name = it->name;
-		std::string item_title;
-
-		if (it->scope == LLEnvKey::SCOPE_LOCAL) // local preset
-		{
-			item_title = preset_name;
-		}
-		else // region preset
-		{
-			item_title = preset_name + " (" + region_name + ")";
-		}
-		LL_DEBUGS("Windlight") << " - " << item_title << LL_ENDL;
-	}
-
-	// Dump day cycles.
-	LL_DEBUGS("Windlight") << "Days:" << LL_ENDL;
-	const LLSD& cur_region_dc = region_settings.getWLDayCycle();
-	if (cur_region_dc.size() != 0)
-	{
-		LL_DEBUGS("Windlight") << " - " << region_name << LL_ENDL;
-	}
-	LLDayCycleManager::preset_name_list_t days;
-	LLDayCycleManager::instance().getPresetNames(days);
-	for (LLDayCycleManager::preset_name_list_t::const_iterator it = days.begin(); it != days.end(); ++it)
-	{
-		LL_DEBUGS("Windlight") << " - " << *it << LL_ENDL;
-	}
-}
-
-void LLEnvManagerNew::requestRegionSettings()
-{
-	LL_DEBUGS("Windlight") << LL_ENDL;
-	LLEnvironmentRequest::initiate();
-}
-
-bool LLEnvManagerNew::sendRegionSettings(const LLEnvironmentSettings& new_settings)
-{
-	LLSD metadata;
-
-	metadata["regionID"] = gAgent.getRegion()->getRegionID();
-	// add last received update ID to outbound message so simulator can handle concurrent updates
-	metadata["messageID"] = mLastReceivedID;
-
-	return LLEnvironmentApply::initiateRequest(new_settings.makePacket(metadata));
-}
-
-boost::signals2::connection LLEnvManagerNew::setPreferencesChangeCallback(const prefs_change_signal_t::slot_type& cb)
-{
-	return mUsePrefsChangeSignal.connect(cb);
-}
-
-boost::signals2::connection LLEnvManagerNew::setRegionSettingsChangeCallback(const region_settings_change_signal_t::slot_type& cb)
-{
-	return mRegionSettingsChangeSignal.connect(cb);
-}
-
-boost::signals2::connection LLEnvManagerNew::setRegionSettingsAppliedCallback(const region_settings_applied_signal_t::slot_type& cb)
-{
-	return mRegionSettingsAppliedSignal.connect(cb);
-}
-
-// static
-bool LLEnvManagerNew::canEditRegionSettings()
-{
-	LLViewerRegion* region = gAgent.getRegion();
-	BOOL owner_or_god = gAgent.isGodlike() || (region && region->getOwner() == gAgent.getID());
-	BOOL owner_or_god_or_manager = owner_or_god || (region && region->isEstateManager());
-
-	LL_DEBUGS("Windlight") << "Can edit region settings: " << (bool) owner_or_god_or_manager << LL_ENDL;
-	return owner_or_god_or_manager;
-}
-
-// static
-const std::string LLEnvManagerNew::getScopeString(LLEnvKey::EScope scope)
-{
-	switch(scope)
-	{
-		case LLEnvKey::SCOPE_LOCAL:
-			return LLTrans::getString("LocalSettings");
-		case LLEnvKey::SCOPE_REGION:
-			return LLTrans::getString("RegionSettings");
-		default:
-			return " (?)";
-	}
-}
-
-void LLEnvManagerNew::onRegionSettingsResponse(const LLSD& content)
-{
-	// If the message was valid, grab the UUID from it and save it for next outbound update message.
-	mLastReceivedID = content[0]["messageID"].asUUID();
-
-	// Refresh cached region settings.
-	LL_WARNS("Windlight") << "Received region environment settings: " << content << LL_ENDL;
-	F32 sun_hour = 0; // *TODO
-	LLEnvironmentSettings new_settings(content[1], content[2], content[3], sun_hour);
-	mCachedRegionPrefs = new_settings;
-
-	// Load region sky presets.
-	LLWLParamManager::instance().refreshRegionPresets(getRegionSettings().getSkyMap());
-
-	// If using server settings, update managers.
-	if (getUseRegionSettings())
-	{
-		updateManagersFromPrefs(mInterpNextChangeMessage);
-	}
-
-	// Let interested parties know about the region settings update.
-	mRegionSettingsChangeSignal();
-
-	// reset
-	mInterpNextChangeMessage = false;
-}
-
-void LLEnvManagerNew::onRegionSettingsApplyResponse(bool ok)
-{
-	LL_DEBUGS("Windlight") << "Applying region settings " << (ok ? "succeeded" : "failed") << LL_ENDL;
-
-	// Clear locally modified region settings because they have just been uploaded.
-	mNewRegionPrefs.clear();
-
-	mRegionSettingsAppliedSignal(ok);
-}
-
-//-- private methods ----------------------------------------------------------
-
-// virtual
-void LLEnvManagerNew::initSingleton()
-{
-	LL_DEBUGS("Windlight") << "Initializing LLEnvManagerNew" << LL_ENDL;
-
-	loadUserPrefs();
-
-	// preferences loaded, can set params
-	std::string preferred_day = getDayCycleName();
-	if (!useDayCycle(preferred_day, LLEnvKey::SCOPE_LOCAL))
-	{
-		LL_WARNS() << "No day cycle named " << preferred_day << ", reverting LLWLParamManager to defaults" << LL_ENDL;
-		LLWLParamManager::instance().setDefaultDay();
-	}
-
-	std::string sky = getSkyPresetName();
-	if (!useSkyPreset(sky))
-	{
-		LL_WARNS() << "No sky preset named " << sky << ", falling back to defaults" << LL_ENDL;
-		LLWLParamManager::instance().setDefaultSky();
-
-		// *TODO: Fix user preferences accordingly.
-	}
-
-	LLWLParamManager::instance().resetAnimator(0.5 /*noon*/, getUseDayCycle());
-}
-
-void LLEnvManagerNew::updateSkyFromPrefs()
-{
-	bool success = true;
-
-	// Sync sky with user prefs.
-	if (getUseRegionSettings()) // apply region-wide settings
-	{
-		success = useRegionSky();
-	}
-	else // apply user-specified settings
-	{
-		if (getUseDayCycle())
-		{
-			success = useDayCycle(getDayCycleName(), LLEnvKey::SCOPE_LOCAL);
-		}
-		else
-		{
-			success = useSkyPreset(getSkyPresetName());
-		}
-	}
-
-	// If something went wrong, fall back to defaults.
-	if (!success)
-	{
-		// *TODO: fix user prefs
-		useDefaultSky();
-	}
-}
-
-void LLEnvManagerNew::updateWaterFromPrefs(bool interpolate)
-{
-	LLWaterParamManager& water_mgr = LLWaterParamManager::instance();
-	LLSD target_water_params;
-
-	// Determine new water settings based on user prefs.
-
-	{
-		// Fall back to default water.
-		LLWaterParamSet default_water;
-		water_mgr.getParamSet("Default", default_water);
-		target_water_params = default_water.getAll();
-	}
-
-	if (getUseRegionSettings())
-	{
-		// *TODO: make sure whether region settings belong to the current region?
-		const LLSD& region_water_params = getRegionSettings().getWaterParams();
-		if (region_water_params.size() != 0) // region has no water settings
-		{
-			LL_DEBUGS("Windlight") << "Applying region water" << LL_ENDL;
-			target_water_params = region_water_params;
-		}
-		else
-		{
-			LL_DEBUGS("Windlight") << "Applying default water" << LL_ENDL;
-		}
-	}
-	else
-	{
-		std::string water = getWaterPresetName();
-		LL_DEBUGS("Windlight") << "Applying water preset [" << water << "]" << LL_ENDL;
-		LLWaterParamSet params;
-		if (!water_mgr.getParamSet(water, params))
-		{
-			LL_WARNS() << "No water preset named " << water << ", falling back to defaults" << LL_ENDL;
-			water_mgr.getParamSet("Default", params);
-
-			// *TODO: Fix user preferences accordingly.
-		}
-		target_water_params = params.getAll();
-	}
-
-	// Sync water with user prefs.
-	water_mgr.applyParams(target_water_params, interpolate);
-}
-
-void LLEnvManagerNew::updateManagersFromPrefs(bool interpolate)
-{
-	LL_DEBUGS("Windlight")<<LL_ENDL;
-	// Apply water settings.
-	updateWaterFromPrefs(interpolate);
-
-	// Apply sky settings.
-	updateSkyFromPrefs();
-}
-
-bool LLEnvManagerNew::useRegionSky()
-{
-	const LLEnvironmentSettings& region_settings = getRegionSettings();
-
-	// If region is set to defaults,
-	if (region_settings.getSkyMap().size() == 0)
-	{
-		// well... apply the default sky settings.
-		useDefaultSky();
-		return true;
-	}
-
-	// Otherwise apply region day cycle/skies.
-	LL_DEBUGS("Windlight") << "Applying region sky" << LL_ENDL;
-
-	// *TODO: Support fixed sky from region. Just do sky reset for now.
-	if (region_settings.getSkyMap().size() == 1)
-	{
-		// Region is set to fixed sky. Reset.
-		useSkyParams(region_settings.getSkyMap().beginMap()->second);
-	}
-	return useDayCycleParams(
-		region_settings.getWLDayCycle(),
-		LLEnvKey::SCOPE_REGION,
-		region_settings.getDayTime());
-}
-
-bool LLEnvManagerNew::useRegionWater()
-{
-	const LLEnvironmentSettings& region_settings = getRegionSettings();
-	const LLSD& region_water = region_settings.getWaterParams();
-
-	// If region is set to defaults,
-	if (region_water.size() == 0)
-	{
-		// well... apply the default water settings.
-		return useDefaultWater();
-	}
-
-	// Otherwise apply region water.
-	LL_DEBUGS("Windlight") << "Applying region sky" << LL_ENDL;
-	return useWaterParams(region_water);
-}
-
-bool LLEnvManagerNew::useDefaultSky()
-{
-	return useDayCycle("Default", LLEnvKey::SCOPE_LOCAL);
-}
-
-bool LLEnvManagerNew::useDefaultWater()
-{
-	return useWaterPreset("Default");
-}
-
-
-void LLEnvManagerNew::onRegionChange()
-{
-	// Avoid duplicating region setting requests
-	// by checking whether the region is actually changing.
-	LLViewerRegion* regionp = gAgent.getRegion();
-	LLUUID region_uuid = regionp ? regionp->getRegionID() : LLUUID::null;
-	if (region_uuid != mCurRegionUUID)
-	{
-	// Clear locally modified region settings.
-	mNewRegionPrefs.clear();
-
-	// *TODO: clear environment settings of the previous region?
-
-	// Request environment settings of the new region.
-	mCurRegionUUID = region_uuid;
-		// for region crossings, interpolate the change; for teleports, don't
-		mInterpNextChangeMessage = (gAgent.getTeleportState() == LLAgent::TELEPORT_NONE);
-		LL_DEBUGS("Windlight") << (mInterpNextChangeMessage ? "Crossed" : "Teleported")
-							   << " to new region: " << region_uuid
-							   << LL_ENDL;
-	requestRegionSettings();
-	}
-	else
-	{
-		LL_DEBUGS("Windlight") << "disregarding region change; interp: "
-							   << (mInterpNextChangeMessage ? "true" : "false")
-							   << " regionp: " << regionp
-							   << " old: " << mCurRegionUUID
-							   << " new: " << region_uuid
-							   << LL_ENDL;
-	}
-}
diff --git a/indra/newview/llenvmanager.h b/indra/newview/llenvmanager.h
deleted file mode 100644
index 31a093ad5d..0000000000
--- a/indra/newview/llenvmanager.h
+++ /dev/null
@@ -1,350 +0,0 @@
-/**
- * @file llenvmanager.h
- * @brief Declaration of classes managing WindLight and water settings.
- *
- * $LicenseInfo:firstyear=2009&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2011, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLENVMANAGER_H
-#define LL_LLENVMANAGER_H
-
-#include "llmemory.h"
-#include "llsd.h"
-
-class LLWLParamManager;
-class LLWaterParamManager;
-class LLWLAnimator;
-
-// generic key
-struct LLEnvKey
-{
-public:
-	// Note: enum ordering is important; for example, a region-level floater (1) will see local and region (all values that are <=)
-	typedef enum e_scope
-	{
-		SCOPE_LOCAL,				// 0
-		SCOPE_REGION//,				// 1
-		// SCOPE_ESTATE,			// 2
-		// etc.
-	} EScope;
-};
-
-struct LLWLParamKey : LLEnvKey
-{
-public:
-	// scope and source of a param set (WL sky preset)
-	std::string name;
-	EScope scope;
-
-	// for conversion from LLSD
-	static const int NAME_IDX = 0;
-	static const int SCOPE_IDX = 1;
-
-	inline LLWLParamKey(const std::string& n, EScope s)
-		: name(n), scope(s)
-	{
-	}
-
-	inline LLWLParamKey(LLSD llsd)
-		: name(llsd[NAME_IDX].asString()), scope(EScope(llsd[SCOPE_IDX].asInteger()))
-	{
-	}
-
-	inline LLWLParamKey() // NOT really valid, just so std::maps can return a default of some sort
-		: name(""), scope(SCOPE_LOCAL)
-	{
-	}
-
-	inline LLWLParamKey(std::string& stringVal)
-	{
-		size_t len = stringVal.length();
-		if (len > 0)
-		{
-			name = stringVal.substr(0, len - 1);
-			scope = (EScope) atoi(stringVal.substr(len - 1, len).c_str());
-		}
-	}
-
-	inline std::string toStringVal() const
-	{
-		std::stringstream str;
-		str << name << scope;
-		return str.str();
-	}
-
-	inline LLSD toLLSD() const
-	{
-		LLSD llsd = LLSD::emptyArray();
-		llsd.append(LLSD(name));
-		llsd.append(LLSD(scope));
-		return llsd;
-	}
-
-	inline void fromLLSD(const LLSD& llsd)
-	{
-		name = llsd[NAME_IDX].asString();
-		scope = EScope(llsd[SCOPE_IDX].asInteger());
-	}
-
-	inline bool operator <(const LLWLParamKey other) const
-	{
-		if (name < other.name)
-		{	
-			return true;
-		}
-		else if (name > other.name)
-		{
-			return false;
-		}
-		else
-		{
-			return scope < other.scope;
-		}
-	}
-
-	inline bool operator ==(const LLWLParamKey other) const
-	{
-		return (name == other.name) && (scope == other.scope);
-	}
-
-	std::string toString() const;
-};
-
-class LLEnvironmentSettings
-{
-public:
-	LLEnvironmentSettings() :
-		mWLDayCycle(LLSD::emptyMap()),
-		mSkyMap(LLSD::emptyMap()),
-		mWaterParams(LLSD::emptyMap()),
-		mDayTime(0.f)
-	{}
-	LLEnvironmentSettings(const LLSD& dayCycle, const LLSD& skyMap, const LLSD& waterParams, F64 dayTime) :
-		mWLDayCycle(dayCycle),
-		mSkyMap(skyMap),
-		mWaterParams(waterParams),
-		mDayTime(dayTime)
-	{}
-	~LLEnvironmentSettings() {}
-
-	void saveParams(const LLSD& dayCycle, const LLSD& skyMap, const LLSD& waterParams, F64 dayTime)
-	{
-		mWLDayCycle = dayCycle;
-		mSkyMap = skyMap;
-		mWaterParams = waterParams;
-		mDayTime = dayTime;
-	}
-
-	const LLSD& getWLDayCycle() const
-	{
-		return mWLDayCycle;
-	}
-
-	const LLSD& getWaterParams() const
-	{
-		return mWaterParams;
-	}
-
-	const LLSD& getSkyMap() const
-	{
-		return mSkyMap;
-	}
-
-	F64 getDayTime() const
-	{
-		return mDayTime;
-	}
-
-	bool isEmpty() const
-	{
-		return mWLDayCycle.size() == 0;
-	}
-
-	void clear()
-	{
-		*this = LLEnvironmentSettings();
-	}
-
-	LLSD makePacket(const LLSD& metadata) const
-	{
-		LLSD full_packet = LLSD::emptyArray();
-
-		// 0: metadata
-		full_packet.append(metadata);
-
-		// 1: day cycle
-		full_packet.append(mWLDayCycle);
-
-		// 2: map of sky setting names to sky settings (as LLSD)
-		full_packet.append(mSkyMap);
-
-		// 3: water params
-		full_packet.append(mWaterParams);
-
-		return full_packet;
-	}
-
-private:
-	LLSD mWLDayCycle, mWaterParams, mSkyMap;
-	F64 mDayTime;
-};
-
-/**
- * User environment preferences.
- */
-class LLEnvPrefs
-{
-public:
-	LLEnvPrefs() : mUseRegionSettings(true), mUseDayCycle(true) {}
-
-	bool getUseRegionSettings() const { return mUseRegionSettings; }
-	bool getUseDayCycle() const { return mUseDayCycle; }
-	bool getUseFixedSky() const { return !getUseDayCycle(); }
-
-	std::string getWaterPresetName() const;
-	std::string getSkyPresetName() const;
-	std::string getDayCycleName() const;
-
-	void setUseRegionSettings(bool val);
-	void setUseWaterPreset(const std::string& name);
-	void setUseSkyPreset(const std::string& name);
-	void setUseDayCycle(const std::string& name);
-
-	bool			mUseRegionSettings;
-	bool			mUseDayCycle;
-	std::string		mWaterPresetName;
-	std::string		mSkyPresetName;
-	std::string		mDayCycleName;
-};
-
-/**
- * Setting:
- * 1. Use region settings.
- * 2. Use my setting: <water preset> + <fixed_sky>|<day_cycle>
- */
-class LLEnvManagerNew : public LLSingleton<LLEnvManagerNew>
-{
-	LLSINGLETON(LLEnvManagerNew);
-	LOG_CLASS(LLEnvManagerNew);
-public:
-	typedef boost::signals2::signal<void()> prefs_change_signal_t;
-	typedef boost::signals2::signal<void()> region_settings_change_signal_t;
-	typedef boost::signals2::signal<void(bool)> region_settings_applied_signal_t;
-
-	// getters to access user env. preferences
-	bool getUseRegionSettings() const;
-	bool getUseDayCycle() const;
-	bool getUseFixedSky() const;
-	std::string getWaterPresetName() const;
-	std::string getSkyPresetName() const;
-	std::string getDayCycleName() const;
-
-	/// @return cached env. settings of the current region.
-	const LLEnvironmentSettings& getRegionSettings() const;
-
-	/**
-	 * Set new region settings without uploading them to the region.
-	 *
-	 * The override will be reset when the changes are applied to the region (=uploaded)
-	 * or user teleports to another region.
-	 */
-	void setRegionSettings(const LLEnvironmentSettings& new_settings);
-
-	// Change environment w/o changing user preferences.
-	bool usePrefs();
-	bool useDefaults();
-	bool useRegionSettings();
-	bool useWaterPreset(const std::string& name);
-	bool useWaterParams(const LLSD& params);
-	bool useSkyPreset(const std::string& name);
-	bool useSkyParams(const LLSD& params);
-	bool useDayCycle(const std::string& name, LLEnvKey::EScope scope);
-	bool useDayCycleParams(const LLSD& params, LLEnvKey::EScope scope, F32 time = 0.5);
-
-	// setters for user env. preferences
-	void setUseRegionSettings(bool val);
-	void setUseWaterPreset(const std::string& name);
-	void setUseSkyPreset(const std::string& name);
-	void setUseDayCycle(const std::string& name);
-	void setUserPrefs(
-		const std::string& water_preset,
-		const std::string& sky_preset,
-		const std::string& day_cycle_preset,
-		bool use_fixed_sky,
-		bool use_region_settings);
-
-	// debugging methods
-	void dumpUserPrefs();
-	void dumpPresets();
-
-	// Misc.
-	void requestRegionSettings();
-	bool sendRegionSettings(const LLEnvironmentSettings& new_settings);
-	boost::signals2::connection setPreferencesChangeCallback(const prefs_change_signal_t::slot_type& cb);
-	boost::signals2::connection setRegionSettingsChangeCallback(const region_settings_change_signal_t::slot_type& cb);
-	boost::signals2::connection setRegionSettingsAppliedCallback(const region_settings_applied_signal_t::slot_type& cb);
-
-	static bool canEditRegionSettings(); /// @return true if we have access to editing region environment
-	static const std::string getScopeString(LLEnvKey::EScope scope);
-
-	// Public callbacks.
-	void onRegionSettingsResponse(const LLSD& content);
-	void onRegionSettingsApplyResponse(bool ok);
-
-private:
-	/*virtual*/ void initSingleton();
-
-	void loadUserPrefs();
-	void saveUserPrefs();
-
-	void updateSkyFromPrefs();
-	void updateWaterFromPrefs(bool interpolate);
-	void updateManagersFromPrefs(bool interpolate);
-
-	bool useRegionSky();
-	bool useRegionWater();
-
-	bool useDefaultSky();
-	bool useDefaultWater();
-
-	void onRegionChange();
-
-
-	/// Emitted when user environment preferences change.
-	prefs_change_signal_t mUsePrefsChangeSignal;
-
-	/// Emitted when region environment settings update comes.
-	region_settings_change_signal_t	mRegionSettingsChangeSignal;
-
-	/// Emitted when agent region changes. Move to LLAgent?
-	region_settings_applied_signal_t mRegionSettingsAppliedSignal;
-
-	LLEnvPrefs				mUserPrefs;					/// User environment preferences.
-	LLEnvironmentSettings	mCachedRegionPrefs;			/// Cached region environment settings.
-	LLEnvironmentSettings	mNewRegionPrefs;			/// Not-yet-uploaded modified region env. settings.
-	bool					mInterpNextChangeMessage;	/// Interpolate env. settings on next region change.
-	LLUUID					mCurRegionUUID;				/// To avoid duplicated region env. settings requests.
-	LLUUID					mLastReceivedID;			/// Id of last received region env. settings.
-};
-
-#endif // LL_LLENVMANAGER_H
-
diff --git a/indra/newview/llfloatereditdaycycle.cpp b/indra/newview/llfloatereditdaycycle.cpp
index 31b0b0c090..efeec72f6e 100644
--- a/indra/newview/llfloatereditdaycycle.cpp
+++ b/indra/newview/llfloatereditdaycycle.cpp
@@ -41,12 +41,11 @@
 
 // newview
 #include "llagent.h"
-#include "lldaycyclemanager.h"
 #include "llregioninfomodel.h"
 #include "llviewerregion.h"
-#include "llwlparammanager.h"
 
 #include "llenvironment.h"
+#include "lltrans.h"
 
 const F32 LLFloaterEditDayCycle::sHoursPerDay = 24.0f;
 
@@ -128,6 +127,7 @@ void LLFloaterEditDayCycle::draw()
 
 void LLFloaterEditDayCycle::initCallbacks(void)
 {
+#if 0
 	mDayCycleNameEditor->setKeystrokeCallback(boost::bind(&LLFloaterEditDayCycle::onDayCycleNameEdited, this), NULL);
 	mDayCyclesCombo->setCommitCallback(boost::bind(&LLFloaterEditDayCycle::onDayCycleSelected, this));
 	mDayCyclesCombo->setTextEntryCallback(boost::bind(&LLFloaterEditDayCycle::onDayCycleNameEdited, this));
@@ -143,58 +143,60 @@ void LLFloaterEditDayCycle::initCallbacks(void)
 	mSaveButton->setRightMouseDownCallback(boost::bind(&LLFloaterEditDayCycle::dumpTrack, this));
 	getChild<LLButton>("cancel")->setCommitCallback(boost::bind(&LLFloaterEditDayCycle::onBtnCancel, this));
 
-#if 0
 	// Connect to env manager events.
 	LLEnvManagerNew& env_mgr = LLEnvManagerNew::instance();
 	env_mgr.setRegionSettingsChangeCallback(boost::bind(&LLFloaterEditDayCycle::onRegionSettingsChange, this));
 	gAgent.addRegionChangedCallback(boost::bind(&LLFloaterEditDayCycle::onRegionChange, this));
 	env_mgr.setRegionSettingsAppliedCallback(boost::bind(&LLFloaterEditDayCycle::onRegionSettingsApplied, this, _1));
-#endif
-
 	// Connect to day cycle manager events.
 	LLDayCycleManager::instance().setModifyCallback(boost::bind(&LLFloaterEditDayCycle::onDayCycleListChange, this));
 
 	// Connect to sky preset list changes.
 	LLWLParamManager::instance().setPresetListChangeCallback(boost::bind(&LLFloaterEditDayCycle::onSkyPresetListChange, this));
 
+
 	// Connect to region info updates.
 	LLRegionInfoModel::instance().setUpdateCallback(boost::bind(&LLFloaterEditDayCycle::onRegionInfoUpdate, this));
+#endif
 }
 
 void LLFloaterEditDayCycle::syncTimeSlider()
 {
+#if 0
 	// set time
 	mTimeSlider->setCurSliderValue((F32)LLWLParamManager::getInstance()->mAnimator.getDayTime() * sHoursPerDay);
+#endif
 }
 
 void LLFloaterEditDayCycle::loadTrack()
 {
-	// clear the slider
-	mKeysSlider->clear();
-	mSliderToKey.clear();
-
-	// add sliders
-
-	LL_DEBUGS() << "Adding " << LLWLParamManager::getInstance()->mDay.mTimeMap.size() << " keys to slider" << LL_ENDL;
-
-	LLWLDayCycle& cur_dayp = LLWLParamManager::instance().mDay;
-	for (std::map<F32, LLWLParamKey>::iterator it = cur_dayp.mTimeMap.begin(); it != cur_dayp.mTimeMap.end(); ++it)
-	{
-		addSliderKey(it->first * sHoursPerDay, it->second);
-	}
-
-	// set drop-down menu to match preset of currently-selected keyframe (one is automatically selected initially)
-	const std::string& cur_sldr = mKeysSlider->getCurSlider();
-	if (strlen(cur_sldr.c_str()) > 0)	// only do this if there is a curSldr, otherwise we put an invalid entry into the map
-	{
-		mSkyPresetsCombo->selectByValue(mSliderToKey[cur_sldr].keyframe.toStringVal());
-	}
-
-	syncTimeSlider();
+// 	// clear the slider
+// 	mKeysSlider->clear();
+// 	mSliderToKey.clear();
+// 
+// 	// add sliders
+// 
+// 	LL_DEBUGS() << "Adding " << LLWLParamManager::getInstance()->mDay.mTimeMap.size() << " keys to slider" << LL_ENDL;
+// 
+// 	LLWLDayCycle& cur_dayp = LLWLParamManager::instance().mDay;
+// 	for (std::map<F32, LLWLParamKey>::iterator it = cur_dayp.mTimeMap.begin(); it != cur_dayp.mTimeMap.end(); ++it)
+// 	{
+// 		addSliderKey(it->first * sHoursPerDay, it->second);
+// 	}
+// 
+// 	// set drop-down menu to match preset of currently-selected keyframe (one is automatically selected initially)
+// 	const std::string& cur_sldr = mKeysSlider->getCurSlider();
+// 	if (strlen(cur_sldr.c_str()) > 0)	// only do this if there is a curSldr, otherwise we put an invalid entry into the map
+// 	{
+// 		mSkyPresetsCombo->selectByValue(mSliderToKey[cur_sldr].keyframe.toStringVal());
+// 	}
+// 
+// 	syncTimeSlider();
 }
 
 void LLFloaterEditDayCycle::applyTrack()
 {
+#if 0
 	LL_DEBUGS() << "Applying track (" << mSliderToKey.size() << ")" << LL_ENDL;
 
 	// if no keys, do nothing
@@ -223,10 +225,12 @@ void LLFloaterEditDayCycle::applyTrack()
 
 	LLWLParamManager::getInstance()->mAnimator.update(
 		LLWLParamManager::getInstance()->mCurParams);
+#endif
 }
 
 void LLFloaterEditDayCycle::refreshSkyPresetsList()
 {
+#if 0
 	// Don't allow selecting region skies for a local day cycle,
 	// because thus we may end up with invalid day cycle.
 	bool include_region_skies = getSelectedDayCycle().scope == LLEnvKey::SCOPE_REGION;
@@ -272,10 +276,12 @@ void LLFloaterEditDayCycle::refreshSkyPresetsList()
 
 	// set defaults on combo boxes
 	mSkyPresetsCombo->selectFirstItem();
+#endif
 }
 
 void LLFloaterEditDayCycle::refreshDayCyclesList()
 {
+#if 0
 	llassert(isNewDay() == false);
 
 	mDayCyclesCombo->removeall();
@@ -311,10 +317,12 @@ void LLFloaterEditDayCycle::refreshDayCyclesList()
 	}
 
 	mDayCyclesCombo->setLabel(getString("combo_label"));
+#endif
 }
 
 void LLFloaterEditDayCycle::onTimeSliderMoved()
 {
+#if 0
 	/// get the slider value
 	F32 val = mTimeSlider->getCurSliderValue() / sHoursPerDay;
 
@@ -325,10 +333,12 @@ void LLFloaterEditDayCycle::onTimeSliderMoved()
 	// then call update once
 	LLWLParamManager::getInstance()->mAnimator.update(
 		LLWLParamManager::getInstance()->mCurParams);
+#endif
 }
 
 void LLFloaterEditDayCycle::onKeyTimeMoved()
 {
+#if 0
 	if (mKeysSlider->getValue().size() == 0)
 	{
 		return;
@@ -354,10 +364,12 @@ void LLFloaterEditDayCycle::onKeyTimeMoved()
 	mTimeCtrl->setTime24(time24);
 
 	applyTrack();
+#endif
 }
 
 void LLFloaterEditDayCycle::onKeyTimeChanged()
 {
+#if 0
 	// if no keys, skipped
 	if (mSliderToKey.size() == 0)
 	{
@@ -375,10 +387,12 @@ void LLFloaterEditDayCycle::onKeyTimeChanged()
 	mSliderToKey[cur_sldr].time = time;
 
 	applyTrack();
+#endif
 }
 
 void LLFloaterEditDayCycle::onKeyPresetChanged()
 {
+#if 0
 	// do nothing if no sliders
 	if (mKeysSlider->getValue().size() == 0)
 	{
@@ -402,10 +416,12 @@ void LLFloaterEditDayCycle::onKeyPresetChanged()
 
 	// Apply changes to current day cycle.
 	applyTrack();
+#endif
 }
 
 void LLFloaterEditDayCycle::onAddKey()
 {
+#if 0
 	llassert_always(mSliderToKey.size() == mKeysSlider->getValue().size());
 
 	S32 max_sliders;
@@ -444,8 +460,10 @@ void LLFloaterEditDayCycle::onAddKey()
 
 	// apply the change to current day cycles
 	applyTrack();
+#endif
 }
 
+#if 0
 void LLFloaterEditDayCycle::addSliderKey(F32 time, LLWLParamKey keyframe)
 {
 	// make a slider
@@ -465,7 +483,9 @@ void LLFloaterEditDayCycle::addSliderKey(F32 time, LLWLParamKey keyframe)
 
 	llassert_always(mSliderToKey.size() == mKeysSlider->getValue().size());
 }
+#endif
 
+#if 0
 LLWLParamKey LLFloaterEditDayCycle::getSelectedDayCycle()
 {
 	LLWLParamKey dc_key;
@@ -492,6 +512,7 @@ LLWLParamKey LLFloaterEditDayCycle::getSelectedDayCycle()
 
 	return dc_key;
 }
+#endif
 
 bool LLFloaterEditDayCycle::isNewDay() const
 {
@@ -500,6 +521,7 @@ bool LLFloaterEditDayCycle::isNewDay() const
 
 void LLFloaterEditDayCycle::dumpTrack()
 {
+#if 0
 	LL_DEBUGS("Windlight") << "Dumping day cycle" << LL_ENDL;
 
 	LLWLDayCycle& cur_dayp = LLWLParamManager::instance().mDay;
@@ -510,6 +532,7 @@ void LLFloaterEditDayCycle::dumpTrack()
 		S32 m = (S32) ((time - h) * 60.0f);
 		LL_DEBUGS("Windlight") << llformat("(%.3f) %02d:%02d", time, h, m) << " => " << it->second.name << LL_ENDL;
 	}
+#endif
 }
 
 void LLFloaterEditDayCycle::enableEditing(bool enable)
@@ -523,6 +546,7 @@ void LLFloaterEditDayCycle::enableEditing(bool enable)
 
 void LLFloaterEditDayCycle::reset()
 {
+#if 0
 	// clear the slider
 	mKeysSlider->clear();
 	mSliderToKey.clear();
@@ -548,6 +572,7 @@ void LLFloaterEditDayCycle::reset()
 		// Disable controls until a day cycle  to edit is selected.
 		enableEditing(false);
 	}
+#endif
 }
 
 void LLFloaterEditDayCycle::saveRegionDayCycle()
@@ -602,6 +627,7 @@ bool LLFloaterEditDayCycle::getApplyProgress() const
 
 void LLFloaterEditDayCycle::onDeleteKey()
 {
+#if 0
 	if (mSliderToKey.size() == 0)
 	{
 		return;
@@ -631,6 +657,7 @@ void LLFloaterEditDayCycle::onDeleteKey()
 	mTimeCtrl->setTime24(time24);
 
 	applyTrack();
+#endif
 }
 
 void LLFloaterEditDayCycle::onRegionSettingsChange()
@@ -656,6 +683,7 @@ void LLFloaterEditDayCycle::onRegionSettingsChange()
 
 void LLFloaterEditDayCycle::onRegionChange()
 {
+#if 0
 	LL_DEBUGS("Windlight") << "Region changed" << LL_ENDL;
 
 	// If we're editing the region day cycle
@@ -663,6 +691,7 @@ void LLFloaterEditDayCycle::onRegionChange()
 	{
 		reset(); // undoes all unsaved changes
 	}
+#endif
 }
 
 void LLFloaterEditDayCycle::onRegionSettingsApplied(bool success)
@@ -695,9 +724,11 @@ void LLFloaterEditDayCycle::onRegionInfoUpdate()
 
 void LLFloaterEditDayCycle::onDayCycleNameEdited()
 {
+#if 0
 	// Disable saving a day cycle having empty name.
 	LLWLParamKey key = getSelectedDayCycle();
 	mSaveButton->setEnabled(!key.name.empty());
+#endif
 }
 
 void LLFloaterEditDayCycle::onDayCycleSelected()
@@ -741,6 +772,7 @@ void LLFloaterEditDayCycle::onDayCycleSelected()
 
 void LLFloaterEditDayCycle::onBtnSave()
 {
+#if 0
 	LLDayCycleManager& day_mgr = LLDayCycleManager::instance();
 	LLWLParamKey selected_day = getSelectedDayCycle();
 
@@ -776,6 +808,7 @@ void LLFloaterEditDayCycle::onBtnSave()
 		// new preset, hence no confirmation needed
 		onSaveConfirmed();
 	}
+#endif
 }
 
 void LLFloaterEditDayCycle::onBtnCancel()
diff --git a/indra/newview/llfloatereditdaycycle.h b/indra/newview/llfloatereditdaycycle.h
index e6e4fe39c1..50d60a2b56 100644
--- a/indra/newview/llfloatereditdaycycle.h
+++ b/indra/newview/llfloatereditdaycycle.h
@@ -29,8 +29,6 @@
 
 #include "llfloater.h"
 
-#include "llwlparammanager.h" // for LLWLParamKey
-
 class LLCheckBoxCtrl;
 class LLComboBox;
 class LLLineEditor;
@@ -70,10 +68,10 @@ private:
 	void refreshDayCyclesList();
 
 	/// add a slider to the track
-	void addSliderKey(F32 time, LLWLParamKey keyframe);
+//	void addSliderKey(F32 time, LLWLParamKey keyframe);
 
 	void initCallbacks();
-	LLWLParamKey getSelectedDayCycle();
+//	LLWLParamKey getSelectedDayCycle();
 	bool isNewDay() const;
 	void dumpTrack();
 	void enableEditing(bool enable);
@@ -109,15 +107,15 @@ private:
 	static std::string getRegionName();
 
 	/// convenience class for holding keyframes mapped to sliders
-	struct SliderKey
-	{
-	public:
-		SliderKey(LLWLParamKey kf, F32 t) : keyframe(kf), time(t) {}
-		SliderKey() : keyframe(), time(0.f) {} // Don't use this default constructor
-
-		LLWLParamKey keyframe;
-		F32 time;
-	};
+// 	struct SliderKey
+// 	{
+// 	public:
+// 		SliderKey(LLWLParamKey kf, F32 t) : keyframe(kf), time(t) {}
+// 		SliderKey() : keyframe(), time(0.f) {} // Don't use this default constructor
+// 
+// 		LLWLParamKey keyframe;
+// 		F32 time;
+// 	};
 
 	static const F32 sHoursPerDay;
 
@@ -131,7 +129,7 @@ private:
 	LLButton*			mSaveButton;
 
 	// map of sliders to parameters
-	std::map<std::string, SliderKey> mSliderToKey;
+//	std::map<std::string, SliderKey> mSliderToKey;
 };
 
 #endif // LL_LLFLOATEREDITDAYCYCLE_H
diff --git a/indra/newview/llfloatereditsky.cpp b/indra/newview/llfloatereditsky.cpp
index a779241cf4..ab9cb81db5 100644
--- a/indra/newview/llfloatereditsky.cpp
+++ b/indra/newview/llfloatereditsky.cpp
@@ -324,8 +324,6 @@ void LLFloaterEditSky::setColorSwatch(const std::string& name, const WLColorCont
 // color control callbacks
 void LLFloaterEditSky::onColorControlMoved(LLUICtrl* ctrl, WLColorControl* color_ctrl)
 {
-	//LLWLParamManager::getInstance()->mAnimator.deactivate();
-
 	LLColorSwatchCtrl* swatch = static_cast<LLColorSwatchCtrl*>(ctrl);
 	LLColor4 color_vec(swatch->get().mV);
 
@@ -701,20 +699,6 @@ void LLFloaterEditSky::onBtnCancel()
 void LLFloaterEditSky::onSkyPresetListChange()
 {
     refreshSkyPresetsList();
-#if 0
-	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();
-	}
-#endif
 }
 
 void LLFloaterEditSky::onRegionSettingsChange()
diff --git a/indra/newview/llfloaterenvironmentsettings.cpp b/indra/newview/llfloaterenvironmentsettings.cpp
index 6908363839..9a41d434ee 100644
--- a/indra/newview/llfloaterenvironmentsettings.cpp
+++ b/indra/newview/llfloaterenvironmentsettings.cpp
@@ -31,8 +31,6 @@
 #include "llcombobox.h"
 #include "llradiogroup.h"
 
-#include "lldaycyclemanager.h"
-
 #include "llenvironment.h"
 
 
@@ -259,7 +257,7 @@ void LLFloaterEnvironmentSettings::apply()
 void LLFloaterEnvironmentSettings::cancel()
 {
 	// Revert environment to user preferences.
-	LLEnvManagerNew::instance().usePrefs();
+//	LLEnvManagerNew::instance().usePrefs();
 }
 
 void LLFloaterEnvironmentSettings::populateWaterPresetsList()
diff --git a/indra/newview/llfloaterregioninfo.cpp b/indra/newview/llfloaterregioninfo.cpp
index 4f0603fe59..e0a56b9412 100644
--- a/indra/newview/llfloaterregioninfo.cpp
+++ b/indra/newview/llfloaterregioninfo.cpp
@@ -52,7 +52,6 @@
 #include "llbutton.h" 
 #include "llcheckboxctrl.h"
 #include "llcombobox.h"
-#include "lldaycyclemanager.h"
 #include "llestateinfomodel.h"
 #include "llfilepicker.h"
 #include "llfloatergodtools.h"	// for send_sim_wide_deletes()
@@ -86,7 +85,6 @@
 #include "llviewertexteditor.h"
 #include "llviewerwindow.h"
 #include "llvlcomposition.h"
-#include "llwaterparammanager.h"
 #include "lltrans.h"
 #include "llagentui.h"
 #include "llmeshrepository.h"
@@ -98,8 +96,6 @@
 #include "llpanelexperiences.h"
 #include "llcorehttputil.h"
 
-#include "llenvmanager.h"
-
 const S32 TERRAIN_TEXTURE_COUNT = 4;
 const S32 CORNER_COUNT = 4;
 
@@ -338,13 +334,13 @@ void LLFloaterRegionInfo::processRegionInfo(LLMessageSystem* msg)
 	{
 		return;
 	}
-
+#if 0
 	// We need to re-request environment setting here,
 	// otherwise after we apply (send) updated region settings we won't get them back,
 	// so our environment won't be updated.
 	// This is also the way to know about externally changed region environment.
 	LLEnvManagerNew::instance().requestRegionSettings();
-	
+#endif	
 	LLTabContainer* tab = floater->getChild<LLTabContainer>("region_panels");
 
 	LLViewerRegion* region = gAgent.getRegion();
@@ -3117,16 +3113,16 @@ BOOL LLPanelEnvironmentInfo::postBuild()
 	mDayCyclePresetCombo->setCommitCallback(boost::bind(&LLPanelEnvironmentInfo::onSelectDayCycle, this));
 
     childSetCommitCallback("apply_btn", boost::bind(&LLPanelEnvironmentInfo::onBtnApply, this), NULL);
-	getChild<LLButton>("apply_btn")->setRightMouseDownCallback(boost::bind(&LLEnvManagerNew::dumpUserPrefs, LLEnvManagerNew::getInstance()));
+//	getChild<LLButton>("apply_btn")->setRightMouseDownCallback(boost::bind(&LLEnvManagerNew::dumpUserPrefs, LLEnvManagerNew::getInstance()));
 	childSetCommitCallback("cancel_btn", boost::bind(&LLPanelEnvironmentInfo::onBtnCancel, this), NULL);
-	getChild<LLButton>("cancel_btn")->setRightMouseDownCallback(boost::bind(&LLEnvManagerNew::dumpPresets, LLEnvManagerNew::getInstance()));
+//	getChild<LLButton>("cancel_btn")->setRightMouseDownCallback(boost::bind(&LLEnvManagerNew::dumpPresets, LLEnvManagerNew::getInstance()));
 
-	LLEnvManagerNew::instance().setRegionSettingsChangeCallback(boost::bind(&LLPanelEnvironmentInfo::onRegionSettingschange, this));
-	LLEnvManagerNew::instance().setRegionSettingsAppliedCallback(boost::bind(&LLPanelEnvironmentInfo::onRegionSettingsApplied, this, _1));
+// 	LLEnvManagerNew::instance().setRegionSettingsChangeCallback(boost::bind(&LLPanelEnvironmentInfo::onRegionSettingschange, this));
+// 	LLEnvManagerNew::instance().setRegionSettingsAppliedCallback(boost::bind(&LLPanelEnvironmentInfo::onRegionSettingsApplied, this, _1));
 
-	LLDayCycleManager::instance().setModifyCallback(boost::bind(&LLPanelEnvironmentInfo::populateDayCyclesList, this));
-	LLWLParamManager::instance().setPresetListChangeCallback(boost::bind(&LLPanelEnvironmentInfo::populateSkyPresetsList, this));
-	LLWaterParamManager::instance().setPresetListChangeCallback(boost::bind(&LLPanelEnvironmentInfo::populateWaterPresetsList, this));
+// 	LLDayCycleManager::instance().setModifyCallback(boost::bind(&LLPanelEnvironmentInfo::populateDayCyclesList, this));
+// 	LLWLParamManager::instance().setPresetListChangeCallback(boost::bind(&LLPanelEnvironmentInfo::populateSkyPresetsList, this));
+// 	LLWaterParamManager::instance().setPresetListChangeCallback(boost::bind(&LLPanelEnvironmentInfo::populateWaterPresetsList, this));
 
 	return TRUE;
 }
@@ -3145,7 +3141,7 @@ void LLPanelEnvironmentInfo::onVisibilityChange(BOOL new_visibility)
 	// display user's preferred environment.
 	if (!new_visibility)
 	{
-		LLEnvManagerNew::instance().usePrefs();
+//		LLEnvManagerNew::instance().usePrefs();
 	}
 }
 
@@ -3165,6 +3161,7 @@ bool LLPanelEnvironmentInfo::refreshFromRegion(LLViewerRegion* region)
 
 void LLPanelEnvironmentInfo::refresh()
 {
+#if 0
 	if(gDisconnected)
 	{
 		return;
@@ -3185,6 +3182,7 @@ void LLPanelEnvironmentInfo::refresh()
 	setControlsEnabled(mEnableEditing);
 
 	setDirty(false);
+#endif
 }
 
 void LLPanelEnvironmentInfo::setControlsEnabled(bool enabled)
@@ -3494,7 +3492,7 @@ void LLPanelEnvironmentInfo::onSwitchRegionSettings()
 
 	if (use_defaults)
 	{
-		LLEnvManagerNew::instance().useDefaults();
+//		LLEnvManagerNew::instance().useDefaults();
 	}
 	else
 	{
@@ -3530,7 +3528,7 @@ void LLPanelEnvironmentInfo::onSelectWaterPreset()
 
 	if (getSelectedWaterParams(water_params))
 	{
-		LLEnvManagerNew::instance().useWaterParams(water_params);
+//		LLEnvManagerNew::instance().useWaterParams(water_params);
 	}
 
 	setDirty(true);
@@ -3543,7 +3541,7 @@ void LLPanelEnvironmentInfo::onSelectSkyPreset()
 
 	if (getSelectedSkyParams(params, dummy))
 	{
-		LLEnvManagerNew::instance().useSkyParams(params);
+//		LLEnvManagerNew::instance().useSkyParams(params);
 	}
 
 	setDirty(true);
@@ -3557,7 +3555,7 @@ void LLPanelEnvironmentInfo::onSelectDayCycle()
 
 	if (getSelectedDayCycleParams(day_cycle, sky_map, scope))
 	{
-		LLEnvManagerNew::instance().useDayCycleParams(day_cycle, (LLEnvKey::EScope) scope);
+//		LLEnvManagerNew::instance().useDayCycleParams(day_cycle, (LLEnvKey::EScope) scope);
 	}
 
 	setDirty(true);
@@ -3583,6 +3581,7 @@ void LLPanelEnvironmentInfo::onBtnApply()
 		{
 			LL_DEBUGS("Windlight") << "Use fixed sky" << LL_ENDL;
 
+#if 0
 			// Get selected sky params.
 			LLSD params;
 			std::string preset_name;
@@ -3603,6 +3602,7 @@ void LLPanelEnvironmentInfo::onBtnApply()
 			param_set.setAll(params);
 			refs[LLWLParamKey(preset_name, LLEnvKey::SCOPE_LOCAL)] = param_set; // scope doesn't matter here
 			sky_map = LLWLParamManager::createSkyMap(refs);
+#endif
 		}
 		else // use day cycle
 		{
@@ -3703,7 +3703,7 @@ void LLPanelEnvironmentInfo::onRegionSettingsApplied(bool ok)
 		// "Unable to update environment settings because the last update your viewer saw was not the same
 		// as the last update sent from the simulator.  Try sending your update again, and if this
 		// does not work, try leaving and returning to the region."
-		LLEnvManagerNew::instance().requestRegionSettings();
+//		LLEnvManagerNew::instance().requestRegionSettings();
 	}
 }
 
diff --git a/indra/newview/llfloaterregioninfo.h b/indra/newview/llfloaterregioninfo.h
index 105280bd99..bbdff84bf6 100644
--- a/indra/newview/llfloaterregioninfo.h
+++ b/indra/newview/llfloaterregioninfo.h
@@ -65,11 +65,6 @@ class LLPanelExperiences;
 class LLPanelRegionExperiences;
 
 class LLEventTimer;
-class LLEnvironmentSettings;
-class LLWLParamManager;
-class LLWaterParamManager;
-class LLWLParamSet;
-class LLWaterParamSet;
 
 class LLFloaterRegionInfo : public LLFloater
 {
diff --git a/indra/newview/llstartup.cpp b/indra/newview/llstartup.cpp
index 92b294678b..21c21ab908 100644
--- a/indra/newview/llstartup.cpp
+++ b/indra/newview/llstartup.cpp
@@ -180,7 +180,6 @@
 #include "llnamebox.h"
 #include "llnameeditor.h"
 #include "llpostprocess.h"
-#include "llwaterparammanager.h"
 #include "llagentlanguage.h"
 #include "llwearable.h"
 #include "llinventorybridge.h"
diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index f25471d4f0..0c073f6be9 100644
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -74,7 +74,6 @@
 #include "llviewerregion.h"
 #include "lldrawpoolwater.h"
 #include "lldrawpoolbump.h"
-#include "llwaterparammanager.h"
 #include "llpostprocess.h"
 #include "llscenemonitor.h"
 
diff --git a/indra/newview/llviewermenu.cpp b/indra/newview/llviewermenu.cpp
index 57eef7e776..647489666f 100644
--- a/indra/newview/llviewermenu.cpp
+++ b/indra/newview/llviewermenu.cpp
@@ -51,7 +51,6 @@
 #include "llagentpilot.h"
 #include "llcompilequeue.h"
 #include "llconsole.h"
-#include "lldaycyclemanager.h"
 #include "lldebugview.h"
 #include "llenvironment.h"
 #include "llfacebookconnect.h"
@@ -121,9 +120,6 @@
 #include "llworldmap.h"
 #include "pipeline.h"
 #include "llviewerjoystick.h"
-#include "llwaterparammanager.h"
-#include "llwlanimator.h"
-#include "llwlparammanager.h"
 #include "llfloatercamera.h"
 #include "lluilistener.h"
 #include "llappearancemgr.h"
@@ -135,6 +131,7 @@
 #include "llstartup.h"
 #include "boost/unordered_map.hpp"
 #include "llcleanup.h"
+#include "llviewershadermgr.h"
 
 using namespace LLAvatarAppearanceDefines;
 
@@ -8509,30 +8506,6 @@ class LLWorldEnableEnvPreset : public view_listener_t
 {
 	bool handleEvent(const LLSD& userdata)
 	{
-		std::string item = userdata.asString();
-
-		if (item == "delete_water")
-		{
-			LLWaterParamManager::preset_name_list_t user_waters;
-			LLWaterParamManager::instance().getUserPresetNames(user_waters);
-			return !user_waters.empty();
-		}
-		else if (item == "delete_sky")
-		{
-			LLWLParamManager::preset_name_list_t user_skies;
-			LLWLParamManager::instance().getUserPresetNames(user_skies);
-			return !user_skies.empty();
-		}
-		else if (item == "delete_day_cycle")
-		{
-			LLDayCycleManager::preset_name_list_t user_days;
-			LLDayCycleManager::instance().getUserPresetNames(user_days);
-			return !user_days.empty();
-		}
-		else
-		{
-			LL_WARNS() << "Unknown item" << LL_ENDL;
-		}
 
 		return false;
 	}
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index f0924486df..e40d3da338 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -38,7 +38,6 @@
 #include "llviewercontrol.h"
 #include "pipeline.h"
 #include "llworld.h"
-#include "llwaterparammanager.h"
 #include "llsky.h"
 #include "llvosky.h"
 #include "llrender.h"
diff --git a/indra/newview/llvosky.cpp b/indra/newview/llvosky.cpp
index 20afc7a41d..22cd14a830 100644
--- a/indra/newview/llvosky.cpp
+++ b/indra/newview/llvosky.cpp
@@ -48,7 +48,6 @@
 #include "llworld.h"
 #include "pipeline.h"
 #include "lldrawpoolwlsky.h"
-#include "llwaterparammanager.h"
 #include "v3colorutil.h"
 
 #include "llsettingssky.h"
diff --git a/indra/newview/llwaterparammanager.cpp b/indra/newview/llwaterparammanager.cpp
deleted file mode 100644
index 9e275fd108..0000000000
--- a/indra/newview/llwaterparammanager.cpp
+++ /dev/null
@@ -1,448 +0,0 @@
-/**
- * @file llwaterparammanager.cpp
- * @brief Implementation for the LLWaterParamManager class.
- *
- * $LicenseInfo:firstyear=2007&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "llviewerprecompiledheaders.h"
-
-#include "llwaterparammanager.h"
-
-#include "llrender.h"
-
-#include "pipeline.h"
-#include "llsky.h"
-
-#include "lldiriterator.h"
-#include "llfloaterreg.h"
-#include "llsliderctrl.h"
-#include "llspinctrl.h"
-#include "llcheckboxctrl.h"
-#include "lluictrlfactory.h"
-#include "llviewercontrol.h"
-#include "llviewercamera.h"
-#include "llcombobox.h"
-#include "lllineeditor.h"
-#include "llsdserialize.h"
-
-#include "v4math.h"
-#include "llviewercontrol.h"
-#include "lldrawpoolwater.h"
-#include "llagent.h"
-#include "llagentcamera.h"
-#include "llviewerregion.h"
-
-#include "llenvironment.h"
-#include "llwaterparamset.h"
-
-#include "curl/curl.h"
-
-LLWaterParamManager::LLWaterParamManager() :
-// 	mFogColor(22.f/255.f, 43.f/255.f, 54.f/255.f, 0.0f, 0.0f, "waterFogColor", "WaterFogColor"),
-// 	mFogDensity(4, "waterFogDensity", 2),
-// 	mUnderWaterFogMod(0.25, "underWaterFogMod"),
-// 	mNormalScale(2.f, 2.f, 2.f, "normScale"),
-// 	mFresnelScale(0.5f, "fresnelScale"),
-// 	mFresnelOffset(0.4f, "fresnelOffset"),
-// 	mScaleAbove(0.025f, "scaleAbove"),
-// 	mScaleBelow(0.2f, "scaleBelow"),
-// 	mBlurMultiplier(0.1f, "blurMultiplier"),
-// 	mWave1Dir(.5f, .5f, "wave1Dir"),
-// 	mWave2Dir(.5f, .5f, "wave2Dir"),
-	mDensitySliderValue(1.0f),
-	mWaterFogKS(1.0f)
-{
-}
-
-LLWaterParamManager::~LLWaterParamManager()
-{
-}
-
-void LLWaterParamManager::loadAllPresets()
-{
-	// First, load system (coming out of the box) water presets.
-	loadPresetsFromDir(getSysDir());
-
-	// Then load user presets. Note that user day presets will modify any system ones already loaded.
-	loadPresetsFromDir(getUserDir());
-}
-
-void LLWaterParamManager::loadPresetsFromDir(const std::string& dir)
-{
-	LL_DEBUGS("AppInit", "Shaders") << "Loading water presets from " << dir << LL_ENDL;
-
-	LLDirIterator dir_iter(dir, "*.xml");
-	while (1)
-	{
-		std::string file;
-		if (!dir_iter.next(file))
-		{
-			break; // no more files
-		}
-
-		std::string path = gDirUtilp->add(dir, file);
-		if (!loadPreset(path))
-		{
-			LL_WARNS() << "Error loading water preset from " << path << LL_ENDL;
-		}
-	}
-}
-
-bool LLWaterParamManager::loadPreset(const std::string& path)
-{
-	llifstream xml_file;
-	std::string name(gDirUtilp->getBaseFileName(LLURI::unescape(path), /*strip_exten = */ true));
-
-	xml_file.open(path.c_str());
-	if (!xml_file)
-	{
-		return false;
-	}
-
-	LL_DEBUGS("AppInit", "Shaders") << "Loading water " << name << LL_ENDL;
-
-	LLSD params_data;
-	LLPointer<LLSDParser> parser = new LLSDXMLParser();
-	parser->parse(xml_file, params_data, LLSDSerialize::SIZE_UNLIMITED);
-	xml_file.close();
-
-	if (hasParamSet(name))
-	{
-		setParamSet(name, params_data);
-	}
-	else
-	{
-		addParamSet(name, params_data);
-	}
-
-	return true;
-}
-
-void LLWaterParamManager::savePreset(const std::string & name)
-{
-	llassert(!name.empty());
-
-	// make an empty llsd
-	LLSD paramsData(LLSD::emptyMap());
-	std::string pathName(getUserDir() + LLURI::escape(name) + ".xml");
-
-	// fill it with LLSD windlight params
-	paramsData = mParamList[name].getAll();
-
-	// write to file
-	llofstream presetsXML(pathName.c_str());
-	LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
-	formatter->format(paramsData, presetsXML, LLSDFormatter::OPTIONS_PRETTY);
-	presetsXML.close();
-
-	propagateParameters();
-}
-
-void LLWaterParamManager::propagateParameters(void)
-{
-	// bind the variables only if we're using shaders
-	if(gPipeline.canUseVertexShaders())
-	{
-		LLViewerShaderMgr::shader_iter shaders_iter, end_shaders;
-		end_shaders = LLViewerShaderMgr::instance()->endShaders();
-		for(shaders_iter = LLViewerShaderMgr::instance()->beginShaders(); shaders_iter != end_shaders; ++shaders_iter)
-		{
-			if (shaders_iter->mProgramObject != 0
-				&& shaders_iter->mShaderGroup == LLGLSLShader::SG_WATER)
-			{
-				shaders_iter->mUniformsDirty = TRUE;
-			}
-		}
-	}
-
-#if 0
-    bool err;
-    F32 fog_density_slider = 
-		log(mCurParams.getFloat(mFogDensity.mName, err)) / 
-		log(mFogDensity.mBase);
-
-	setDensitySliderValue(fog_density_slider);
-#endif
-}
-
-void LLWaterParamManager::updateShaderUniforms(LLGLSLShader * shader)
-{
-#if 0
-	if (shader->mShaderGroup == LLGLSLShader::SG_WATER)
-	{
-		shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, LLEnvironment::instance().getRotatedLight().mV);
-        shader->uniform3fv(LLShaderMgr::WL_CAMPOSLOCAL, 1, LLViewerCamera::getInstance()->getOrigin().mV);
-		shader->uniform4fv(LLShaderMgr::WATER_FOGCOLOR, 1, LLDrawPoolWater::sWaterFogColor.mV);
-		shader->uniform4fv(LLShaderMgr::WATER_WATERPLANE, 1, mWaterPlane.mV);
-		shader->uniform1f(LLShaderMgr::WATER_FOGDENSITY, getFogDensity());
-		shader->uniform1f(LLShaderMgr::WATER_FOGKS, mWaterFogKS);
-		shader->uniform1f(LLViewerShaderMgr::DISTANCE_MULTIPLIER, 0);
-	}
-#endif
-}
-
-void LLWaterParamManager::applyParams(const LLSD& params, bool interpolate)
-{
-	if (params.size() == 0)
-	{
-		LL_WARNS() << "Undefined water params" << LL_ENDL;
-		return;
-	}
-
-	if (interpolate)
-	{
-        // *LAPRAS
-
-		//LLWLParamManager::getInstance()->mAnimator.startInterpolation(params);
-	}
-	else
-	{
-		mCurParams.setAll(params);
-	}
-}
-
-static LLTrace::BlockTimerStatHandle FTM_UPDATE_WATERPARAM("Update Water Params");
-
-void LLWaterParamManager::update(LLViewerCamera * cam)
-{
-	LL_RECORD_BLOCK_TIME(FTM_UPDATE_WATERPARAM);
-	
-	// update the shaders and the menu
-	propagateParameters();
-	
-	// only do this if we're dealing with shaders
-	if(gPipeline.canUseVertexShaders()) 
-	{
-		//transform water plane to eye space
-		glh::vec3f norm(0.f, 0.f, 1.f);
-		glh::vec3f p(0.f, 0.f, gAgent.getRegion()->getWaterHeight()+0.1f);
-		
-		F32 modelView[16];
-		for (U32 i = 0; i < 16; i++)
-		{
-			modelView[i] = (F32) gGLModelView[i];
-		}
-
-		glh::matrix4f mat(modelView);
-		glh::matrix4f invtrans = mat.inverse().transpose();
-		glh::vec3f enorm;
-		glh::vec3f ep;
-		invtrans.mult_matrix_vec(norm, enorm);
-		enorm.normalize();
-		mat.mult_matrix_vec(p, ep);
-
-		mWaterPlane = LLVector4(enorm.v[0], enorm.v[1], enorm.v[2], -ep.dot(enorm));
-
-		LLVector3 sunMoonDir;
-		if (gSky.getSunDirection().mV[2] > LLSky::NIGHTTIME_ELEVATION_COS) 	 
-		{ 	 
-			sunMoonDir = gSky.getSunDirection(); 	 
-		} 	 
-		else  	 
-		{ 	 
-			sunMoonDir = gSky.getMoonDirection(); 	 
-		}
-		sunMoonDir.normVec();
-		mWaterFogKS = 1.f/llmax(sunMoonDir.mV[2], WATER_FOG_LIGHT_CLAMP);
-
-		LLViewerShaderMgr::shader_iter shaders_iter, end_shaders;
-		end_shaders = LLViewerShaderMgr::instance()->endShaders();
-		for(shaders_iter = LLViewerShaderMgr::instance()->beginShaders(); shaders_iter != end_shaders; ++shaders_iter)
-		{
-			if (shaders_iter->mProgramObject != 0
-				&& shaders_iter->mShaderGroup == LLGLSLShader::SG_WATER)
-			{
-				shaders_iter->mUniformsDirty = TRUE;
-			}
-		}
-	}
-}
-
-bool LLWaterParamManager::addParamSet(const std::string& name, LLWaterParamSet& param)
-{
-	// add a new one if not one there already
-	preset_map_t::iterator mIt = mParamList.find(name);
-	if(mIt == mParamList.end()) 
-	{	
-		mParamList[name] = param;
-		mPresetListChangeSignal();
-		return true;
-	}
-
-	return false;
-}
-
-BOOL LLWaterParamManager::addParamSet(const std::string& name, LLSD const & param)
-{
-	LLWaterParamSet param_set;
-	param_set.setAll(param);
-	return addParamSet(name, param_set);
-}
-
-bool LLWaterParamManager::getParamSet(const std::string& name, LLWaterParamSet& param)
-{
-	// find it and set it
-	preset_map_t::iterator mIt = mParamList.find(name);
-	if(mIt != mParamList.end()) 
-	{
-		param = mParamList[name];
-		param.mName = name;
-		return true;
-	}
-
-	return false;
-}
-
-bool LLWaterParamManager::hasParamSet(const std::string& name)
-{
-	LLWaterParamSet dummy;
-	return getParamSet(name, dummy);
-}
-
-bool LLWaterParamManager::setParamSet(const std::string& name, LLWaterParamSet& param)
-{
-	mParamList[name] = param;
-
-	return true;
-}
-
-bool LLWaterParamManager::setParamSet(const std::string& name, const LLSD & param)
-{
-	// quick, non robust (we won't be working with files, but assets) check
-	if(!param.isMap()) 
-	{
-		return false;
-	}
-	
-	mParamList[name].setAll(param);
-
-	return true;
-}
-
-bool LLWaterParamManager::removeParamSet(const std::string& name, bool delete_from_disk)
-{
-	// remove from param list
-	preset_map_t::iterator it = mParamList.find(name);
-	if (it == mParamList.end())
-	{
-		LL_WARNS("WindLight") << "No water preset named " << name << LL_ENDL;
-		return false;
-	}
-
-	mParamList.erase(it);
-
-	// remove from file system if requested
-	if (delete_from_disk)
-	{
-		if (gDirUtilp->deleteFilesInDir(getUserDir(), LLURI::escape(name) + ".xml") < 1)
-		{
-			LL_WARNS("WindLight") << "Error removing water preset " << name << " from disk" << LL_ENDL;
-		}
-	}
-
-	// signal interested parties
-	mPresetListChangeSignal();
-	return true;
-}
-
-bool LLWaterParamManager::isSystemPreset(const std::string& preset_name) const
-{
-	// *TODO: file system access is excessive here.
-	return gDirUtilp->fileExists(getSysDir() + LLURI::escape(preset_name) + ".xml");
-}
-
-void LLWaterParamManager::getPresetNames(preset_name_list_t& presets) const
-{
-	presets.clear();
-
-	for (preset_map_t::const_iterator it = mParamList.begin(); it != mParamList.end(); ++it)
-	{
-		presets.push_back(it->first);
-	}
-}
-
-void LLWaterParamManager::getPresetNames(preset_name_list_t& user_presets, preset_name_list_t& system_presets) const
-{
-	user_presets.clear();
-	system_presets.clear();
-
-	for (preset_map_t::const_iterator it = mParamList.begin(); it != mParamList.end(); ++it)
-	{
-		if (isSystemPreset(it->first))
-		{
-			system_presets.push_back(it->first);
-		}
-		else
-		{
-			user_presets.push_back(it->first);
-		}
-	}
-}
-
-void LLWaterParamManager::getUserPresetNames(preset_name_list_t& user_presets) const
-{
-	preset_name_list_t dummy;
-	getPresetNames(user_presets, dummy);
-}
-
-boost::signals2::connection LLWaterParamManager::setPresetListChangeCallback(const preset_list_signal_t::slot_type& cb)
-{
-	return mPresetListChangeSignal.connect(cb);
-}
-
-F32 LLWaterParamManager::getFogDensity(void)
-{
-	bool err;
-
-	F32 fogDensity = mCurParams.getFloat("waterFogDensity", err);
-	
-	// modify if we're underwater
-	const F32 water_height = gAgent.getRegion() ? gAgent.getRegion()->getWaterHeight() : 0.f;
-	F32 camera_height = gAgentCamera.getCameraPositionAgent().mV[2];
-	if(camera_height <= water_height)
-	{
-		// raise it to the underwater fog density modifier
-		fogDensity = pow(fogDensity, mCurParams.getFloat("underWaterFogMod", err));
-	}
-
-	return fogDensity;
-}
-
-// virtual static
-void LLWaterParamManager::initSingleton()
-{
-	LL_DEBUGS("Windlight") << "Initializing water" << LL_ENDL;
-	loadAllPresets();
-}
-
-// static
-std::string LLWaterParamManager::getSysDir()
-{
-	return gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/water", "");
-}
-
-// static
-std::string LLWaterParamManager::getUserDir()
-{
-	return gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS , "windlight/water", "");
-}
diff --git a/indra/newview/llwaterparammanager.h b/indra/newview/llwaterparammanager.h
deleted file mode 100644
index 392e287e3f..0000000000
--- a/indra/newview/llwaterparammanager.h
+++ /dev/null
@@ -1,413 +0,0 @@
-/**
- * @file llwaterparammanager.h
- * @brief Implementation for the LLWaterParamManager class.
- *
- * $LicenseInfo:firstyear=2007&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_WATER_PARAMMANAGER_H
-#define LL_WATER_PARAMMANAGER_H
-
-#include <list>
-#include <map>
-#include "llwaterparamset.h"
-#include "llviewercamera.h"
-#include "v4color.h"
-
-const F32 WATER_FOG_LIGHT_CLAMP = 0.3f;
-#if 0
-// color control
-struct WaterColorControl {
-	
-	F32 mR, mG, mB, mA, mI;			/// the values
-	std::string mName;				/// name to use to dereference params
-	std::string mSliderName;		/// name of the slider in menu
-	bool mHasSliderName;			/// only set slider name for true color types
-
-	inline WaterColorControl(F32 red, F32 green, F32 blue, F32 alpha,
-							 F32 intensity, const std::string& n, const std::string& sliderName = LLStringUtil::null)
-		: mR(red), mG(green), mB(blue), mA(alpha), mI(intensity), mName(n), mSliderName(sliderName)
-	{
-		// if there's a slider name, say we have one
-		mHasSliderName = false;
-		if (mSliderName != "") {
-			mHasSliderName = true;
-		}
-	}
-
-	inline WaterColorControl & operator = (LLColor4 const & val) 
-	{
-		mR = val.mV[0];
-		mG = val.mV[1];
-		mB = val.mV[2];
-		mA = val.mV[3];		
-		return *this;
-	}
-
-	inline operator LLColor4 (void) const
-	{
-		return LLColor4(mR, mG, mB, mA);
-	}
-
-	inline WaterColorControl & operator = (LLVector4 const & val) 
-	{
-		mR = val.mV[0];
-		mG = val.mV[1];
-		mB = val.mV[2];
-		mA = val.mV[3];		
-		return *this;
-	}
-
-	inline operator LLVector4 (void) const 
-	{
-		return LLVector4(mR, mG, mB, mA);
-	}
-
-	inline operator LLVector3 (void) const 
-	{
-		return LLVector3(mR, mG, mB);
-	}
-
-	inline void update(LLWaterParamSet & params) const 
-	{
-		params.set(mName, mR, mG, mB, mA);
-	}
-};
-
-struct WaterVector3Control 
-{
-	F32 mX;
-	F32 mY;
-	F32 mZ;
-
-	std::string mName;
-
-	// basic constructor
-	inline WaterVector3Control(F32 valX, F32 valY, F32 valZ, const std::string& n)
-		: mX(valX), mY(valY), mZ(valZ), mName(n)
-	{
-	}
-
-	inline WaterVector3Control & operator = (LLVector3 const & val) 
-	{
-		mX = val.mV[0];
-		mY = val.mV[1];
-		mZ = val.mV[2];
-
-		return *this;
-	}
-
-	inline void update(LLWaterParamSet & params) const 
-	{
-		params.set(mName, mX, mY, mZ);
-	}
-
-};
-
-struct WaterVector2Control 
-{
-	F32 mX;
-	F32 mY;
-
-	std::string mName;
-
-	// basic constructor
-	inline WaterVector2Control(F32 valX, F32 valY, const std::string& n)
-		: mX(valX), mY(valY), mName(n)
-	{
-	}
-
-	inline WaterVector2Control & operator = (LLVector2 const & val) 
-	{
-		mX = val.mV[0];
-		mY = val.mV[1];
-
-		return *this;
-	}
-
-	inline void update(LLWaterParamSet & params) const 
-	{
-		params.set(mName, mX, mY);
-	}
-};
-
-// float slider control
-struct WaterFloatControl 
-{
-	F32 mX;
-	std::string mName;
-	F32 mMult;
-
-	inline WaterFloatControl(F32 val, const std::string& n, F32 m=1.0f)
-		: mX(val), mName(n), mMult(m)
-	{
-	}
-
-	inline WaterFloatControl & operator = (LLVector4 const & val) 
-	{
-		mX = val.mV[0];
-
-		return *this;
-	}
-
-	inline operator F32 (void) const 
-	{
-		return mX;
-	}
-
-	inline void update(LLWaterParamSet & params) const 
-	{
-		params.set(mName, mX);
-	}
-};
-
-// float slider control
-struct WaterExpFloatControl 
-{
-	F32 mExp;
-	std::string mName;
-	F32 mBase;
-
-	inline WaterExpFloatControl(F32 val, const std::string& n, F32 b)
-		: mExp(val), mName(n), mBase(b)
-	{
-	}
-
-	inline WaterExpFloatControl & operator = (F32 val) 
-	{
-		mExp = log(val) / log(mBase);
-
-		return *this;
-	}
-
-	inline operator F32 (void) const 
-	{
-		return pow(mBase, mExp);
-	}
-
-	inline void update(LLWaterParamSet & params) const 
-	{
-		params.set(mName, pow(mBase, mExp));
-	}
-};
-#endif
-
-/// WindLight parameter manager class - what controls all the wind light shaders
-class LLWaterParamManager : public LLSingleton<LLWaterParamManager>
-{
-	LLSINGLETON(LLWaterParamManager);
-	~LLWaterParamManager();
-	LOG_CLASS(LLWaterParamManager);
-public:
-	typedef std::list<std::string> preset_name_list_t;
-	typedef std::map<std::string, LLWaterParamSet> preset_map_t;
-	typedef boost::signals2::signal<void()> preset_list_signal_t;
-
-	/// save the parameter presets to file
-	void savePreset(const std::string & name);
-
-	/// send the parameters to the shaders
-	void propagateParameters(void);
-
-	// display specified water
-	void applyParams(const LLSD& params, bool interpolate);
-
-	/// update information for the shader
-	void update(LLViewerCamera * cam);
-
-	/// Update shader uniforms that have changed.
-	void updateShaderUniforms(LLGLSLShader * shader);
-
-	/// add a param to the list
-	bool addParamSet(const std::string& name, LLWaterParamSet& param);
-
-	/// add a param to the list
-	BOOL addParamSet(const std::string& name, LLSD const & param);
-
-	/// get a param from the list
-	bool getParamSet(const std::string& name, LLWaterParamSet& param);
-
-	/// check whether the preset is in the list
-	bool hasParamSet(const std::string& name);
-
-	/// set the param in the list with a new param
-	bool setParamSet(const std::string& name, LLWaterParamSet& param);
-	
-	/// set the param in the list with a new param
-	bool setParamSet(const std::string& name, LLSD const & param);	
-
-	/// gets rid of a parameter and any references to it
-	/// returns true if successful
-	bool removeParamSet(const std::string& name, bool delete_from_disk);
-
-	/// @return true if the preset comes out of the box
-	bool isSystemPreset(const std::string& preset_name) const;
-
-	/// @return all named water presets.
-	const preset_map_t& getPresets() const { return mParamList; }
-
-	/// @return user and system preset names as a single list
-	void getPresetNames(preset_name_list_t& presets) const;
-
-	/// @return user and system preset names separately
-	void getPresetNames(preset_name_list_t& user_presets, preset_name_list_t& system_presets) const;
-
-	/// @return list of user presets names
-	void getUserPresetNames(preset_name_list_t& user_presets) const;
-
-	/// Emitted when a preset gets added or deleted.
-	boost::signals2::connection setPresetListChangeCallback(const preset_list_signal_t::slot_type& cb);
-
-	/// set the normap map we want for water
-	bool setNormalMapID(const LLUUID& img);
-
-	void setDensitySliderValue(F32 val);
-
-	/// getters for all the different things water param manager maintains
-	LLUUID getNormalMapID(void);
-	LLVector2 getWave1Dir(void);
-	LLVector2 getWave2Dir(void);
-	F32 getScaleAbove(void);
-	F32 getScaleBelow(void);
-	LLVector3 getNormalScale(void);
-	F32 getFresnelScale(void);
-	F32 getFresnelOffset(void);
-	F32 getBlurMultiplier(void);
-	F32 getFogDensity(void);
-	LLColor4 getFogColor(void);
-
-public:
-
-	LLWaterParamSet mCurParams;
-#if 0
-	/// Atmospherics
-	WaterColorControl mFogColor;
-	WaterExpFloatControl mFogDensity;
-	WaterFloatControl mUnderWaterFogMod;
-
-	/// wavelet scales and directions
-	WaterVector3Control mNormalScale;
-	WaterVector2Control mWave1Dir;
-	WaterVector2Control mWave2Dir;
-
-	// controls how water is reflected and refracted
-	WaterFloatControl mFresnelScale;
-	WaterFloatControl mFresnelOffset;
-	WaterFloatControl mScaleAbove;
-	WaterFloatControl mScaleBelow;
-	WaterFloatControl mBlurMultiplier;
-#endif	
-    F32 mDensitySliderValue;
-
-private:
-	/*virtual*/ void initSingleton();
-	void loadAllPresets();
-	void loadPresetsFromDir(const std::string& dir);
-	bool loadPreset(const std::string& path);
-
-	static std::string getSysDir();
-	static std::string getUserDir();
-
-	LLVector4 mWaterPlane;
-	F32 mWaterFogKS;
-
-	// list of all the parameters, listed by name
-	preset_map_t mParamList;
-
-	preset_list_signal_t mPresetListChangeSignal;
-};
-
-inline void LLWaterParamManager::setDensitySliderValue(F32 val)
-{
-	val /= 10.0f;
-	val = 1.0f - val;
-	val *= val * val;
-//	val *= val;
-	mDensitySliderValue = val;
-}
-
-inline LLUUID LLWaterParamManager::getNormalMapID()
-{	
-	return mCurParams.mParamValues["normalMap"].asUUID();
-}
-
-inline bool LLWaterParamManager::setNormalMapID(const LLUUID& id)
-{
-	mCurParams.mParamValues["normalMap"] = id;
-	return true;
-}
-
-inline LLVector2 LLWaterParamManager::getWave1Dir(void)
-{
-	bool err;
-	return mCurParams.getVector2("wave1Dir", err);
-}
-
-inline LLVector2 LLWaterParamManager::getWave2Dir(void)
-{
-	bool err;
-	return mCurParams.getVector2("wave2Dir", err);
-}
-
-inline F32 LLWaterParamManager::getScaleAbove(void)
-{
-	bool err;
-	return mCurParams.getFloat("scaleAbove", err);
-}
-
-inline F32 LLWaterParamManager::getScaleBelow(void)
-{
-	bool err;
-	return mCurParams.getFloat("scaleBelow", err);
-}
-
-inline LLVector3 LLWaterParamManager::getNormalScale(void)
-{
-	bool err;
-	return mCurParams.getVector3("normScale", err);
-}
-
-inline F32 LLWaterParamManager::getFresnelScale(void)
-{
-	bool err;
-	return mCurParams.getFloat("fresnelScale", err);
-}
-
-inline F32 LLWaterParamManager::getFresnelOffset(void)
-{
-	bool err;
-	return mCurParams.getFloat("fresnelOffset", err);
-}
-
-inline F32 LLWaterParamManager::getBlurMultiplier(void)
-{
-	bool err;
-	return mCurParams.getFloat("blurMultiplier", err);
-}
-
-inline LLColor4 LLWaterParamManager::getFogColor(void)
-{
-	bool err;
-	return LLColor4(mCurParams.getVector4("waterFogColor", err));
-}
-
-#endif
diff --git a/indra/newview/llwaterparamset.cpp b/indra/newview/llwaterparamset.cpp
deleted file mode 100644
index 9cc91d2246..0000000000
--- a/indra/newview/llwaterparamset.cpp
+++ /dev/null
@@ -1,266 +0,0 @@
-/**
- * @file llwaterparamset.cpp
- * @brief Implementation for the LLWaterParamSet class.
- *
- * $LicenseInfo:firstyear=2005&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "llviewerprecompiledheaders.h"
-
-#include "llwaterparamset.h"
-#include "llsd.h"
-
-#include "llwaterparammanager.h"
-#include "lluictrlfactory.h"
-#include "llsliderctrl.h"
-#include "llviewertexturelist.h"
-#include "llviewercontrol.h"
-#include "lluuid.h"
-
-#include <llgl.h>
-
-#include <sstream>
-
-LLWaterParamSet::LLWaterParamSet(void) :
-	mName("Unnamed Preset")
-{
-	LLSD vec4;
-	LLSD vec3;
-	LLSD real(0.0f);
-
-	vec4 = LLSD::emptyArray();
-	vec4.append(22.f/255.f);
-	vec4.append(43.f/255.f);
-	vec4.append(54.f/255.f);
-	vec4.append(0.f/255.f);
-
-	vec3 = LLSD::emptyArray();
-	vec3.append(2);
-	vec3.append(2);
-	vec3.append(2);
-
-	LLSD wave1, wave2;
-	wave1 = LLSD::emptyArray();
-	wave2 = LLSD::emptyArray();
-	wave1.append(0.5f);
-	wave1.append(-.17f);
-	wave2.append(0.58f);
-	wave2.append(-.67f);
-
-	mParamValues.insert("waterFogColor", vec4);
-	mParamValues.insert("waterFogDensity", 16.0f);
-	mParamValues.insert("underWaterFogMod", 0.25f);
-	mParamValues.insert("normScale", vec3);
-	mParamValues.insert("fresnelScale", 0.5f);
-	mParamValues.insert("fresnelOffset", 0.4f);
-	mParamValues.insert("scaleAbove", 0.025f);
-	mParamValues.insert("scaleBelow", 0.2f);
-	mParamValues.insert("blurMultiplier", 0.01f);
-	mParamValues.insert("wave1Dir", wave1);
-	mParamValues.insert("wave2Dir", wave2);
-	mParamValues.insert("normalMap", DEFAULT_WATER_NORMAL);
-
-}
-
-void LLWaterParamSet::set(const std::string& paramName, float x) 
-{	
-	// handle case where no array
-	if(mParamValues[paramName].isReal()) 
-	{
-		mParamValues[paramName] = x;
-	} 
-	
-	// handle array
-	else if(mParamValues[paramName].isArray() &&
-			mParamValues[paramName][0].isReal())
-	{
-		mParamValues[paramName][0] = x;
-	}
-}
-
-void LLWaterParamSet::set(const std::string& paramName, float x, float y) {
-	mParamValues[paramName][0] = x;
-	mParamValues[paramName][1] = y;
-}
-
-void LLWaterParamSet::set(const std::string& paramName, float x, float y, float z)
-{
-	mParamValues[paramName][0] = x;
-	mParamValues[paramName][1] = y;
-	mParamValues[paramName][2] = z;
-}
-
-void LLWaterParamSet::set(const std::string& paramName, float x, float y, float z, float w) 
-{
-	mParamValues[paramName][0] = x;
-	mParamValues[paramName][1] = y;
-	mParamValues[paramName][2] = z;
-	mParamValues[paramName][3] = w;
-}
-
-void LLWaterParamSet::set(const std::string& paramName, const float * val) 
-{
-	mParamValues[paramName][0] = val[0];
-	mParamValues[paramName][1] = val[1];
-	mParamValues[paramName][2] = val[2];
-	mParamValues[paramName][3] = val[3];
-}
-
-void LLWaterParamSet::set(const std::string& paramName, const LLVector4 & val) 
-{
-	mParamValues[paramName][0] = val.mV[0];
-	mParamValues[paramName][1] = val.mV[1];
-	mParamValues[paramName][2] = val.mV[2];
-	mParamValues[paramName][3] = val.mV[3];
-}
-
-void LLWaterParamSet::set(const std::string& paramName, const LLColor4 & val) 
-{
-	mParamValues[paramName][0] = val.mV[0];
-	mParamValues[paramName][1] = val.mV[1];
-	mParamValues[paramName][2] = val.mV[2];
-	mParamValues[paramName][3] = val.mV[3];
-}
-
-LLVector4 LLWaterParamSet::getVector4(const std::string& paramName, bool& error) 
-{
-	
-	// test to see if right type
-	LLSD cur_val = mParamValues.get(paramName);
-	if (!cur_val.isArray() || cur_val.size() != 4) 
-	{
-		error = true;
-		return LLVector4(0,0,0,0);
-	}
-	
-	LLVector4 val;
-	val.mV[0] = (F32) cur_val[0].asReal();
-	val.mV[1] = (F32) cur_val[1].asReal();
-	val.mV[2] = (F32) cur_val[2].asReal();
-	val.mV[3] = (F32) cur_val[3].asReal();
-	
-	error = false;
-	return val;
-}
-
-LLVector3 LLWaterParamSet::getVector3(const std::string& paramName, bool& error) 
-{
-	
-	// test to see if right type
-	LLSD cur_val = mParamValues.get(paramName);
-	if (!cur_val.isArray()|| cur_val.size() != 3) 
-	{
-		error = true;
-		return LLVector3(0,0,0);
-	}
-	
-	LLVector3 val;
-	val.mV[0] = (F32) cur_val[0].asReal();
-	val.mV[1] = (F32) cur_val[1].asReal();
-	val.mV[2] = (F32) cur_val[2].asReal();
-	
-	error = false;
-	return val;
-}
-
-LLVector2 LLWaterParamSet::getVector2(const std::string& paramName, bool& error) 
-{
-	// test to see if right type
-	LLSD cur_val = mParamValues.get(paramName);
-	if (!cur_val.isArray() || cur_val.size() != 2) 
-	{
-		error = true;
-		return LLVector2(0,0);
-	}
-	
-	LLVector2 val;
-	val.mV[0] = (F32) cur_val[0].asReal();
-	val.mV[1] = (F32) cur_val[1].asReal();
-	
-	error = false;
-	return val;
-}
-
-F32 LLWaterParamSet::getFloat(const std::string& paramName, bool& error) 
-{
-	
-	// test to see if right type
-	LLSD cur_val = mParamValues.get(paramName);
-	if (cur_val.isArray() && cur_val.size() != 0)
-	{
-		error = false;
-		return (F32) cur_val[0].asReal();	
-	}
-	
-	if(cur_val.isReal())
-	{
-		error = false;
-		return (F32) cur_val.asReal();
-	}
-	
-	error = true;
-	return 0;
-}
-
-// Added for interpolation effect in DEV-33645
-// Based on LLWLParamSet::mix, but written by Jacob without an intimate knowledge of how WindLight works.
-// The function definition existed in the header but was never implemented.  If you think there is something
-// wrong with this, you're probably right.  Ask Jacob, Q, or a member of the original WindLight team.
-void LLWaterParamSet::mix(LLWaterParamSet& src, LLWaterParamSet& dest, F32 weight)
-{
-	// Setup
-	LLSD srcVal, destVal;													// LLSD holders for get/set calls, reusable
-
-	// Iterate through values
-	for(LLSD::map_iterator iter = mParamValues.beginMap(); iter != mParamValues.endMap(); ++iter)
-	{
-		// If param exists in both src and dest, set the holder variables, otherwise skip
-		if(src.mParamValues.has(iter->first) && dest.mParamValues.has(iter->first))
-		{
-			srcVal = src.mParamValues[iter->first];
-			destVal = dest.mParamValues[iter->first];
-		}
-		else
-		{
-			continue;
-		}
-		
-		if(iter->second.isReal())									// If it's a real, interpolate directly
-		{
-			iter->second = srcVal.asReal() + ((destVal.asReal() - srcVal.asReal()) * weight);
-		}		
-		else if(iter->second.isArray() && iter->second[0].isReal()	// If it's an array of reals, loop through the reals and interpolate on those
-				&& iter->second.size() == srcVal.size() && iter->second.size() == destVal.size())
-		{
-			// Actually do interpolation: old value + (difference in values * factor)
-			for(int i=0; i < iter->second.size(); ++i) 
-			{
-				// iter->second[i] = (1.f-weight)*(F32)srcVal[i].asReal() + weight*(F32)destVal[i].asReal();	// old way of doing it -- equivalent but one more operation
-				iter->second[i] = srcVal[i].asReal() + ((destVal[i].asReal() - srcVal[i].asReal()) * weight);
-			}
-		}
-		else														// Else, skip
-		{
-			continue;
-		}
-	}
-}
diff --git a/indra/newview/llwaterparamset.h b/indra/newview/llwaterparamset.h
deleted file mode 100644
index 368cb0ccba..0000000000
--- a/indra/newview/llwaterparamset.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/**
- * @file llwlparamset.h
- * @brief Interface for the LLWaterParamSet class.
- *
- * $LicenseInfo:firstyear=2005&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_WATER_PARAM_SET_H
-#define LL_WATER_PARAM_SET_H
-
-#include <string>
-#include <map>
-
-#include "v4math.h"
-#include "v4color.h"
-#include "llviewershadermgr.h"
-#include "llstringtable.h"
-
-class LLWaterParamSet;
-
-/// A class representing a set of parameter values for the Water shaders.
-class LLWaterParamSet 
-{
-	friend class LLWaterParamManager;
-
-public:
-	std::string mName;	
-	
-private:
-
-	LLSD mParamValues;
-	std::vector<LLStaticHashedString> mParamHashedNames;
-
-	void updateHashedNames();
-
-public:
-
-	LLWaterParamSet();
-
-	/// Bind this set of parameter values to the uniforms of a particular shader.
-	void update(LLGLSLShader * shader) const;
-
-	/// set the total llsd
-	void setAll(const LLSD& val);
-	
-	/// get the total llsd
-	const LLSD& getAll();		
-
-	/// Set a float parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param x			The float value to set.
-	void set(const std::string& paramName, float x);
-
-	/// Set a float2 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param x			The x component's value to set.
-	/// \param y			The y component's value to set.
-	void set(const std::string& paramName, float x, float y);
-
-	/// Set a float3 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param x			The x component's value to set.
-	/// \param y			The y component's value to set.
-	/// \param z			The z component's value to set.
-	void set(const std::string& paramName, float x, float y, float z);
-
-	/// Set a float4 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param x			The x component's value to set.
-	/// \param y			The y component's value to set.
-	/// \param z			The z component's value to set.
-	/// \param w			The w component's value to set.
-	void set(const std::string& paramName, float x, float y, float z, float w);
-
-	/// Set a float4 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param val			An array of the 4 float values to set the parameter to.
-	void set(const std::string& paramName, const float * val);
-
-	/// Set a float4 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param val			A struct of the 4 float values to set the parameter to.
-	void set(const std::string& paramName, const LLVector4 & val);
-
-	/// Set a float4 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param val			A struct of the 4 float values to set the parameter to.
-	void set(const std::string& paramName, const LLColor4 & val);
-
-	/// Get a float4 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param error		A flag to set if it's not the proper return type
-	LLVector4 getVector4(const std::string& paramName, bool& error);
-
-	/// Get a float3 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param error		A flag to set if it's not the proper return type
-	LLVector3 getVector3(const std::string& paramName, bool& error);
-	
-	/// Get a float2 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param error		A flag to set if it's not the proper return type
-	LLVector2 getVector2(const std::string& paramName, bool& error);
-	
-	/// Get an integer parameter
-	/// \param paramName	The name of the parameter to set.
-	/// \param error		A flag to set if it's not the proper return type	
-	F32 getFloat(const std::string& paramName, bool& error);
-		
-	/// interpolate two parameter sets
-	/// \param src			The parameter set to start with
-	/// \param dest			The parameter set to end with
-	/// \param weight		The amount to interpolate
-	void mix(LLWaterParamSet& src, LLWaterParamSet& dest, 
-		F32 weight);
-
-};
-
-inline void LLWaterParamSet::setAll(const LLSD& val)
-{
-	if(val.isMap()) {
-		LLSD::map_const_iterator mIt = val.beginMap();
-		for(; mIt != val.endMap(); mIt++)
-		{
-			mParamValues[mIt->first] = mIt->second;
-		}
-	}
-	updateHashedNames();
-}
-
-inline void LLWaterParamSet::updateHashedNames()
-{
-	mParamHashedNames.clear();
-	// Iterate through values
-	for(LLSD::map_iterator iter = mParamValues.beginMap(); iter != mParamValues.endMap(); ++iter)
-	{
-		mParamHashedNames.push_back(LLStaticHashedString(iter->first));
-	}
-}
-
-inline const LLSD& LLWaterParamSet::getAll()
-{
-	return mParamValues;
-}
-
-#endif // LL_WaterPARAM_SET_H
diff --git a/indra/newview/llwlanimator.cpp b/indra/newview/llwlanimator.cpp
deleted file mode 100644
index c8879e73eb..0000000000
--- a/indra/newview/llwlanimator.cpp
+++ /dev/null
@@ -1,324 +0,0 @@
-/**
- * @file llwlanimator.cpp
- * @brief Implementation for the LLWLAnimator class.
- *
- * $LicenseInfo:firstyear=2007&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "llviewerprecompiledheaders.h"
-
-#include "llwlanimator.h"
-#include "llsky.h"
-#include "pipeline.h"
-#include "llwlparammanager.h"
-#include "llwaterparammanager.h"
-
-extern LLControlGroup gSavedSettings;
-
-F64 LLWLAnimator::INTERP_TOTAL_SECONDS = 3.f;
-
-LLWLAnimator::LLWLAnimator() : mStartTime(0.f), mDayRate(1.f), mDayTime(0.f),
-							mIsRunning(FALSE), mIsInterpolating(FALSE), mTimeType(TIME_LINDEN),
-							mInterpStartTime(), mInterpEndTime()
-{
-	mInterpBeginWL = new LLWLParamSet();
-	mInterpBeginWater = new LLWaterParamSet();
-	mInterpEndWater = new LLWaterParamSet();
-}
-
-void LLWLAnimator::update(LLWLParamSet& curParams)
-{
-	//llassert(mUseLindenTime != mUseLocalTime);
-
-	F64 curTime;
-	curTime = getDayTime();
-
-	// don't do anything if empty
-	if(mTimeTrack.size() == 0)
-	{
-		return;
-	}
-
-	// start it off
-	mFirstIt = mTimeTrack.begin();
-	mSecondIt = mTimeTrack.begin();
-	mSecondIt++;
-
-	// grab the two tween iterators
-	while(mSecondIt != mTimeTrack.end() && curTime > mSecondIt->first)
-	{
-		mFirstIt++;
-		mSecondIt++;
-	}
-
-	// scroll it around when you get to the end
-	if(mSecondIt == mTimeTrack.end() || mFirstIt->first > curTime)
-	{
-		mSecondIt = mTimeTrack.begin();
-		mFirstIt = mTimeTrack.end();
-		mFirstIt--;
-	}
-
-	F32 weight = 0;
-
-	if(mFirstIt->first < mSecondIt->first)
-	{
-	
-		// get the delta time and the proper weight
-		weight = F32 (curTime - mFirstIt->first) / 
-			(mSecondIt->first - mFirstIt->first);
-	
-	// handle the ends
-	}
-	else if(mFirstIt->first > mSecondIt->first)
-	{
-		
-		// right edge of time line
-		if(curTime >= mFirstIt->first)
-		{
-			weight = F32 (curTime - mFirstIt->first) /
-			((1 + mSecondIt->first) - mFirstIt->first);
-		// left edge of time line
-		}
-		else
-		{
-			weight = F32 ((1 + curTime) - mFirstIt->first) /
-			((1 + mSecondIt->first) - mFirstIt->first);
-		}
-
-	// handle same as whatever the last one is
-	}
-	else
-	{
-		weight = 1;
-	}
-
-	if(mIsInterpolating)
-	{
-		// *TODO_JACOB: this is kind of laggy.  Not sure why.  The part that lags is the curParams.mix call, and none of the other mixes.  It works, though.
-		clock_t current = clock();
-		if(current >= mInterpEndTime)
-		{
-			mIsInterpolating = false;
-			return;
-		}
-		
-		// determine moving target for final interpolation value
-		// *TODO: this will not work with lazy loading of sky presets.
-		LLWLParamSet buf = LLWLParamSet();
-		buf.setAll(LLWLParamManager::getInstance()->mParamList[mFirstIt->second].getAll());	// just give it some values, otherwise it has no params to begin with (see comment in constructor)
-		buf.mix(LLWLParamManager::getInstance()->mParamList[mFirstIt->second], LLWLParamManager::getInstance()->mParamList[mSecondIt->second], weight);	// mix to determine moving target for interpolation finish (as below)
-
-		// mix from previous value to moving target
-		weight = (current - mInterpStartTime) / (INTERP_TOTAL_SECONDS * CLOCKS_PER_SEC);
-		curParams.mix(*mInterpBeginWL, buf, weight);
-		
-		// mix water
-		LLWaterParamManager::getInstance()->mCurParams.mix(*mInterpBeginWater, *mInterpEndWater, weight);
-	}
-	else
-	{
-	// do the interpolation and set the parameters
-		// *TODO: this will not work with lazy loading of sky presets.
-		curParams.mix(LLWLParamManager::getInstance()->mParamList[mFirstIt->second], LLWLParamManager::getInstance()->mParamList[mSecondIt->second], weight);
-	}
-}
-
-F64 LLWLAnimator::getDayTime()
-{
-	if(!mIsRunning)
-	{
-		return mDayTime;
-	}
-	else if(mTimeType == TIME_LINDEN)
-	{
-		F32 phase = gSky.getSunPhase() / F_PI;
-
-		// we're not solving the non-linear equation that determines sun phase
-		// we're just linearly interpolating between the major points
-
-		if (phase <= 5.0 / 4.0)
-		{
-			// mDayTime from 0.33 to 0.75 (6:00 to 21:00)
-			mDayTime = (1.0 / 3.0) * phase + (1.0 / 3.0);
-		}
-		else if (phase > 7.0 / 4.0)
-		{
-			// maximum value for phase is 2
-			// mDayTime from 0.25 to 0.33 (3:00 to 6:00)
-			mDayTime = (1.0 / 3.0) - (1.0 / 3.0) * (2 - phase);
-		}
-		else
-		{
-			// phase == 3/2 is where day restarts (24:00)
-			// mDayTime from 0.75 to 0.999 and 0 to 0.25 (21:00 to 03:00)
-			mDayTime = phase - (1.0 / 2.0);
-
-			if(mDayTime > 1)
-			{
-				mDayTime--;
-			}
-		}
-
-		return mDayTime;
-	}
-	else if(mTimeType == TIME_LOCAL)
-	{
-		return getLocalTime();
-	}
-
-	// get the time;
-	mDayTime = (LLTimer::getElapsedSeconds() - mStartTime) / mDayRate;
-
-	// clamp it
-	if(mDayTime < 0)
-	{
-		mDayTime = 0;
-	} 
-	while(mDayTime > 1)
-	{
-		mDayTime--;
-	}
-
-	return (F32)mDayTime;
-}
-
-void LLWLAnimator::setDayTime(F64 dayTime)
-{
-	//retroactively set start time;
-	mStartTime = LLTimer::getElapsedSeconds() - dayTime * mDayRate;
-	mDayTime = dayTime;
-
-	// clamp it
-	if(mDayTime < 0)
-	{
-		mDayTime = 0;
-	}
-	else if(mDayTime > 1)
-	{
-		mDayTime = 1;
-	}
-}
-
-
-void LLWLAnimator::setTrack(std::map<F32, LLWLParamKey>& curTrack,
-							F32 dayRate, F64 dayTime, bool run)
-{
-	mTimeTrack = curTrack;
-	mDayRate = dayRate;
-	setDayTime(dayTime);
-
-	mIsRunning = run;
-}
-
-void LLWLAnimator::startInterpolation(const LLSD& targetWater)
-{
-	mInterpBeginWL->setAll(LLWLParamManager::getInstance()->mCurParams.getAll());
-	mInterpBeginWater->setAll(LLWaterParamManager::getInstance()->mCurParams.getAll());
-	
-	mInterpStartTime = clock();
-	mInterpEndTime = mInterpStartTime + clock_t(INTERP_TOTAL_SECONDS) * CLOCKS_PER_SEC;
-
-	// Don't set any ending WL -- this is continuously calculated as the animator updates since it's a moving target
-	mInterpEndWater->setAll(targetWater);
-
-	mIsInterpolating = true;
-}
-
-std::string LLWLAnimator::timeToString(F32 curTime)
-{
-	S32 hours;
-	S32 min;
-	bool isPM = false;
-
-	// get hours and minutes
-	hours = (S32) (24.0 * curTime);
-	curTime -= ((F32) hours / 24.0f);
-	min = ll_round(24.0f * 60.0f * curTime);
-
-	// handle case where it's 60
-	if(min == 60) 
-	{
-		hours++;
-		min = 0;
-	}
-
-	// set for PM
-	if(hours >= 12 && hours < 24)
-	{
-		isPM = true;
-	}
-
-	// convert to non-military notation
-	if(hours >= 24) 
-	{
-		hours = 12;
-	} 
-	else if(hours > 12) 
-	{
-		hours -= 12;
-	} 
-	else if(hours == 0) 
-	{
-		hours = 12;
-	}
-
-	// make the string
-	std::stringstream newTime;
-	newTime << hours << ":";
-	
-	// double 0
-	if(min < 10) 
-	{
-		newTime << 0;
-	}
-	
-	// finish it
-	newTime << min << " ";
-	if(isPM) 
-	{
-		newTime << "PM";
-	} 
-	else 
-	{
-		newTime << "AM";
-	}
-
-	return newTime.str();
-}
-
-F64 LLWLAnimator::getLocalTime()
-{
-	char buffer[9];
-	time_t rawtime;
-	struct tm* timeinfo;
-
-	time(&rawtime);
-	timeinfo = localtime(&rawtime);
-	strftime(buffer, 9, "%H:%M:%S", timeinfo);
-	std::string timeStr(buffer);
-
-	F64 tod = ((F64)atoi(timeStr.substr(0,2).c_str())) / 24.f +
-			  ((F64)atoi(timeStr.substr(3,2).c_str())) / 1440.f + 
-			  ((F64)atoi(timeStr.substr(6,2).c_str())) / 86400.f;
-	return tod;
-}
diff --git a/indra/newview/llwlanimator.h b/indra/newview/llwlanimator.h
deleted file mode 100644
index cbb12eb9b7..0000000000
--- a/indra/newview/llwlanimator.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/**
- * @file llwlanimator.h
- * @brief Interface for the LLWLAnimator class.
- *
- * $LicenseInfo:firstyear=2007&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_WL_ANIMATOR_H
-#define LL_WL_ANIMATOR_H
-
-#include "llwlparamset.h"
-#include "llwaterparamset.h"
-#include "llenvmanager.h"
-
-#include <string>
-#include <map>
-
-class LLWLAnimator {
-public:
-	typedef enum e_time
-	{
-		TIME_LINDEN,
-		TIME_LOCAL,
-		TIME_CUSTOM
-	} ETime;
-
-	F64 mStartTime;
-	F32 mDayRate;
-	F64 mDayTime;
-	
-	// track to play
-	std::map<F32, LLWLParamKey> mTimeTrack;
-	std::map<F32, LLWLParamKey>::iterator mFirstIt, mSecondIt;
-
-	// simple constructor
-	LLWLAnimator();
-
-	~LLWLAnimator()
-	{
-		delete mInterpBeginWL;
-		delete mInterpBeginWater;
-		delete mInterpEndWater;
-	}
-
-	// update the parameters
-	void update(LLWLParamSet& curParams);
-
-	// get time in seconds
-	//F64 getTime(void);
-
-	// returns a float 0 - 1 saying what time of day is it?
-	F64 getDayTime(void);
-
-	// sets a float 0 - 1 saying what time of day it is
-	void setDayTime(F64 dayTime);
-
-	// set an animation track
-	void setTrack(std::map<F32, LLWLParamKey>& track,
-		F32 dayRate, F64 dayTime = 0, bool run = true);
-
-	void deactivate()
-	{
-		mIsRunning = false;
-	}
-
-	void activate(ETime time)
-	{
-		mIsRunning = true;
-		mTimeType = time;
-	}
-
-	void startInterpolation(const LLSD& targetWater);
-
-	bool getIsRunning()
-	{
-		return mIsRunning;
-	}
-
-	bool getUseCustomTime()
-	{
-		return mTimeType == TIME_CUSTOM;
-	}
-
-	bool getUseLocalTime()
-	{
-		return mTimeType == TIME_LOCAL;
-	}
-
-	bool getUseLindenTime()
-	{
-		return mTimeType == TIME_LINDEN;
-	}
-
-	void setTimeType(ETime time)
-	{
-		mTimeType = time;
-	}
-
-	ETime getTimeType()
-	{
-		return mTimeType;
-	}
-
-	/// convert the present time to a digital clock time
-	static std::string timeToString(F32 curTime);
-
-	/// get local time between 0 and 1
-	static F64 getLocalTime();
-
-private:
-	ETime mTimeType;
-	bool mIsRunning, mIsInterpolating;
-	LLWLParamSet *mInterpBeginWL;
-	LLWaterParamSet *mInterpBeginWater, *mInterpEndWater;
-	clock_t mInterpStartTime, mInterpEndTime;
-
-	static F64 INTERP_TOTAL_SECONDS;
-};
-
-#endif // LL_WL_ANIMATOR_H
-
diff --git a/indra/newview/llwldaycycle.cpp b/indra/newview/llwldaycycle.cpp
index 106f17f61b..0a331d1823 100644
--- a/indra/newview/llwldaycycle.cpp
+++ b/indra/newview/llwldaycycle.cpp
@@ -46,6 +46,7 @@ LLWLDayCycle::~LLWLDayCycle()
 
 void LLWLDayCycle::loadDayCycle(const LLSD& day_data, LLWLParamKey::EScope scope)
 {
+#if 0
 	LL_DEBUGS() << "Loading day cycle (day_data.size() = " << day_data.size() << ", scope = " << scope << ")" << LL_ENDL;
 	mTimeMap.clear();
 
@@ -88,6 +89,7 @@ void LLWLDayCycle::loadDayCycle(const LLSD& day_data, LLWLParamKey::EScope scope
 		// then add the keyframe
 		addKeyframe((F32)day_data[i][0].asReal(), frame);
 	}
+#endif
 }
 
 void LLWLDayCycle::loadDayCycleFromFile(const std::string & fileName)
@@ -158,35 +160,35 @@ LLSD LLWLDayCycle::asLLSD()
 	return day_data;
 }
 
-bool LLWLDayCycle::getSkyRefs(std::map<LLWLParamKey, LLWLParamSet>& refs) const
-{
-	bool result = true;
-	LLWLParamManager& wl_mgr = LLWLParamManager::instance();
-
-	refs.clear();
-	for (std::map<F32, LLWLParamKey>::const_iterator iter = mTimeMap.begin(); iter != mTimeMap.end(); ++iter)
-	{
-		const LLWLParamKey& key = iter->second;
-		if (!wl_mgr.getParamSet(key, refs[key]))
-		{
-			LL_WARNS() << "Cannot find sky [" << key.name << "] referenced by a day cycle" << LL_ENDL;
-			result = false;
-		}
-	}
-
-	return result;
-}
+// bool LLWLDayCycle::getSkyRefs(std::map<LLWLParamKey, LLWLParamSet>& refs) const
+// {
+// 	bool result = true;
+// 	LLWLParamManager& wl_mgr = LLWLParamManager::instance();
+// 
+// 	refs.clear();
+// 	for (std::map<F32, LLWLParamKey>::const_iterator iter = mTimeMap.begin(); iter != mTimeMap.end(); ++iter)
+// 	{
+// 		const LLWLParamKey& key = iter->second;
+// 		if (!wl_mgr.getParamSet(key, refs[key]))
+// 		{
+// 			LL_WARNS() << "Cannot find sky [" << key.name << "] referenced by a day cycle" << LL_ENDL;
+// 			result = false;
+// 		}
+// 	}
+// 
+// 	return result;
+// }
 
 bool LLWLDayCycle::getSkyMap(LLSD& sky_map) const
 {
-	std::map<LLWLParamKey, LLWLParamSet> refs;
-
-	if (!getSkyRefs(refs))
-	{
-		return false;
-	}
-
-	sky_map = LLWLParamManager::createSkyMap(refs);
+// 	std::map<LLWLParamKey, LLWLParamSet> refs;
+// 
+// 	if (!getSkyRefs(refs))
+// 	{
+// 		return false;
+// 	}
+// 
+// 	sky_map = LLWLParamManager::createSkyMap(refs);
 	return true;
 }
 
@@ -235,23 +237,23 @@ bool LLWLDayCycle::changeKeyframeTime(F32 oldTime, F32 newTime)
 	return addKeyframe(newTime, frame);
 }
 
-bool LLWLDayCycle::changeKeyframeParam(F32 time, LLWLParamKey key)
-{
-	LL_DEBUGS() << "Changing key frame param (" << time << ", " << key.toLLSD() << ")" << LL_ENDL;
-
-	// just remove and add back
-	// make sure param exists
-	LLWLParamSet tmp;
-	bool stat = LLWLParamManager::getInstance()->getParamSet(key, tmp);
-	if(stat == false) 
-	{
-		LL_DEBUGS() << "Failed to change key frame param (" << time << ", " << key.toLLSD() << ")" << LL_ENDL;
-		return stat;
-	}
-
-	mTimeMap[time] = key;
-	return true;
-}
+// bool LLWLDayCycle::changeKeyframeParam(F32 time, LLWLParamKey key)
+// {
+// 	LL_DEBUGS() << "Changing key frame param (" << time << ", " << key.toLLSD() << ")" << LL_ENDL;
+// 
+// 	// just remove and add back
+// 	// make sure param exists
+// 	LLWLParamSet tmp;
+// 	bool stat = LLWLParamManager::getInstance()->getParamSet(key, tmp);
+// 	if(stat == false) 
+// 	{
+// 		LL_DEBUGS() << "Failed to change key frame param (" << time << ", " << key.toLLSD() << ")" << LL_ENDL;
+// 		return stat;
+// 	}
+// 
+// 	mTimeMap[time] = key;
+// 	return true;
+// }
 
 
 bool LLWLDayCycle::removeKeyframe(F32 time)
@@ -285,19 +287,19 @@ bool LLWLDayCycle::getKeytime(LLWLParamKey frame, F32& key_time) const
 	return false;
 }
 
-bool LLWLDayCycle::getKeyedParam(F32 time, LLWLParamSet& param)
-{
-	// just scroll on through till you find it
-	std::map<F32, LLWLParamKey>::iterator mIt = mTimeMap.find(time);
-	if(mIt != mTimeMap.end())
-	{
-		return LLWLParamManager::getInstance()->getParamSet(mIt->second, param);
-	}
-
-	// return error if not found
-	LL_DEBUGS() << "Key " << time << " not found" << LL_ENDL;
-	return false;
-}
+// bool LLWLDayCycle::getKeyedParam(F32 time, LLWLParamSet& param)
+// {
+// 	// just scroll on through till you find it
+// 	std::map<F32, LLWLParamKey>::iterator mIt = mTimeMap.find(time);
+// 	if(mIt != mTimeMap.end())
+// 	{
+// 		return LLWLParamManager::getInstance()->getParamSet(mIt->second, param);
+// 	}
+// 
+// 	// return error if not found
+// 	LL_DEBUGS() << "Key " << time << " not found" << LL_ENDL;
+// 	return false;
+// }
 
 bool LLWLDayCycle::getKeyedParamName(F32 time, std::string & name)
 {
diff --git a/indra/newview/llwldaycycle.h b/indra/newview/llwldaycycle.h
index aef999f3ec..2f9a2e5c4a 100644
--- a/indra/newview/llwldaycycle.h
+++ b/indra/newview/llwldaycycle.h
@@ -32,8 +32,7 @@ class LLWLDayCycle;
 #include <vector>
 #include <map>
 #include <string>
-#include "llwlparamset.h"
-#include "llwlanimator.h"
+#include "llenvmanager.h"
 struct LLWLParamKey;
 
 class LLWLDayCycle
@@ -77,7 +76,7 @@ public:
 	LLSD asLLSD();
 
 	// get skies referenced by this day cycle
-	bool getSkyRefs(std::map<LLWLParamKey, LLWLParamSet>& refs) const;
+//	bool getSkyRefs(std::map<LLWLParamKey, LLWLParamSet>& refs) const;
 
 	// get referenced skies as LLSD
 	bool getSkyMap(LLSD& sky_map) const;
@@ -109,7 +108,7 @@ public:
 
 	/// get the param set at a given time
 	/// returns true if found one
-	bool getKeyedParam(F32 time, LLWLParamSet& param);
+//	bool getKeyedParam(F32 time, LLWLParamSet& param);
 
 	/// get the name
 	/// returns true if it found one
diff --git a/indra/newview/llwlparammanager.cpp b/indra/newview/llwlparammanager.cpp
deleted file mode 100644
index 966a7840cf..0000000000
--- a/indra/newview/llwlparammanager.cpp
+++ /dev/null
@@ -1,714 +0,0 @@
-/**
- * @file llwlparammanager.cpp
- * @brief Implementation for the LLWLParamManager class.
- *
- * $LicenseInfo:firstyear=2007&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "llviewerprecompiledheaders.h"
-
-#include "llwlparammanager.h"
-
-#include "pipeline.h"
-#include "llsky.h"
-
-#include "lldiriterator.h"
-#include "llfloaterreg.h"
-#include "llsliderctrl.h"
-#include "llspinctrl.h"
-#include "llcheckboxctrl.h"
-#include "lluictrlfactory.h"
-#include "llviewercamera.h"
-#include "llcombobox.h"
-#include "lllineeditor.h"
-#include "llsdserialize.h"
-
-#include "v4math.h"
-#include "llviewerdisplay.h"
-#include "llviewercontrol.h"
-#include "llviewerwindow.h"
-#include "lldrawpoolwater.h"
-#include "llagent.h"
-#include "llviewerregion.h"
-
-#include "llwlparamset.h"
-#include "llpostprocess.h"
-
-#include "llviewershadermgr.h"
-#include "llglslshader.h"
-
-#include "curl/curl.h"
-#include "llstreamtools.h"
-
-#include "llenvironment.h"
-
-LLWLParamManager::LLWLParamManager() :
-
-	//set the defaults for the controls
-
-	/// Sun Delta Terrain tweak variables.
-	mSunDeltaYaw(180.0f),
-	mSceneLightStrength(2.0f),
-//	mWLGamma(1.0f, "gamma"),
-
-// 	mBlueHorizon(0.25f, 0.25f, 1.0f, 1.0f, "blue_horizon", "WLBlueHorizon"),
-// 	mHazeDensity(1.0f, "haze_density"),
-// 	mBlueDensity(0.25f, 0.25f, 0.25f, 1.0f, "blue_density", "WLBlueDensity"),
-// 	mDensityMult(1.0f, "density_multiplier", 1000),
-// 	mHazeHorizon(1.0f, "haze_horizon"),
-// 	mMaxAlt(4000.0f, "max_y"),
-
-	// Lighting
-// 	mLightnorm(0.f, 0.707f, -0.707f, 1.f, "lightnorm"),
-// 	mSunlight(0.5f, 0.5f, 0.5f, 1.0f, "sunlight_color", "WLSunlight"),
-// 	mAmbient(0.5f, 0.75f, 1.0f, 1.19f, "ambient", "WLAmbient"),
-// 	mGlow(18.0f, 0.0f, -0.01f, 1.0f, "glow"),
-
-	// Clouds
-// 	mCloudColor(0.5f, 0.5f, 0.5f, 1.0f, "cloud_color", "WLCloudColor"),
-// 	mCloudMain(0.5f, 0.5f, 0.125f, 1.0f, "cloud_pos_density1"),
-// 	mCloudCoverage(0.0f, "cloud_shadow"),
-// 	mCloudDetail(0.0f, 0.0f, 0.0f, 1.0f, "cloud_pos_density2"),
-// 	mDistanceMult(1.0f, "distance_multiplier"),
-// 	mCloudScale(0.42f, "cloud_scale"),
-
-	// sky dome
-	mDomeOffset(0.96f),
-	mDomeRadius(15000.f)
-{
-}
-
-LLWLParamManager::~LLWLParamManager()
-{
-}
-
-void LLWLParamManager::clearParamSetsOfScope(LLWLParamKey::EScope scope)
-{
-	if (LLWLParamKey::SCOPE_LOCAL == scope)
-	{
-		LL_WARNS("Windlight") << "Tried to clear windlight sky presets from local system!  This shouldn't be called..." << LL_ENDL;
-		return;
-	}
-
-	std::set<LLWLParamKey> to_remove;
-	for(std::map<LLWLParamKey, LLWLParamSet>::iterator iter = mParamList.begin(); iter != mParamList.end(); ++iter)
-	{
-		if(iter->first.scope == scope)
-		{
-			to_remove.insert(iter->first);
-		}
-	}
-
-	for(std::set<LLWLParamKey>::iterator iter = to_remove.begin(); iter != to_remove.end(); ++iter)
-	{
-		mParamList.erase(*iter);
-	}
-}
-
-// returns all skies referenced by the day cycle, with their final names
-// side effect: applies changes to all internal structures!
-std::map<LLWLParamKey, LLWLParamSet> LLWLParamManager::finalizeFromDayCycle(LLWLParamKey::EScope scope)
-{
-	LL_DEBUGS() << "mDay before finalizing:" << LL_ENDL;
-	{
-		for (std::map<F32, LLWLParamKey>::iterator iter = mDay.mTimeMap.begin(); iter != mDay.mTimeMap.end(); ++iter)
-		{
-			LLWLParamKey& key = iter->second;
-			LL_DEBUGS() << iter->first << "->" << key.name << LL_ENDL;
-		}
-	}
-
-	std::map<LLWLParamKey, LLWLParamSet> final_references;
-
-	// Move all referenced to desired scope, renaming if necessary
-	// First, save skies referenced
-	std::map<LLWLParamKey, LLWLParamSet> current_references; // all skies referenced by the day cycle, with their current names
-	// guard against skies with same name and different scopes
-	std::set<std::string> inserted_names;
-	std::map<std::string, unsigned int> conflicted_names; // integer later used as a count, for uniquely renaming conflicts
-
-	LLWLDayCycle& cycle = mDay;
-	for(std::map<F32, LLWLParamKey>::iterator iter = cycle.mTimeMap.begin();
-		iter != cycle.mTimeMap.end();
-		++iter)
-	{
-		LLWLParamKey& key = iter->second;
-		std::string desired_name = key.name;
-		replace_newlines_with_whitespace(desired_name); // already shouldn't have newlines, but just in case
-		if(inserted_names.find(desired_name) == inserted_names.end())
-		{
-			inserted_names.insert(desired_name);
-		}
-		else
-		{
-			// make exist in map
-			conflicted_names[desired_name] = 0;
-		}
-		current_references[key] = mParamList[key];
-	}
-
-	// forget all old skies in target scope, and rebuild, renaming as needed
-	clearParamSetsOfScope(scope);
-	for(std::map<LLWLParamKey, LLWLParamSet>::iterator iter = current_references.begin(); iter != current_references.end(); ++iter)
-	{
-		const LLWLParamKey& old_key = iter->first;
-
-		std::string desired_name(old_key.name);
-		replace_newlines_with_whitespace(desired_name);
-
-		LLWLParamKey new_key(desired_name, scope); // name will be replaced later if necessary
-
-		// if this sky is one with a non-unique name, rename via appending a number
-		// an existing preset of the target scope gets to keep its name
-		if (scope != old_key.scope && conflicted_names.find(desired_name) != conflicted_names.end())
-		{
-			std::string& new_name = new_key.name;
-
-			do
-			{
-				// if this executes more than once, this is an absurdly pathological case
-				// (e.g. "x" repeated twice, but "x 1" already exists, so need to use "x 2")
-				std::stringstream temp;
-				temp << desired_name << " " << (++conflicted_names[desired_name]);
-				new_name = temp.str();
-			} while (inserted_names.find(new_name) != inserted_names.end());
-
-			// yay, found one that works
-			inserted_names.insert(new_name); // track names we consume here; shouldn't be necessary due to ++int? but just in case
-
-			// *TODO factor out below into a rename()?
-
-			LL_INFOS("Windlight") << "Renamed " << old_key.name << " (scope" << old_key.scope << ") to "
-				<< new_key.name << " (scope " << new_key.scope << ")" << LL_ENDL;
-
-			// update name in sky
-			iter->second.mName = new_name;
-
-			// update keys in day cycle
-			for(std::map<F32, LLWLParamKey>::iterator frame = cycle.mTimeMap.begin(); frame != cycle.mTimeMap.end(); ++frame)
-			{
-				if (frame->second == old_key)
-				{
-					frame->second = new_key;
-				}
-			}
-
-			// add to master sky map
-			mParamList[new_key] = iter->second;
-		}
-
-		final_references[new_key] = iter->second;
-	}
-
-	LL_DEBUGS() << "mDay after finalizing:" << LL_ENDL;
-	{
-		for (std::map<F32, LLWLParamKey>::iterator iter = mDay.mTimeMap.begin(); iter != mDay.mTimeMap.end(); ++iter)
-		{
-			LLWLParamKey& key = iter->second;
-			LL_DEBUGS() << iter->first << "->" << key.name << LL_ENDL;
-		}
-	}
-
-	return final_references;
-}
-
-// static
-LLSD LLWLParamManager::createSkyMap(std::map<LLWLParamKey, LLWLParamSet> refs)
-{
-	LLSD skies = LLSD::emptyMap();
-	for(std::map<LLWLParamKey, LLWLParamSet>::iterator iter = refs.begin(); iter != refs.end(); ++iter)
-	{
-		skies.insert(iter->first.name, iter->second.getAll());
-	}
-	return skies;
-}
-
-void LLWLParamManager::addAllSkies(const LLWLParamKey::EScope scope, const LLSD& sky_presets)
-{
-	for(LLSD::map_const_iterator iter = sky_presets.beginMap(); iter != sky_presets.endMap(); ++iter)
-	{
-		LLWLParamSet set;
-		set.setAll(iter->second);
-		mParamList[LLWLParamKey(iter->first, scope)] = set;
-	}
-}
-
-void LLWLParamManager::refreshRegionPresets(const LLSD& region_sky_presets)
-{
-	// Remove all region sky presets because they may belong to a previously visited region.
-	clearParamSetsOfScope(LLEnvKey::SCOPE_REGION);
-
-	// Add all sky presets belonging to the current region.
-	addAllSkies(LLEnvKey::SCOPE_REGION, region_sky_presets);
-}
-
-void LLWLParamManager::loadAllPresets()
-{
-	// First, load system (coming out of the box) sky presets.
-	loadPresetsFromDir(getSysDir());
-
-	// Then load user presets. Note that user day presets will modify any system ones already loaded.
-	loadPresetsFromDir(getUserDir());
-}
-
-void LLWLParamManager::loadPresetsFromDir(const std::string& dir)
-{
-	LL_INFOS("AppInit", "Shaders") << "Loading sky presets from " << dir << LL_ENDL;
-
-	LLDirIterator dir_iter(dir, "*.xml");
-	while (1)
-	{
-		std::string file;
-		if (!dir_iter.next(file))
-		{
-			break; // no more files
-		}
-
-		std::string path = gDirUtilp->add(dir, file);
-		if (!loadPreset(path))
-		{
-			LL_WARNS() << "Error loading sky preset from " << path << LL_ENDL;
-		}
-	}
-}
-
-bool LLWLParamManager::loadPreset(const std::string& path)
-{
-	llifstream xml_file;
-	std::string name(gDirUtilp->getBaseFileName(LLURI::unescape(path), /*strip_exten = */ true));
-
-	xml_file.open(path.c_str());
-	if (!xml_file)
-	{
-		return false;
-	}
-
-	LL_DEBUGS("AppInit", "Shaders") << "Loading sky " << name << LL_ENDL;
-
-	LLSD params_data;
-	LLPointer<LLSDParser> parser = new LLSDXMLParser();
-	parser->parse(xml_file, params_data, LLSDSerialize::SIZE_UNLIMITED);
-	xml_file.close();
-
-	LLWLParamKey key(name, LLEnvKey::SCOPE_LOCAL);
-	if (hasParamSet(key))
-	{
-		setParamSet(key, params_data);
-	}
-	else
-	{
-		addParamSet(key, params_data);
-	}
-
-	return true;
-}
-
-void LLWLParamManager::savePreset(LLWLParamKey key)
-{
-	llassert(key.scope == LLEnvKey::SCOPE_LOCAL && !key.name.empty());
-
-	// make an empty llsd
-	LLSD paramsData(LLSD::emptyMap());
-	std::string pathName(getUserDir() + escapeString(key.name) + ".xml");
-
-	// fill it with LLSD windlight params
-	paramsData = mParamList[key].getAll();
-
-	// write to file
-	llofstream presetsXML(pathName.c_str());
-	LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
-	formatter->format(paramsData, presetsXML, LLSDFormatter::OPTIONS_PRETTY);
-	presetsXML.close();
-
-	propagateParameters();
-}
-
-void LLWLParamManager::updateShaderUniforms(LLGLSLShader * shader)
-{
-	if (gPipeline.canUseWindLightShaders())
-	{
-        //LLEnvironment::instance().updateGLVariablesForSettings(shader, LLEnvironment::instance().getCurrentSky());
-		mCurParams.update(shader);
-	}
-
-	if (shader->mShaderGroup == LLGLSLShader::SG_DEFAULT)
-	{
-		shader->uniform4fv(LLShaderMgr::LIGHTNORM, 1, mRotatedLightDir.mV);
-		shader->uniform3fv(LLShaderMgr::WL_CAMPOSLOCAL, 1, LLViewerCamera::getInstance()->getOrigin().mV);
-	} 
-
-	else if (shader->mShaderGroup == LLGLSLShader::SG_SKY)
-	{
-		shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, mClampedLightDir.mV);
-	}
-
-	shader->uniform1f(LLShaderMgr::SCENE_LIGHT_STRENGTH, mSceneLightStrength);
-	
-}
-
-static LLTrace::BlockTimerStatHandle FTM_UPDATE_WLPARAM("Update Windlight Params");
-
-void LLWLParamManager::propagateParameters(void)
-{
-	LL_RECORD_BLOCK_TIME(FTM_UPDATE_WLPARAM);
-	
-	LLVector4 sunDir;
-	LLVector4 moonDir;
-
-	// set the sun direction from SunAngle and EastAngle
-	F32 sinTheta = sin(mCurParams.getEastAngle());
-	F32 cosTheta = cos(mCurParams.getEastAngle());
-
-	F32 sinPhi = sin(mCurParams.getSunAngle());
-	F32 cosPhi = cos(mCurParams.getSunAngle());
-
-	sunDir.mV[0] = -sinTheta * cosPhi;
-	sunDir.mV[1] = sinPhi;
-	sunDir.mV[2] = cosTheta * cosPhi;
-	sunDir.mV[3] = 0;
-
-	moonDir = -sunDir;
-
-	// is the normal from the sun or the moon
-	if(sunDir.mV[1] >= 0)
-	{
-		mLightDir = sunDir;
-	}
-	else if(sunDir.mV[1] < 0 && sunDir.mV[1] > LLSky::NIGHTTIME_ELEVATION_COS)
-	{
-		// clamp v1 to 0 so sun never points up and causes weirdness on some machines
-		LLVector3 vec(sunDir.mV[0], sunDir.mV[1], sunDir.mV[2]);
-		vec.mV[1] = 0;
-		vec.normVec();
-		mLightDir = LLVector4(vec, 0.f);
-	}
-	else
-	{
-		mLightDir = moonDir;
-	}
-
-	// calculate the clamp lightnorm for sky (to prevent ugly banding in sky
-	// when haze goes below the horizon
-	mClampedLightDir = sunDir;
-
-	if (mClampedLightDir.mV[1] < -0.1f)
-	{
-		mClampedLightDir.mV[1] = -0.1f;
-	}
-
-	mCurParams.set("lightnorm", mLightDir);
-
-	// bind the variables for all shaders only if we're using WindLight
-	LLViewerShaderMgr::shader_iter shaders_iter, end_shaders;
-	end_shaders = LLViewerShaderMgr::instance()->endShaders();
-	for(shaders_iter = LLViewerShaderMgr::instance()->beginShaders(); shaders_iter != end_shaders; ++shaders_iter) 
-	{
-		if (shaders_iter->mProgramObject != 0
-			&& (gPipeline.canUseWindLightShaders()
-				|| shaders_iter->mShaderGroup == LLGLSLShader::SG_WATER))
-		{
-			shaders_iter->mUniformsDirty = TRUE;
-		}
-	}
-
-	// get the cfr version of the sun's direction
-	LLVector3 cfrSunDir(sunDir.mV[2], sunDir.mV[0], sunDir.mV[1]);
-
-	// set direction and don't allow overriding
-	gSky.setSunDirection(cfrSunDir, LLVector3(0,0,0));
-	gSky.setOverrideSun(TRUE);
-}
-
-void LLWLParamManager::update(LLViewerCamera * cam)
-{
-	LL_RECORD_BLOCK_TIME(FTM_UPDATE_WLPARAM);
-	
-	// update clouds, sun, and general
-	mCurParams.updateCloudScrolling();
-	
-	// update only if running
-	if(mAnimator.getIsRunning()) 
-	{
-		mAnimator.update(mCurParams);
-	}
-
-	// update the shaders and the menu
-	propagateParameters();
-	
-	F32 camYaw = cam->getYaw();
-
-	stop_glerror();
-
-	// *TODO: potential optimization - this block may only need to be
-	// executed some of the time.  For example for water shaders only.
-	{
-		F32 camYawDelta = mSunDeltaYaw * DEG_TO_RAD;
-		
-		LLVector3 lightNorm3(mLightDir);
-		lightNorm3 *= LLQuaternion(-(camYaw + camYawDelta), LLVector3(0.f, 1.f, 0.f));
-		mRotatedLightDir = LLVector4(lightNorm3, 0.f);
-
-		LLViewerShaderMgr::shader_iter shaders_iter, end_shaders;
-		end_shaders = LLViewerShaderMgr::instance()->endShaders();
-		for(shaders_iter = LLViewerShaderMgr::instance()->beginShaders(); shaders_iter != end_shaders; ++shaders_iter)
-		{
-			if (shaders_iter->mProgramObject != 0
-				&& (gPipeline.canUseWindLightShaders()
-				|| shaders_iter->mShaderGroup == LLGLSLShader::SG_WATER))
-			{
-				shaders_iter->mUniformsDirty = TRUE;
-			}
-		}
-	}
-}
-
-bool LLWLParamManager::applyDayCycleParams(const LLSD& params, LLEnvKey::EScope scope, F32 time)
-{
-	mDay.loadDayCycle(params, scope);
-	resetAnimator(time, true); // set to specified time and start animator
-	return true;
-}
-
-void LLWLParamManager::setDefaultDay()
-{
-	mDay.loadDayCycleFromFile("Default.xml");
-}
-
-bool LLWLParamManager::applySkyParams(const LLSD& params)
-{
-	mAnimator.deactivate();
-	mCurParams.setAll(params);
-	return true;
-}
-
-void LLWLParamManager::setDefaultSky()
-{
-	getParamSet(LLWLParamKey("Default", LLWLParamKey::SCOPE_LOCAL), mCurParams);
-}
-
-
-void LLWLParamManager::resetAnimator(F32 curTime, bool run)
-{
-	mAnimator.setTrack(mDay.mTimeMap, mDay.mDayRate, 
-		curTime, run);
-
-	return;
-}
-
-bool LLWLParamManager::addParamSet(const LLWLParamKey& key, LLWLParamSet& param)
-{
-	// add a new one if not one there already
-	std::map<LLWLParamKey, LLWLParamSet>::iterator mIt = mParamList.find(key);
-	if(mIt == mParamList.end()) 
-	{	
-		llassert(!key.name.empty());
-		// *TODO: validate params
-		mParamList[key] = param;
-		mPresetListChangeSignal();
-		return true;
-	}
-
-	return false;
-}
-
-BOOL LLWLParamManager::addParamSet(const LLWLParamKey& key, LLSD const & param)
-{
-	LLWLParamSet param_set;
-	param_set.setAll(param);
-	return addParamSet(key, param_set);
-}
-
-bool LLWLParamManager::getParamSet(const LLWLParamKey& key, LLWLParamSet& param)
-{
-	// find it and set it
-	std::map<LLWLParamKey, LLWLParamSet>::iterator mIt = mParamList.find(key);
-	if(mIt != mParamList.end()) 
-	{
-		param = mParamList[key];
-		param.mName = key.name;
-		return true;
-	}
-
-	return false;
-}
-
-bool LLWLParamManager::hasParamSet(const LLWLParamKey& key)
-{
-	LLWLParamSet dummy;
-	return getParamSet(key, dummy);
-}
-
-bool LLWLParamManager::setParamSet(const LLWLParamKey& key, LLWLParamSet& param)
-{
-	llassert(!key.name.empty());
-	// *TODO: validate params
-	mParamList[key] = param;
-
-	return true;
-}
-
-bool LLWLParamManager::setParamSet(const LLWLParamKey& key, const LLSD & param)
-{
-	llassert(!key.name.empty());
-	// *TODO: validate params
-
-	// quick, non robust (we won't be working with files, but assets) check
-	// this might not actually be true anymore....
-	if(!param.isMap()) 
-	{
-		return false;
-	}
-	
-	LLWLParamSet param_set;
-	param_set.setAll(param);
-	return setParamSet(key, param_set);
-}
-
-void LLWLParamManager::removeParamSet(const LLWLParamKey& key, bool delete_from_disk)
-{
-	// *NOTE: Removing a sky preset invalidates day cycles that refer to it.
-
-	if (key.scope == LLEnvKey::SCOPE_REGION)
-	{
-		LL_WARNS() << "Removing region skies not supported" << LL_ENDL;
-		llassert(key.scope == LLEnvKey::SCOPE_LOCAL);
-		return;
-	}
-
-	// remove from param list
-	std::map<LLWLParamKey, LLWLParamSet>::iterator it = mParamList.find(key);
-	if (it == mParamList.end())
-	{
-		LL_WARNS("WindLight") << "No sky preset named " << key.name << LL_ENDL;
-		return;
-	}
-
-	mParamList.erase(it);
-	mDay.removeReferencesTo(key);
-
-	// remove from file system if requested
-	if (delete_from_disk)
-	{
-		std::string path_name(getUserDir());
-		std::string escaped_name = escapeString(key.name);
-
-		if(gDirUtilp->deleteFilesInDir(path_name, escaped_name + ".xml") < 1)
-		{
-			LL_WARNS("WindLight") << "Error removing sky preset " << key.name << " from disk" << LL_ENDL;
-		}
-	}
-
-	// signal interested parties
-	mPresetListChangeSignal();
-}
-
-bool LLWLParamManager::isSystemPreset(const std::string& preset_name) const
-{
-	// *TODO: file system access is excessive here.
-	return gDirUtilp->fileExists(getSysDir() + escapeString(preset_name) + ".xml");
-}
-
-void LLWLParamManager::getPresetNames(preset_name_list_t& region, preset_name_list_t& user, preset_name_list_t& sys) const
-{
-	region.clear();
-	user.clear();
-	sys.clear();
-
-	for (std::map<LLWLParamKey, LLWLParamSet>::const_iterator it = mParamList.begin(); it != mParamList.end(); it++)
-	{
-		const LLWLParamKey& key = it->first;
-		const std::string& name = key.name;
-
-		if (key.scope == LLEnvKey::SCOPE_REGION)
-		{
-			region.push_back(name);
-		}
-		else
-		{
-			if (isSystemPreset(name))
-			{
-				sys.push_back(name);
-			}
-			else
-			{
-				user.push_back(name);
-			}
-		}
-	}
-}
-
-void LLWLParamManager::getUserPresetNames(preset_name_list_t& user) const
-{
-	preset_name_list_t region, sys; // unused
-	getPresetNames(region, user, sys);
-}
-
-void LLWLParamManager::getPresetKeys(preset_key_list_t& keys) const
-{
-	keys.clear();
-
-	for (std::map<LLWLParamKey, LLWLParamSet>::const_iterator it = mParamList.begin(); it != mParamList.end(); it++)
-	{
-		keys.push_back(it->first);
-	}
-}
-
-boost::signals2::connection LLWLParamManager::setPresetListChangeCallback(const preset_list_signal_t::slot_type& cb)
-{
-	return mPresetListChangeSignal.connect(cb);
-}
-
-// virtual static
-void LLWLParamManager::initSingleton()
-{
-	LL_DEBUGS("Windlight") << "Initializing sky" << LL_ENDL;
-
-	loadAllPresets();
-
-	// but use linden time sets it to what the estate is
-	mAnimator.setTimeType(LLWLAnimator::TIME_LINDEN);
-}
-
-// static
-std::string LLWLParamManager::getSysDir()
-{
-	return gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/skies", "");
-}
-
-// static
-std::string LLWLParamManager::getUserDir()
-{
-	return gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS , "windlight/skies", "");
-}
-
-// static
-std::string LLWLParamManager::escapeString(const std::string& str)
-{
-	// Don't use LLURI::escape() because it doesn't encode '-' characters
-	// which may break handling of some system presets like "A-12AM".
-	char* curl_str = curl_escape(str.c_str(), str.size());
-	std::string escaped_str(curl_str);
-	curl_free(curl_str);
-
-	return escaped_str;
-}
-
diff --git a/indra/newview/llwlparammanager.h b/indra/newview/llwlparammanager.h
deleted file mode 100644
index d475a26da6..0000000000
--- a/indra/newview/llwlparammanager.h
+++ /dev/null
@@ -1,329 +0,0 @@
-/**
- * @file llwlparammanager.h
- * @brief Implementation for the LLWLParamManager class.
- *
- * $LicenseInfo:firstyear=2007&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_WLPARAMMANAGER_H
-#define LL_WLPARAMMANAGER_H
-
-#include <list>
-#include <map>
-#include "llwlparamset.h"
-#include "llwlanimator.h"
-#include "llwldaycycle.h"
-#include "llviewercamera.h"
-#include "lltrans.h"
-#include "llenvmanager.h"
-
-class LLGLSLShader;
- 
-#if 0
-// color control
-struct WLColorControl {
-	
-	F32 r, g, b, i;				/// the values
-	std::string mName;			/// name to use to dereference params
-	std::string mSliderName;	/// name of the slider in menu
-	bool hasSliderName;			/// only set slider name for true color types
-	bool isSunOrAmbientColor;			/// flag for if it's the sun or ambient color controller
-	bool isBlueHorizonOrDensity;		/// flag for if it's the Blue Horizon or Density color controller
-
-	inline WLColorControl(F32 red, F32 green, F32 blue, F32 intensity,
-						  const std::string& n, const std::string& sliderName = LLStringUtil::null)
-		: r(red), g(green), b(blue), i(intensity), mName(n), mSliderName(sliderName)
-	{
-		// if there's a slider name, say we have one
-		hasSliderName = false;
-		if (mSliderName != "") {
-			hasSliderName = true;
-		}
-
-		// if it's the sun controller
-		isSunOrAmbientColor = false;
-		if (mSliderName == "WLSunlight" || mSliderName == "WLAmbient") {
-			isSunOrAmbientColor = true;
-		}
-
-		isBlueHorizonOrDensity = false;
-		if (mSliderName == "WLBlueHorizon" || mSliderName == "WLBlueDensity") {
-			isBlueHorizonOrDensity = true;
-		}
-	}
-
-	inline WLColorControl & operator = (LLVector4 const & val) {
-		r = val.mV[0];
-		g = val.mV[1];
-		b = val.mV[2];
-		i = val.mV[3];
-		return *this;
-	}
-
-	inline operator LLVector4 (void) const {
-		return LLVector4(r, g, b, i);
-	}
-
-	inline operator LLVector3 (void) const {
-		return LLVector3(r, g, b);
-	}
-
-	inline void update(LLWLParamSet & params) const {
-		params.set(mName, r, g, b, i);
-	}
-};
-
-// float slider control
-struct WLFloatControl {
-	F32 x;
-	std::string mName;
-	F32 mult;
-
-	inline WLFloatControl(F32 val, const std::string& n, F32 m=1.0f)
-		: x(val), mName(n), mult(m)
-	{
-	}
-
-	inline WLFloatControl & operator = (F32 val) {
-		x = val;
-		return *this;
-	}
-
-	inline operator F32 (void) const {
-		return x;
-	}
-
-	inline void update(LLWLParamSet & params) const {
-		params.set(mName, x);
-	}
-};
-
-#endif
-
-/// WindLight parameter manager class - what controls all the wind light shaders
-class LLWLParamManager : public LLSingleton<LLWLParamManager>
-{
-	LLSINGLETON(LLWLParamManager);
-	~LLWLParamManager();
-	LOG_CLASS(LLWLParamManager);
-
-public:
-	typedef std::list<std::string> preset_name_list_t;
-	typedef std::list<LLWLParamKey> preset_key_list_t;
-	typedef boost::signals2::signal<void()> preset_list_signal_t;
-
-	/// save the parameter presets to file
-	void savePreset(const LLWLParamKey key);
-
-	/// Set shader uniforms dirty, so they'll update automatically.
-	void propagateParameters(void);
-	
-	/// Update shader uniforms that have changed.
-	void updateShaderUniforms(LLGLSLShader * shader);
-
-	/// setup the animator to run
-	void resetAnimator(F32 curTime, bool run);
-
-	/// update information camera dependent parameters
-	void update(LLViewerCamera * cam);
-
-	/// apply specified day cycle, setting time to noon by default
-	bool applyDayCycleParams(const LLSD& params, LLEnvKey::EScope scope, F32 time = 0.5);
-
-	/// Apply Default.xml map
-	void setDefaultDay();
-
-	/// apply specified fixed sky params
-	bool applySkyParams(const LLSD& params);
-
-	void setDefaultSky();
-
-	// get where the light is pointing
-	inline LLVector4 getLightDir(void) const;
-
-	// get where the light is pointing
-	inline LLVector4 getClampedLightDir(void) const;
-
-	// get where the light is pointing
-	inline LLVector4 getRotatedLightDir(void) const;
-	
-	/// get the dome's offset
-	inline F32 getDomeOffset(void) const;
-
-	/// get the radius of the dome
-	inline F32 getDomeRadius(void) const;
-	
-	/// add a param set (preset) to the list
-	bool addParamSet(const LLWLParamKey& key, LLWLParamSet& param);
-
-	/// add a param set (preset) to the list
-	BOOL addParamSet(const LLWLParamKey& key, LLSD const & param);
-
-	/// get a param set (preset) from the list
-	bool getParamSet(const LLWLParamKey& key, LLWLParamSet& param);
-
-	/// check whether the preset is in the list
-	bool hasParamSet(const LLWLParamKey& key);
-
-	/// set the param in the list with a new param
-	bool setParamSet(const LLWLParamKey& key, LLWLParamSet& param);
-	
-	/// set the param in the list with a new param
-	bool setParamSet(const LLWLParamKey& key, LLSD const & param);
-
-	/// gets rid of a parameter and any references to it
-	/// ignores "delete_from_disk" if the scope is not local
-	void removeParamSet(const LLWLParamKey& key, bool delete_from_disk);
-
-	/// clear parameter mapping of a given scope
-	void clearParamSetsOfScope(LLEnvKey::EScope scope);
-
-	/// @return true if the preset comes out of the box
-	bool isSystemPreset(const std::string& preset_name) const;
-
-	/// @return user and system preset names as a single list
-	void getPresetNames(preset_name_list_t& region, preset_name_list_t& user, preset_name_list_t& sys) const;
-
-	/// @return user preset names
-	void getUserPresetNames(preset_name_list_t& user) const;
-
-	/// @return keys of all known presets
-	void getPresetKeys(preset_key_list_t& keys) const;
-
-	/// Emitted when a preset gets added or deleted.
-	boost::signals2::connection setPresetListChangeCallback(const preset_list_signal_t::slot_type& cb);
-
-	/// add all skies in LLSD using the given scope
-	void addAllSkies(LLEnvKey::EScope scope, const LLSD& preset_map);
-
-	/// refresh region-scope presets
-	void refreshRegionPresets(const LLSD& region_sky_presets);
-
-	// returns all skies referenced by the current day cycle (in mDay), with their final names
-	// side effect: applies changes to all internal structures!  (trashes all unreferenced skies in scope, keys in day cycle rescoped to scope, etc.)
-	std::map<LLWLParamKey, LLWLParamSet> finalizeFromDayCycle(LLWLParamKey::EScope scope);
-
-	// returns all skies in map (intended to be called with output from a finalize)
-	static LLSD createSkyMap(std::map<LLWLParamKey, LLWLParamSet> map);
-
-	/// escape string in a way different from LLURI::escape()
-	static std::string escapeString(const std::string& str);
-
-	// helper variables
-	LLWLAnimator mAnimator;
-
-	/// actual direction of the sun
-	LLVector4 mLightDir;
-
-	/// light norm adjusted so haze works correctly
-	LLVector4 mRotatedLightDir;
-
-	/// clamped light norm for shaders that
-	/// are adversely affected when the sun goes below the
-	/// horizon
-	LLVector4 mClampedLightDir;
-
-	// list of params and how they're cycled for days
-	LLWLDayCycle mDay;
-
-	LLWLParamSet mCurParams;
-
-	/// Sun Delta Terrain tweak variables.
-	F32 mSunDeltaYaw;
-#if 0
-	WLFloatControl mWLGamma;
-#endif
-	F32 mSceneLightStrength;
-	
-#if 0
-	/// Atmospherics
-	WLColorControl mBlueHorizon;
-	WLFloatControl mHazeDensity;
-	WLColorControl mBlueDensity;
-	WLFloatControl mDensityMult;
-	WLFloatControl mHazeHorizon;
-	WLFloatControl mMaxAlt;
-
-	/// Lighting
-	WLColorControl mLightnorm;
-	WLColorControl mSunlight;
-	WLColorControl mAmbient;
-	WLColorControl mGlow;
-
-	/// Clouds
-	WLColorControl mCloudColor;
-	WLColorControl mCloudMain;
-	WLFloatControl mCloudCoverage;
-	WLColorControl mCloudDetail;
-	WLFloatControl mDistanceMult;
-	WLFloatControl mCloudScale;
-#endif
-	/// sky dome
-	F32 mDomeOffset;
-	F32 mDomeRadius;
-	
-
-private:
-
-	friend class LLWLAnimator;
-
-	void loadAllPresets();
-	void loadPresetsFromDir(const std::string& dir);
-	bool loadPreset(const std::string& path);
-
-	static std::string getSysDir();
-	static std::string getUserDir();
-
-	/*virtual*/ void initSingleton();
-	// list of all the parameters, listed by name
-	std::map<LLWLParamKey, LLWLParamSet> mParamList;
-
-	preset_list_signal_t mPresetListChangeSignal;
-};
-
-inline F32 LLWLParamManager::getDomeOffset(void) const
-{
-	return mDomeOffset;
-}
-
-inline F32 LLWLParamManager::getDomeRadius(void) const
-{
-	return mDomeRadius;
-}
-
-inline LLVector4 LLWLParamManager::getLightDir(void) const
-{
-	return mLightDir;
-}
-
-inline LLVector4 LLWLParamManager::getClampedLightDir(void) const
-{
-	return mClampedLightDir;
-}
-
-inline LLVector4 LLWLParamManager::getRotatedLightDir(void) const
-{
-	return mRotatedLightDir;
-}
-
-#endif
-
diff --git a/indra/newview/llwlparamset.cpp b/indra/newview/llwlparamset.cpp
deleted file mode 100644
index a2ff2c0c95..0000000000
--- a/indra/newview/llwlparamset.cpp
+++ /dev/null
@@ -1,426 +0,0 @@
-/**
- * @file llwlparamset.cpp
- * @brief Implementation for the LLWLParamSet class.
- *
- * $LicenseInfo:firstyear=2005&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "llviewerprecompiledheaders.h"
-
-#include "llwlparamset.h"
-#include "llwlanimator.h"
-
-#include "llwlparammanager.h"
-#include "llglslshader.h"
-#include "lluictrlfactory.h"
-#include "llsliderctrl.h"
-#include "pipeline.h"
-
-#include <llgl.h>
-
-#include <sstream>
-
-static LLStaticHashedString sStarBrightness("star_brightness");
-static LLStaticHashedString sPresetNum("preset_num");
-static LLStaticHashedString sSunAngle("sun_angle");
-static LLStaticHashedString sEastAngle("east_angle");
-static LLStaticHashedString sEnableCloudScroll("enable_cloud_scroll");
-static LLStaticHashedString sCloudScrollRate("cloud_scroll_rate");
-static LLStaticHashedString sLightNorm("lightnorm");
-static LLStaticHashedString sCloudDensity("cloud_pos_density1");
-static LLStaticHashedString sCloudScale("cloud_scale");
-static LLStaticHashedString sCloudShadow("cloud_shadow");
-static LLStaticHashedString sDensityMultiplier("density_multiplier");
-static LLStaticHashedString sDistanceMultiplier("distance_multiplier");
-static LLStaticHashedString sHazeDensity("haze_density");
-static LLStaticHashedString sHazeHorizon("haze_horizon");
-static LLStaticHashedString sMaxY("max_y");
-
-LLWLParamSet::LLWLParamSet(void) :
-	mName("Unnamed Preset"),
-	mCloudScrollXOffset(0.f), mCloudScrollYOffset(0.f)	
-{}
-
-static LLTrace::BlockTimerStatHandle FTM_WL_PARAM_UPDATE("WL Param Update");
-
-void LLWLParamSet::update(LLGLSLShader * shader) const 
-{	
-	LL_RECORD_BLOCK_TIME(FTM_WL_PARAM_UPDATE);
-    //_WARNS("RIDER") << "----------------------------------------------------------------" << LL_ENDL;
-
-	LLSD::map_const_iterator i = mParamValues.beginMap();
-	std::vector<LLStaticHashedString>::const_iterator n = mParamHashedNames.begin();
-	for(;(i != mParamValues.endMap()) && (n != mParamHashedNames.end());++i, n++)
-	{
-		const LLStaticHashedString& param = *n;
-		
-		// check that our pre-hashed names are still tracking the mParamValues map correctly
-		//
-		llassert(param.String() == i->first);
-
-		if (param == sStarBrightness || param == sPresetNum || param == sSunAngle ||
-			param == sEastAngle || param == sEnableCloudScroll ||
-			param == sCloudScrollRate || param == sLightNorm ) 
-		{
-			continue;
-		}
-		
-		if (param == sCloudDensity)
-		{
-			LLVector4 val;
-			val.mV[0] = F32(i->second[0].asReal()) + mCloudScrollXOffset;
-			val.mV[1] = F32(i->second[1].asReal()) + mCloudScrollYOffset;
-			val.mV[2] = (F32) i->second[2].asReal();
-			val.mV[3] = (F32) i->second[3].asReal();
-
-			stop_glerror();
-            //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
-            shader->uniform4fv(param, 1, val.mV);
-			stop_glerror();
-		}
-		else if (param == sCloudScale || param == sCloudShadow ||
-				 param == sDensityMultiplier || param == sDistanceMultiplier ||
-				 param == sHazeDensity || param == sHazeHorizon ||
-				 param == sMaxY )
-		{
-			F32 val = (F32) i->second[0].asReal();
-
-			stop_glerror();
-            //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
-            shader->uniform1f(param, val);
-			stop_glerror();
-		}
-		else // param is the uniform name
-		{
-			// handle all the different cases
-			if (i->second.isArray() && i->second.size() == 4)
-			{
-				LLVector4 val;
-
-				val.mV[0] = (F32) i->second[0].asReal();
-				val.mV[1] = (F32) i->second[1].asReal();
-				val.mV[2] = (F32) i->second[2].asReal();
-				val.mV[3] = (F32) i->second[3].asReal();															
-
-				stop_glerror();
-                //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
-                shader->uniform4fv(param, 1, val.mV);
-				stop_glerror();
-			} 
-			else if (i->second.isReal())
-			{
-				F32 val = (F32) i->second.asReal();
-
-				stop_glerror();
-                //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
-                shader->uniform1f(param, val);
-				stop_glerror();
-			} 
-			else if (i->second.isInteger())
-			{
-				S32 val = (S32) i->second.asInteger();
-
-				stop_glerror();
-                //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
-                shader->uniform1i(param, val);
-				stop_glerror();
-			} 
-			else if (i->second.isBoolean())
-			{
-				S32 val = (i->second.asBoolean() ? 1 : 0);
-
-				stop_glerror();
-                //_WARNS("RIDER") << "pushing '" << param.String() << "' as " << val << LL_ENDL;
-                shader->uniform1i(param, val);
-				stop_glerror();
-			}
-		}
-	}
-	
-	if (LLPipeline::sRenderDeferred && !LLPipeline::sReflectionRender && !LLPipeline::sUnderWaterRender)
-	{
-		shader->uniform1f(LLShaderMgr::GLOBAL_GAMMA, 2.2);
-	} else {
-		shader->uniform1f(LLShaderMgr::GLOBAL_GAMMA, 1.0);
-	}
-}
-
-void LLWLParamSet::set(const std::string& paramName, float x) 
-{	
-	// handle case where no array
-	if(mParamValues[paramName].isReal()) 
-	{
-		mParamValues[paramName] = x;
-	} 
-	
-	// handle array
-	else if(mParamValues[paramName].isArray() &&
-			mParamValues[paramName][0].isReal())
-	{
-		mParamValues[paramName][0] = x;
-	}
-}
-
-void LLWLParamSet::set(const std::string& paramName, float x, float y)
-{
-	mParamValues[paramName][0] = x;
-	mParamValues[paramName][1] = y;
-}
-
-void LLWLParamSet::set(const std::string& paramName, float x, float y, float z) 
-{
-	mParamValues[paramName][0] = x;
-	mParamValues[paramName][1] = y;
-	mParamValues[paramName][2] = z;
-}
-
-void LLWLParamSet::set(const std::string& paramName, float x, float y, float z, float w) 
-{
-	mParamValues[paramName][0] = x;
-	mParamValues[paramName][1] = y;
-	mParamValues[paramName][2] = z;
-	mParamValues[paramName][3] = w;
-}
-
-void LLWLParamSet::set(const std::string& paramName, const float * val) 
-{
-	mParamValues[paramName][0] = val[0];
-	mParamValues[paramName][1] = val[1];
-	mParamValues[paramName][2] = val[2];
-	mParamValues[paramName][3] = val[3];
-}
-
-void LLWLParamSet::set(const std::string& paramName, const LLVector4 & val) 
-{
-	mParamValues[paramName][0] = val.mV[0];
-	mParamValues[paramName][1] = val.mV[1];
-	mParamValues[paramName][2] = val.mV[2];
-	mParamValues[paramName][3] = val.mV[3];
-}
-
-void LLWLParamSet::set(const std::string& paramName, const LLColor4 & val) 
-{
-	mParamValues[paramName][0] = val.mV[0];
-	mParamValues[paramName][1] = val.mV[1];
-	mParamValues[paramName][2] = val.mV[2];
-	mParamValues[paramName][3] = val.mV[3];
-}
-
-LLVector4 LLWLParamSet::getVector(const std::string& paramName, bool& error) 
-{
-	// test to see if right type
-	LLSD cur_val = mParamValues.get(paramName);
-	if (!cur_val.isArray()) 
-	{
-		error = true;
-		return LLVector4(0,0,0,0);
-	}
-	
-	LLVector4 val;
-	val.mV[0] = (F32) cur_val[0].asReal();
-	val.mV[1] = (F32) cur_val[1].asReal();
-	val.mV[2] = (F32) cur_val[2].asReal();
-	val.mV[3] = (F32) cur_val[3].asReal();
-	
-	error = false;
-	return val;
-}
-
-F32 LLWLParamSet::getFloat(const std::string& paramName, bool& error) 
-{
-	// test to see if right type
-	LLSD cur_val = mParamValues.get(paramName);
-	if (cur_val.isArray() && cur_val.size() != 0) 
-	{
-		error = false;
-		return (F32) cur_val[0].asReal();	
-	}
-	
-	if(cur_val.isReal())
-	{
-		error = false;
-		return (F32) cur_val.asReal();
-	}
-	
-	error = true;
-	return 0;
-}
-
-void LLWLParamSet::setSunAngle(float val) 
-{
-	// keep range 0 - 2pi
-	if(val > F_TWO_PI || val < 0)
-	{
-		F32 num = val / F_TWO_PI;
-		num -= floor(num);
-		val = F_TWO_PI * num;
-	}
-
-	mParamValues["sun_angle"] = val;
-}
-
-
-void LLWLParamSet::setEastAngle(float val) 
-{
-	// keep range 0 - 2pi
-	if(val > F_TWO_PI || val < 0)
-	{
-		F32 num = val / F_TWO_PI;
-		num -= floor(num);
-		val = F_TWO_PI * num;
-	}
-
-	mParamValues["east_angle"] = val;
-}
-
-void LLWLParamSet::mix(LLWLParamSet& src, LLWLParamSet& dest, F32 weight)
-{
-	// set up the iterators
-
-	// keep cloud positions and coverage the same
-	/// TODO masking will do this later
-	F32 cloudPos1X = (F32) mParamValues["cloud_pos_density1"][0].asReal();
-	F32 cloudPos1Y = (F32) mParamValues["cloud_pos_density1"][1].asReal();
-	F32 cloudPos2X = (F32) mParamValues["cloud_pos_density2"][0].asReal();
-	F32 cloudPos2Y = (F32) mParamValues["cloud_pos_density2"][1].asReal();
-	F32 cloudCover = (F32) mParamValues["cloud_shadow"][0].asReal();
-
-	LLSD srcVal;
-	LLSD destVal;
-
-	// Iterate through values
-	for(LLSD::map_iterator iter = mParamValues.beginMap(); iter != mParamValues.endMap(); ++iter)
-	{
-		// If param exists in both src and dest, set the holder variables, otherwise skip
-		if(src.mParamValues.has(iter->first) && dest.mParamValues.has(iter->first))
-		{
-			srcVal = src.mParamValues[iter->first];
-			destVal = dest.mParamValues[iter->first];
-		}
-		else
-		{
-			continue;
-		}
-		
-		if(iter->second.isReal())									// If it's a real, interpolate directly
-		{
-			iter->second = srcVal.asReal() + ((destVal.asReal() - srcVal.asReal()) * weight);
-		}
-		else if(iter->second.isArray() && iter->second[0].isReal()	// If it's an array of reals, loop through the reals and interpolate on those
-				&& iter->second.size() == srcVal.size() && iter->second.size() == destVal.size())
-		{
-			// Actually do interpolation: old value + (difference in values * factor)
-			for(int i=0; i < iter->second.size(); ++i) 
-			{
-				// iter->second[i] = (1.f-weight)*(F32)srcVal[i].asReal() + weight*(F32)destVal[i].asReal();	// old way of doing it -- equivalent but one more operation
-				iter->second[i] = srcVal[i].asReal() + ((destVal[i].asReal() - srcVal[i].asReal()) * weight);
-			}
-		}
-		else														// Else, skip
-		{
-			continue;
-		}		
-	}
-
-	// now mix the extra parameters
-	setStarBrightness((1 - weight) * (F32) src.getStarBrightness()
-		+ weight * (F32) dest.getStarBrightness());
-
-	llassert(src.getSunAngle() >= - F_PI && 
-					src.getSunAngle() <= 3 * F_PI);
-	llassert(dest.getSunAngle() >= - F_PI && 
-					dest.getSunAngle() <= 3 * F_PI);
-	llassert(src.getEastAngle() >= 0 && 
-					src.getEastAngle() <= 4 * F_PI);
-	llassert(dest.getEastAngle() >= 0 && 
-					dest.getEastAngle() <= 4 * F_PI);
-
-	// sun angle and east angle require some handling to make sure
-	// they go in circles.  Yes quaternions would work better.
-	F32 srcSunAngle = src.getSunAngle();
-	F32 destSunAngle = dest.getSunAngle();
-	F32 srcEastAngle = src.getEastAngle();
-	F32 destEastAngle = dest.getEastAngle();
-	
-	if(fabsf(srcSunAngle - destSunAngle) > F_PI) 
-	{
-		if(srcSunAngle > destSunAngle) 
-		{
-			destSunAngle += 2 * F_PI;
-		} 
-		else 
-		{
-			srcSunAngle += 2 * F_PI;
-		}
-	}
-
-	if(fabsf(srcEastAngle - destEastAngle) > F_PI) 
-	{
-		if(srcEastAngle > destEastAngle) 
-		{
-			destEastAngle += 2 * F_PI;
-		} 
-		else 
-		{
-			srcEastAngle += 2 * F_PI;
-		}
-	}
-
-	setSunAngle((1 - weight) * srcSunAngle + weight * destSunAngle);
-	setEastAngle((1 - weight) * srcEastAngle + weight * destEastAngle);
-	
-	// now setup the sun properly
-
-	// reset those cloud positions
-	mParamValues["cloud_pos_density1"][0] = cloudPos1X;
-	mParamValues["cloud_pos_density1"][1] = cloudPos1Y;
-	mParamValues["cloud_pos_density2"][0] = cloudPos2X;
-	mParamValues["cloud_pos_density2"][1] = cloudPos2Y;
-	mParamValues["cloud_shadow"][0] = cloudCover;
-}
-
-void LLWLParamSet::updateCloudScrolling(void) 
-{
-	static LLTimer s_cloud_timer;
-
-	F64 delta_t = s_cloud_timer.getElapsedTimeAndResetF64();
-
-	if(getEnableCloudScrollX())
-	{
-		mCloudScrollXOffset += F32(delta_t * (getCloudScrollX() - 10.f) / 100.f);
-	}
-	if(getEnableCloudScrollY())
-	{
-		mCloudScrollYOffset += F32(delta_t * (getCloudScrollY() - 10.f) / 100.f);
-	}
-}
-
-void LLWLParamSet::updateHashedNames()
-{
-	mParamHashedNames.clear();
-	// Iterate through values
-	for(LLSD::map_iterator iter = mParamValues.beginMap(); iter != mParamValues.endMap(); ++iter)
-	{
-		mParamHashedNames.push_back(LLStaticHashedString(iter->first));
-	}
-}
-
diff --git a/indra/newview/llwlparamset.h b/indra/newview/llwlparamset.h
deleted file mode 100644
index 6e5f1d3a4b..0000000000
--- a/indra/newview/llwlparamset.h
+++ /dev/null
@@ -1,246 +0,0 @@
-/**
- * @file llwlparamset.h
- * @brief Interface for the LLWLParamSet class.
- *
- * $LicenseInfo:firstyear=2005&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_WLPARAM_SET_H
-#define LL_WLPARAM_SET_H
-
-#include <string>
-#include <map>
-#include <vector>
-
-#include "v4math.h"
-#include "v4color.h"
-#include "llstaticstringtable.h"
-
-class LLWLParamSet;
-class LLGLSLShader;
-
-/// A class representing a set of parameter values for the WindLight shaders.
-class LLWLParamSet {
-
-	friend class LLWLParamManager;
-
-public:
-	std::string mName;	
-	
-private:
-
-	LLSD mParamValues;
-	std::vector<LLStaticHashedString> mParamHashedNames;
-
-	float mCloudScrollXOffset, mCloudScrollYOffset;
-
-	void updateHashedNames();
-
-public:
-
-	LLWLParamSet();
-
-	/// Update this set of shader uniforms from the parameter values.
-	void update(LLGLSLShader * shader) const;
-
-	/// set the total llsd
-	void setAll(const LLSD& val);
-	
-	/// get the total llsd
-	const LLSD& getAll();		
-	
-
-	/// Set a float parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param x			The float value to set.
-	void set(const std::string& paramName, float x);
-
-	/// Set a float2 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param x			The x component's value to set.
-	/// \param y			The y component's value to set.
-	void set(const std::string& paramName, float x, float y);
-
-	/// Set a float3 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param x			The x component's value to set.
-	/// \param y			The y component's value to set.
-	/// \param z			The z component's value to set.
-	void set(const std::string& paramName, float x, float y, float z);
-
-	/// Set a float4 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param x			The x component's value to set.
-	/// \param y			The y component's value to set.
-	/// \param z			The z component's value to set.
-	/// \param w			The w component's value to set.
-	void set(const std::string& paramName, float x, float y, float z, float w);
-
-	/// Set a float4 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param val			An array of the 4 float values to set the parameter to.
-	void set(const std::string& paramName, const float * val);
-
-	/// Set a float4 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param val			A struct of the 4 float values to set the parameter to.
-	void set(const std::string& paramName, const LLVector4 & val);
-
-	/// Set a float4 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param val			A struct of the 4 float values to set the parameter to.
-	void set(const std::string& paramName, const LLColor4 & val);
-
-	/// Get a float4 parameter.
-	/// \param paramName	The name of the parameter to set.
-	/// \param error		A flag to set if it's not the proper return type
-	LLVector4 getVector(const std::string& paramName, bool& error);
-
-	/// Get a float parameter
-	/// \param paramName	The name of the parameter to set.
-	/// \param error		A flag to set if it's not the proper return type	
-	F32 getFloat(const std::string& paramName, bool& error);
-	
-	
-	// specific getters and setters
-	
-	
-	/// set the star's brightness
-	/// \param val brightness value
-	void setStarBrightness(F32 val);
-	
-	/// get the star brightness value;
-	F32 getStarBrightness();	
-	
-	void setSunAngle(F32 val);
-	F32 getSunAngle();	
-	
-	void setEastAngle(F32 val);
-	F32 getEastAngle();	
-	
-							
-	
-	/// set the cloud scroll x enable value
-	/// \param val scroll x value	
-	void setEnableCloudScrollX(bool val);
-
-	/// get the scroll x enable value;	
-	bool getEnableCloudScrollX();
-	
-	/// set the star's brightness
-	/// \param val scroll y bool value		
-	void setEnableCloudScrollY(bool val);	
-
-	/// get the scroll enable y value;
-	bool getEnableCloudScrollY();
-	
-	/// set the cloud scroll x enable value
-	/// \param val scroll x value	
-	void setCloudScrollX(F32 val);
-
-	/// get the scroll x enable value;	
-	F32 getCloudScrollX();
-	
-	/// set the star's brightness
-	/// \param val scroll y bool value		
-	void setCloudScrollY(F32 val);	
-
-	/// get the scroll enable y value;
-	F32 getCloudScrollY();	
-
-	/// interpolate two parameter sets
-	/// \param src			The parameter set to start with
-	/// \param dest			The parameter set to end with
-	/// \param weight		The amount to interpolate
-	void mix(LLWLParamSet& src, LLWLParamSet& dest, 
-		F32 weight);
-
-	void updateCloudScrolling(void);
-};
-
-inline void LLWLParamSet::setAll(const LLSD& val)
-{
-	if(val.isMap()) {
-		mParamValues = val;
-	}
-
-	updateHashedNames();
-}
-
-inline const LLSD& LLWLParamSet::getAll()
-{
-	return mParamValues;
-}
-
-inline void LLWLParamSet::setStarBrightness(float val) {
-	mParamValues["star_brightness"] = val;
-}
-
-inline F32 LLWLParamSet::getStarBrightness() {
-	return (F32) mParamValues["star_brightness"].asReal();
-}
-
-inline F32 LLWLParamSet::getSunAngle() {
-	return (F32) mParamValues["sun_angle"].asReal();
-}
-
-inline F32 LLWLParamSet::getEastAngle() {
-	return (F32) mParamValues["east_angle"].asReal();
-}
-
-
-inline void LLWLParamSet::setEnableCloudScrollX(bool val) {
-	mParamValues["enable_cloud_scroll"][0] = val;
-}
-
-inline bool LLWLParamSet::getEnableCloudScrollX() {
-	return mParamValues["enable_cloud_scroll"][0].asBoolean();
-}
-
-inline void LLWLParamSet::setEnableCloudScrollY(bool val) {
-	mParamValues["enable_cloud_scroll"][1] = val;
-}
-
-inline bool LLWLParamSet::getEnableCloudScrollY() {
-	return mParamValues["enable_cloud_scroll"][1].asBoolean();
-}
-
-
-inline void LLWLParamSet::setCloudScrollX(F32 val) {
-	mParamValues["cloud_scroll_rate"][0] = val;
-}
-
-inline F32 LLWLParamSet::getCloudScrollX() {
-	return (F32) mParamValues["cloud_scroll_rate"][0].asReal();
-}
-
-inline void LLWLParamSet::setCloudScrollY(F32 val) {
-	mParamValues["cloud_scroll_rate"][1] = val;
-}
-
-inline F32 LLWLParamSet::getCloudScrollY() {
-	return (F32) mParamValues["cloud_scroll_rate"][1].asReal();
-}
-
-
-#endif // LL_WLPARAM_SET_H
-
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 55c0a092bf..108a8e3e62 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -100,7 +100,6 @@
 #include "llviewerstats.h"
 #include "llviewerjoystick.h"
 #include "llviewerdisplay.h"
-#include "llwaterparammanager.h"
 #include "llspatialpartition.h"
 #include "llmutelist.h"
 #include "lltoolpie.h"
-- 
cgit v1.3