Add render debug controls for forcing disable of ambient, sun, and local light contributions

(engages AMBIENT_KILL, SUNLIGHT_KILL, and LOCAL_LIGHT_KILL defines in shaders to accomplish
  those tasks as required by each render mode).

1 files changed, 204 insertions, 1 deletions

diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index c77a631554..ea43203f1c 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -927,7 +927,7 @@ BOOL LLViewerShaderMgr::loadBasicShaders()
 	if (gGLManager.mIsMobileGF)
 		sum_lights_class = 3;
 #endif
-	
+
 	// Use the feature table to mask out the max light level to use.  Also make sure it's at least 1.
 	S32 max_light_class = gSavedSettings.getS32("RenderShaderLightingMaxLevel");
 	sum_lights_class = llclamp(sum_lights_class, 1, max_light_class);
@@ -959,6 +959,25 @@ BOOL LLViewerShaderMgr::loadBasicShaders()
 	attribs["MAX_JOINTS_PER_MESH_OBJECT"] = 
 		boost::lexical_cast<std::string>(LLSkinningUtil::getMaxJointCount());
 
+    BOOL ambient_kill = gSavedSettings.getBOOL("AmbientDisable");
+	BOOL sunlight_kill = gSavedSettings.getBOOL("SunlightDisable");
+    BOOL local_light_kill = gSavedSettings.getBOOL("LocalLightDisable");
+
+    if (ambient_kill)
+    {
+        attribs["AMBIENT_KILL"] = "1";
+    }
+
+    if (sunlight_kill)
+    {
+        attribs["SUNLIGHT_KILL"] = "1";
+    }
+
+    if (local_light_kill)
+    {
+       attribs["LOCAL_LIGHT_KILL"] = "1";
+    }
+
 	// We no longer have to bind the shaders to global glhandles, they are automatically added to a map now.
 	for (U32 i = 0; i < shaders.size(); i++)
 	{
@@ -1232,6 +1251,10 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 {
     bool use_sun_shadow = mShaderLevel[SHADER_DEFERRED] > 1;
 
+    BOOL ambient_kill = gSavedSettings.getBOOL("AmbientDisable");
+	BOOL sunlight_kill = gSavedSettings.getBOOL("SunlightDisable");
+    BOOL local_light_kill = gSavedSettings.getBOOL("LocalLightDisable");
+
 	if (mShaderLevel[SHADER_DEFERRED] == 0)
 	{
 		gDeferredTreeProgram.unload();
@@ -1457,6 +1480,22 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		{
 			gDeferredSkinnedAlphaProgram.addPermutation("HAS_SHADOW", "1");
 		}
+
+        if (ambient_kill)
+        {
+            gDeferredSkinnedAlphaProgram.addPermutation("AMBIENT_KILL", "1");
+        }
+
+        if (sunlight_kill)
+        {
+            gDeferredSkinnedAlphaProgram.addPermutation("SUNLIGHT_KILL", "1");
+        }
+
+        if (local_light_kill)
+        {
+            gDeferredSkinnedAlphaProgram.addPermutation("LOCAL_LIGHT_KILL", "1");
+        }
+
 		success = gDeferredSkinnedAlphaProgram.createShader(NULL, NULL);
 		llassert(success);
 
@@ -1525,6 +1564,21 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 				gDeferredMaterialProgram[i].addPermutation("HAS_SPECULAR_MAP", "1");
 			}
 
+            if (ambient_kill)
+            {
+                gDeferredMaterialProgram[i].addPermutation("AMBIENT_KILL", "1");
+            }
+
+            if (sunlight_kill)
+            {
+                gDeferredMaterialProgram[i].addPermutation("SUNLIGHT_KILL", "1");
+            }
+
+            if (local_light_kill)
+            {
+                gDeferredMaterialProgram[i].addPermutation("LOCAL_LIGHT_KILL", "1");
+            }
+
             gDeferredMaterialProgram[i].addPermutation("DIFFUSE_ALPHA_MODE", llformat("%d", alpha_mode));
 
             if (use_sun_shadow)
@@ -1593,6 +1647,21 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
             }
             gDeferredMaterialWaterProgram[i].addPermutation("WATER_FOG","1");
 
+            if (ambient_kill)
+            {
+                gDeferredMaterialWaterProgram[i].addPermutation("AMBIENT_KILL", "1");
+            }
+
+            if (sunlight_kill)
+            {
+                gDeferredMaterialWaterProgram[i].addPermutation("SUNLIGHT_KILL", "1");
+            }
+
+            if (local_light_kill)
+            {
+                gDeferredMaterialWaterProgram[i].addPermutation("LOCAL_LIGHT_KILL", "1");
+            }
+
             gDeferredMaterialWaterProgram[i].mFeatures.hasWaterFog = true;
             gDeferredMaterialWaterProgram[i].mFeatures.hasSrgb = true;
             gDeferredMaterialWaterProgram[i].mFeatures.encodesNormal = true;
@@ -1681,6 +1750,23 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredLightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
+        gDeferredLightProgram.clearPermutations();
+
+        if (ambient_kill)
+        {
+            gDeferredLightProgram.addPermutation("AMBIENT_KILL", "1");
+        }
+
+        if (sunlight_kill)
+        {
+            gDeferredLightProgram.addPermutation("SUNLIGHT_KILL", "1");
+        }
+
+        if (local_light_kill)
+        {
+            gDeferredLightProgram.addPermutation("LOCAL_LIGHT_KILL", "1");
+        }
+
 		success = gDeferredLightProgram.createShader(NULL, NULL);
         llassert(success);
 	}
