Merge branch 'master' into DRTVWR-507-maint

1 files changed, 248 insertions, 128 deletions

diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index 643c368870..1383020873 100644
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -25,22 +25,14 @@
  */
 
 #include "linden_common.h"
-
 #include "llshadermgr.h"
-
-#include "llfile.h"
 #include "llrender.h"
+#include "llfile.h"
 
 #if LL_DARWIN
 #include "OpenGL/OpenGL.h"
 #endif
 
-#ifdef LL_RELEASE_FOR_DOWNLOAD
-#define UNIFORM_ERRS LL_WARNS_ONCE("Shader")
-#else
-#define UNIFORM_ERRS LL_ERRS("Shader")
-#endif
-
 // Lots of STL stuff in here, using namespace std to keep things more readable
 using std::vector;
 using std::pair;
@@ -87,20 +79,20 @@ 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;
 		}
 	}
 
-	if (features->calculatesLighting || features->atmosphericHelpers)
+	if (features->calculatesLighting || features->calculatesAtmospherics)
 	{
-		if (!shader->attachObject("windlight/atmosphericsHelpersV.glsl"))
+		if (!shader->attachVertexObject("windlight/atmosphericsHelpersV.glsl"))
 		{
 			return FALSE;
 		}
@@ -110,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;
 			}
@@ -152,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;
 		}
@@ -161,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;
 		}
@@ -169,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;
 		}
@@ -179,33 +175,95 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 	// Attach Fragment Shader Features Next
 	///////////////////////////////////////
 
+// NOTE order of shader object attaching is VERY IMPORTANT!!!
+
 	if(features->calculatesAtmospherics)
 	{
 		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;
+		}
+	}
+
+    if (features->calculatesLighting || features->calculatesAtmospherics)
+	{
+        if (!shader->attachFragmentObject("windlight/atmosphericsHelpersF.glsl"))
+		{
+			return FALSE;
+		}
+	}
+
+    // we want this BEFORE shadows and AO because those facilities use pos/norm access
+    if (features->isDeferred)
+	{
+        if (!shader->attachFragmentObject("deferred/deferredUtil.glsl"))
+		{
+			return FALSE;
+		}
+	}
+
+    if (features->hasShadows)
+	{
+        if (!shader->attachFragmentObject("deferred/shadowUtil.glsl"))
+		{
+			return FALSE;
+		}
+	}
+
+    if (features->hasAmbientOcclusion)
+	{
+        if (!shader->attachFragmentObject("deferred/aoUtil.glsl"))
+		{
+			return FALSE;
+		}
+	}
+
+    if (features->hasIndirect)
+	{
+        if (!shader->attachFragmentObject("deferred/indirect.glsl"))
 		{
 			return FALSE;
 		}
 	}
 
-	// NOTE order of shader object attaching is VERY IMPORTANT!!!
 	if (features->hasGamma)
 	{
-		if (!shader->attachObject("windlight/gammaF.glsl"))
+        if (!shader->attachFragmentObject("windlight/gammaF.glsl"))
 		{
 			return FALSE;
 		}
 	}
-	
-	if (features->hasAtmospherics)
+
+	if (features->hasSrgb)
 	{
-		if (!shader->attachObject("windlight/atmosphericsF.glsl"))
+        if (!shader->attachFragmentObject("environment/srgbF.glsl"))
+		{
+			return FALSE;
+		}
+	}
+
+    if (features->encodesNormal)
+	{
+        if (!shader->attachFragmentObject("environment/encodeNormF.glsl"))
+		{
+			return FALSE;
+		}
+	}
+
+	if (features->hasAtmospherics)
+    {
+        if (!shader->attachFragmentObject("windlight/atmosphericsFuncs.glsl")) {
+            return FALSE;
+        }
+
+        if (!shader->attachFragmentObject("windlight/atmosphericsF.glsl"))
 		{
 			return FALSE;
 		}
@@ -213,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;
 		}
@@ -225,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;
 		}
@@ -239,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;
 					}
@@ -256,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;
 					}
@@ -278,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;
 					}
