Merged in Geenz/viewer-eep/OPEN-340 (pull request #345)

OPEN-340 & OPEN-343 - Consolidate shader atmospheric calcs into a singular utility shader + fix fog on fullbright in deferred

13 files changed, 253 insertions, 288 deletions

diff --git a/indra/llrender/llglslshader.cpp b/indra/llrender/llglslshader.cpp
index f8b5dd0559..babf649ece 100644
--- a/indra/llrender/llglslshader.cpp
+++ b/indra/llrender/llglslshader.cpp
@@ -485,12 +485,27 @@ BOOL LLGLSLShader::createShader(std::vector<LLStaticHashedString> * attributes,
     return success;
 }
 
-BOOL LLGLSLShader::attachObject(std::string object_path)
+BOOL LLGLSLShader::attachVertexObject(std::string object_path) {
+    if (LLShaderMgr::instance()->mVertexShaderObjects.count(object_path) > 0)
+    {
+        stop_glerror();
+        glAttachObjectARB(mProgramObject, LLShaderMgr::instance()->mVertexShaderObjects[object_path]);
+        stop_glerror();
+        return TRUE;
+    }
+    else
+    {
+        LL_SHADER_LOADING_WARNS() << "Attempting to attach shader object: '" << object_path << "' that hasn't been compiled." << LL_ENDL;
+        return FALSE;
+    }
+}
+
+BOOL LLGLSLShader::attachFragmentObject(std::string object_path)
 {
-    if (LLShaderMgr::instance()->mShaderObjects.count(object_path) > 0)
+    if (LLShaderMgr::instance()->mFragmentShaderObjects.count(object_path) > 0)
     {
         stop_glerror();
-        glAttachObjectARB(mProgramObject, LLShaderMgr::instance()->mShaderObjects[object_path]);
+        glAttachObjectARB(mProgramObject, LLShaderMgr::instance()->mFragmentShaderObjects[object_path]);
         stop_glerror();
         return TRUE;
     }
diff --git a/indra/llrender/llglslshader.h b/indra/llrender/llglslshader.h
index 974d0ea005..38dc980a97 100644
--- a/indra/llrender/llglslshader.h
+++ b/indra/llrender/llglslshader.h
@@ -102,7 +102,8 @@ public:
 						std::vector<LLStaticHashedString> * uniforms,
 						U32 varying_count = 0,
 						const char** varyings = NULL);
-	BOOL attachObject(std::string object);
+    BOOL attachFragmentObject(std::string object);
+    BOOL attachVertexObject(std::string object);
 	void attachObject(GLhandleARB object);
 	void attachObjects(GLhandleARB* objects = NULL, S32 count = 0);
 	BOOL mapAttributes(const std::vector<LLStaticHashedString> * attributes);
diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 4303c3ed11..27f9e36f0f 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -79,12 +79,12 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	{
 		if (features->hasWaterFog)
 		{
-			if (!shader->attachObject("windlight/atmosphericsVarsWaterV.glsl"))
+			if (!shader->attachVertexObject("windlight/atmosphericsVarsWaterV.glsl"))
 			{
 				return FALSE;
 			}
 		}
-		else if (!shader->attachObject("windlight/atmosphericsVarsV.glsl"))
+        else if (!shader->attachVertexObject("windlight/atmosphericsVarsV.glsl"))
 		{
 			return FALSE;
 		}
@@ -92,7 +92,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
 	if (features->calculatesLighting || features->calculatesAtmospherics)
 	{
-		if (!shader->attachObject("windlight/atmosphericsHelpersV.glsl"))
+		if (!shader->attachVertexObject("windlight/atmosphericsHelpersV.glsl"))
 		{
 			return FALSE;
 		}
@@ -102,40 +102,40 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	{
 		if (features->isSpecular)
 		{
-			if (!shader->attachObject("lighting/lightFuncSpecularV.glsl"))
+            if (!shader->attachVertexObject("lighting/lightFuncSpecularV.glsl"))
 			{
 				return FALSE;
 			}
 		
 			if (!features->isAlphaLighting)
 			{
-				if (!shader->attachObject("lighting/sumLightsSpecularV.glsl"))
+                if (!shader->attachVertexObject("lighting/sumLightsSpecularV.glsl"))
 				{
 					return FALSE;
 				}
 			}
 			
-			if (!shader->attachObject("lighting/lightSpecularV.glsl"))
+            if (!shader->attachVertexObject("lighting/lightSpecularV.glsl"))
 			{
 				return FALSE;
 			}
 		}
 		else 
 		{
-			if (!shader->attachObject("lighting/lightFuncV.glsl"))
+            if (!shader->attachVertexObject("lighting/lightFuncV.glsl"))
 			{
 				return FALSE;
 			}
 			
 			if (!features->isAlphaLighting)
 			{
-				if (!shader->attachObject("lighting/sumLightsV.glsl"))
+                if (!shader->attachVertexObject("lighting/sumLightsV.glsl"))
 				{
 					return FALSE;
 				}
 			}
 			
-			if (!shader->attachObject("lighting/lightV.glsl"))
+            if (!shader->attachVertexObject("lighting/lightV.glsl"))
 			{
 				return FALSE;
 			}
@@ -144,8 +144,12 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	
 	// NOTE order of shader object attaching is VERY IMPORTANT!!!
 	if (features->calculatesAtmospherics)
-	{
-		if (!shader->attachObject("windlight/atmosphericsV.glsl"))
+    {
+        if (!shader->attachVertexObject("windlight/atmosphericsFuncs.glsl")) {
+            return FALSE;
+        }
+
+        if (!shader->attachVertexObject("windlight/atmosphericsV.glsl"))
 		{
 			return FALSE;
 		}
@@ -153,7 +157,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
 	if (features->hasSkinning)
 	{
-		if (!shader->attachObject("avatar/avatarSkinV.glsl"))
+        if (!shader->attachVertexObject("avatar/avatarSkinV.glsl"))
 		{
 			return FALSE;
 		}
@@ -161,7 +165,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
 	if (features->hasObjectSkinning)
 	{
-		if (!shader->attachObject("avatar/objectSkinV.glsl"))
+        if (!shader->attachVertexObject("avatar/objectSkinV.glsl"))
 		{
 			return FALSE;
 		}
@@ -177,12 +181,12 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	{
 		if (features->hasWaterFog)
 		{
-			if (!shader->attachObject("windlight/atmosphericsVarsWaterF.glsl"))
+			if (!shader->attachFragmentObject("windlight/atmosphericsVarsWaterF.glsl"))
 			{
 				return FALSE;
 			}
 		}
-		else if (!shader->attachObject("windlight/atmosphericsVarsF.glsl"))
+        else if (!shader->attachFragmentObject("windlight/atmosphericsVarsF.glsl"))
 		{
 			return FALSE;
 		}
@@ -190,7 +194,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
     if (features->calculatesLighting || features->calculatesAtmospherics)
 	{
-		if (!shader->attachObject("windlight/atmosphericsHelpersF.glsl"))
+        if (!shader->attachFragmentObject("windlight/atmosphericsHelpersF.glsl"))
 		{
 			return FALSE;
 		}
@@ -199,7 +203,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
     // we want this BEFORE shadows and AO because those facilities use pos/norm access
     if (features->isDeferred)
 	{
-		if (!shader->attachObject("deferred/deferredUtil.glsl"))
+        if (!shader->attachFragmentObject("deferred/deferredUtil.glsl"))
 		{
 			return FALSE;
 		}
@@ -207,7 +211,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
     if (features->hasShadows)
 	{
-		if (!shader->attachObject("deferred/shadowUtil.glsl"))
+        if (!shader->attachFragmentObject("deferred/shadowUtil.glsl"))
 		{
 			return FALSE;
 		}
@@ -215,7 +219,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
     if (features->hasAmbientOcclusion)
 	{
-		if (!shader->attachObject("deferred/aoUtil.glsl"))
+        if (!shader->attachFragmentObject("deferred/aoUtil.glsl"))
 		{
 			return FALSE;
 		}
@@ -223,7 +227,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
     if (features->hasIndirect)
 	{
-		if (!shader->attachObject("deferred/indirect.glsl"))
+        if (!shader->attachFragmentObject("deferred/indirect.glsl"))
 		{
 			return FALSE;
 		}
@@ -231,7 +235,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
 	if (features->hasGamma)
 	{
-		if (!shader->attachObject("windlight/gammaF.glsl"))
+        if (!shader->attachFragmentObject("windlight/gammaF.glsl"))
 		{
 			return FALSE;
 		}
@@ -239,7 +243,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
 	if (features->hasSrgb)
 	{
-		if (!shader->attachObject("environment/srgbF.glsl"))
+        if (!shader->attachFragmentObject("environment/srgbF.glsl"))
 		{
 			return FALSE;
 		}
@@ -247,15 +251,19 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
     if (features->encodesNormal)
 	{
-		if (!shader->attachObject("environment/encodeNormF.glsl"))
+        if (!shader->attachFragmentObject("environment/encodeNormF.glsl"))
 		{
 			return FALSE;
 		}
 	}
 
 	if (features->hasAtmospherics)
-	{
-		if (!shader->attachObject("windlight/atmosphericsF.glsl"))
+    {
+        if (!shader->attachFragmentObject("windlight/atmosphericsFuncs.glsl")) {
+            return FALSE;
+        }
+
+        if (!shader->attachFragmentObject("windlight/atmosphericsF.glsl"))
 		{
 			return FALSE;
 		}
@@ -263,7 +271,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	
 	if (features->hasTransport)
 	{
-		if (!shader->attachObject("windlight/transportF.glsl"))
+        if (!shader->attachFragmentObject("windlight/transportF.glsl"))
 		{
 			return FALSE;
 		}
@@ -275,7 +283,7 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	// NOTE order of shader object attaching is VERY IMPORTANT!!!
 	if (features->hasWaterFog)
 	{
-		if (!shader->attachObject("environment/waterFogF.glsl"))
+        if (!shader->attachFragmentObject("environment/waterFogF.glsl"))
 		{
 			return FALSE;
 		}
@@ -289,14 +297,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 			{
 				if (features->hasAlphaMask)
 				{
-					if (!shader->attachObject("lighting/lightWaterAlphaMaskNonIndexedF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightWaterAlphaMaskNonIndexedF.glsl"))
 					{
 						return FALSE;
 					}
 				}
 				else
 				{
-					if (!shader->attachObject("lighting/lightWaterNonIndexedF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightWaterNonIndexedF.glsl"))
 					{
 						return FALSE;
 					}
@@ -306,14 +314,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 			{
 				if (features->hasAlphaMask)
 				{
-					if (!shader->attachObject("lighting/lightWaterAlphaMaskF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightWaterAlphaMaskF.glsl"))
 					{
 						return FALSE;
 					}
 				}
 				else
 				{
-					if (!shader->attachObject("lighting/lightWaterF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightWaterF.glsl"))
 					{
 						return FALSE;
 					}
@@ -328,14 +336,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 			{
 				if (features->hasAlphaMask)
 				{
-					if (!shader->attachObject("lighting/lightAlphaMaskNonIndexedF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightAlphaMaskNonIndexedF.glsl"))
 					{
 						return FALSE;
 					}
 				}
 				else
 				{
-					if (!shader->attachObject("lighting/lightNonIndexedF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightNonIndexedF.glsl"))
 					{
 						return FALSE;
 					}
@@ -345,14 +353,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 			{
 				if (features->hasAlphaMask)
 				{
-					if (!shader->attachObject("lighting/lightAlphaMaskF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightAlphaMaskF.glsl"))
 					{
 						return FALSE;
 					}
 				}
 				else
 				{
-					if (!shader->attachObject("lighting/lightF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightF.glsl"))
 					{
 						return FALSE;
 					}
@@ -370,14 +378,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 		{
 			if (features->disableTextureIndex)
 			{
-				if (!shader->attachObject("lighting/lightFullbrightShinyWaterNonIndexedF.glsl"))
+                if (!shader->attachFragmentObject("lighting/lightFullbrightShinyWaterNonIndexedF.glsl"))
 				{
 					return FALSE;
 				}
 			}
 			else 
 			{
-				if (!shader->attachObject("lighting/lightFullbrightShinyWaterF.glsl"))
+                if (!shader->attachFragmentObject("lighting/lightFullbrightShinyWaterF.glsl"))
 				{
 					return FALSE;
 				}
@@ -390,12 +398,12 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 			{
 				if (features->hasAlphaMask)
 				{
-					if (!shader->attachObject("lighting/lightFullbrightWaterNonIndexedAlphaMaskF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightFullbrightWaterNonIndexedAlphaMaskF.glsl"))
 					{
 						return FALSE;
 					}
 				}
-				else if (!shader->attachObject("lighting/lightFullbrightWaterNonIndexedF.glsl"))
+                else if (!shader->attachFragmentObject("lighting/lightFullbrightWaterNonIndexedF.glsl"))
 				{
 					return FALSE;
 				}
@@ -404,12 +412,12 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 			{
 				if (features->hasAlphaMask)
 				{
-					if (!shader->attachObject("lighting/lightFullbrightWaterAlphaMaskF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightFullbrightWaterAlphaMaskF.glsl"))
 					{
 						return FALSE;
 					}
 				}
-				else if (!shader->attachObject("lighting/lightFullbrightWaterF.glsl"))
+                else if (!shader->attachFragmentObject("lighting/lightFullbrightWaterF.glsl"))
 				{
 					return FALSE;
 				}
@@ -421,14 +429,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 		{
 			if (features->disableTextureIndex)
 			{
-				if (!shader->attachObject("lighting/lightFullbrightShinyNonIndexedF.glsl"))
+                if (!shader->attachFragmentObject("lighting/lightFullbrightShinyNonIndexedF.glsl"))
 				{
 					return FALSE;
 				}
 			}
 			else 
 			{
-				if (!shader->attachObject("lighting/lightFullbrightShinyF.glsl"))
+                if (!shader->attachFragmentObject("lighting/lightFullbrightShinyF.glsl"))
 				{
 					return FALSE;
 				}
@@ -443,14 +451,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
 				if (features->hasAlphaMask)
 				{
-					if (!shader->attachObject("lighting/lightFullbrightNonIndexedAlphaMaskF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightFullbrightNonIndexedAlphaMaskF.glsl"))
 					{
 						return FALSE;
 					}
 				}
 				else
 				{
-					if (!shader->attachObject("lighting/lightFullbrightNonIndexedF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightFullbrightNonIndexedF.glsl"))
 					{
 						return FALSE;
 					}
@@ -460,14 +468,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 			{
 				if (features->hasAlphaMask)
 				{
-					if (!shader->attachObject("lighting/lightFullbrightAlphaMaskF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightFullbrightAlphaMaskF.glsl"))
 					{
 						return FALSE;
 					}
 				}
 				else
 				{
-					if (!shader->attachObject("lighting/lightFullbrightF.glsl"))
+                    if (!shader->attachFragmentObject("lighting/lightFullbrightF.glsl"))
 					{
 						return FALSE;
 					}
@@ -485,14 +493,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 		{
 			if (features->disableTextureIndex)
 			{
-				if (!shader->attachObject("lighting/lightShinyWaterNonIndexedF.glsl"))
+                if (!shader->attachFragmentObject("lighting/lightShinyWaterNonIndexedF.glsl"))
 				{
 					return FALSE;
 				}
 			}
 			else 
 			{
-				if (!shader->attachObject("lighting/lightShinyWaterF.glsl"))
+                if (!shader->attachFragmentObject("lighting/lightShinyWaterF.glsl"))
 				{
 					return FALSE;
 				}
@@ -504,14 +512,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 		{
 			if (features->disableTextureIndex)
 			{
-				if (!shader->attachObject("lighting/lightShinyNonIndexedF.glsl"))
+                if (!shader->attachFragmentObject("lighting/lightShinyNonIndexedF.glsl"))
 				{
 					return FALSE;
 				}
 			}
 			else 
 			{
-				if (!shader->attachObject("lighting/lightShinyF.glsl"))
+                if (!shader->attachFragmentObject("lighting/lightShinyF.glsl"))
 				{
 					return FALSE;
 				}
@@ -522,14 +530,14 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
 	if (features->mIndexedTextureChannels <= 1)
 	{
-		if (!shader->attachObject("objects/nonindexedTextureV.glsl"))
+		if (!shader->attachVertexObject("objects/nonindexedTextureV.glsl"))
 		{
 			return FALSE;
 		}
 	}
 	else
 	{
-		if (!shader->attachObject("objects/indexedTextureV.glsl"))
+        if (!shader->attachVertexObject("objects/indexedTextureV.glsl"))
 		{
 			return FALSE;
 		}
@@ -999,7 +1007,12 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 	if (ret)
 	{
 		// Add shader file to map
-		mShaderObjects[filename] = ret;
+        if (type == GL_VERTEX_SHADER_ARB) {
+            mVertexShaderObjects[filename] = ret;
+        }
+        else if (type == GL_FRAGMENT_SHADER_ARB) {
+            mFragmentShaderObjects[filename] = ret;
+        }
 		shader_level = try_gpu_class;
 	}
 	else
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index e0a67e6198..98caa9295e 100644
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -275,7 +275,8 @@ public:
 
 public:
 	// Map of shader names to compiled
-	std::map<std::string, GLhandleARB> mShaderObjects;
+    std::map<std::string, GLhandleARB> mVertexShaderObjects;
+    std::map<std::string, GLhandleARB> mFragmentShaderObjects;
 
 	//global (reserved slot) shader parameters
 	std::vector<std::string> mReservedAttribs;
diff --git a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
index 4fe0d1351d..ca82dd9432 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
@@ -77,7 +77,7 @@ vec2 encode_normal (vec3 n);
 vec3 scaleSoftClipFrag(vec3 l);
 vec3 atmosFragLighting(vec3 light, vec3 additive, vec3 atten);
 
-void calcFragAtmospherics(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 atten, out vec3 additive);
+void calcAtmosphericVars(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 atten, out vec3 additive);
 
 #ifdef HAS_SHADOW
 float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen);
@@ -184,7 +184,7 @@ void main()
     vec3 additive;
     vec3 atten;
 
-    calcFragAtmospherics(pos.xyz, 1.0, sunlit, amblit, additive, atten);
+    calcAtmosphericVars(pos.xyz, 1.0, sunlit, amblit, additive, atten);
 
     vec2 abnormal = encode_normal(norm.xyz);
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
index d5ef010017..f98fc0d518 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
@@ -45,6 +45,9 @@ VARYING vec2 vary_texcoord0;
 vec4 applyWaterFogView(vec3 pos, vec4 color);
 #endif
 
+vec3 fullbrightAtmosTransport(vec3 light);
+vec3 fullbrightScaleSoftClip(vec3 light);
+
 #ifdef HAS_ALPHA_MASK
 uniform float minimum_alpha;
 #endif
@@ -74,6 +77,8 @@ void main()
 	color.rgb = fogged.rgb;
 	color.a   = fogged.a;
 #else
+	color.rgb = fullbrightAtmosTransport(color.rgb);
+	color.rgb = fullbrightScaleSoftClip(color.rgb);
 	color.a   = final_alpha;
 #endif
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
index 6d7162b5a2..9b07c11361 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
@@ -41,7 +41,7 @@ vec4 applyWaterFogView(vec3 pos, vec4 color);
 vec3 atmosFragLighting(vec3 l, vec3 additive, vec3 atten);
 vec3 scaleSoftClipFrag(vec3 l);
 
-void calcFragAtmospherics(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten);
+void calcAtmosphericVars(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten);
 
 vec3 srgb_to_linear(vec3 cs);
 vec3 linear_to_srgb(vec3 cs);
@@ -290,7 +290,7 @@ void main()
     vec3 additive;
     vec3 atten;
 
-    calcFragAtmospherics(pos.xyz, 1.0, sunlit, amblit, additive, atten);
+    calcAtmosphericVars(pos.xyz, 1.0, sunlit, amblit, additive, atten);
 
     vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
index 4b9e8290dd..ff30004ffd 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
@@ -71,7 +71,7 @@ vec3 getNorm(vec2 pos_screen);
 vec3 atmosFragLighting(vec3 l, vec3 additive, vec3 atten);
 vec3 fullbrightAtmosTransportFrag(vec3 l, vec3 additive, vec3 atten);
 
-void calcFragAtmospherics(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten);
+void calcAtmosphericVars(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten);
 
 vec3 scaleSoftClipFrag(vec3 l);
 
@@ -107,8 +107,8 @@ void main()
         vec3 additive;
         vec3 atten;
 
-        calcFragAtmospherics(pos.xyz, 1.0, sunlit, amblit, additive, atten);
-
+        calcAtmosphericVars(pos.xyz, 1.0, sunlit, amblit, additive, atten);
+        sunlit *= 0.5;
         float ambient = da;
         ambient *= 0.5;
         ambient *= ambient;
@@ -166,7 +166,7 @@ vec3 post_diffuse = col.rgb;
             col = mix(col.rgb, refcol, envIntensity); 
         }
                 
-        if (norm.w < 0.5)
+        if (norm.w < 1)
         {
             col = atmosFragLighting(col, additive, atten);
             col = scaleSoftClipFrag(col);
diff --git a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsFuncs.glsl b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsFuncs.glsl
new file mode 100644
index 0000000000..a099083883
--- /dev/null
+++ b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsFuncs.glsl
@@ -0,0 +1,116 @@
+uniform vec4 gamma;

+uniform vec4 lightnorm;

+uniform vec4 sunlight_color;

+uniform vec4 moonlight_color;

+uniform int sun_up_factor;

+uniform vec4 ambient;

+uniform vec4 blue_horizon;

+uniform vec4 blue_density;

+uniform float haze_horizon;

+uniform float haze_density;

+uniform float cloud_shadow;

+uniform float density_multiplier;

+uniform float distance_multiplier;

+uniform float max_y;

+uniform vec4 glow;

+uniform float scene_light_strength;

+uniform mat3 ssao_effect_mat;

+uniform int no_atmo;

+uniform float sun_moon_glow_factor;

+

+vec3 nothing() {

+    return vec3(0, 0, 0);

+}

+

+void calcAtmosphericVars(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten) {

+

+    vec3 P = inPositionEye;

+   

+    //(TERRAIN) limit altitude

+    if (P.y > max_y) P *= (max_y / P.y);

+    if (P.y < -max_y) P *= (-max_y / P.y); 

+

+    vec3 tmpLightnorm = lightnorm.xyz;

+

+    vec3 Pn = normalize(P);

+    float Plen = length(P);

+

+    vec4 temp1 = vec4(0);

+    vec3 temp2 = vec3(0);

+    vec4 blue_weight;

+    vec4 haze_weight;

+    vec4 sunlight = (sun_up_factor == 1) ? sunlight_color : moonlight_color;

+    vec4 light_atten;

+

+    //sunlight attenuation effect (hue and brightness) due to atmosphere

+    //this is used later for sunlight modulation at various altitudes

+    light_atten = (blue_density + vec4(haze_density * 0.25)) * (density_multiplier * max_y);

+        //I had thought blue_density and haze_density should have equal weighting,

+        //but attenuation due to haze_density tends to seem too strong

+

+    temp1 = blue_density + vec4(haze_density);

+    blue_weight = blue_density / temp1;

+    haze_weight = vec4(haze_density) / temp1;

+

+    //(TERRAIN) compute sunlight from lightnorm only (for short rays like terrain)

+    temp2.y = max(0.0, tmpLightnorm.y);

+    if (temp2.y > 0.001f)

+    {

+        temp2.y = 1. / temp2.y;

+    }

+    temp2.y = max(0.001f, temp2.y);

+    sunlight *= exp(-light_atten * temp2.y);

+

+    // main atmospheric scattering line integral

+    temp2.z = Plen * density_multiplier;

+

+    // Transparency (-> temp1)

+    // ATI Bugfix -- can't store temp1*temp2.z*distance_multiplier in a variable because the ati

+    // compiler gets confused.

+    temp1 = exp(-temp1 * temp2.z * distance_multiplier);

+

+    //final atmosphere attenuation factor

+    atten = temp1.rgb;

+    

+    //compute haze glow

+    //(can use temp2.x as temp because we haven't used it yet)

+    temp2.x = dot(Pn, tmpLightnorm.xyz);

+    temp2.x = 1. - temp2.x;

+        //temp2.x is 0 at the sun and increases away from sun

+    temp2.x = max(temp2.x, .001);    //was glow.y

+        //set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)

+    temp2.x *= glow.x;

+        //higher glow.x gives dimmer glow (because next step is 1 / "angle")

+    temp2.x = pow(temp2.x, glow.z);

+        //glow.z should be negative, so we're doing a sort of (1 / "angle") function

+

+    //add "minimum anti-solar illumination"

+    temp2.x += .25;

+

+    temp2.x *= sun_moon_glow_factor;

+    

+    //increase ambient when there are more clouds

+    vec4 tmpAmbient = ambient + (vec4(1.) - ambient) * cloud_shadow * 0.5;

+    

+    /*  decrease value and saturation (that in HSV, not HSL) for occluded areas

+     * // for HSV color/geometry used here, see http://gimp-savvy.com/BOOK/index.html?node52.html

+     * // The following line of code performs the equivalent of:

+     * float ambAlpha = tmpAmbient.a;

+     * float ambValue = dot(vec3(tmpAmbient), vec3(0.577)); // projection onto <1/rt(3), 1/rt(3), 1/rt(3)>, the neutral white-black axis

+     * vec3 ambHueSat = vec3(tmpAmbient) - vec3(ambValue);

+     * tmpAmbient = vec4(RenderSSAOEffect.valueFactor * vec3(ambValue) + RenderSSAOEffect.saturationFactor *(1.0 - ambFactor) * ambHueSat, ambAlpha);

+     */

+    tmpAmbient = vec4(mix(ssao_effect_mat * tmpAmbient.rgb, tmpAmbient.rgb, ambFactor), tmpAmbient.a);

+

+    //haze color

+        additive =

+        vec3(blue_horizon * blue_weight * (sunlight*(1.-cloud_shadow) + tmpAmbient)

+      + (haze_horizon * haze_weight) * (sunlight*(1.-cloud_shadow) * temp2.x

+          + tmpAmbient));

+

+    //brightness of surface both sunlight and ambient

+    sunlit = sunlight.rgb;

+    amblit = tmpAmbient.rgb * .25;

+    additive  = normalize(additive);

+    additive *= vec3(1.0 - exp(-temp2.z * distance_multiplier)) * 0.5;

+}
\ No newline at end of file
diff --git a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
index 8814587fbc..d87b2560ce 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
@@ -67,11 +67,12 @@ uniform vec2 screen_res;
 
 vec3 getNorm(vec2 pos_screen);
 
-void calcFragAtmospherics(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten);
 vec3 atmosFragLighting(vec3 l, vec3 additive, vec3 atten);
 vec3 fullbrightScaleSoftClipFrag(vec3 l, vec3 add, vec3 atten);
 vec3 scaleSoftClipFrag(vec3 l);
 
+void calcAtmosphericVars(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten);
+
 vec3 atmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
 vec3 fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
 vec3 fullbrightShinyAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
@@ -79,6 +80,8 @@ vec3 fullbrightShinyAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
 vec4 getPositionWithDepth(vec2 pos_screen, float depth);
 vec4 getPosition(vec2 pos_screen);
 
+vec3 nothing();
+
 #ifdef WATER_FOG
 vec4 applyWaterFogView(vec3 pos, vec4 color);
 #endif
@@ -121,8 +124,8 @@ void main()
         vec3 additive;
         vec3 atten;
     
-        calcFragAtmospherics(pos.xyz, ambocc, sunlit, amblit, additive, atten);
-
+        calcAtmosphericVars(pos.xyz, ambocc, sunlit, amblit, additive, atten);
+        sunlit *= 0.5;
         float ambient = da;
         ambient *= 0.5;
         ambient *= ambient;
@@ -180,7 +183,7 @@ vec3 post_diffuse = col.rgb;
             col = mix(col.rgb, refcol, envIntensity); 
         }
         
-        if (norm.w < 0.5)
+        if (norm.w < 1)
         {
             //col = mix(atmosFragLighting(col, additive, atten), fullbrightAtmosTransportFrag(col, additive, atten), diffuse.a);
             //col = mix(scaleSoftClipFrag(col), fullbrightScaleSoftClipFrag(col, additive, atten), diffuse.a);
diff --git a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsV.glsl b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsV.glsl
index 6c4098b9fb..ac7931209e 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsV.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsV.glsl
@@ -34,128 +34,20 @@ void setPositionEye(vec3 v);
 
 vec3 getAdditiveColor();
 
-//VARYING vec4 vary_CloudUVs;
-//VARYING float vary_CloudDensity;
-
-// Inputs
-uniform vec4 morphFactor;
-uniform vec3 camPosLocal;
-//uniform vec4 camPosWorld;
-
-uniform vec4 lightnorm;
-uniform vec4 sunlight_color;
-uniform vec4 moonlight_color;
-uniform int sun_up_factor;
-uniform vec4 ambient;
-uniform vec4 blue_horizon;
-uniform vec4 blue_density;
-uniform float haze_horizon;
-uniform float haze_density;
-uniform float cloud_shadow;
-uniform float density_multiplier;
-uniform float distance_multiplier;
-uniform float max_y;
-uniform vec4 glow;
-uniform float sun_moon_glow_factor;
+void calcAtmosphericVars(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten);
 
 void calcAtmospherics(vec3 inPositionEye) {
 
     vec3 P = inPositionEye;
     setPositionEye(P);
-    
-    //(TERRAIN) limit altitude
-    if (P.y > max_y) P *= (max_y / P.y);
-    if (P.y < -max_y) P *= (-max_y / P.y);
-
-    vec3 tmpLightnorm = lightnorm.xyz;
-
-    vec3 Pn = normalize(P);
-    float  Plen = length(P);
-
-    vec4 temp1 = vec4(0);
-    vec3 temp2 = vec3(0);
-    vec4 blue_weight;
-    vec4 haze_weight;
-    vec4 sunlight = (sun_up_factor == 1) ? sunlight_color : moonlight_color;
-    vec4 light_atten;
-
-    //sunlight attenuation effect (hue and brightness) due to atmosphere
-    //this is used later for sunlight modulation at various altitudes
-    light_atten = (blue_density + vec4(haze_density * 0.25)) * (density_multiplier * max_y);
-        //I had thought blue_density and haze_density should have equal weighting,
-        //but attenuation due to haze_density tends to seem too strong
-
-    temp1 = blue_density + vec4(haze_density);
-    blue_weight = blue_density / temp1;
-    haze_weight = vec4(haze_density) / temp1;
-
-    //(TERRAIN) compute sunlight from lightnorm only (for short rays like terrain)
-    temp2.y = max(0.0, tmpLightnorm.y);
-    if (temp2.y > 0.001f)
-    {
-        temp2.y = 1. / temp2.y;
-    }
-    temp2.y = max(0.001f, temp2.y);
-    sunlight *= exp( - light_atten * temp2.y);
-
-    // main atmospheric scattering line integral
-    temp2.z = Plen * density_multiplier;
-
-    // Transparency (-> temp1)
-    // ATI Bugfix -- can't store temp1*temp2.z*distance_multiplier in a variable because the ati
-    // compiler gets confused.
-    temp1 = exp(-temp1 * temp2.z * distance_multiplier);
-
-    //final atmosphere attenuation factor
-    setAtmosAttenuation(temp1.rgb);
-    //vary_AtmosAttenuation = distance_multiplier / 10000.;
-    //vary_AtmosAttenuation = density_multiplier * 100.;
-    //vary_AtmosAttenuation = vec4(Plen / 100000., 0., 0., 1.);
-
-    //compute haze glow
-    //(can use temp2.x as temp because we haven't used it yet)
-    temp2.x = dot(Pn, tmpLightnorm.xyz);
-    temp2.x = 1. - temp2.x;
-        //temp2.x is 0 at the sun and increases away from sun
-    temp2.x = max(temp2.x, .03);    //was glow.y
-        //set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
-    temp2.x *= glow.x;
-        //higher glow.x gives dimmer glow (because next step is 1 / "angle")
-    temp2.x = pow(temp2.x, glow.z);
-        //glow.z should be negative, so we're doing a sort of (1 / "angle") function
-
-    temp2.x *= sun_moon_glow_factor;
-
-    //add "minimum anti-solar illumination"
-    temp2.x += .25;
-
-    //increase ambient when there are more clouds
-    vec4 tmpAmbient = ambient + (vec4(1.) - ambient) * cloud_shadow * 0.5;
-
-    vec3 additive = 
-        vec3(blue_horizon * blue_weight * (sunlight*(1.-cloud_shadow) + tmpAmbient)
-      + (haze_horizon * haze_weight) * (sunlight*(1.-cloud_shadow) * temp2.x
-          + tmpAmbient));
-    additive = normalize(additive);
-
-    //brightness of surface both sunlight and ambient
-    setSunlitColor(vec3(sunlight * .5));
-    setAmblitColor(vec3(tmpAmbient * .25));
-    setAdditiveColor(additive * vec3(1.0 - exp(-temp2.z * distance_multiplier)) * 0.5);
-
-    /*
-    const float cloudShadowScale = 100.;
-    // Get cloud uvs for shadowing
-    vec3 cloudPos = inPositionEye + camPosWorld - cloudShadowScale / 2.;
-    vary_CloudUVs.xy = cloudPos.xz / cloudShadowScale;
-
-    // We can take uv1 and multiply it by (TerrainSpan / CloudSpan)
-//  cloudUVs *= (((worldMaxZ - worldMinZ) * 20) /40000.);
-    vary_CloudUVs *= (10000./40000.);
-
-    // Offset by sun vector * (CloudAltitude / CloudSpan)
-    vary_CloudUVs.x += tmpLightnorm.x / tmpLightnorm.y * (3000./40000.);
-    vary_CloudUVs.y += tmpLightnorm.z / tmpLightnorm.y * (3000./40000.);
-    */
+    vec3 tmpsunlit = vec3(1);
+    vec3 tmpamblit = vec3(1);
+    vec3 tmpaddlit = vec3(1);
+    vec3 tmpattenlit = vec3(1);
+    calcAtmosphericVars(inPositionEye, 1, tmpsunlit, tmpamblit, tmpaddlit, tmpattenlit);
+    setSunlitColor(tmpsunlit);
+    setAmblitColor(tmpamblit);
+    setAdditiveColor(tmpaddlit);
+    setAtmosAttenuation(tmpattenlit);
 }
 
diff --git a/indra/newview/app_settings/shaders/class3/windlight/atmosphericsV.glsl b/indra/newview/app_settings/shaders/class3/windlight/atmosphericsV.glsl
index 9bd75cf118..b8c0547102 100644
--- a/indra/newview/app_settings/shaders/class3/windlight/atmosphericsV.glsl
+++ b/indra/newview/app_settings/shaders/class3/windlight/atmosphericsV.glsl
@@ -32,104 +32,20 @@ void setPositionEye(vec3 v);
 
 vec3 getAdditiveColor();
 
-// Inputs
-uniform vec4 morphFactor;
-uniform vec3 camPosLocal;
-
-uniform vec4 lightnorm;
-uniform vec4 sunlight_color;
-uniform vec4 moonlight_color;
-uniform int sun_up_factor;
-uniform vec4 ambient;
-uniform vec4 blue_horizon;
-uniform vec4 blue_density;
-uniform float haze_horizon;
-uniform float haze_density;
-uniform float cloud_shadow;
-uniform float density_multiplier;
-uniform float distance_multiplier;
-uniform float max_y;
-uniform vec4 glow;
+void calcAtmosphericVars(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten);
 
 void calcAtmospherics(vec3 inPositionEye) {
 
-	vec3 P = inPositionEye;
-	setPositionEye(P);
-	
-	vec3 tmpLightnorm = lightnorm.xyz;
-
-	vec3 Pn = normalize(P);
-	float Plen = length(P);
-
-	vec4 temp1 = vec4(0);
-	vec3 temp2 = vec3(0);
-	vec4 blue_weight;
-	vec4 haze_weight;
-	vec4 sunlight = (sun_up_factor == 1) ? sunlight_color : moonlight_color;
-	vec4 light_atten;
-
-	//sunlight attenuation effect (hue and brightness) due to atmosphere
-	//this is used later for sunlight modulation at various altitudes
-	light_atten = (blue_density + vec4(haze_density * 0.25)) * (density_multiplier * max_y);
-		//I had thought blue_density and haze_density should have equal weighting,
-		//but attenuation due to haze_density tends to seem too strong
-
-	temp1 = blue_density + vec4(haze_density);
-	blue_weight = blue_density / temp1;
-	haze_weight = vec4(haze_density) / temp1;
-
-	//(TERRAIN) compute sunlight from lightnorm only (for short rays like terrain)
-	temp2.y = max(0.0, tmpLightnorm.y);
-	temp2.y = 1. / temp2.y;
-	sunlight *= exp( - light_atten * temp2.y);
-
-	// main atmospheric scattering line integral
-	temp2.z = Plen * density_multiplier;
-
-	// Transparency (-> temp1)
-	// ATI Bugfix -- can't store temp1*temp2.z*distance_multiplier in a variable because the ati
-	// compiler gets confused.
-	temp1 = exp(-temp1 * temp2.z * distance_multiplier);
-
-	//final atmosphere attenuation factor
-	setAtmosAttenuation(temp1.rgb);
-	
-	//compute haze glow
-	//(can use temp2.x as temp because we haven't used it yet)
-	temp2.x = dot(Pn, tmpLightnorm.xyz);
-	temp2.x = 1. - temp2.x;
-		//temp2.x is 0 at the sun and increases away from sun
-	temp2.x = max(temp2.x, .03);	//was glow.y
-		//set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
-	temp2.x *= glow.x;
-		//higher glow.x gives dimmer glow (because next step is 1 / "angle")
-	temp2.x = pow(temp2.x, glow.z);
-		//glow.z should be negative, so we're doing a sort of (1 / "angle") function
-
-	//add "minimum anti-solar illumination"
-	temp2.x += .25;
-	
-	//increase ambient when there are more clouds
-	vec4 tmpAmbient = ambient + (vec4(1.) - ambient) * cloud_shadow * 0.5;
-	
-	/*  decrease value and saturation (that in HSV, not HSL) for occluded areas
-	 * // for HSV color/geometry used here, see http://gimp-savvy.com/BOOK/index.html?node52.html
-	 * // The following line of code performs the equivalent of:
-	 * float ambAlpha = tmpAmbient.a;
-	 * float ambValue = dot(vec3(tmpAmbient), vec3(0.577)); // projection onto <1/rt(3), 1/rt(3), 1/rt(3)>, the neutral white-black axis
-	 * vec3 ambHueSat = vec3(tmpAmbient) - vec3(ambValue);
-	 * tmpAmbient = vec4(RenderSSAOEffect.valueFactor * vec3(ambValue) + RenderSSAOEffect.saturationFactor *(1.0 - ambFactor) * ambHueSat, ambAlpha);
-	 */
-	//tmpAmbient = vec4(mix(ssao_effect_mat * tmpAmbient.rgb, tmpAmbient.rgb, ambFactor), tmpAmbient.a);
-
-	//haze color
-	setAdditiveColor(
-		vec3(blue_horizon * blue_weight * (sunlight*(1.-cloud_shadow) + tmpAmbient)
-	  + (haze_horizon * haze_weight) * (sunlight*(1.-cloud_shadow) * temp2.x
-		  + tmpAmbient)));
-
-	//brightness of surface both sunlight and ambient
-	setSunlitColor(vec3(sunlight * .5));
-	setAmblitColor(vec3(tmpAmbient * .25));
-	setAdditiveColor(getAdditiveColor() * vec3(1.0 - temp1));
+    vec3 P = inPositionEye;
+    setPositionEye(P);
+    vec3 tmpsunlit = vec3(1);
+    vec3 tmpamblit = vec3(1);
+    vec3 tmpaddlit = vec3(1);
+    vec3 tmpattenlit = vec3(1);
+    calcAtmosphericVars(inPositionEye, 1, tmpsunlit, tmpamblit, tmpaddlit, tmpattenlit);
+    setSunlitColor(tmpsunlit);
+    setAmblitColor(tmpamblit);
+    setAdditiveColor(tmpaddlit);
+    setAtmosAttenuation(tmpattenlit);
 }
+
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index cf0cd693ae..1b1759aeaf 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -424,7 +424,8 @@ void LLViewerShaderMgr::setShaders()
 	LLShaderMgr::instance()->mDefinitions["NUM_TEX_UNITS"] = llformat("%d", gGLManager.mNumTextureImageUnits);
 	
 	// Make sure the compiled shader map is cleared before we recompile shaders.
-	mShaderObjects.clear();
+    mVertexShaderObjects.clear();
+    mFragmentShaderObjects.clear();
 	
 	initAttribsAndUniforms();
 	gPipeline.releaseGLBuffers();
@@ -938,6 +939,7 @@ BOOL LLViewerShaderMgr::loadBasicShaders()
 	shaders.push_back( make_pair( "lighting/lightFuncSpecularV.glsl",       mShaderLevel[SHADER_LIGHTING] ) );
 	shaders.push_back( make_pair( "lighting/sumLightsSpecularV.glsl",       sum_lights_class ) );
 	shaders.push_back( make_pair( "lighting/lightSpecularV.glsl",           mShaderLevel[SHADER_LIGHTING] ) );
+    shaders.push_back( make_pair( "windlight/atmosphericsFuncs.glsl",       mShaderLevel[SHADER_WINDLIGHT] ) );
 	shaders.push_back( make_pair( "windlight/atmosphericsV.glsl",           mShaderLevel[SHADER_WINDLIGHT] ) );
 	shaders.push_back( make_pair( "avatar/avatarSkinV.glsl",                1 ) );
 	shaders.push_back( make_pair( "avatar/objectSkinV.glsl",                1 ) );
@@ -978,6 +980,7 @@ BOOL LLViewerShaderMgr::loadBasicShaders()
 	index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/atmosphericsVarsWaterF.glsl",     mShaderLevel[SHADER_WINDLIGHT] ) );
 	index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/atmosphericsHelpersF.glsl",       mShaderLevel[SHADER_WINDLIGHT] ) );
 	index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/gammaF.glsl",                 mShaderLevel[SHADER_WINDLIGHT]) );
+    index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/atmosphericsFuncs.glsl",       mShaderLevel[SHADER_WINDLIGHT] ) );
 	index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/atmosphericsF.glsl",          mShaderLevel[SHADER_WINDLIGHT] ) );
 	index_channels.push_back(-1);    shaders.push_back( make_pair( "windlight/transportF.glsl",             mShaderLevel[SHADER_WINDLIGHT] ) ); 
 	index_channels.push_back(-1);    shaders.push_back( make_pair( "environment/waterFogF.glsl",                mShaderLevel[SHADER_WATER] ) );
@@ -1006,7 +1009,7 @@ BOOL LLViewerShaderMgr::loadBasicShaders()
 	index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightWaterAlphaMaskF.glsl",    mShaderLevel[SHADER_LIGHTING] ) );
 	index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightFullbrightWaterF.glsl",   mShaderLevel[SHADER_LIGHTING] ) );
 	index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightFullbrightWaterAlphaMaskF.glsl",  mShaderLevel[SHADER_LIGHTING] ) );
-	index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightShinyF.glsl",             mShaderLevel[SHADER_LIGHTING] ) );
+	index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightShinyF.glsl",             mShaderLevel[SHADER_LIGHTING] ) ); 
 	index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightFullbrightShinyF.glsl",   mShaderLevel[SHADER_LIGHTING] ) );
 	index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightShinyWaterF.glsl",            mShaderLevel[SHADER_LIGHTING] ) );
     index_channels.push_back(ch);    shaders.push_back( make_pair( "lighting/lightFullbrightShinyWaterF.glsl", mShaderLevel[SHADER_LIGHTING] ) );