@@ -1693,11 +1779,28 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 			gDeferredMultiLightProgram[i].mFeatures.isDeferred = true;
 			gDeferredMultiLightProgram[i].mFeatures.hasShadows = true;
 
+            gDeferredMultiLightProgram[i].clearPermutations();
 			gDeferredMultiLightProgram[i].mShaderFiles.clear();
 			gDeferredMultiLightProgram[i].mShaderFiles.push_back(make_pair("deferred/multiPointLightV.glsl", GL_VERTEX_SHADER_ARB));
 			gDeferredMultiLightProgram[i].mShaderFiles.push_back(make_pair("deferred/multiPointLightF.glsl", GL_FRAGMENT_SHADER_ARB));
 			gDeferredMultiLightProgram[i].mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 			gDeferredMultiLightProgram[i].addPermutation("LIGHT_COUNT", llformat("%d", i+1));
+
+            if (ambient_kill)
+            {
+                gDeferredMultiLightProgram[i].addPermutation("AMBIENT_KILL", "1");
+            }
+
+            if (sunlight_kill)
+            {
+                gDeferredMultiLightProgram[i].addPermutation("SUNLIGHT_KILL", "1");
+            }
+
+            if (local_light_kill)
+            {
+                gDeferredMultiLightProgram[i].addPermutation("LOCAL_LIGHT_KILL", "1");
+            }
+
 			success = gDeferredMultiLightProgram[i].createShader(NULL, NULL);
             llassert(success);
 		}
@@ -1711,10 +1814,26 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredSpotLightProgram.mFeatures.isDeferred = true;
 		gDeferredSpotLightProgram.mFeatures.hasShadows = true;
 
+        gDeferredSpotLightProgram.clearPermutations();
 		gDeferredSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/pointLightV.glsl", GL_VERTEX_SHADER_ARB));
 		gDeferredSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/spotLightF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredSpotLightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
+        if (ambient_kill)
+        {
+            gDeferredSpotLightProgram.addPermutation("AMBIENT_KILL", "1");
+        }
+
+        if (sunlight_kill)
+        {
+            gDeferredSpotLightProgram.addPermutation("SUNLIGHT_KILL", "1");
+        }
+
+        if (local_light_kill)
+        {
+            gDeferredSpotLightProgram.addPermutation("LOCAL_LIGHT_KILL", "1");
+        }
+
 		success = gDeferredSpotLightProgram.createShader(NULL, NULL);
         llassert(success);
 	}
@@ -1726,11 +1845,17 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredMultiSpotLightProgram.mFeatures.isDeferred = true;
 		gDeferredMultiSpotLightProgram.mFeatures.hasShadows = true;
 
+        gDeferredMultiSpotLightProgram.clearPermutations();
 		gDeferredMultiSpotLightProgram.mShaderFiles.clear();
 		gDeferredMultiSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/multiPointLightV.glsl", GL_VERTEX_SHADER_ARB));
 		gDeferredMultiSpotLightProgram.mShaderFiles.push_back(make_pair("deferred/multiSpotLightF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredMultiSpotLightProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
+        if (local_light_kill)
+        {
+            gDeferredMultiSpotLightProgram.addPermutation("LOCAL_LIGHT_KILL", "1");
+        }
+
 		success = gDeferredMultiSpotLightProgram.createShader(NULL, NULL);
         llassert(success);
 	}
@@ -1821,6 +1946,22 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
             gDeferredAlphaProgram.addPermutation("HAS_SHADOW", "1");
         }
         gDeferredAlphaProgram.addPermutation("USE_VERTEX_COLOR", "1");
+
+        if (ambient_kill)
+        {
+            gDeferredAlphaProgram.addPermutation("AMBIENT_KILL", "1");
+        }
+
+        if (sunlight_kill)
+        {
+            gDeferredAlphaProgram.addPermutation("SUNLIGHT_KILL", "1");
+        }
+
+        if (local_light_kill)
+        {
+            gDeferredAlphaProgram.addPermutation("LOCAL_LIGHT_KILL", "1");
+        }
+
         gDeferredAlphaProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
         success = gDeferredAlphaProgram.createShader(NULL, NULL);