@@ -295,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;
 					}
@@ -320,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;
 				}
@@ -340,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;
 				}
@@ -354,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;
 				}
@@ -371,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;
 				}
@@ -393,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;
 					}
@@ -410,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;
 					}
@@ -435,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;
 				}
@@ -454,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;
 				}
@@ -472,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;
 		}
@@ -509,31 +567,56 @@ static std::string get_object_log(GLhandleARB ret)
 	return res;
 }
 
+//dump shader source for debugging
+void LLShaderMgr::dumpShaderSource(U32 shader_code_count, GLcharARB** shader_code_text)
+{
+	char num_str[16]; // U32 = max 10 digits
+
+	LL_SHADER_LOADING_WARNS() << "\n";
+
+	for (U32 i = 0; i < shader_code_count; i++)
+	{
+		snprintf(num_str, sizeof(num_str), "%4d: ", i+1);
+		std::string line_number(num_str);
+		LL_CONT << line_number << shader_code_text[i];
+	}
+    LL_CONT << LL_ENDL;
+}
+
 void LLShaderMgr::dumpObjectLog(GLhandleARB ret, BOOL warns, const std::string& filename) 
 {
 	std::string log = get_object_log(ret);
+    std::string fname = filename;
+    if (filename.empty())
+    {
+        fname = "unknown shader file";
+    }
 
-	if (log.length() > 0 || warns)
+	if (log.length() > 0)
 	{
-        LL_DEBUGS("ShaderLoading") << "Shader loading ";
-        
-		if (!filename.empty())
-		{
-            LL_CONT << "From " << filename << ":\n";
-		}
-        LL_CONT << log << LL_ENDL;
+        LL_SHADER_LOADING_WARNS() << "Shader loading from " << fname << LL_ENDL;
+        LL_SHADER_LOADING_WARNS() << "\n" << log << LL_ENDL;
 	}
  }
 
 GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type, boost::unordered_map<std::string, std::string>* defines, S32 texture_index_channels)
 {
+
+// endsure work-around for missing GLSL funcs gets propogated to feature shader files (e.g. srgbF.glsl)
+#if LL_DARWIN
+    if (defines)
+    {
+        (*defines)["OLD_SELECT"] = "1";
+    }
+#endif
+
 	GLenum error = GL_NO_ERROR;
 	if (gDebugGL)
 	{
 		error = glGetError();
 		if (error != GL_NO_ERROR)
 		{
-			LL_WARNS("ShaderLoading") << "GL ERROR entering loadShaderFile(): " << error << LL_ENDL;
+			LL_SHADER_LOADING_WARNS() << "GL ERROR entering loadShaderFile(): " << error << LL_ENDL;
 		}
 	}
 	
@@ -549,6 +632,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 	S32 try_gpu_class = shader_level;
 	S32 gpu_class;
 
+    std::string open_file_name;
 	//find the most relevant file
 	for (gpu_class = try_gpu_class; gpu_class > 0; gpu_class--)
 	{	//search from the current gpu class down to class 1 to find the most relevant shader
@@ -556,18 +640,33 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 		fname << getShaderDirPrefix();
 		fname << gpu_class << "/" << filename;
 		
- 		
-		file = LLFile::fopen(fname.str(), "r");		/* Flawfinder: ignore */
+        open_file_name = fname.str();
+
+        /*
+        Would be awesome, if we didn't have shaders that re-use files
+        with different environments to say, add skinning, etc
+        can't depend on cached version to have evaluate ifdefs identically...
+        if we can define a deterministic hash for the shader based on
+        all the inputs, maybe we can save some time here.
+        if (mShaderObjects.count(filename) > 0)
+        {
+            return mShaderObjects[filename];
+        }
+
+        */
+
+ 		LL_DEBUGS("ShaderLoading") << "Looking in " << open_file_name << LL_ENDL;
+		file = LLFile::fopen(open_file_name, "r");		/* Flawfinder: ignore */
 		if (file)
 		{
-			LL_DEBUGS("ShaderLoading") << "Loading file: shaders/class" << gpu_class << "/" << filename << " (Want class " << gpu_class << ")" << LL_ENDL;
+			LL_DEBUGS("ShaderLoading") << "Loading file: " << open_file_name << " (Want class " << gpu_class << ")" << LL_ENDL;            
 			break; // done
 		}
 	}
 	
 	if (file == NULL)
 	{
-		LL_WARNS("ShaderLoading") << "GLSL Shader file not found: " << filename << LL_ENDL;
+		LL_SHADER_LOADING_WARNS() << "GLSL Shader file not found: " << open_file_name << LL_ENDL;
 		return 0;
 	}
 
@@ -612,7 +711,31 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 	}
 	else
 	{  
-		if (major_version < 4)
+        if (major_version >= 4)
+        {
+            //set version to 400
+			shader_code_text[shader_code_count++] = strdup("#version 400\n");
+        }
+        else if (major_version == 3)
+        {
+            if (minor_version < 10)
+		    {
+			    shader_code_text[shader_code_count++] = strdup("#version 300\n");
+		    }
+		    else if (minor_version <= 19)
+		    {
+			    shader_code_text[shader_code_count++] = strdup("#version 310\n");
+		    }
+		    else if (minor_version <= 29)
+		    {
+			    shader_code_text[shader_code_count++] = strdup("#version 320\n");
+		    }
+            else
+            {
+                shader_code_text[shader_code_count++] = strdup("#version 330\n");
+            }
+        }
+		else
 		{
 			//set version to 1.30
 			shader_code_text[shader_code_count++] = strdup("#version 130\n");
@@ -620,10 +743,6 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 			extra_code_text[extra_code_count++] = strdup("precision mediump int;\n");
 			extra_code_text[extra_code_count++] = strdup("precision highp float;\n");
 		}
-		else
-		{ //set version to 400
-			shader_code_text[shader_code_count++] = strdup("#version 400\n");
-		}
 
 		extra_code_text[extra_code_count++] = strdup("#define DEFINE_GL_FRAGCOLOR 1\n");
 		extra_code_text[extra_code_count++] = strdup("#define FXAA_GLSL_130 1\n");
@@ -646,7 +765,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 		extra_code_text[extra_code_count++] = strdup("#define texture2D texture\n");
 		extra_code_text[extra_code_count++] = strdup("#define textureCube texture\n");
 		extra_code_text[extra_code_count++] = strdup("#define texture2DLod textureLod\n");
-		extra_code_text[extra_code_count++] = strdup("#define	shadow2D(a,b) vec2(texture(a,b))\n");
+		extra_code_text[extra_code_count++] = strdup("#define shadow2D(a,b) vec2(texture(a,b))\n");
 		
 		if (major_version > 1 || minor_version >= 40)
 		{ //GLSL 1.40 replaces texture2DRect et al with texture
@@ -704,7 +823,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 		}
 		*/
 
-		extra_code_text[extra_code_count++] = strdup("#define HAS_DIFFUSE_LOOKUP 1\n");
+		extra_code_text[extra_code_count++] = strdup("#define HAS_DIFFUSE_LOOKUP\n");
 
 		//uniform declartion
 		for (S32 i = 0; i < texture_index_channels; ++i)
@@ -763,11 +882,6 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 			LL_ERRS() << "Indexed texture rendering requires GLSL 1.30 or later." << LL_ENDL;
 		}
 	}
-	else
-	{
-		extra_code_text[extra_code_count++] = strdup("#define HAS_DIFFUSE_LOOKUP 0\n");
-	}
-
     
 	//copy file into memory
 	enum {
@@ -897,38 +1011,8 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 			{
 				//an error occured, print log
 				LL_WARNS("ShaderLoading") << "GLSL Compilation Error:" << LL_ENDL;
-				dumpObjectLog(ret, TRUE, filename);
-#if LL_WINDOWS
-				std::stringstream ostr;
-				//dump shader source for debugging
-				for (GLuint i = 0; i < shader_code_count; i++)
-				{
-					ostr << i << ": " << shader_code_text[i];
-
-					if (i % 128 == 0)
-					{ //dump every 128 lines
-
-						LL_WARNS("ShaderLoading") << "\n" << ostr.str() << LL_ENDL;
-						ostr = std::stringstream();
-					}
-
-				}
-
-				LL_WARNS("ShaderLoading") << "\n" << ostr.str() << LL_ENDL;
-#else
-				std::string str;
-				
-				for (GLuint i = 0; i < shader_code_count; i++) {
-					str.append(shader_code_text[i]);
-					
-					if (i % 128 == 0)
-					{
-						LL_WARNS("ShaderLoading") << str << LL_ENDL;
-						str = "";
-					}
-				}
-#endif
-
+				dumpObjectLog(ret, TRUE, open_file_name);
+                dumpShaderSource(shader_code_count, shader_code_text);
 				ret = 0;
 			}
 		}