@@ -1914,6 +2055,21 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		{
 			gDeferredAlphaWaterProgram.addPermutation("HAS_SHADOW", "1");
 		}
+
+        if (ambient_kill)
+        {
+            gDeferredAlphaWaterProgram.addPermutation("AMBIENT_KILL", "1");
+        }
+
+        if (sunlight_kill)
+        {
+            gDeferredAlphaWaterProgram.addPermutation("SUNLIGHT_KILL", "1");
+        }
+
+        if (local_light_kill)
+        {
+            gDeferredAlphaWaterProgram.addPermutation("LOCAL_LIGHT_KILL", "1");
+        }
         gDeferredAlphaWaterProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
 		success = gDeferredAlphaWaterProgram.createShader(NULL, NULL);
@@ -2129,11 +2285,27 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredSoftenProgram.mFeatures.isDeferred = true;
 		gDeferredSoftenProgram.mFeatures.hasShadows = use_sun_shadow;
 
+        gDeferredSoftenProgram.clearPermutations();
 		gDeferredSoftenProgram.mShaderFiles.push_back(make_pair("deferred/softenLightV.glsl", GL_VERTEX_SHADER_ARB));
 		gDeferredSoftenProgram.mShaderFiles.push_back(make_pair("deferred/softenLightF.glsl", GL_FRAGMENT_SHADER_ARB));
 
 		gDeferredSoftenProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
+        if (ambient_kill)
+        {
+            gDeferredSoftenProgram.addPermutation("AMBIENT_KILL", "1");
+        }
+
+        if (sunlight_kill)
+        {
+            gDeferredSoftenProgram.addPermutation("SUNLIGHT_KILL", "1");
+        }
+
+        if (local_light_kill)
+        {
+            gDeferredSoftenProgram.addPermutation("LOCAL_LIGHT_KILL", "1");
+        }
+
 		if (gSavedSettings.getBOOL("RenderDeferredSSAO"))
 		{ //if using SSAO, take screen space light map into account as if shadows are enabled
 			gDeferredSoftenProgram.mShaderLevel = llmax(gDeferredSoftenProgram.mShaderLevel, 2);
@@ -2150,6 +2322,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredSoftenWaterProgram.mShaderFiles.push_back(make_pair("deferred/softenLightV.glsl", GL_VERTEX_SHADER_ARB));
 		gDeferredSoftenWaterProgram.mShaderFiles.push_back(make_pair("deferred/softenLightF.glsl", GL_FRAGMENT_SHADER_ARB));
 
+        gDeferredSoftenWaterProgram.clearPermutations();
 		gDeferredSoftenWaterProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 		gDeferredSoftenWaterProgram.addPermutation("WATER_FOG", "1");
 		gDeferredSoftenWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
@@ -2162,6 +2335,21 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         gDeferredSoftenWaterProgram.mFeatures.isDeferred = true;
         gDeferredSoftenWaterProgram.mFeatures.hasShadows = use_sun_shadow;
 
+        if (ambient_kill)
+        {
+            gDeferredSoftenWaterProgram.addPermutation("AMBIENT_KILL", "1");
+        }
+
+        if (sunlight_kill)
+        {
+            gDeferredSoftenWaterProgram.addPermutation("SUNLIGHT_KILL", "1");
+        }
+
+        if (local_light_kill)
+        {
+            gDeferredSoftenWaterProgram.addPermutation("LOCAL_LIGHT_KILL", "1");
+        }
+
 		if (gSavedSettings.getBOOL("RenderDeferredSSAO"))
 		{ //if using SSAO, take screen space light map into account as if shadows are enabled
 			gDeferredSoftenWaterProgram.mShaderLevel = llmax(gDeferredSoftenWaterProgram.mShaderLevel, 2);
@@ -2397,6 +2585,21 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		{
 			gDeferredAvatarAlphaProgram.addPermutation("HAS_SHADOW", "1");
 		}
+
+        if (ambient_kill)
+        {
+            gDeferredAvatarAlphaProgram.addPermutation("AMBIENT_KILL", "1");
+        }
+
+        if (sunlight_kill)
+        {
+            gDeferredAvatarAlphaProgram.addPermutation("SUNLIGHT_KILL", "1");
+        }
+
+        if (local_light_kill)
+        {
+            gDeferredAvatarAlphaProgram.addPermutation("LOCAL_LIGHT_KILL", "1");
+        }
 		gDeferredAvatarAlphaProgram.mShaderLevel = mShaderLevel[SHADER_DEFERRED];
 
 		success = gDeferredAvatarAlphaProgram.createShader(NULL, NULL);