@@ -949,7 +1033,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
@@ -957,7 +1046,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 		if (shader_level > 1)
 		{
 			shader_level--;
-			return loadShaderFile(filename,shader_level,type, defines, texture_index_channels);
+			return loadShaderFile(filename, shader_level, type, defines, texture_index_channels);
 		}
 		LL_WARNS("ShaderLoading") << "Failed to load " << filename << LL_ENDL;	
 	}
@@ -973,7 +1062,7 @@ BOOL LLShaderMgr::linkProgramObject(GLhandleARB obj, BOOL suppress_errors)
 	if (!suppress_errors && success == GL_FALSE) 
 	{
 		//an error occured, print log
-		LL_WARNS("ShaderLoading") << "GLSL Linker Error:" << LL_ENDL;
+		LL_SHADER_LOADING_WARNS() << "GLSL Linker Error:" << LL_ENDL;
 	}
 
 #if LL_DARWIN
@@ -1006,7 +1095,7 @@ BOOL LLShaderMgr::linkProgramObject(GLhandleARB obj, BOOL suppress_errors)
 		CGLGetParameter(ctx, kCGLCPGPUFragmentProcessing, &fragmentGPUProcessing);
 		if (!fragmentGPUProcessing || !vertexGPUProcessing)
 		{
-			LL_WARNS("ShaderLoading") << "GLSL Linker: Running in Software:" << LL_ENDL;
+			LL_SHADER_LOADING_WARNS() << "GLSL Linker: Running in Software:" << LL_ENDL;
 			success = GL_FALSE;
 			suppress_errors = FALSE;		
 		}
@@ -1017,7 +1106,7 @@ BOOL LLShaderMgr::linkProgramObject(GLhandleARB obj, BOOL suppress_errors)
 	LLStringUtil::toLower(log);
 	if (log.find("software") != std::string::npos)
 	{
-		LL_WARNS("ShaderLoading") << "GLSL Linker: Running in Software:" << LL_ENDL;
+		LL_SHADER_LOADING_WARNS() << "GLSL Linker: Running in Software:" << LL_ENDL;
 		success = GL_FALSE;
 		suppress_errors = FALSE;
 	}
@@ -1033,7 +1122,7 @@ BOOL LLShaderMgr::validateProgramObject(GLhandleARB obj)
 	glGetObjectParameterivARB(obj, GL_OBJECT_VALIDATE_STATUS_ARB, &success);
 	if (success == GL_FALSE)
 	{
-		LL_WARNS("ShaderLoading") << "GLSL program not valid: " << LL_ENDL;
+		LL_SHADER_LOADING_WARNS() << "GLSL program not valid: " << LL_ENDL;
 		dumpObjectLog(obj);
 	}
 	else
@@ -1067,6 +1156,7 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("projection_matrix");
 	mReservedUniforms.push_back("inv_proj");
 	mReservedUniforms.push_back("modelview_projection_matrix");
+    mReservedUniforms.push_back("inv_modelview");
 	mReservedUniforms.push_back("normal_matrix");
 	mReservedUniforms.push_back("texture_matrix0");
 	mReservedUniforms.push_back("texture_matrix1");
@@ -1109,14 +1199,17 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("color");
 		
 	mReservedUniforms.push_back("diffuseMap");
+    mReservedUniforms.push_back("altDiffuseMap");
 	mReservedUniforms.push_back("specularMap");
 	mReservedUniforms.push_back("bumpMap");
+    mReservedUniforms.push_back("bumpMap2");
 	mReservedUniforms.push_back("environmentMap");
-	mReservedUniforms.push_back("cloude_noise_texture");
+	mReservedUniforms.push_back("cloud_noise_texture");
+    mReservedUniforms.push_back("cloud_noise_texture_next");
 	mReservedUniforms.push_back("fullbright");
 	mReservedUniforms.push_back("lightnorm");
-	mReservedUniforms.push_back("sunlight_color_copy");
-	mReservedUniforms.push_back("ambient");
+	mReservedUniforms.push_back("sunlight_color");
+	mReservedUniforms.push_back("ambient_color");
 	mReservedUniforms.push_back("blue_horizon");
 	mReservedUniforms.push_back("blue_density");
 	mReservedUniforms.push_back("haze_horizon");
@@ -1175,6 +1268,7 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("spot_shadow_bias");
 	mReservedUniforms.push_back("spot_shadow_offset");
 	mReservedUniforms.push_back("sun_dir");
+    mReservedUniforms.push_back("moon_dir");
 	mReservedUniforms.push_back("shadow_res");
 	mReservedUniforms.push_back("proj_shadow_res");
 	mReservedUniforms.push_back("depth_cutoff");
@@ -1217,8 +1311,6 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("bloomMap");
 	mReservedUniforms.push_back("projectionMap");
 	mReservedUniforms.push_back("norm_mat");
-
-	mReservedUniforms.push_back("global_gamma");
 	mReservedUniforms.push_back("texture_gamma");
 	
 	mReservedUniforms.push_back("specular_color");
@@ -1232,8 +1324,8 @@ void LLShaderMgr::initAttribsAndUniforms()
 	mReservedUniforms.push_back("refTex");
 	mReservedUniforms.push_back("eyeVec");
 	mReservedUniforms.push_back("time");
-	mReservedUniforms.push_back("d1");
-	mReservedUniforms.push_back("d2");
+	mReservedUniforms.push_back("waveDir1");
+	mReservedUniforms.push_back("waveDir2");
 	mReservedUniforms.push_back("lightDir");
 	mReservedUniforms.push_back("specular");
 	mReservedUniforms.push_back("lightExp");
@@ -1265,6 +1357,34 @@ void LLShaderMgr::initAttribsAndUniforms()
 
 	mReservedUniforms.push_back("origin");
 	mReservedUniforms.push_back("display_gamma");
+
+    mReservedUniforms.push_back("inscatter");
+    mReservedUniforms.push_back("sun_size");
+    mReservedUniforms.push_back("fog_color");
+
+    mReservedUniforms.push_back("transmittance_texture");
+    mReservedUniforms.push_back("scattering_texture");
+    mReservedUniforms.push_back("single_mie_scattering_texture");
+    mReservedUniforms.push_back("irradiance_texture");
+    mReservedUniforms.push_back("blend_factor");
+    mReservedUniforms.push_back("no_atmo");
+    mReservedUniforms.push_back("moisture_level");
+    mReservedUniforms.push_back("droplet_radius");
+    mReservedUniforms.push_back("ice_level");
+    mReservedUniforms.push_back("rainbow_map");
+    mReservedUniforms.push_back("halo_map");
+    mReservedUniforms.push_back("moon_brightness");
+    mReservedUniforms.push_back("cloud_variance");
+
+    mReservedUniforms.push_back("sh_input_r");
+    mReservedUniforms.push_back("sh_input_g");
+    mReservedUniforms.push_back("sh_input_b");
+
+    mReservedUniforms.push_back("sun_moon_glow_factor");
+    mReservedUniforms.push_back("water_edge");
+    mReservedUniforms.push_back("sun_up_factor");
+    mReservedUniforms.push_back("moonlight_color");
+
 	llassert(mReservedUniforms.size() == END_RESERVED_UNIFORMS);
 
 	std::set<std::string> dupe_check;