From 167fc262734dfb72e33e57a0b309d0ce6a17ce47 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Tue, 9 Jul 2013 06:38:12 -0700
Subject: NORSPEC-291 WIP drop the no deferred underwater logic only

---
 indra/newview/lldrawpoolalpha.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

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

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index c832e1401d..737da2e209 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -113,6 +113,15 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 		gObjectFullbrightAlphaMaskProgram.setMinimumAlpha(0.33f);
 	}
 
+	if (LLPipeline::sUnderWaterRender)
+	{
+		emissive_shader = &gObjectEmissiveWaterProgram;
+	}
+	else
+	{
+		emissive_shader = &gObjectEmissiveProgram;
+	}
+
 	deferred_render = TRUE;
 	if (mVertexShaderLevel > 0)
 	{
@@ -352,7 +361,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
 				
 				LLMaterial* mat = NULL;
 
-				if (deferred_render && !LLPipeline::sUnderWaterRender)
+				if (deferred_render)
 				{
 					mat = params.mMaterial;
 				}
-- 
cgit v1.3


From fbf3d8b78137a5229ccfabd1e42a0712d92b061f Mon Sep 17 00:00:00 2001
From: "Graham Madarasz (Graham)" <graham@lindenlab.com>
Date: Thu, 11 Jul 2013 16:21:23 -0700
Subject: NORSPEC-291 WIP materials underwater with haze, reflection broken,
 water dist broken

---
 .../shaders/class1/deferred/materialF.glsl         | 37 +++++-----------
 .../shaders/class1/deferred/materialV.glsl         |  1 +
 .../shaders/class1/deferred/softenLightF.glsl      | 15 ++++---
 .../shaders/class2/deferred/softenLightF.glsl      |  9 ++++
 indra/newview/lldrawpoolalpha.cpp                  |  6 +++
 indra/newview/lldrawpoolavatar.cpp                 | 15 +++----
 indra/newview/lldrawpoolmaterials.cpp              |  9 ++--
 indra/newview/lldrawpoolsky.cpp                    |  3 +-
 indra/newview/lldrawpoolwlsky.cpp                  |  5 ++-
 indra/newview/llviewerdisplay.cpp                  | 11 +----
 indra/newview/llviewershadermgr.cpp                | 50 ++++++++--------------
 indra/newview/llviewershadermgr.h                  |  3 +-
 indra/newview/pipeline.cpp                         |  2 -
 13 files changed, 70 insertions(+), 96 deletions(-)

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

diff --git a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
index 393074344b..9ce4d89df7 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
@@ -136,20 +136,15 @@ uniform vec3 light_attenuation[8];
 uniform vec3 light_diffuse[8];
 
 #ifdef WATER_FOG
-vec3 getPositionEye()
-{
-	return vary_PositionEye;
-}
-
 uniform vec4 waterPlane;
 uniform vec4 waterFogColor;
 uniform float waterFogDensity;
 uniform float waterFogKS;
 
-vec4 applyWaterFogDeferred(vec4 color)
+vec4 applyWaterFogDeferred(vec3 pos, vec4 color)
 {
 	//normalize view vector
-	vec3 view = normalize(getPositionEye());
+	vec3 view = normalize(pos);
 	float es = -(dot(view, waterPlane.xyz));
 
 	//find intersection point with water plane and eye vector
@@ -160,7 +155,7 @@ vec4 applyWaterFogDeferred(vec4 color)
 	vec3 int_v = waterPlane.w > 0.0 ? view * waterPlane.w/es : vec3(0.0, 0.0, 0.0);
 	
 	//get object depth
-	float depth = length(getPositionEye() - int_v);
+	float depth = length(pos - int_v);
 		
 	//get "thickness" of water
 	float l = max(depth, 0.1);
@@ -463,21 +458,6 @@ out vec4 frag_data[3];
 #else
 #define frag_data gl_FragData
 #endif
-
-VARYING vec3 vary_position;
-
-#ifdef WATER_FOG
-vec3 vary_PositionEye;
-vec3 getPositionEye()
-{
-	return vary_PositionEye;
-}
-void setPositionEye(vec3 e)
-{
-	vary_PositionEye = e;
-}
-#endif
-
 #endif
 
 uniform sampler2D diffuseMap;
@@ -749,15 +729,18 @@ void main()
 	float al = max(diffcol.a,glare)*vertex_color.a;
 
 #ifdef WATER_FOG
-	frag_color = applyWaterFogDeferred(vec4(col.rgb, al));
-#else
+	vec4 temp = applyWaterFogDeferred(pos, vec4(col.rgb, al));
+	col.rgb = temp.rgb;
+	al = temp.a;
+#endif
+
 	frag_color.rgb = col.rgb;
 	frag_color.a   = al;
-#endif
 
 #else
 	frag_data[0] = final_color;
 	frag_data[1] = final_specular; // XYZ = Specular color. W = Specular exponent.
 	frag_data[2] = final_normal; // XY = Normal.  Z = Env. intensity.
-#endif%
+#endif
 }
+
diff --git a/indra/newview/app_settings/shaders/class1/deferred/materialV.glsl b/indra/newview/app_settings/shaders/class1/deferred/materialV.glsl
index 154db09583..e44a6fcec8 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/materialV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/materialV.glsl
@@ -141,3 +141,4 @@ vary_normal  = n;
 #endif
 #endif
 }
+
diff --git a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
index 1706d41da0..953f0189f0 100755
--- a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
@@ -133,6 +133,7 @@ vec3 getPositionEye()
 {
 	return vary_PositionEye;
 }
+
 vec3 getSunlitColor()
 {
 	return vary_SunlitColor;
@@ -182,10 +183,10 @@ uniform vec4 waterFogColor;
 uniform float waterFogDensity;
 uniform float waterFogKS;
 
-vec4 applyWaterFogDeferred(vec4 color)
+vec4 applyWaterFogDeferred(vec3 pos, vec4 color)
 {
 	//normalize view vector
-	vec3 view = normalize(getPositionEye());
+	vec3 view = normalize(pos);
 	float es = -(dot(view, waterPlane.xyz));
 
 	//find intersection point with water plane and eye vector
@@ -196,7 +197,7 @@ vec4 applyWaterFogDeferred(vec4 color)
 	vec3 int_v = waterPlane.w > 0.0 ? view * waterPlane.w/es : vec3(0.0, 0.0, 0.0);
 	
 	//get object depth
-	float depth = length(getPositionEye() - int_v);
+	float depth = length(pos - int_v);
 		
 	//get "thickness" of water
 	float l = max(depth, 0.1);
@@ -435,13 +436,14 @@ void main()
 		if (norm.w < 0.5)
 		{
 			col = mix(atmosLighting(col), fullbrightAtmosTransport(col), diffuse.a);
-			col = mix(scaleSoftClip(col), fullbrightScaleSoftClip(col), diffuse.a);
 
 			#ifdef WATER_FOG
-				vec4 fogged = applyWaterFogDeferred(vec4(col, bloom));
+				vec4 fogged = applyWaterFogDeferred(pos,vec4(col, bloom));
 				col = fogged.rgb;
 				bloom = fogged.a;
 			#endif
+
+			col = mix(scaleSoftClip(col), fullbrightScaleSoftClip(col), diffuse.a);			
 		}
 
 		col = srgb_to_linear(col);
@@ -450,6 +452,7 @@ void main()
 		//col.g = envIntensity;
 	}
 
-	frag_color.rgb = col;
+	frag_color.rgb = col.rgb;
 	frag_color.a = bloom;
 }
+
diff --git a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
index 06447261b4..4464358b1e 100755
--- a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
@@ -133,6 +133,13 @@ vec4 getPosition(vec2 pos_screen)
 	return getPosition_d(pos_screen, depth);
 }
 
+#ifdef WATER_FOG
+vec3 getPositionEye();
+vec3 getSunlitColor();
+vec3 getAmblitColor();
+vec3 getAdditiveColor();
+vec3 getAtmosAttenuation();
+#else
 vec3 getPositionEye()
 {
 	return vary_PositionEye;
@@ -153,6 +160,7 @@ vec3 getAtmosAttenuation()
 {
 	return vary_AtmosAttenuation;
 }
+#endif
 
 void setPositionEye(vec3 v)
 {
@@ -421,3 +429,4 @@ void main()
 	frag_color.rgb = col;
 	frag_color.a = bloom;
 }
+
diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 737da2e209..e53c783161 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -405,6 +405,11 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
 					llassert(mask < LLMaterial::SHADER_COUNT);
 					target_shader = &(gDeferredMaterialProgram[mask]);
 
+					if (LLPipeline::sUnderWaterRender)
+					{
+						target_shader = &(gDeferredMaterialWaterProgram[mask]);
+					}
+
 					if (current_shader != target_shader)
 					{
 						gPipeline.bindDeferredShader(*target_shader);
@@ -554,3 +559,4 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
 		gPipeline.enableLightsDynamic();
 	}
 }
+
diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp
index 45abb87bad..3815548dba 100755
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -297,14 +297,12 @@ void LLDrawPoolAvatar::beginDeferredRiggedMaterialAlpha(S32 pass)
 
 	pass += LLMaterial::SHADER_COUNT;
 
+	sVertexProgram = &gDeferredMaterialProgram[pass];
+
 	if (LLPipeline::sUnderWaterRender)
 	{
 		sVertexProgram = &(gDeferredMaterialWaterProgram[pass]);
 	}
-	else
-	{
-		sVertexProgram = &(gDeferredMaterialProgram[pass]);
-	}
 
 	gPipeline.bindDeferredShader(*sVertexProgram);
 	sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
@@ -1099,14 +1097,13 @@ void LLDrawPoolAvatar::beginDeferredRiggedMaterial(S32 pass)
 	{ //skip alpha passes
 		return;
 	}
+	sVertexProgram = &gDeferredMaterialProgram[pass+LLMaterial::SHADER_COUNT];
+
 	if (LLPipeline::sUnderWaterRender)
 	{
-		sVertexProgram = &gDeferredMaterialWaterProgram[pass+LLMaterial::SHADER_COUNT];
-	}
-	else
-	{
-		sVertexProgram = &gDeferredMaterialProgram[pass+LLMaterial::SHADER_COUNT];
+		sVertexProgram = &(gDeferredMaterialWaterProgram[pass]);
 	}
+
 	sVertexProgram->bind();
 	normal_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::BUMP_MAP);
 	specular_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::SPECULAR_MAP);
diff --git a/indra/newview/lldrawpoolmaterials.cpp b/indra/newview/lldrawpoolmaterials.cpp
index 49619e6b1d..d1b5080650 100644
--- a/indra/newview/lldrawpoolmaterials.cpp
+++ b/indra/newview/lldrawpoolmaterials.cpp
@@ -71,15 +71,13 @@ void LLDrawPoolMaterials::beginDeferredPass(S32 pass)
 		15, //LLRenderPass::PASS_NORMSPEC_GLOW,
 	};
 	
+	mShader = &(gDeferredMaterialProgram[shader_idx[pass]]);
+
 	if (LLPipeline::sUnderWaterRender)
 	{
 		mShader = &(gDeferredMaterialWaterProgram[shader_idx[pass]]);
 	}
-	else
-	{
-		mShader = &(gDeferredMaterialProgram[shader_idx[pass]]);
-	}
-	
+
 	mShader->bind();
 
 	diffuse_channel = mShader->enableTexture(LLShaderMgr::DIFFUSE_MAP);
@@ -223,3 +221,4 @@ void LLDrawPoolMaterials::pushBatch(LLDrawInfo& params, U32 mask, BOOL texture,
 		gGL.matrixMode(LLRender::MM_MODELVIEW);
 	}
 }
+
diff --git a/indra/newview/lldrawpoolsky.cpp b/indra/newview/lldrawpoolsky.cpp
index d36b9ace94..ef8bdc3304 100755
--- a/indra/newview/lldrawpoolsky.cpp
+++ b/indra/newview/lldrawpoolsky.cpp
@@ -77,7 +77,7 @@ void LLDrawPoolSky::render(S32 pass)
 	}
 	
 	// don't render sky under water (background just gets cleared to fog color)
-	if(mVertexShaderLevel > 0 /*&& !LLPipeline::sRenderDeferred*/ && LLPipeline::sUnderWaterRender)
+	if(mVertexShaderLevel > 0 && LLPipeline::sUnderWaterRender)
 	{
 		return;
 	}
@@ -155,3 +155,4 @@ void LLDrawPoolSky::renderSkyCubeFace(U8 side)
 void LLDrawPoolSky::endRenderPass( S32 pass )
 {
 }
+
diff --git a/indra/newview/lldrawpoolwlsky.cpp b/indra/newview/lldrawpoolwlsky.cpp
index 56b58aaeb4..53339222eb 100755
--- a/indra/newview/lldrawpoolwlsky.cpp
+++ b/indra/newview/lldrawpoolwlsky.cpp
@@ -99,12 +99,12 @@ LLViewerTexture *LLDrawPoolWLSky::getDebugTexture()
 void LLDrawPoolWLSky::beginRenderPass( S32 pass )
 {
 	sky_shader =
-		(LLPipeline::sUnderWaterRender /*&& !LLPipeline::sRenderDeferred*/) ?
+		LLPipeline::sUnderWaterRender ?
 			&gObjectFullbrightNoColorWaterProgram :
 			&gWLSkyProgram;
 
 	cloud_shader =
-			(LLPipeline::sUnderWaterRender /*&& !LLPipeline::sRenderDeferred*/) ?
+			LLPipeline::sUnderWaterRender ?
 				&gObjectFullbrightNoColorWaterProgram :
 				&gWLCloudProgram;
 }
@@ -420,3 +420,4 @@ void LLDrawPoolWLSky::restoreGL()
 		sCloudNoiseTexture = LLViewerTextureManager::getLocalTexture(sCloudNoiseRawImage.get(), TRUE);
 	}
 }
+
diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index d9fd171b4e..bbebeea3e0 100755
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -893,15 +893,7 @@ void display(BOOL rebuild, F32 zoom_factor, int subfield, BOOL for_snapshot)
 			if (LLPipeline::sRenderDeferred)
 			{
 				gPipeline.mDeferredScreen.bindTarget();
-				if (LLPipeline::sUnderWaterRender)
-				{
-					const LLColor4 &col = LLDrawPoolWater::sWaterFogColor;
-					glClearColor(col.mV[0], col.mV[1], col.mV[2], 0.f);
-				}
-				else
-				{
-					glClearColor(1,0,1,1);
-				}				
+				glClearColor(1,0,1,1);
 				gPipeline.mDeferredScreen.clear();
 			}
 			else
@@ -1631,3 +1623,4 @@ void display_cleanup()
 {
 	gDisconnectedImagep = NULL;
 }
+
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index 88593346c0..3df8115402 100755
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -168,7 +168,6 @@ LLGLSLShader			gPostNightVisionProgram;
 // Deferred rendering shaders
 LLGLSLShader			gDeferredImpostorProgram;
 LLGLSLShader			gDeferredWaterProgram;
-LLGLSLShader			gDeferredUnderWaterProgram;
 LLGLSLShader			gDeferredDiffuseProgram;
 LLGLSLShader			gDeferredDiffuseAlphaMaskProgram;
 LLGLSLShader			gDeferredNonIndexedDiffuseProgram;
@@ -285,21 +284,21 @@ LLViewerShaderMgr::LLViewerShaderMgr() :
 	mShaderList.push_back(&gDeferredSoftenProgram);
 	mShaderList.push_back(&gDeferredSoftenWaterProgram);
 	mShaderList.push_back(&gDeferredMaterialProgram[1]);
-	mShaderList.push_back(&gDeferredMaterialWaterProgram[1]);
 	mShaderList.push_back(&gDeferredMaterialProgram[5]);
-	mShaderList.push_back(&gDeferredMaterialWaterProgram[5]);
 	mShaderList.push_back(&gDeferredMaterialProgram[9]);
-	mShaderList.push_back(&gDeferredMaterialWaterProgram[9]);
 	mShaderList.push_back(&gDeferredMaterialProgram[13]);
-	mShaderList.push_back(&gDeferredMaterialWaterProgram[13]);
 	mShaderList.push_back(&gDeferredMaterialProgram[1+LLMaterial::SHADER_COUNT]);
-	mShaderList.push_back(&gDeferredMaterialWaterProgram[1+LLMaterial::SHADER_COUNT]);
 	mShaderList.push_back(&gDeferredMaterialProgram[5+LLMaterial::SHADER_COUNT]);
-	mShaderList.push_back(&gDeferredMaterialWaterProgram[5+LLMaterial::SHADER_COUNT]);
 	mShaderList.push_back(&gDeferredMaterialProgram[9+LLMaterial::SHADER_COUNT]);
-	mShaderList.push_back(&gDeferredMaterialWaterProgram[9+LLMaterial::SHADER_COUNT]);
 	mShaderList.push_back(&gDeferredMaterialProgram[13+LLMaterial::SHADER_COUNT]);	
-	mShaderList.push_back(&gDeferredMaterialWaterProgram[13+LLMaterial::SHADER_COUNT]);
+	mShaderList.push_back(&gDeferredMaterialWaterProgram[1]);
+	mShaderList.push_back(&gDeferredMaterialWaterProgram[5]);
+	mShaderList.push_back(&gDeferredMaterialWaterProgram[9]);
+	mShaderList.push_back(&gDeferredMaterialWaterProgram[13]);
+	mShaderList.push_back(&gDeferredMaterialWaterProgram[1+LLMaterial::SHADER_COUNT]);
+	mShaderList.push_back(&gDeferredMaterialWaterProgram[5+LLMaterial::SHADER_COUNT]);
+	mShaderList.push_back(&gDeferredMaterialWaterProgram[9+LLMaterial::SHADER_COUNT]);
+	mShaderList.push_back(&gDeferredMaterialWaterProgram[13+LLMaterial::SHADER_COUNT]);	
 	mShaderList.push_back(&gDeferredAlphaProgram);
 	mShaderList.push_back(&gDeferredSkinnedAlphaProgram);
 	mShaderList.push_back(&gDeferredFullbrightProgram);
@@ -1154,7 +1153,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredPostGammaCorrectProgram.unload();
 		gFXAAProgram.unload();
 		gDeferredWaterProgram.unload();
-		gDeferredUnderWaterProgram.unload();
 		gDeferredWLSkyProgram.unload();
 		gDeferredWLCloudProgram.unload();
 		gDeferredStarProgram.unload();
@@ -1332,7 +1330,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 
 		if (success)
 		{
-			gDeferredMaterialProgram[i].mName = llformat("Deferred Material Shader %d", i);
+			gDeferredMaterialWaterProgram[i].mName = llformat("Deferred Underwater Material Shader %d", i);
 
 			U32 alpha_mode = i & 0x3;
 
@@ -1340,23 +1338,22 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 			gDeferredMaterialWaterProgram[i].mShaderFiles.push_back(make_pair("deferred/materialV.glsl", GL_VERTEX_SHADER_ARB));
 			gDeferredMaterialWaterProgram[i].mShaderFiles.push_back(make_pair("deferred/materialF.glsl", GL_FRAGMENT_SHADER_ARB));
 			gDeferredMaterialWaterProgram[i].mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
+			gDeferredMaterialWaterProgram[i].mShaderGroup = LLGLSLShader::SG_WATER;
+
 			gDeferredMaterialWaterProgram[i].addPermutation("HAS_NORMAL_MAP", i & 0x8? "1" : "0");
 			gDeferredMaterialWaterProgram[i].addPermutation("HAS_SPECULAR_MAP", i & 0x4 ? "1" : "0");
 			gDeferredMaterialWaterProgram[i].addPermutation("DIFFUSE_ALPHA_MODE", llformat("%d", alpha_mode));
 			gDeferredMaterialWaterProgram[i].addPermutation("HAS_SUN_SHADOW", mVertexShaderLevel[SHADER_DEFERRED] > 1 ? "1" : "0");
 			bool has_skin = i & 0x10;
 			gDeferredMaterialWaterProgram[i].addPermutation("HAS_SKIN",has_skin ? "1" : "0");
-
 			gDeferredMaterialWaterProgram[i].addPermutation("WATER_FOG","1");
-			gDeferredMaterialWaterProgram[i].mFeatures.hasWaterFog = true;
-			gDeferredMaterialWaterProgram[i].mShaderGroup = SHADER_WATER;
 
 			if (has_skin)
 			{
 				gDeferredMaterialWaterProgram[i].mFeatures.hasObjectSkinning = true;
 			}
 
-			success = gDeferredMaterialWaterProgram[i].createShader(NULL, NULL);
+			success = gDeferredMaterialWaterProgram[i].createShader(NULL, NULL);//&mWLUniforms);
 		}
 	}
 
@@ -1377,6 +1374,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	gDeferredMaterialWaterProgram[5+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
 	gDeferredMaterialWaterProgram[9+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
 	gDeferredMaterialWaterProgram[13+LLMaterial::SHADER_COUNT].mFeatures.hasLighting = true;
+
 	
 	if (success)
 	{
@@ -1642,21 +1640,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		success = gDeferredWaterProgram.createShader(NULL, &mWaterUniforms);
 	}
 
-	if (success)
-	{
-		// load water shader
-		/*gDeferredUnderWaterProgram.mName = "Deferred Under Water Shader";
-		gDeferredUnderWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gDeferredUnderWaterProgram.mFeatures.hasGamma = true;
-		gDeferredUnderWaterProgram.mShaderFiles.clear();
-		gDeferredUnderWaterProgram.mShaderFiles.push_back(make_pair("deferred/waterV.glsl", GL_VERTEX_SHADER_ARB));
-		gDeferredUnderWaterProgram.mShaderFiles.push_back(make_pair("deferred/underWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gDeferredUnderWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_WATER];
-		gDeferredUnderWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-
-		success = gDeferredUnderWaterProgram.createShader(NULL, &mWaterUniforms);*/
-	}
-
 	if (success)
 	{
 		gDeferredSoftenProgram.mName = "Deferred Soften Shader";
@@ -1677,21 +1660,21 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 	if (success)
 	{
 		gDeferredSoftenWaterProgram.mName = "Deferred Soften Underwater Shader";
-		gDeferredSoftenWaterProgram.mFeatures.hasWaterFog = true;
 		gDeferredSoftenWaterProgram.mShaderFiles.clear();
+
 		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.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		gDeferredSoftenWaterProgram.addPermutation("WATER_FOG", "1");
-		gDeferredSoftenWaterProgram.mShaderGroup = SHADER_WATER;
+		gDeferredSoftenWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
 
 		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);
 		}
 
-		success = gDeferredSoftenWaterProgram.createShader(NULL, NULL);
+		success = gDeferredSoftenWaterProgram.createShader(NULL, &mWLUniforms);
 	}
 
 	if (success)
@@ -3275,3 +3258,4 @@ LLViewerShaderMgr::shader_iter LLViewerShaderMgr::endShaders() const
 {
 	return mShaderList.end();
 }
+
diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h
index 34a0f6b89d..5310076013 100755
--- a/indra/newview/llviewershadermgr.h
+++ b/indra/newview/llviewershadermgr.h
@@ -330,7 +330,6 @@ extern LLGLSLShader			gPostNightVisionProgram;
 // Deferred rendering shaders
 extern LLGLSLShader			gDeferredImpostorProgram;
 extern LLGLSLShader			gDeferredWaterProgram;
-extern LLGLSLShader			gDeferredUnderWaterProgram;
 extern LLGLSLShader			gDeferredDiffuseProgram;
 extern LLGLSLShader			gDeferredDiffuseAlphaMaskProgram;
 extern LLGLSLShader			gDeferredNonIndexedDiffuseAlphaMaskProgram;
@@ -380,5 +379,5 @@ extern LLGLSLShader			gNormalMapGenProgram;
 // Deferred materials shaders
 extern LLGLSLShader			gDeferredMaterialProgram[LLMaterial::SHADER_COUNT*2];
 extern LLGLSLShader			gDeferredMaterialWaterProgram[LLMaterial::SHADER_COUNT*2];
-
 #endif
+
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index a44cc73678..c605735170 100755
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -8725,8 +8725,6 @@ void LLPipeline::renderDeferredLighting()
 						count = 0; 
 						mDeferredVB->setBuffer(LLVertexBuffer::MAP_VERTEX);
 						mDeferredVB->drawArrays(LLRender::TRIANGLES, 0, 3);
-// seems like this should be done here...
-						//unbindDeferredShader(gDeferredMultiLightProgram[idx]);
 					}
 				}
 				
-- 
cgit v1.3


From caefe0e74cf553de41c6c8748dd2ea5ef4d82c06 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Sun, 21 Jul 2013 14:28:54 -0700
Subject: NORSPEC-311 fix alpha / opaque lighting diffs

---
 indra/newview/app_settings/settings.xml            | 11 +++
 .../shaders/class1/deferred/alphaF.glsl            | 56 +++++++++++++-
 .../class1/deferred/fullbrightAlphaMaskF.glsl      | 55 +++++++++++++-
 .../shaders/class1/deferred/fullbrightF.glsl       | 73 +++++++++++++++++-
 .../shaders/class1/deferred/fullbrightV.glsl       |  9 ++-
 .../class1/deferred/postDeferredGammaCorrect.glsl  |  2 +-
 indra/newview/lldrawpoolalpha.cpp                  | 14 +++-
 indra/newview/lldrawpoolsimple.cpp                 | 48 +++++++++---
 indra/newview/llviewershadermgr.cpp                | 88 +++++++++++++++++++++-
 indra/newview/llviewershadermgr.h                  |  3 +
 indra/newview/pipeline.cpp                         |  8 +-
 11 files changed, 336 insertions(+), 31 deletions(-)

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

diff --git a/indra/newview/app_settings/settings.xml b/indra/newview/app_settings/settings.xml
index 2d3b32159a..6570189c5b 100755
--- a/indra/newview/app_settings/settings.xml
+++ b/indra/newview/app_settings/settings.xml
@@ -8894,6 +8894,17 @@
       <key>Value</key>
       <real>1.0</real>
     </map>
+  <key>RenderDeferredDisplayGamma</key>
+  <map>
+    <key>Comment</key>
+    <string>Gamma ramp exponent for final correction before display gamma.</string>
+    <key>Persist</key>
+    <integer>1</integer>
+    <key>Type</key>
+    <string>F32</string>
+    <key>Value</key>
+    <real>1.8</real>
+  </map>
     <key>RenderGLCoreProfile</key>
     <map>
       <key>Comment</key>
diff --git a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
index b64852f17b..69b0f8f012 100755
--- a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
@@ -136,6 +136,52 @@ float pcfShadow(sampler2DShadow shadowMap, vec4 stc)
 }
 #endif
 
+#if WATER_FOG
+uniform vec4 waterPlane;
+uniform vec4 waterFogColor;
+uniform float waterFogDensity;
+uniform float waterFogKS;
+
+vec4 applyWaterFogDeferred(vec3 pos, vec4 color)
+{
+	//normalize view vector
+	vec3 view = normalize(pos);
+	float es = -(dot(view, waterPlane.xyz));
+
+	//find intersection point with water plane and eye vector
+	
+	//get eye depth
+	float e0 = max(-waterPlane.w, 0.0);
+	
+	vec3 int_v = waterPlane.w > 0.0 ? view * waterPlane.w/es : vec3(0.0, 0.0, 0.0);
+	
+	//get object depth
+	float depth = length(pos - int_v);
+		
+	//get "thickness" of water
+	float l = max(depth, 0.1);
+
+	float kd = waterFogDensity;
+	float ks = waterFogKS;
+	vec4 kc = waterFogColor;
+	
+	float F = 0.98;
+	
+	float t1 = -kd * pow(F, ks * e0);
+	float t2 = kd + ks * es;
+	float t3 = pow(F, t2*l) - 1.0;
+	
+	float L = min(t1/t2*t3, 1.0);
+	
+	float D = pow(0.98, l*kd);
+	
+	color.rgb = color.rgb * D + kc.rgb * L;
+	color.a = kc.a + color.a;
+	
+	return color;
+}
+#endif
+
 vec3 srgb_to_linear(vec3 cs)
 {
 	
@@ -240,8 +286,9 @@ void main()
 	vec4 gamma_diff = diff;
 
 	diff.rgb = srgb_to_linear(diff.rgb);
-
+	
 #ifdef USE_VERTEX_COLOR
+	diff.rgb *= vertex_color.rgb;
 	float vertex_color_alpha = vertex_color.a;	
 #else
 	float vertex_color_alpha = 1.0;
@@ -266,6 +313,7 @@ void main()
 	color.rgb = scaleSoftClip(color.rgb);
 
 	color.rgb = srgb_to_linear(color.rgb);
+	
 	col = vec4(0,0,0,0);
 	
    #define LIGHT_LOOP(i) col.rgb += light_diffuse[i].rgb * calcPointLightOrSpotLight(pos.xyz, normal, light_position[i], light_direction[i].xyz, light_attenuation[i].x, light_attenuation[i].y, light_attenuation[i].z);
@@ -281,7 +329,11 @@ void main()
 	color.rgb += diff.rgb * vary_pointlight_col_linear * col.rgb;
 
 	color.rgb = linear_to_srgb(color.rgb);
-	//color.rgb = vec3(1,0,1);
+
+#if WATER_FOG
+	color = applyWaterFogDeferred(pos.xyz, color);
+#endif
+
 	frag_color = color;
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/fullbrightAlphaMaskF.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightAlphaMaskF.glsl
index a74256de81..00743abe34 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightAlphaMaskF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/fullbrightAlphaMaskF.glsl
@@ -61,6 +61,52 @@ vec3 linear_to_srgb(vec3 cl)
 	return 1.055 * pow(cl, vec3(0.41666)) - 0.055;
 }
 
+#ifdef WATER_FOG
+uniform vec4 waterPlane;
+uniform vec4 waterFogColor;
+uniform float waterFogDensity;
+uniform float waterFogKS;
+
+vec4 applyWaterFogDeferred(vec3 pos, vec4 color)
+{
+	//normalize view vector
+	vec3 view = normalize(pos);
+	float es = -(dot(view, waterPlane.xyz));
+
+	//find intersection point with water plane and eye vector
+	
+	//get eye depth
+	float e0 = max(-waterPlane.w, 0.0);
+	
+	vec3 int_v = waterPlane.w > 0.0 ? view * waterPlane.w/es : vec3(0.0, 0.0, 0.0);
+	
+	//get object depth
+	float depth = length(pos - int_v);
+		
+	//get "thickness" of water
+	float l = max(depth, 0.1);
+
+	float kd = waterFogDensity;
+	float ks = waterFogKS;
+	vec4 kc = waterFogColor;
+	
+	float F = 0.98;
+	
+	float t1 = -kd * pow(F, ks * e0);
+	float t2 = kd + ks * es;
+	float t3 = pow(F, t2*l) - 1.0;
+	
+	float L = min(t1/t2*t3, 1.0);
+	
+	float D = pow(0.98, l*kd);
+	
+	color.rgb = color.rgb * D + kc.rgb * L;
+	color.a = kc.a + color.a;
+	
+	return color;
+}
+#endif
+
 uniform float minimum_alpha;
 
 void main() 
@@ -72,7 +118,7 @@ void main()
 #endif
 
 	float final_alpha = color.a * vertex_color.a;
-	if (final_alpha < minimum_alpha)
+	if (color.a < minimum_alpha)
 	{
 		discard;
 	}
@@ -84,7 +130,12 @@ void main()
 	color.rgb = fullbrightScaleSoftClip(color.rgb);
 
 	color.rgb = linear_to_srgb(color.rgb);
-	//color.rgb = vec3(1,0,1);
+
+
+#ifdef WATER_FOG
+	color = applyWaterFogDeferred(pos, vec4(color));
+#endif
+
 	frag_color.rgb = color.rgb;
 	frag_color.a   = final_alpha;
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
index 5876efedec..1e8df68a72 100755
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
@@ -35,12 +35,63 @@ out vec4 frag_color;
 uniform sampler2D diffuseMap;
 #endif
 
+VARYING vec3 vary_position;
 VARYING vec4 vertex_color;
 VARYING vec2 vary_texcoord0;
 
 vec3 fullbrightAtmosTransport(vec3 light);
 vec3 fullbrightScaleSoftClip(vec3 light);
 
+#if HAS_ALPHA_MASK
+uniform float minimum_alpha;
+#endif
+
+#ifdef WATER_FOG
+uniform vec4 waterPlane;
+uniform vec4 waterFogColor;
+uniform float waterFogDensity;
+uniform float waterFogKS;
+
+vec4 applyWaterFogDeferred(vec3 pos, vec4 color)
+{
+	//normalize view vector
+	vec3 view = normalize(pos);
+	float es = -(dot(view, waterPlane.xyz));
+
+	//find intersection point with water plane and eye vector
+	
+	//get eye depth
+	float e0 = max(-waterPlane.w, 0.0);
+	
+	vec3 int_v = waterPlane.w > 0.0 ? view * waterPlane.w/es : vec3(0.0, 0.0, 0.0);
+	
+	//get object depth
+	float depth = length(pos - int_v);
+		
+	//get "thickness" of water
+	float l = max(depth, 0.1);
+
+	float kd = waterFogDensity;
+	float ks = waterFogKS;
+	vec4 kc = waterFogColor;
+	
+	float F = 0.98;
+	
+	float t1 = -kd * pow(F, ks * e0);
+	float t2 = kd + ks * es;
+	float t3 = pow(F, t2*l) - 1.0;
+	
+	float L = min(t1/t2*t3, 1.0);
+	
+	float D = pow(0.98, l*kd);
+	
+	color.rgb = color.rgb * D + kc.rgb * L;
+	color.a = kc.a + color.a;
+	
+	return color;
+}
+#endif
+
 vec3 srgb_to_linear(vec3 cs)
 {
 	
@@ -69,15 +120,31 @@ void main()
 	vec4 color = texture2D(diffuseMap, vary_texcoord0.xy);
 #endif
 
+	float final_alpha = color.a * vertex_color.a;
+
+#if HAS_ALPHA_MASK
+	if (color.a < minimum_alpha)
+	{
+		discard;
+	}
+#endif
 
-	color.rgb = srgb_to_linear(color.rgb);
 	color.rgb *= vertex_color.rgb;
+	color.rgb = srgb_to_linear(color.rgb);
+	
 
 	color.rgb = fullbrightAtmosTransport(color.rgb);
 	color.rgb = fullbrightScaleSoftClip(color.rgb);
-
+	
 	color.rgb = linear_to_srgb(color.rgb);
-	//color.rgb = vec3(1,0,1);
+
+#ifdef WATER_FOG
+	vec3 pos = vary_position;
+	vec4 fogged = applyWaterFogDeferred(pos, vec4(color.rgb, final_alpha));
+	color.rgb = fogged.rgb;
+	color.a   = fogged.a;
+#endif
+
 	frag_color.rgb = color.rgb;
 	frag_color.a   = color.a;
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl
index 3f09a15375..22f47b7572 100755
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/fullbrightV.glsl
@@ -40,6 +40,9 @@ vec3 atmosAffectDirectionalLight(float lightIntensity);
 vec3 scaleDownLight(vec3 light);
 vec3 scaleUpLight(vec3 light);
 
+#if WATER_FOG
+VARYING vec3 vary_position;
+#endif
 
 VARYING vec4 vertex_color;
 VARYING vec2 vary_texcoord0;
@@ -53,7 +56,11 @@ void main()
 	passTextureIndex();
 
 	gl_Position = modelview_projection_matrix*vec4(position.xyz, 1.0);
-	
+
+#if WATER_FOG
+	vary_position = pos.xyz;
+#endif
+
 	vary_texcoord0 = (texture_matrix0 * vec4(texcoord0,0,1)).xy;
 	
 	calcAtmospherics(pos.xyz);
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
index a3610bfffa..59b027a045 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
@@ -51,7 +51,7 @@ vec3 linear_to_srgb(vec3 cl)
 void main() 
 {
 	vec4 diff = texture2DRect(diffuseRect, vary_fragcoord);
-	diff.rgb = linear_to_srgb(diff.rgb);
+	diff.rgb = pow(diff.rgb,vec3(texture_gamma));
 	frag_color = diff;
 }
 
diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index e53c783161..973e263572 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -93,11 +93,21 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 
 	if (pass == 0)
 	{
-		simple_shader = &gDeferredAlphaProgram;
-		fullbright_shader = &gObjectFullbrightProgram;
+		if (LLPipeline::sUnderWaterRender)
+		{
+			simple_shader = &gDeferredAlphaWaterProgram;
+			fullbright_shader = &gDeferredFullbrightWaterProgram;
+		}
+		else
+		{
+			simple_shader = &gDeferredAlphaProgram;
+			fullbright_shader = &gDeferredFullbrightProgram;
+		}
+
 		fullbright_shader->bind();
 		fullbright_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f); 
 		fullbright_shader->unbind();
+
 		//prime simple shader (loads shadow relevant uniforms)
 		gPipeline.bindDeferredShader(*simple_shader);
 	}
diff --git a/indra/newview/lldrawpoolsimple.cpp b/indra/newview/lldrawpoolsimple.cpp
index 87fbeaf2c0..d51b84cfbc 100755
--- a/indra/newview/lldrawpoolsimple.cpp
+++ b/indra/newview/lldrawpoolsimple.cpp
@@ -111,7 +111,14 @@ void LLDrawPoolGlow::render(S32 pass)
 	
 	LLGLSLShader* shader = LLPipeline::sUnderWaterRender ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
 	shader->bind();
-	shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.f);
+	if (LLPipeline::sRenderDeferred)
+	{
+		shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
+	}
+	else
+	{
+		shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.f);
+	}	
 
 	LLGLDepthTest depth(GL_TRUE, GL_FALSE);
 	gGL.setColorMask(false, true);
@@ -536,7 +543,15 @@ void LLDrawPoolFullbright::prerender()
 
 void LLDrawPoolFullbright::beginPostDeferredPass(S32 pass)
 {
-	gDeferredFullbrightProgram.bind();
+	if (LLPipeline::sUnderWaterRender)
+	{
+		gDeferredFullbrightWaterProgram.bind();
+	}
+	else
+	{
+		gDeferredFullbrightProgram.bind();
+	}
+	
 }
 
 void LLDrawPoolFullbright::renderPostDeferred(S32 pass)
@@ -550,7 +565,14 @@ void LLDrawPoolFullbright::renderPostDeferred(S32 pass)
 
 void LLDrawPoolFullbright::endPostDeferredPass(S32 pass)
 {
-	gDeferredFullbrightProgram.unbind();
+	if (LLPipeline::sUnderWaterRender)
+	{
+		gDeferredFullbrightWaterProgram.unbind();
+	}
+	else
+	{
+		gDeferredFullbrightProgram.unbind();
+	}
 	LLRenderPass::endRenderPass(pass);
 }
 
@@ -633,15 +655,17 @@ void LLDrawPoolFullbrightAlphaMask::beginPostDeferredPass(S32 pass)
 	} 
 	else 
 	{
-#if LL_DARWIN
-		// the OS X 10.6.8 GeForce driver is a real POS
-		// this is a work-around for NORSPEC-314
-		gObjectFullbrightAlphaMaskProgram.bind();
-		gObjectFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
-#else
-		gDeferredFullbrightAlphaMaskProgram.bind();
-		gDeferredFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
-#endif
+		if (LLPipeline::sUnderWaterRender)
+		{
+			gDeferredFullbrightAlphaMaskWaterProgram.bind();
+			gDeferredFullbrightAlphaMaskWaterProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
+		}
+		else
+		{
+			gDeferredFullbrightAlphaMaskProgram.bind();
+			gDeferredFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
+		}
+		
 	}
 }
 
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index e9c3990e9a..f0e4825279 100755
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -197,9 +197,12 @@ LLGLSLShader			gDeferredShadowAlphaMaskProgram;
 LLGLSLShader			gDeferredAvatarShadowProgram;
 LLGLSLShader			gDeferredAttachmentShadowProgram;
 LLGLSLShader			gDeferredAlphaProgram;
+LLGLSLShader			gDeferredAlphaWaterProgram;
 LLGLSLShader			gDeferredAvatarEyesProgram;
 LLGLSLShader			gDeferredFullbrightProgram;
 LLGLSLShader			gDeferredFullbrightAlphaMaskProgram;
+LLGLSLShader			gDeferredFullbrightWaterProgram;
+LLGLSLShader			gDeferredFullbrightAlphaMaskWaterProgram;
 LLGLSLShader			gDeferredEmissiveProgram;
 LLGLSLShader			gDeferredPostProgram;
 LLGLSLShader			gDeferredCoFProgram;
@@ -301,9 +304,12 @@ LLViewerShaderMgr::LLViewerShaderMgr() :
 	mShaderList.push_back(&gDeferredMaterialWaterProgram[9+LLMaterial::SHADER_COUNT]);
 	mShaderList.push_back(&gDeferredMaterialWaterProgram[13+LLMaterial::SHADER_COUNT]);	
 	mShaderList.push_back(&gDeferredAlphaProgram);
+	mShaderList.push_back(&gDeferredAlphaWaterProgram);
 	mShaderList.push_back(&gDeferredSkinnedAlphaProgram);
 	mShaderList.push_back(&gDeferredFullbrightProgram);
-	mShaderList.push_back(&gDeferredFullbrightAlphaMaskProgram);	
+	mShaderList.push_back(&gDeferredFullbrightAlphaMaskProgram);
+	mShaderList.push_back(&gDeferredFullbrightWaterProgram);
+	mShaderList.push_back(&gDeferredFullbrightAlphaMaskWaterProgram);	
 	mShaderList.push_back(&gDeferredFullbrightShinyProgram);
 	mShaderList.push_back(&gDeferredSkinnedFullbrightShinyProgram);
 	mShaderList.push_back(&gDeferredSkinnedFullbrightProgram);
@@ -1145,8 +1151,11 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAvatarProgram.unload();
 		gDeferredAvatarAlphaProgram.unload();
 		gDeferredAlphaProgram.unload();
+		gDeferredAlphaWaterProgram.unload();
 		gDeferredFullbrightProgram.unload();
 		gDeferredFullbrightAlphaMaskProgram.unload();
+		gDeferredFullbrightWaterProgram.unload();
+		gDeferredFullbrightAlphaMaskWaterProgram.unload();
 		gDeferredEmissiveProgram.unload();
 		gDeferredAvatarEyesProgram.unload();
 		gDeferredPostProgram.unload();		
@@ -1518,7 +1527,8 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAlphaProgram.mShaderFiles.push_back(make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER_ARB));
 		gDeferredAlphaProgram.mShaderFiles.push_back(make_pair("deferred/alphaF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredAlphaProgram.addPermutation("USE_INDEXED_TEX", "1");
-		gDeferredAlphaProgram.addPermutation("USE_VERTEX_COLOR", "1");
+		//gDeferredAlphaProgram.addPermutation("USE_VERTEX_COLOR", "1");
+		gDeferredAlphaProgram.addPermutation("WATER_FOG", "0");
 		gDeferredAlphaProgram.addPermutation("HAS_SHADOW", mVertexShaderLevel[SHADER_DEFERRED] > 1 ? "1" : "0");
 		gDeferredAlphaProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 
@@ -1529,6 +1539,42 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAlphaProgram.mFeatures.hasLighting = true;
 	}
 
+	if (success)
+	{
+		gDeferredAlphaWaterProgram.mName = "Deferred Alpha Underwater Shader";
+		gDeferredAlphaWaterProgram.mFeatures.atmosphericHelpers = true;
+		gDeferredAlphaWaterProgram.mFeatures.calculatesLighting = false;
+		gDeferredAlphaWaterProgram.mFeatures.calculatesAtmospherics = true;
+		gDeferredAlphaWaterProgram.mFeatures.hasGamma = true;
+		gDeferredAlphaWaterProgram.mFeatures.hasAtmospherics = true;
+		gDeferredAlphaWaterProgram.mFeatures.hasLighting = false;
+		gDeferredAlphaWaterProgram.mFeatures.isAlphaLighting = true;
+		gDeferredAlphaWaterProgram.mFeatures.disableTextureIndex = true; //hack to disable auto-setup of texture channels
+		if (mVertexShaderLevel[SHADER_DEFERRED] < 1)
+		{
+			gDeferredAlphaWaterProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+		}
+		else
+		{ //shave off some texture units for shadow maps
+			gDeferredAlphaWaterProgram.mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels - 6, 1);
+		}
+		gDeferredAlphaWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
+		gDeferredAlphaWaterProgram.mShaderFiles.clear();
+		gDeferredAlphaWaterProgram.mShaderFiles.push_back(make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER_ARB));
+		gDeferredAlphaWaterProgram.mShaderFiles.push_back(make_pair("deferred/alphaF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredAlphaWaterProgram.addPermutation("USE_INDEXED_TEX", "1");
+		//gDeferredAlphaWaterProgram.addPermutation("USE_VERTEX_COLOR", "1");
+		gDeferredAlphaWaterProgram.addPermutation("WATER_FOG", "1");
+		gDeferredAlphaWaterProgram.addPermutation("HAS_SHADOW", mVertexShaderLevel[SHADER_DEFERRED] > 1 ? "1" : "0");
+		gDeferredAlphaWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
+
+		success = gDeferredAlphaWaterProgram.createShader(NULL, NULL);
+
+		// Hack
+		gDeferredAlphaWaterProgram.mFeatures.calculatesLighting = true;
+		gDeferredAlphaWaterProgram.mFeatures.hasLighting = true;
+	}
+
 	if (success)
 	{
 		gDeferredAvatarEyesProgram.mName = "Deferred Avatar Eyes Shader";
@@ -1559,18 +1605,52 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 
 	if (success)
 	{
-		gDeferredFullbrightAlphaMaskProgram.mName = "Deferred Fullbright Alpha Mask Shader";
+		gDeferredFullbrightAlphaMaskProgram.mName = "Deferred Fullbright Alpha Masking Shader";
 		gDeferredFullbrightAlphaMaskProgram.mFeatures.calculatesAtmospherics = true;
 		gDeferredFullbrightAlphaMaskProgram.mFeatures.hasGamma = true;
 		gDeferredFullbrightAlphaMaskProgram.mFeatures.hasTransport = true;
 		gDeferredFullbrightAlphaMaskProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
 		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.clear();
 		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
-		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightAlphaMaskF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredFullbrightAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
+		gDeferredFullbrightAlphaMaskProgram.addPermutation("HAS_ALPHA_MASK","1");
 		success = gDeferredFullbrightAlphaMaskProgram.createShader(NULL, NULL);
 	}
 
+	if (success)
+	{
+		gDeferredFullbrightWaterProgram.mName = "Deferred Fullbright Underwater Shader";
+		gDeferredFullbrightWaterProgram.mFeatures.calculatesAtmospherics = true;
+		gDeferredFullbrightWaterProgram.mFeatures.hasGamma = true;
+		gDeferredFullbrightWaterProgram.mFeatures.hasTransport = true;
+		gDeferredFullbrightWaterProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+		gDeferredFullbrightWaterProgram.mShaderFiles.clear();
+		gDeferredFullbrightWaterProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
+		gDeferredFullbrightWaterProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredFullbrightWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
+		gDeferredFullbrightWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
+		gDeferredFullbrightWaterProgram.addPermutation("WATER_FOG","1");
+		success = gDeferredFullbrightWaterProgram.createShader(NULL, NULL);
+	}
+
+	if (success)
+	{
+		gDeferredFullbrightAlphaMaskWaterProgram.mName = "Deferred Fullbright Underwater Alpha Masking Shader";
+		gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.calculatesAtmospherics = true;
+		gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.hasGamma = true;
+		gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.hasTransport = true;
+		gDeferredFullbrightAlphaMaskWaterProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+		gDeferredFullbrightAlphaMaskWaterProgram.mShaderFiles.clear();
+		gDeferredFullbrightAlphaMaskWaterProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
+		gDeferredFullbrightAlphaMaskWaterProgram.mShaderFiles.push_back(make_pair("deferred/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredFullbrightAlphaMaskWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
+		gDeferredFullbrightAlphaMaskWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
+		gDeferredFullbrightAlphaMaskWaterProgram.addPermutation("HAS_ALPHA_MASK","1");
+		gDeferredFullbrightAlphaMaskWaterProgram.addPermutation("WATER_FOG","1");
+		success = gDeferredFullbrightAlphaMaskWaterProgram.createShader(NULL, NULL);
+	}
+
 	if (success)
 	{
 		gDeferredFullbrightShinyProgram.mName = "Deferred FullbrightShiny Shader";
diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h
index f14180d957..5fa9b82170 100755
--- a/indra/newview/llviewershadermgr.h
+++ b/indra/newview/llviewershadermgr.h
@@ -366,6 +366,9 @@ extern LLGLSLShader			gDeferredAttachmentShadowProgram;
 extern LLGLSLShader			gDeferredAlphaProgram;
 extern LLGLSLShader			gDeferredFullbrightProgram;
 extern LLGLSLShader			gDeferredFullbrightAlphaMaskProgram;
+extern LLGLSLShader			gDeferredAlphaWaterProgram;
+extern LLGLSLShader			gDeferredFullbrightWaterProgram;
+extern LLGLSLShader			gDeferredFullbrightAlphaMaskWaterProgram;
 extern LLGLSLShader			gDeferredEmissiveProgram;
 extern LLGLSLShader			gDeferredAvatarEyesProgram;
 extern LLGLSLShader			gDeferredAvatarAlphaProgram;
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index d89ad615ae..c593c85ce7 100755
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -8831,9 +8831,9 @@ void LLPipeline::renderDeferredLighting()
 		
 		gDeferredPostGammaCorrectProgram.uniform2f(LLShaderMgr::DEFERRED_SCREEN_RES, mScreen.getWidth(), mScreen.getHeight());
 		
-		F32 gamma = 1.0/2.2;
+		F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
 
-		gDeferredPostGammaCorrectProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, gamma);
+		gDeferredPostGammaCorrectProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 		
 		gGL.begin(LLRender::TRIANGLE_STRIP);
 		gGL.texCoord2f(tc1.mV[0], tc1.mV[1]);
@@ -9380,9 +9380,9 @@ void LLPipeline::renderDeferredLightingToRT(LLRenderTarget* target)
 		
 		gDeferredPostGammaCorrectProgram.uniform2f(LLShaderMgr::DEFERRED_SCREEN_RES, target->getWidth(), target->getHeight());
 		
-		F32 gamma = 1.0/2.2;
+		F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
 
-		gDeferredPostGammaCorrectProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, gamma);
+		gDeferredPostGammaCorrectProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 		
 		gGL.begin(LLRender::TRIANGLE_STRIP);
 		gGL.texCoord2f(tc1.mV[0], tc1.mV[1]);
-- 
cgit v1.3


From e290dd3fa175c2a891cc4f4e0c401edb10cedfb4 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Wed, 24 Jul 2013 04:03:27 -0700
Subject: NORSPEC-311 make post deferred (alpha objects) respect same gamma
 ramp as deferred (opaque objects)

---
 indra/llrender/llshadermgr.cpp                                |  3 ++-
 indra/llrender/llshadermgr.h                                  |  3 ++-
 .../newview/app_settings/shaders/class1/deferred/alphaF.glsl  | 11 +++++++++--
 .../app_settings/shaders/class1/deferred/fullbrightF.glsl     |  5 +++++
 .../app_settings/shaders/class1/deferred/materialF.glsl       |  9 +++++++--
 .../shaders/class1/deferred/postDeferredGammaCorrect.glsl     |  8 ++++++--
 .../app_settings/shaders/class1/deferred/softenLightF.glsl    |  9 ++++++---
 .../app_settings/shaders/class2/deferred/softenLightF.glsl    |  7 +++++--
 indra/newview/lldrawpoolalpha.cpp                             |  5 +++++
 indra/newview/pipeline.cpp                                    |  4 ++--
 10 files changed, 49 insertions(+), 15 deletions(-)

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

diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index fea4ee2819..942f6dc86f 100755
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -1138,7 +1138,8 @@ void LLShaderMgr::initAttribsAndUniforms()
 	
 	mReservedUniforms.push_back("global_gamma");
 	mReservedUniforms.push_back("texture_gamma");
-	
+	mReservedUniforms.push_back("display_gamma");
+
 	mReservedUniforms.push_back("specular_color");
 	mReservedUniforms.push_back("env_intensity");
 
diff --git a/indra/llrender/llshadermgr.h b/indra/llrender/llshadermgr.h
index c049e935b8..2cbeea5049 100755
--- a/indra/llrender/llshadermgr.h
+++ b/indra/llrender/llshadermgr.h
@@ -168,7 +168,8 @@ public:
 		
 		GLOBAL_GAMMA,
 		TEXTURE_GAMMA,
-		
+		DISPLAY_GAMMA,
+
 		SPECULAR_COLOR,
 		ENVIRONMENT_INTENSITY,
 		
diff --git a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
index b928761358..e836e9750f 100755
--- a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
@@ -35,6 +35,8 @@ out vec4 frag_color;
 #define frag_color gl_FragColor
 #endif
 
+uniform float display_gamma;
+
 #if HAS_SHADOW
 uniform sampler2DShadow shadowMap0;
 uniform sampler2DShadow shadowMap1;
@@ -204,6 +206,11 @@ vec3 linear_to_srgb(vec3 cl)
     cs = {  1.055 * cl^0.41666 - 0.055,   0.0031308 <= cl < 1
             {  1.0,                                       cl >= 1*/
 
+	cl = clamp(cl, vec3(0), vec3(1));
+
+	if ((cl.r+cl.g+cl.b) < 0.0031308)
+		return 12.92 * cl;
+
 	return 1.055 * pow(cl, vec3(0.41666)) - 0.055;
 }
 
@@ -295,7 +302,7 @@ void main()
 #ifdef USE_VERTEX_COLOR
 	float vertex_color_alpha = diff.a * vertex_color.a;	
 #else
-	float vertex_color_alpha = 1.0;
+	float vertex_color_alpha = diff.a;
 #endif
 	
 	vec3 normal = vary_norm; 
@@ -333,7 +340,7 @@ void main()
 
 	color.rgb += diff.rgb * vary_pointlight_col_linear * col.rgb;
 
-	color.rgb = linear_to_srgb(color.rgb);
+	color.rgb = pow(color.rgb,vec3(display_gamma));
 
 #ifdef WATER_FOG
 	color = applyWaterFogDeferred(pos.xyz, color);
diff --git a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
index da2585f662..da4ebfea58 100755
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
@@ -117,6 +117,11 @@ vec3 linear_to_srgb(vec3 cl)
     cs = {  1.055 * cl^0.41666 - 0.055,   0.0031308 <= cl < 1
             {  1.0,                                       cl >= 1*/
 
+	cl = clamp(cl, vec3(0), vec3(1));
+
+	if ((cl.r+cl.g+cl.b) < 0.0031308)
+		return 12.92 * cl;
+
 	return 1.055 * pow(cl, vec3(0.41666)) - 0.055;
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
index e028eef900..a46fbd9516 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
@@ -53,6 +53,11 @@ vec3 linear_to_srgb(vec3 cl)
     cs = {  1.055 * cl^0.41666 - 0.055,   0.0031308 <= cl < 1
             {  1.0,                                       cl >= 1*/
 
+	cl = clamp(cl, vec3(0), vec3(1));
+
+	if ((cl.r+cl.g+cl.b) < 0.0031308)
+		return 12.92 * cl;
+
 	return 1.055 * pow(cl, vec3(0.41666)) - 0.055;
 }
 
@@ -701,7 +706,7 @@ void main()
 		col += spec_contrib;
 	}
 
-	col = mix(col.rgb, old_diffcol.rgb, diffuse.a);
+	col = mix(col.rgb, diffcol.rgb, diffuse.a);
 
 	if (envIntensity > 0.0)
 	{
@@ -754,7 +759,7 @@ void main()
 	frag_color.a   = al;
 
 #else
-	//final_color.rgb = vec3(1,0,1);
+	//final_color.rgb = old_diffcol.rgb;
 	frag_data[0] = final_color;
 	frag_data[1] = final_specular; // XYZ = Specular color. W = Specular exponent.
 	frag_data[2] = final_normal; // XY = Normal.  Z = Env. intensity.
diff --git a/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl b/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
index 59b027a045..01f9d99682 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/postDeferredGammaCorrect.glsl
@@ -36,7 +36,7 @@ uniform sampler2DRect diffuseRect;
 uniform vec2 screen_res;
 VARYING vec2 vary_fragcoord;
 
-uniform float texture_gamma;
+uniform float display_gamma;
 
 vec3 linear_to_srgb(vec3 cl)
 {
@@ -45,13 +45,17 @@ vec3 linear_to_srgb(vec3 cl)
     cs = {  1.055 * cl^0.41666 - 0.055,   0.0031308 <= cl < 1
             {  1.0,                                       cl >= 1*/
 
+	cl = clamp(cl, vec3(0), vec3(1));
+
+	if ((cl.r+cl.g+cl.b) < 0.0031308)
+		return 12.92 * cl;
 	return 1.055 * pow(cl, vec3(0.41666)) - 0.055;
 }
 
 void main() 
 {
 	vec4 diff = texture2DRect(diffuseRect, vary_fragcoord);
-	diff.rgb = pow(diff.rgb,vec3(texture_gamma));
+	diff.rgb = pow(diff.rgb,vec3(display_gamma));
 	frag_color = diff;
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
index 6f11e8427c..045b449bbf 100755
--- a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
@@ -101,6 +101,11 @@ vec3 linear_to_srgb(vec3 cl)
     cs = {  1.055 * cl^0.41666 - 0.055,   0.0031308 <= cl < 1
             {  1.0,                                       cl >= 1*/
 
+	cl = clamp(cl, vec3(0), vec3(1));
+
+	if ((cl.r+cl.g+cl.b) < 0.0031308)
+		return 12.92 * cl;
+
 	return 1.055 * pow(cl, vec3(0.41666)) - 0.055;
 }
 
@@ -403,9 +408,7 @@ void main()
 		ambient = (1.0-ambient);
 
 		col.rgb *= ambient;
-
-		col += atmosAffectDirectionalLight(max(min(da, 1.0), 0.0));
-	
+		col += atmosAffectDirectionalLight(max(min(da, 1.0), 0.0));	
 		col *= diffuse.rgb;
 	
 		vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
diff --git a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
index dbb32c40f4..fa67c4ecea 100755
--- a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
@@ -100,6 +100,11 @@ vec3 linear_to_srgb(vec3 cl)
     cs = {  1.055 * cl^0.41666 - 0.055,   0.0031308 <= cl < 1
             {  1.0,                                       cl >= 1*/
 
+	cl = clamp(cl, vec3(0), vec3(1));
+
+	if ((cl.r+cl.g+cl.b) < 0.0031308)
+		return 12.92 * cl;
+
 	return 1.055 * pow(cl, vec3(0.41666)) - 0.055;
 }
 
@@ -467,8 +472,6 @@ void main()
 			bloom = fogged.a;
 		#endif
 
-
-
 		col = srgb_to_linear(col);
 
 		//col = vec3(1,0,1);
diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 973e263572..6302cf6b00 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -103,13 +103,18 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 			simple_shader = &gDeferredAlphaProgram;
 			fullbright_shader = &gDeferredFullbrightProgram;
 		}
+		
+		F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
 
 		fullbright_shader->bind();
 		fullbright_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f); 
+		fullbright_shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 		fullbright_shader->unbind();
 
 		//prime simple shader (loads shadow relevant uniforms)
 		gPipeline.bindDeferredShader(*simple_shader);
+
+		simple_shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 	}
 	else
 	{
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index c593c85ce7..165b28beb5 100755
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -8833,7 +8833,7 @@ void LLPipeline::renderDeferredLighting()
 		
 		F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
 
-		gDeferredPostGammaCorrectProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
+		gDeferredPostGammaCorrectProgram.uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 		
 		gGL.begin(LLRender::TRIANGLE_STRIP);
 		gGL.texCoord2f(tc1.mV[0], tc1.mV[1]);
@@ -9382,7 +9382,7 @@ void LLPipeline::renderDeferredLightingToRT(LLRenderTarget* target)
 		
 		F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
 
-		gDeferredPostGammaCorrectProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
+		gDeferredPostGammaCorrectProgram.uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 		
 		gGL.begin(LLRender::TRIANGLE_STRIP);
 		gGL.texCoord2f(tc1.mV[0], tc1.mV[1]);
-- 
cgit v1.3


From b44e7303d85ffc59afe34a97342d83a04b180c48 Mon Sep 17 00:00:00 2001
From: "Graham Madarasz (Graham Linden)" <graham@lindenlab.com>
Date: Mon, 29 Jul 2013 18:59:45 -0700
Subject: NORSPEC-314 WIP fix srgb_mac use and issues found with RenderDebugGL
 on Mac

---
 indra/llrender/llshadermgr.cpp      |  5 ++++
 indra/llrender/llvertexbuffer.cpp   | 57 +++++++++++++++++++++++++++++++++----
 indra/newview/lldrawpoolalpha.cpp   |  3 +-
 indra/newview/llviewershadermgr.cpp |  1 -
 indra/newview/pipeline.cpp          | 19 ++++++-------
 5 files changed, 68 insertions(+), 17 deletions(-)

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

diff --git a/indra/llrender/llshadermgr.cpp b/indra/llrender/llshadermgr.cpp
index c3e76f5e0e..21b8322bf1 100755
--- a/indra/llrender/llshadermgr.cpp
+++ b/indra/llrender/llshadermgr.cpp
@@ -177,7 +177,12 @@ BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
 
 	if (features->hasSRGB)
 	{
+#if LL_DARWIN
+		if (!shader->attachObject("deferred/srgb_mac.glsl"))
+
+#else
 		if (!shader->attachObject("deferred/srgb.glsl"))
+#endif
 		{
 			return FALSE;
 		}
diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
index b1ef6e0576..f1249a842a 100755
--- a/indra/llrender/llvertexbuffer.cpp
+++ b/indra/llrender/llvertexbuffer.cpp
@@ -753,10 +753,10 @@ void LLVertexBuffer::drawRange(U32 mode, U32 start, U32 end, U32 count, U32 indi
 	U16* idx = ((U16*) getIndicesPointer())+indices_offset;
 
 	stop_glerror();
-	LLGLSLShader::startProfile();
-	glDrawRangeElements(sGLMode[mode], start, end, count, GL_UNSIGNED_SHORT, 
+		LLGLSLShader::startProfile();
+		glDrawRangeElements(sGLMode[mode], start, end, count, GL_UNSIGNED_SHORT, 
 		idx);
-	LLGLSLShader::stopProfile(count, mode);
+		LLGLSLShader::stopProfile(count, mode);
 	stop_glerror();
 
 	
@@ -2209,11 +2209,32 @@ void LLVertexBuffer::bindForFeedback(U32 channel, U32 type, U32 index, U32 count
 #endif
 }
 
+void DumpComponents(U32 mask)
+{
+	llinfos <<
+	((mask & LLVertexBuffer::MAP_VERTEX)		? "vertex:"		: " ") <<
+	((mask & LLVertexBuffer::MAP_NORMAL)		? "norms:"		: " ") <<
+	((mask & LLVertexBuffer::MAP_TEXCOORD0)	? "TC0:"		: " ") <<
+	((mask & LLVertexBuffer::MAP_TEXCOORD1)	? "TC1:"		: " ") <<
+	((mask & LLVertexBuffer::MAP_TEXCOORD2)	? "TC2:"		: " ") <<
+	((mask & LLVertexBuffer::MAP_TEXCOORD3)	? "TC3:"		: " ") <<
+	((mask & LLVertexBuffer::MAP_COLOR)		? "color:"		: " ") <<
+	((mask & LLVertexBuffer::MAP_EMISSIVE)	? "emissive:"	: " ") <<
+	((mask & LLVertexBuffer::MAP_TANGENT)	? "tangents"	: " ") << llendl;
+}
+
 // Set for rendering
 void LLVertexBuffer::setBuffer(U32 data_mask)
 {
 	flush();
 
+	if((getTypeMask() & data_mask) != data_mask)
+	{
+		llinfos << "Missing VB stream components." << llendl;
+		DumpComponents(data_mask & ~getTypeMask());
+		data_mask &= getTypeMask();
+	}
+	
 	//set up pointers if the data mask is different ...
 	bool setup = (sLastMask != data_mask);
 
@@ -2237,15 +2258,36 @@ void LLVertexBuffer::setBuffer(U32 data_mask)
 				}
 			}
 
+            static bool done_done_it = false;
+            
+            if (!done_done_it)
+            {
+                done_done_it = true;
+            
+            llinfos <<
+             "MAP_VERTEX: " << MAP_VERTEX <<
+             "MAP_VERTEX: " << MAP_NORMAL <<
+             "MAP_VERTEX: " << MAP_TEXCOORD0 <<
+             "MAP_VERTEX: " << MAP_TEXCOORD1 <<
+             "MAP_VERTEX: " << MAP_TEXCOORD2 <<
+             "MAP_VERTEX: " << MAP_TEXCOORD3 <<
+             "MAP_VERTEX: " << MAP_COLOR <<
+             "MAP_VERTEX: " << MAP_EMISSIVE <<
+             "MAP_VERTEX: " << MAP_TANGENT << llendl;
+            
+            
+            }
+                
 			if ((data_mask & required_mask) != required_mask)
 			{
 				
 				U32 unsatisfied_mask = (required_mask & ~data_mask);
 				U32 i = 0;
 
-				while (i < 15)
+				while (i < TYPE_MAX)
 				{
-					switch ((unsatisfied_mask & (1 << i)))
+                    U32 unsatisfied_flag = unsatisfied_mask & (1 << i);
+					switch (unsatisfied_flag)
 					{
 						case MAP_VERTEX: llinfos << "Missing vert pos" << llendl; break;
 						case MAP_NORMAL: llinfos << "Missing normals" << llendl; break;
@@ -2264,6 +2306,11 @@ void LLVertexBuffer::setBuffer(U32 data_mask)
 					}					
 				}
 
+                if (unsatisfied_mask & (1 << TYPE_INDEX))
+                {
+                    llinfos << "Missing indices" << llendl;
+                }
+
 				llerrs << "Shader consumption mismatches data provision." << llendl;
 			}
 		}
diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 6302cf6b00..f4f63e1042 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -529,7 +529,8 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
 					}
 				}
 
-				params.mVertexBuffer->setBuffer(mask);
+				params.mVertexBuffer->setBuffer(mask & ~(params.mFullbright ? (LLVertexBuffer::MAP_TEXTURE_INDEX | LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2) : 0));
+                
 				params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
 				gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
 				
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index 545a236f81..73177d549b 100755
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -1444,7 +1444,6 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		{
 			gDeferredMultiLightProgram[i].mName = llformat("Deferred MultiLight Shader %d", i);
 			gDeferredMultiLightProgram[i].mShaderFiles.clear();
-			gDeferredMultiLightProgram[i].mFeatures.hasSRGB = true;
 			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 = mVertexShaderLevel[SHADER_DEFERRED];
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 165b28beb5..05390f64f0 100755
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -8695,12 +8695,6 @@ void LLPipeline::renderDeferredLighting()
 				unbindDeferredShader(gDeferredSpotLightProgram);
 			}
 
-			//reset mDeferredVB to fullscreen triangle
-			mDeferredVB->getVertexStrider(vert);
-			vert[0].set(-1,1,0);
-			vert[1].set(-1,-3,0);
-			vert[2].set(3,1,0);
-
 			{
 				LLGLDepthTest depth(GL_FALSE);
 
@@ -8719,6 +8713,10 @@ void LLPipeline::renderDeferredLighting()
 
 				F32 far_z = 0.f;
 
+				bindDeferredShader(gDeferredMultiLightProgram[0]);
+
+				mDeferredVB->setBuffer(LLVertexBuffer::MAP_VERTEX);
+				
 				while (!fullscreen_lights.empty())
 				{
 					LLFastTimer ftm(FTM_FULLSCREEN_LIGHTS);
@@ -8743,14 +8741,15 @@ void LLPipeline::renderDeferredLighting()
 						gDeferredMultiLightProgram[idx].uniform4fv(LLShaderMgr::MULTI_LIGHT_COL, count, (GLfloat*) col);
 						gDeferredMultiLightProgram[idx].uniform1f(LLShaderMgr::MULTI_LIGHT_FAR_Z, far_z);
 						far_z = 0.f;
-						count = 0; 
-						mDeferredVB->setBuffer(LLVertexBuffer::MAP_VERTEX);
+						count = 0;
+                        mDeferredVB->setBuffer(LLVertexBuffer::MAP_VERTEX);
 						mDeferredVB->drawArrays(LLRender::TRIANGLES, 0, 3);
+						unbindDeferredShader(gDeferredMultiLightProgram[idx]);
 					}
 				}
-				
-				unbindDeferredShader(gDeferredMultiLightProgram[0]);
 
+				unbindDeferredShader(gDeferredMultiLightProgram[0]);
+				
 				bindDeferredShader(gDeferredMultiSpotLightProgram);
 
 				gDeferredMultiSpotLightProgram.enableTexture(LLShaderMgr::DEFERRED_PROJECTION);
-- 
cgit v1.3


From 4a3c99beb228680b297e9a3388df3290b594cd57 Mon Sep 17 00:00:00 2001
From: "Graham Madarasz (Graham Linden)" <graham@lindenlab.com>
Date: Thu, 1 Aug 2013 10:34:36 -0700
Subject: NORSPEC-304 fix glow pass rendering over alpha pass after ALM toggle

---
 indra/newview/lldrawpoolalpha.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

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

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index f4f63e1042..bd8ecdb166 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -545,8 +545,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
 
 					emissive_shader->bind();
 					
-					// glow doesn't use vertex colors from the mesh data
-					params.mVertexBuffer->setBuffer((mask & ~LLVertexBuffer::MAP_COLOR) | LLVertexBuffer::MAP_EMISSIVE);
+					params.mVertexBuffer->setBuffer(mask & LLVertexBuffer::MAP_EMISSIVE);
 					
 					// do the actual drawing, again
 					params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
-- 
cgit v1.3


From 2d065562f1dabd090a12b75f1aa4233ce9d7ce33 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Thu, 1 Aug 2013 14:01:37 -0700
Subject: NORSPEC-336 fix glow regression from 304 fix

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

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

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index bd8ecdb166..1cc81fa863 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -545,7 +545,10 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
 
 					emissive_shader->bind();
 					
-					params.mVertexBuffer->setBuffer(mask & LLVertexBuffer::MAP_EMISSIVE);
+					U32 final_mask = params.mFullbright ? (mask | LLVertexBuffer::MAP_EMISSIVE)
+																	: ((mask & ~LLVertexBuffer::MAP_COLOR) | LLVertexBuffer::MAP_EMISSIVE);
+
+					params.mVertexBuffer->setBuffer(final_mask);
 					
 					// do the actual drawing, again
 					params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
-- 
cgit v1.3


From 14c7108ca3f646a8f7fd0d024ca200919bbf79bf Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Sat, 3 Aug 2013 06:52:56 -0700
Subject: NORSPEC-304 NORSPEC-334 NORSPEC-336 fix black glow overdraw without
 breaking glow

---
 indra/newview/lldrawpoolalpha.cpp | 5 +----
 indra/newview/llvovolume.cpp      | 5 ++++-
 2 files changed, 5 insertions(+), 5 deletions(-)

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

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 1cc81fa863..237579cec5 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -545,10 +545,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
 
 					emissive_shader->bind();
 					
-					U32 final_mask = params.mFullbright ? (mask | LLVertexBuffer::MAP_EMISSIVE)
-																	: ((mask & ~LLVertexBuffer::MAP_COLOR) | LLVertexBuffer::MAP_EMISSIVE);
-
-					params.mVertexBuffer->setBuffer(final_mask);
+					params.mVertexBuffer->setBuffer((mask & ~LLVertexBuffer::MAP_COLOR) | LLVertexBuffer::MAP_EMISSIVE);
 					
 					// do the actual drawing, again
 					params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 406591046f..3eb5b19de5 100755
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -4881,7 +4881,10 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
 	if (emissive)
 	{ //emissive faces are present, include emissive byte to preserve batching
 		simple_mask = simple_mask | LLVertexBuffer::MAP_EMISSIVE;
-		alpha_mask = alpha_mask | LLVertexBuffer::MAP_EMISSIVE;
+		
+		// doing this seems to cause NORSPEC-304
+		//alpha_mask = alpha_mask | LLVertexBuffer::MAP_EMISSIVE;
+
 		bump_mask = bump_mask | LLVertexBuffer::MAP_EMISSIVE;
 		fullbright_mask = fullbright_mask | LLVertexBuffer::MAP_EMISSIVE;
 		norm_mask = norm_mask | LLVertexBuffer::MAP_EMISSIVE;
-- 
cgit v1.3


From 9557926fff5992276811c1b1d9aa371ede9004a8 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Sat, 3 Aug 2013 08:25:03 -0700
Subject: NORSPEC-332 fix fullbright tex indexing fail

---
 indra/newview/lldrawpoolalpha.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 237579cec5..fca4492fbb 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -529,7 +529,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
 					}
 				}
 
-				params.mVertexBuffer->setBuffer(mask & ~(params.mFullbright ? (LLVertexBuffer::MAP_TEXTURE_INDEX | LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2) : 0));
+				params.mVertexBuffer->setBuffer(mask & ~(params.mFullbright ? (LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2) : 0));
                 
 				params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
 				gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
-- 
cgit v1.3


From fe69b4049bdbdf36a179ccc28a2f253af13e61c5 Mon Sep 17 00:00:00 2001
From: "Graham Madarasz (Graham Linden)" <graham@lindenlab.com>
Date: Mon, 5 Aug 2013 10:16:17 -0700
Subject: NORSPEC-304 NORSPEC-336 another attempt as resolving black glow
 overdraw without breaking glow (even for alpha-blended) faces

---
 indra/newview/lldrawpoolalpha.cpp | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

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

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index fca4492fbb..b5d37ba5cc 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -128,14 +128,22 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 		gObjectFullbrightAlphaMaskProgram.setMinimumAlpha(0.33f);
 	}
 
-	if (LLPipeline::sUnderWaterRender)
-	{
-		emissive_shader = &gObjectEmissiveWaterProgram;
-	}
-	else
-	{
-		emissive_shader = &gObjectEmissiveProgram;
-	}
+
+    if (LLPipeline::sRenderDeferred)
+    {
+		emissive_shader = &gDeferredEmissiveProgram;
+    }
+    else
+    {
+		if (LLPipeline::sUnderWaterRender)
+		{
+			emissive_shader = &gObjectEmissiveWaterProgram;
+		}
+		else
+		{
+			emissive_shader = &gObjectEmissiveProgram;
+		}
+    }
 
 	deferred_render = TRUE;
 	if (mVertexShaderLevel > 0)
-- 
cgit v1.3


From 5b400d50e1f25667e2c865d85fd93546ffe7f96f Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Tue, 6 Aug 2013 14:16:46 -0700
Subject: NORSPEC-322 NORSPEC-342 fix issues with black impostors and missing
 alpha attachments on impostors

---
 .../shaders/class1/deferred/impostorF.glsl         | 31 +++++++++++++++++++---
 indra/newview/lldrawpoolalpha.cpp                  |  9 +++++--
 indra/newview/lldrawpoolavatar.cpp                 | 21 +++------------
 indra/newview/pipeline.cpp                         | 21 +++++++--------
 4 files changed, 48 insertions(+), 34 deletions(-)

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

diff --git a/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl b/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
index bc0719cb82..d52744103f 100755
--- a/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
@@ -38,6 +38,31 @@ uniform sampler2D specularMap;
 
 VARYING vec2 vary_texcoord0;
 
+vec2 encode_normal(vec3 n)
+{
+	float f = sqrt(8 * n.z + 8);
+	return n.xy / f + 0.5;
+}
+
+vec3 linear_to_srgb(vec3 cl)
+{
+	cl = clamp(cl, vec3(0), vec3(1));
+	vec3 low_range  = cl * 12.92;
+	vec3 high_range = 1.055 * pow(cl, vec3(0.41666)) - 0.055;
+	bvec3 lt = lessThan(cl,vec3(0.0031308));
+
+#ifdef OLD_SELECT
+	vec3 result;
+	result.r = lt.r ? low_range.r : high_range.r;
+	result.g = lt.g ? low_range.g : high_range.g;
+	result.b = lt.b ? low_range.b : high_range.b;
+    return result;
+#else
+	return mix(high_range, low_range, lt);
+#endif
+
+}
+
 void main() 
 {
 	vec4 col = texture2D(diffuseMap, vary_texcoord0.xy);
@@ -47,7 +72,7 @@ void main()
 		discard;
 	}
 
-	frag_data[0] = vec4(col.rgb, col.a * 0.005);
-	frag_data[1] = texture2D(specularMap, vary_texcoord0.xy);
-	frag_data[2] = vec4(texture2D(normalMap, vary_texcoord0.xy).xyz, 0.0);
+	frag_data[0] = vec4(linear_to_srgb(col.rgb), col.a);
+	frag_data[1] = vec4(texture2D(specularMap, vary_texcoord0.xy));
+	frag_data[2] = vec4(texture2D(normalMap, vary_texcoord0.xy).xy,0,0);
 }
diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index b5d37ba5cc..60e22c08dc 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -224,8 +224,13 @@ void LLDrawPoolAlpha::render(S32 pass)
 		gGL.setColorMask(true, true);
 	}
 	
-	LLGLDepthTest depth(GL_TRUE, LLDrawPoolWater::sSkipScreenCopy || 
-				(deferred_render && pass == 1) ? GL_TRUE : GL_FALSE);
+	bool write_depth = LLDrawPoolWater::sSkipScreenCopy
+						 || (deferred_render && pass == 1)
+						 // we want depth written so that rendered alpha will
+						 // contribute to the alpha mask used for impostors
+						 || LLPipeline::sImpostorRender;
+
+	LLGLDepthTest depth(GL_TRUE, write_depth ? GL_TRUE : GL_FALSE);
 
 	if (deferred_render && pass == 1)
 	{
diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp
index e2a23ef56f..9434b51685 100755
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -505,7 +505,7 @@ S32 LLDrawPoolAvatar::getNumDeferredPasses()
 {
 	if (LLPipeline::sImpostorRender)
 	{
-		return 3;
+		return 19;
 	}
 	else
 	{
@@ -690,28 +690,15 @@ void LLDrawPoolAvatar::beginDeferredImpostor()
 		LLVOAvatar::sNumVisibleAvatars = 0;
 	}
 
-#if DEFERRED_IMPOSTORS
 	sVertexProgram = &gDeferredImpostorProgram;
-
-	specular_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::SPECULAR_MAP);
-	normal_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::DEFERRED_NORMAL);
-	sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
-#else
-	sVertexProgram = &gImpostorProgram;
-	sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
-#endif
-	sVertexProgram->bind();
+	gPipeline.bindDeferredShader(*sVertexProgram);
 	sVertexProgram->setMinimumAlpha(0.01f);
 }
 
 void LLDrawPoolAvatar::endDeferredImpostor()
 {
 	sShaderLevel = mVertexShaderLevel;
-	sVertexProgram->disableTexture(LLViewerShaderMgr::DEFERRED_NORMAL);
-	sVertexProgram->disableTexture(LLViewerShaderMgr::SPECULAR_MAP);
-	sVertexProgram->disableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
-	sVertexProgram->unbind();
-	gGL.getTexUnit(0)->activate();
+	gPipeline.unbindDeferredShader(*sVertexProgram);
 }
 
 void LLDrawPoolAvatar::beginDeferredRigid()
@@ -1268,7 +1255,6 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
 
 		if (impostor)
 		{
-#if DEFERRED_IMPOSTORS
 			if (LLPipeline::sRenderDeferred && !LLPipeline::sReflectionRender && avatarp->mImpostor.isComplete()) 
 			{
 				if (normal_channel > -1)
@@ -1280,7 +1266,6 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
 					avatarp->mImpostor.bindTexture(1, specular_channel);
 				}
 			}
-#endif
 			avatarp->renderImpostor(LLColor4U(255,255,255,255), sDiffuseChannel);
 		}
 		return;
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 9aa375767b..29b7e30655 100755
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -11358,15 +11358,18 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
 		if (!avatar->mImpostor.isComplete())
 		{
 			LLFastTimer t(FTM_IMPOSTOR_ALLOCATE);
-			avatar->mImpostor.allocate(resX,resY,GL_RGBA,TRUE,FALSE);
+			
 
-#if DEFERRED_IMPOSTORS
 			if (LLPipeline::sRenderDeferred)
 			{
+				avatar->mImpostor.allocate(resX,resY,GL_SRGB8_ALPHA8,TRUE,FALSE);
 				addDeferredAttachments(avatar->mImpostor);
 			}
-#endif
-			
+			else
+			{
+				avatar->mImpostor.allocate(resX,resY,GL_RGBA,TRUE,FALSE);
+			}
+
 			gGL.getTexUnit(0)->bind(&avatar->mImpostor);
 			gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
 			gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
@@ -11374,38 +11377,34 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
 		else if(resX != avatar->mImpostor.getWidth() || resY != avatar->mImpostor.getHeight())
 		{
 			LLFastTimer t(FTM_IMPOSTOR_RESIZE);
-			avatar->mImpostor.resize(resX,resY,GL_RGBA);
+			avatar->mImpostor.resize(resX,resY,LLPipeline::sRenderDeferred ? GL_SRGB8_ALPHA8 : GL_RGBA);
 		}
 
 		avatar->mImpostor.bindTarget();		
 	}
 
-#if DEFERRED_IMPOSTORS
 	if (LLPipeline::sRenderDeferred)
 	{
-		avatar->mImpostor.clear();
+		avatar->mImpostor.clear();		
 		renderGeomDeferred(camera);
 		renderGeomPostDeferred(camera);
 	}
 	else
-#endif
 	{		
 		LLGLEnable scissor(GL_SCISSOR_TEST);
 		glScissor(0, 0, resX, resY);	
 		avatar->mImpostor.clear();
 		renderGeom(camera);
 	}
-	
+
 	{ //create alpha mask based on depth buffer (grey out if muted)
 		LLFastTimer t(FTM_IMPOSTOR_BACKGROUND);
 
-#if DEFERRED_IMPOSTORS
 		if (LLPipeline::sRenderDeferred)
 		{
 			GLuint buff = GL_COLOR_ATTACHMENT0;
 			glDrawBuffersARB(1, &buff);
 		}
-#endif
 
 		LLGLDisable blend(GL_BLEND);
 
-- 
cgit v1.3


From bfe2377a9a3061094e3c1fa10bb0afed06cac709 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Wed, 7 Aug 2013 08:42:35 -0700
Subject: NORSPEC-342 WIP fix issues with skimpy clothes getting too skimpy in
 impostors

---
 .../shaders/class1/deferred/impostorF.glsl         | 20 ++++++++++++---
 indra/newview/lldrawpoolalpha.cpp                  |  2 +-
 indra/newview/pipeline.cpp                         | 29 +++++++++++++++++++++-
 indra/newview/pipeline.h                           |  1 +
 4 files changed, 47 insertions(+), 5 deletions(-)

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

diff --git a/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl b/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
index d52744103f..d1eaabf901 100755
--- a/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
@@ -38,6 +38,17 @@ uniform sampler2D specularMap;
 
 VARYING vec2 vary_texcoord0;
 
+vec3 decode_normal (vec2 enc)
+{
+    vec2 fenc = enc*4-2;
+    float f = dot(fenc,fenc);
+    float g = sqrt(1-f/4);
+    vec3 n;
+    n.xy = fenc*g;
+    n.z = 1-f/2;
+    return n;
+}
+
 vec2 encode_normal(vec3 n)
 {
 	float f = sqrt(8 * n.z + 8);
@@ -72,7 +83,10 @@ void main()
 		discard;
 	}
 
-	frag_data[0] = vec4(linear_to_srgb(col.rgb), col.a);
-	frag_data[1] = vec4(texture2D(specularMap, vary_texcoord0.xy));
-	frag_data[2] = vec4(texture2D(normalMap, vary_texcoord0.xy).xy,0,0);
+	vec4 norm = texture2D(normalMap,   vary_texcoord0.xy);
+	vec4 spec = texture2D(specularMap, vary_texcoord0.xy);
+
+	frag_data[0] = vec4(col.rgb, col.a);
+	frag_data[1] = spec;
+	frag_data[2] = vec4(norm.xy,0,0);
 }
diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 60e22c08dc..8b2cbb1b9d 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -228,7 +228,7 @@ void LLDrawPoolAlpha::render(S32 pass)
 						 || (deferred_render && pass == 1)
 						 // we want depth written so that rendered alpha will
 						 // contribute to the alpha mask used for impostors
-						 || LLPipeline::sImpostorRender;
+						 || LLPipeline::sImpostorRenderAlphaDepthPass;
 
 	LLGLDepthTest depth(GL_TRUE, write_depth ? GL_TRUE : GL_FALSE);
 
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 29b7e30655..9378c89eb7 100755
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -379,6 +379,7 @@ BOOL	LLPipeline::sWaterReflections = FALSE;
 BOOL	LLPipeline::sRenderGlow = FALSE;
 BOOL	LLPipeline::sReflectionRender = FALSE;
 BOOL	LLPipeline::sImpostorRender = FALSE;
+BOOL	LLPipeline::sImpostorRenderAlphaDepthPass = FALSE;
 BOOL	LLPipeline::sUnderWaterRender = FALSE;
 BOOL	LLPipeline::sTextureBindTest = FALSE;
 BOOL	LLPipeline::sRenderFrameTest = FALSE;
@@ -11387,14 +11388,40 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
 	{
 		avatar->mImpostor.clear();		
 		renderGeomDeferred(camera);
+
+		renderGeomPostDeferred(camera);		
+
+		// Shameless hack time: render it all again,
+		// this time writing the depth
+		// values we need to generate the alpha mask below
+		// while preserving the alpha-sorted color rendering
+		// from the previous pass
+		//
+		sImpostorRenderAlphaDepthPass = true;
+		// depth-only here...
+		//
+		gGL.setColorMask(false,false);
 		renderGeomPostDeferred(camera);
+		sImpostorRenderAlphaDepthPass = false;
 	}
 	else
-	{		
+	{
 		LLGLEnable scissor(GL_SCISSOR_TEST);
 		glScissor(0, 0, resX, resY);	
 		avatar->mImpostor.clear();
 		renderGeom(camera);
+
+		// Shameless hack time: render it all again,
+		// this time writing the depth
+		// values we need to generate the alpha mask below
+		// while preserving the alpha-sorted color rendering
+		// from the previous pass
+		//
+		sImpostorRenderAlphaDepthPass = true;
+		// depth-only here...
+		//
+		gGL.setColorMask(false,false);
+		renderGeom(camera);
 	}
 
 	{ //create alpha mask based on depth buffer (grey out if muted)
diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h
index 36b293b998..5e68524067 100755
--- a/indra/newview/pipeline.h
+++ b/indra/newview/pipeline.h
@@ -588,6 +588,7 @@ public:
 	static BOOL				sPickAvatar;
 	static BOOL				sReflectionRender;
 	static BOOL				sImpostorRender;
+	static BOOL				sImpostorRenderAlphaDepthPass;
 	static BOOL				sUnderWaterRender;
 	static BOOL				sRenderGlow;
 	static BOOL				sTextureBindTest;
-- 
cgit v1.3


From 79686b6974bb07063f2ff470d4ff0cfd38ac8847 Mon Sep 17 00:00:00 2001
From: "Graham Madarasz (Graham Linden)" <graham@lindenlab.com>
Date: Wed, 7 Aug 2013 16:30:27 -0700
Subject: NORSPEC-342 fix alpha objects appearing black in impostor images

---
 indra/newview/lldrawpoolalpha.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

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

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 8b2cbb1b9d..ba83c95518 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -548,7 +548,8 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
 				gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
 				
 				// If this alpha mesh has glow, then draw it a second time to add the destination-alpha (=glow).  Interleaving these state-changing calls could be expensive, but glow must be drawn Z-sorted with alpha.
-				if (current_shader && 
+				if (current_shader &&
+                    !LLPipeline::sImpostorRender &&
 					draw_glow_for_this_partition &&
 					params.mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_EMISSIVE))
 				{
-- 
cgit v1.3


From 51dfcb9c67f7c3464bf3640adfdd87a061f60390 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Mon, 12 Aug 2013 15:55:25 -0700
Subject: NORSPEC-342 WIP MATBUG-347 make impostor rendering not contribute to
 depth for mostly-transparent buffer pixels, aka hair in ALM only

---
 .../shaders/class1/deferred/alphaF.glsl            | 19 +++++++++--
 .../shaders/class1/deferred/impostorF.glsl         |  2 ++
 indra/newview/lldrawpoolalpha.cpp                  | 11 +++++--
 indra/newview/lldrawpoolavatar.cpp                 |  8 ++---
 indra/newview/llviewershadermgr.cpp                | 37 ++++++++++++++++++++++
 indra/newview/llviewershadermgr.h                  |  1 +
 indra/newview/pipeline.cpp                         |  5 +++
 7 files changed, 74 insertions(+), 9 deletions(-)

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

diff --git a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
index d0c7cc9dde..f35ff25dcb 100755
--- a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
@@ -531,6 +531,19 @@ void main()
 	vec4 diff = texture2D(diffuseMap,vary_texcoord0.xy);
 #endif
 
+#if FOR_IMPOSTOR
+	vec4 color;
+	color.rgb = diff.rgb;
+	color.a   = diff.a;
+
+	// Insure we don't pollute depth with invis pixels in impostor rendering
+	//
+	if (color.a < 0.01)
+	{
+		discard;
+	}
+#else
+
 #ifdef USE_VERTEX_COLOR
 	float final_alpha = diff.a * vertex_color.a;
 	diff.rgb *= vertex_color.rgb;
@@ -538,6 +551,7 @@ void main()
 	float final_alpha = diff.a;
 #endif
 
+
 	vec4 gamma_diff = diff;	
 	diff.rgb = srgb_to_linear(diff.rgb);
 
@@ -567,11 +581,10 @@ void main()
 	ambient = (1.0-ambient);
 
 	color.rgb *= ambient;
-
 	color.rgb += atmosAffectDirectionalLight(final_da);
 	color.rgb *= gamma_diff.rgb;
 
-	color.rgb = mix(diff.rgb, color.rgb, final_alpha);
+	//color.rgb = mix(diff.rgb, color.rgb, final_alpha);
 
 	color.rgb = atmosLighting(color.rgb);
 	color.rgb = scaleSoftClip(color.rgb);
@@ -600,6 +613,8 @@ void main()
 
 #ifdef WATER_FOG
 	color = applyWaterFogDeferred(pos.xyz, color);
+#endif
+
 #endif
 
 	frag_color = color;
diff --git a/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl b/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
index d1eaabf901..506323fdce 100755
--- a/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/impostorF.glsl
@@ -86,6 +86,8 @@ void main()
 	vec4 norm = texture2D(normalMap,   vary_texcoord0.xy);
 	vec4 spec = texture2D(specularMap, vary_texcoord0.xy);
 
+	col.rgb = linear_to_srgb(col.rgb);
+
 	frag_data[0] = vec4(col.rgb, col.a);
 	frag_data[1] = spec;
 	frag_data[2] = vec4(norm.xy,0,0);
diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index ba83c95518..a8010d17d6 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -93,7 +93,12 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 
 	if (pass == 0)
 	{
-		if (LLPipeline::sUnderWaterRender)
+		if (LLPipeline::sImpostorRender)
+		{
+			simple_shader = &gDeferredAlphaImpostorProgram;
+			fullbright_shader = &gDeferredFullbrightProgram;
+		}
+		else if (LLPipeline::sUnderWaterRender)
 		{
 			simple_shader = &gDeferredAlphaWaterProgram;
 			fullbright_shader = &gDeferredFullbrightWaterProgram;
@@ -116,7 +121,7 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 
 		simple_shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 	}
-	else
+	else if (!LLPipeline::sImpostorRender)
 	{
 		//update depth buffer sampler
 		gPipeline.mScreen.flush();
@@ -156,7 +161,7 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 
 void LLDrawPoolAlpha::endPostDeferredPass(S32 pass) 
 { 
-	if (pass == 1)
+	if (pass == 1 && !LLPipeline::sImpostorRender)
 	{
 		gPipeline.mDeferredDepth.flush();
 		gPipeline.mScreen.bindTarget();
diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp
index 9dbc85d121..8b1e934224 100755
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -691,7 +691,7 @@ void LLDrawPoolAvatar::beginDeferredImpostor()
 	}
 
 	sVertexProgram = &gDeferredImpostorProgram;
-    specular_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::SPECULAR_MAP);
+	specular_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::SPECULAR_MAP);
 	normal_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::DEFERRED_NORMAL);
 	sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
 	gPipeline.bindDeferredShader(*sVertexProgram);
@@ -701,12 +701,12 @@ void LLDrawPoolAvatar::beginDeferredImpostor()
 void LLDrawPoolAvatar::endDeferredImpostor()
 {
 	sShaderLevel = mVertexShaderLevel;
-    sVertexProgram->disableTexture(LLViewerShaderMgr::DEFERRED_NORMAL);
+   sVertexProgram->disableTexture(LLViewerShaderMgr::DEFERRED_NORMAL);
 	sVertexProgram->disableTexture(LLViewerShaderMgr::SPECULAR_MAP);
 	sVertexProgram->disableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
 	gPipeline.unbindDeferredShader(*sVertexProgram);
-    sVertexProgram = NULL;
-    sDiffuseChannel = 0;
+   sVertexProgram = NULL;
+   sDiffuseChannel = 0;
 }
 
 void LLDrawPoolAvatar::beginDeferredRigid()
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index 264655029a..b2f7949388 100755
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -197,6 +197,7 @@ LLGLSLShader			gDeferredShadowAlphaMaskProgram;
 LLGLSLShader			gDeferredAvatarShadowProgram;
 LLGLSLShader			gDeferredAttachmentShadowProgram;
 LLGLSLShader			gDeferredAlphaProgram;
+LLGLSLShader			gDeferredAlphaImpostorProgram;
 LLGLSLShader			gDeferredAlphaWaterProgram;
 LLGLSLShader			gDeferredAvatarEyesProgram;
 LLGLSLShader			gDeferredFullbrightProgram;
@@ -304,6 +305,8 @@ LLViewerShaderMgr::LLViewerShaderMgr() :
 	mShaderList.push_back(&gDeferredMaterialWaterProgram[9+LLMaterial::SHADER_COUNT]);
 	mShaderList.push_back(&gDeferredMaterialWaterProgram[13+LLMaterial::SHADER_COUNT]);	
 	mShaderList.push_back(&gDeferredAlphaProgram);
+	mShaderList.push_back(&gDeferredAlphaProgram);
+	mShaderList.push_back(&gDeferredAlphaImpostorProgram);
 	mShaderList.push_back(&gDeferredAlphaWaterProgram);
 	mShaderList.push_back(&gDeferredSkinnedAlphaProgram);
 	mShaderList.push_back(&gDeferredFullbrightProgram);
@@ -1531,6 +1534,40 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredAlphaProgram.mFeatures.hasLighting = true;
 	}
 
+	if (success)
+	{
+		gDeferredAlphaImpostorProgram.mName = "Deferred Alpha Shader";
+
+		gDeferredAlphaImpostorProgram.mFeatures.calculatesLighting = false;
+		gDeferredAlphaImpostorProgram.mFeatures.hasLighting = false;
+		gDeferredAlphaImpostorProgram.mFeatures.isAlphaLighting = true;
+		gDeferredAlphaImpostorProgram.mFeatures.disableTextureIndex = true; //hack to disable auto-setup of texture channels
+		if (mVertexShaderLevel[SHADER_DEFERRED] < 1)
+		{
+			gDeferredAlphaImpostorProgram.mFeatures.mIndexedTextureChannels = LLGLSLShader::sIndexedTextureChannels;
+		}
+		else
+		{ //shave off some texture units for shadow maps
+			gDeferredAlphaImpostorProgram.mFeatures.mIndexedTextureChannels = llmax(LLGLSLShader::sIndexedTextureChannels - 6, 1);
+		}
+
+		gDeferredAlphaImpostorProgram.mShaderFiles.clear();
+		gDeferredAlphaImpostorProgram.mShaderFiles.push_back(make_pair("deferred/alphaV.glsl", GL_VERTEX_SHADER_ARB));
+		gDeferredAlphaImpostorProgram.mShaderFiles.push_back(make_pair("deferred/alphaF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredAlphaImpostorProgram.addPermutation("USE_INDEXED_TEX", "1");
+		gDeferredAlphaImpostorProgram.addPermutation("HAS_SHADOW", mVertexShaderLevel[SHADER_DEFERRED] > 1 ? "1" : "0");
+		gDeferredAlphaImpostorProgram.addPermutation("USE_VERTEX_COLOR", "1");
+		gDeferredAlphaImpostorProgram.addPermutation("FOR_IMPOSTOR", "1");
+
+		gDeferredAlphaImpostorProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
+
+		success = gDeferredAlphaImpostorProgram.createShader(NULL, NULL);
+
+		// Hack
+		gDeferredAlphaImpostorProgram.mFeatures.calculatesLighting = true;
+		gDeferredAlphaImpostorProgram.mFeatures.hasLighting = true;
+	}
+
 	if (success)
 	{
 		gDeferredAlphaWaterProgram.mName = "Deferred Alpha Underwater Shader";
diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h
index 5fa9b82170..08c1ce6911 100755
--- a/indra/newview/llviewershadermgr.h
+++ b/indra/newview/llviewershadermgr.h
@@ -364,6 +364,7 @@ extern LLGLSLShader			gDeferredPostGammaCorrectProgram;
 extern LLGLSLShader			gDeferredAvatarShadowProgram;
 extern LLGLSLShader			gDeferredAttachmentShadowProgram;
 extern LLGLSLShader			gDeferredAlphaProgram;
+extern LLGLSLShader			gDeferredAlphaImpostorProgram;
 extern LLGLSLShader			gDeferredFullbrightProgram;
 extern LLGLSLShader			gDeferredFullbrightAlphaMaskProgram;
 extern LLGLSLShader			gDeferredAlphaWaterProgram;
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 9378c89eb7..31baf4188b 100755
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -11402,7 +11402,9 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
 		//
 		gGL.setColorMask(false,false);
 		renderGeomPostDeferred(camera);
+
 		sImpostorRenderAlphaDepthPass = false;
+
 	}
 	else
 	{
@@ -11418,10 +11420,13 @@ void LLPipeline::generateImpostor(LLVOAvatar* avatar)
 		// from the previous pass
 		//
 		sImpostorRenderAlphaDepthPass = true;
+
 		// depth-only here...
 		//
 		gGL.setColorMask(false,false);
 		renderGeom(camera);
+
+		sImpostorRenderAlphaDepthPass = false;
 	}
 
 	{ //create alpha mask based on depth buffer (grey out if muted)
-- 
cgit v1.3


From a43a762c0ddf3ecac2056b36d0ede1f99e71231e Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Mon, 12 Aug 2013 17:22:47 -0700
Subject: NORSPEC-342 fix blocky hair in ALM from writing depth for transparent
 pixels in impostor rendering

---
 indra/newview/lldrawpoolalpha.cpp   |  8 +++++++-
 indra/newview/lldrawpoolsimple.cpp  |  6 +++++-
 indra/newview/llviewershadermgr.cpp | 25 +++++++++++++++++++++++++
 indra/newview/llviewershadermgr.h   |  1 +
 4 files changed, 38 insertions(+), 2 deletions(-)

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

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index a8010d17d6..5ebc58fb7d 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -181,7 +181,13 @@ void LLDrawPoolAlpha::beginRenderPass(S32 pass)
 {
 	LLFastTimer t(FTM_RENDER_ALPHA);
 	
-	if (LLPipeline::sUnderWaterRender)
+	if (LLPipeline::sImpostorRender)
+	{
+		simple_shader = &gObjectSimpleImpostorProgram;
+		fullbright_shader = &gObjectFullbrightProgram;
+		emissive_shader = &gObjectEmissiveProgram;
+	}
+	else if (LLPipeline::sUnderWaterRender)
 	{
 		simple_shader = &gObjectSimpleWaterProgram;
 		fullbright_shader = &gObjectFullbrightWaterProgram;
diff --git a/indra/newview/lldrawpoolsimple.cpp b/indra/newview/lldrawpoolsimple.cpp
index aee9d19d19..8926f64c64 100755
--- a/indra/newview/lldrawpoolsimple.cpp
+++ b/indra/newview/lldrawpoolsimple.cpp
@@ -156,7 +156,11 @@ void LLDrawPoolSimple::beginRenderPass(S32 pass)
 {
 	LLFastTimer t(FTM_RENDER_SIMPLE);
 
-	if (LLPipeline::sUnderWaterRender)
+	if (LLPipeline::sImpostorRender)
+	{
+		simple_shader = &gObjectSimpleImpostorProgram;
+	}
+	else if (LLPipeline::sUnderWaterRender)
 	{
 		simple_shader = &gObjectSimpleWaterProgram;
 	}
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index b2f7949388..995eb599b8 100755
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -83,6 +83,7 @@ LLGLSLShader	gAlphaMaskProgram;
 
 //object shaders
 LLGLSLShader		gObjectSimpleProgram;
+LLGLSLShader		gObjectSimpleImpostorProgram;
 LLGLSLShader		gObjectPreviewProgram;
 LLGLSLShader		gObjectSimpleWaterProgram;
 LLGLSLShader		gObjectSimpleAlphaMaskProgram;
@@ -237,6 +238,7 @@ LLViewerShaderMgr::LLViewerShaderMgr() :
 	mShaderList.push_back(&gWaterProgram);
 	mShaderList.push_back(&gAvatarEyeballProgram); 
 	mShaderList.push_back(&gObjectSimpleProgram);
+	mShaderList.push_back(&gObjectSimpleImpostorProgram);
 	mShaderList.push_back(&gObjectPreviewProgram);
 	mShaderList.push_back(&gImpostorProgram);
 	mShaderList.push_back(&gObjectFullbrightNoColorProgram);
@@ -729,6 +731,7 @@ void LLViewerShaderMgr::unloadShaders()
 	gObjectFullbrightNoColorProgram.unload();
 	gObjectFullbrightNoColorWaterProgram.unload();
 	gObjectSimpleProgram.unload();
+	gObjectSimpleImpostorProgram.unload();
 	gObjectPreviewProgram.unload();
 	gImpostorProgram.unload();
 	gObjectSimpleAlphaMaskProgram.unload();
@@ -2020,6 +2023,7 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		gObjectFullbrightNoColorProgram.unload();
 		gObjectFullbrightNoColorWaterProgram.unload();
 		gObjectSimpleProgram.unload();
+		gObjectSimpleImpostorProgram.unload();
 		gObjectPreviewProgram.unload();
 		gImpostorProgram.unload();
 		gObjectSimpleAlphaMaskProgram.unload();
@@ -2440,6 +2444,27 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		success = gObjectSimpleProgram.createShader(NULL, NULL);
 	}
 
+	if (success)
+	{
+		gObjectSimpleImpostorProgram.mName = "Simple Impostor Shader";
+		gObjectSimpleImpostorProgram.mFeatures.calculatesLighting = true;
+		gObjectSimpleImpostorProgram.mFeatures.calculatesAtmospherics = true;
+		gObjectSimpleImpostorProgram.mFeatures.hasGamma = true;
+		gObjectSimpleImpostorProgram.mFeatures.hasAtmospherics = true;
+		gObjectSimpleImpostorProgram.mFeatures.hasLighting = true;
+		gObjectSimpleImpostorProgram.mFeatures.mIndexedTextureChannels = 0;
+		// force alpha mask version of lighting so we can weed out
+		// transparent pixels from impostor temp buffer
+		//
+		gObjectSimpleImpostorProgram.mFeatures.hasAlphaMask = true; 
+		gObjectSimpleImpostorProgram.mShaderFiles.clear();
+		gObjectSimpleImpostorProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER_ARB));
+		gObjectSimpleImpostorProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gObjectSimpleImpostorProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
+		
+		success = gObjectSimpleImpostorProgram.createShader(NULL, NULL);
+	}
+
 	if (success)
 	{
 		gObjectSimpleWaterProgram.mName = "Simple Water Shader";
diff --git a/indra/newview/llviewershadermgr.h b/indra/newview/llviewershadermgr.h
index 08c1ce6911..e4684c19d5 100755
--- a/indra/newview/llviewershadermgr.h
+++ b/indra/newview/llviewershadermgr.h
@@ -242,6 +242,7 @@ extern LLGLSLShader			gOneTextureNoColorProgram;
 
 //object shaders
 extern LLGLSLShader			gObjectSimpleProgram;
+extern LLGLSLShader			gObjectSimpleImpostorProgram;
 extern LLGLSLShader			gObjectPreviewProgram;
 extern LLGLSLShader			gObjectSimpleAlphaMaskProgram;
 extern LLGLSLShader			gObjectSimpleWaterProgram;
-- 
cgit v1.3


From 55c36ab7dbee9463c3df72d60cdc882cdeb69b9d Mon Sep 17 00:00:00 2001
From: Arun Bapu <arun@lindenlab.com>
Date: Wed, 14 Aug 2013 11:35:06 -0700
Subject: Fix for NORSPEC 271 - Transparent prims in Materials Viewer are
 incorrectly affecting depth of field by modifying the depth buffer

---
 indra/newview/lldrawpoolalpha.cpp | 27 ++++++++++++++++++++++-----
 indra/newview/lldrawpoolalpha.h   |  2 +-
 2 files changed, 23 insertions(+), 6 deletions(-)

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

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index ba83c95518..9c510d360f 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -100,7 +100,7 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 		}
 		else
 		{
-			simple_shader = &gDeferredAlphaProgram;
+		simple_shader = &gDeferredAlphaProgram;
 			fullbright_shader = &gDeferredFullbrightProgram;
 		}
 		
@@ -276,11 +276,11 @@ void LLDrawPoolAlpha::render(S32 pass)
 
 	if (mVertexShaderLevel > 0)
 	{
-		renderAlpha(getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX | LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2);
+		renderAlpha(getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX | LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2, pass);
 	}
 	else
 	{
-		renderAlpha(getVertexDataMask());
+		renderAlpha(getVertexDataMask(), pass);
 	}
 
 	gGL.setColorMask(true, false);
@@ -352,7 +352,7 @@ void LLDrawPoolAlpha::renderAlphaHighlight(U32 mask)
 	}
 }
 
-void LLDrawPoolAlpha::renderAlpha(U32 mask)
+void LLDrawPoolAlpha::renderAlpha(U32 mask, S32 pass)
 {
 	BOOL initialized_lighting = FALSE;
 	BOOL light_enabled = TRUE;
@@ -385,6 +385,23 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
 					continue;
 				}
 
+				// Fix for bug - NORSPEC-271
+				// If the face is more than 90% transparent, then don't update the Depth buffer for Dof
+				// We don't want the nearly invisible objects to cause of DoF effects
+				if(pass == 1)
+				{
+					LLFace*	face = params.mFace;
+					if(face)
+					{
+						const LLTextureEntry* tep = face->getTextureEntry();
+						if(tep)
+						{
+							if(tep->getColor().mV[3] < 0.1f)
+								continue;
+						}
+					}
+				}
+
 				LLRenderPass::applyModelMatrix(params);
 				
 				LLMaterial* mat = NULL;
@@ -548,7 +565,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask)
 				gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
 				
 				// If this alpha mesh has glow, then draw it a second time to add the destination-alpha (=glow).  Interleaving these state-changing calls could be expensive, but glow must be drawn Z-sorted with alpha.
-				if (current_shader &&
+				if (current_shader && 
                     !LLPipeline::sImpostorRender &&
 					draw_glow_for_this_partition &&
 					params.mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_EMISSIVE))
diff --git a/indra/newview/lldrawpoolalpha.h b/indra/newview/lldrawpoolalpha.h
index 43122218ed..d064a3a324 100755
--- a/indra/newview/lldrawpoolalpha.h
+++ b/indra/newview/lldrawpoolalpha.h
@@ -63,7 +63,7 @@ public:
 	/*virtual*/ void prerender();
 
 	void renderGroupAlpha(LLSpatialGroup* group, U32 type, U32 mask, BOOL texture = TRUE);
-	void renderAlpha(U32 mask);
+	void renderAlpha(U32 mask, S32 pass);
 	void renderAlphaHighlight(U32 mask);
 		
 	static BOOL sShowDebugAlpha;
-- 
cgit v1.3


From 8675ed0491efee860ac1b2d1d5fe88d150768217 Mon Sep 17 00:00:00 2001
From: Graham Linden <graham@lindenlab.com>
Date: Mon, 19 Aug 2013 16:04:28 -0700
Subject: Fix merge regressions from missed changes to LoD updates

---
 indra/llrender/llvertexbuffer.cpp  | 28 ----------------------------
 indra/newview/lldrawpoolalpha.cpp  |  3 +--
 indra/newview/lldrawpoolavatar.cpp | 10 ++++++++++
 indra/newview/llvovolume.cpp       |  7 +++++++
 4 files changed, 18 insertions(+), 30 deletions(-)

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

diff --git a/indra/llrender/llvertexbuffer.cpp b/indra/llrender/llvertexbuffer.cpp
index fd7b846928..6a7cec3bad 100755
--- a/indra/llrender/llvertexbuffer.cpp
+++ b/indra/llrender/llvertexbuffer.cpp
@@ -2209,39 +2209,11 @@ void LLVertexBuffer::bindForFeedback(U32 channel, U32 type, U32 index, U32 count
 #endif
 }
 
-void DumpComponents(U32 mask)
-{
-	llinfos <<
-	((mask & LLVertexBuffer::MAP_VERTEX)		? "vertex:"		: " ") <<
-	((mask & LLVertexBuffer::MAP_NORMAL)		? "norms:"		: " ") <<
-	((mask & LLVertexBuffer::MAP_TEXCOORD0)	? "TC0:"		: " ") <<
-	((mask & LLVertexBuffer::MAP_TEXCOORD1)	? "TC1:"		: " ") <<
-	((mask & LLVertexBuffer::MAP_TEXCOORD2)	? "TC2:"		: " ") <<
-	((mask & LLVertexBuffer::MAP_TEXCOORD3)	? "TC3:"		: " ") <<
-	((mask & LLVertexBuffer::MAP_COLOR)		? "color:"		: " ") <<
-	((mask & LLVertexBuffer::MAP_EMISSIVE)	? "emissive:"	: " ") <<
-	((mask & LLVertexBuffer::MAP_TANGENT)	? "tangents"	: " ") << llendl;
-}
-
 // Set for rendering
 void LLVertexBuffer::setBuffer(U32 data_mask)
 {
 	flush();
 
-	if((getTypeMask() & data_mask) != data_mask)
-	{
-		if (gDebugGL)
-		{			
-			// Dump info about what was missing
-			//
-			DumpComponents(data_mask & ~getTypeMask());
-			llwarns << "Missing VB stream components. ^^" << llendl;
-		}
-		// Make sure we don't write checks we can't cash below...
-		//
-		data_mask = (data_mask & getTypeMask());
-	}
-	
 	//set up pointers if the data mask is different ...
 	bool setup = (sLastMask != data_mask);
 
diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 500fad4f78..e4ebfea665 100755
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -399,7 +399,7 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, S32 pass)
 				// Fix for bug - NORSPEC-271
 				// If the face is more than 90% transparent, then don't update the Depth buffer for Dof
 				// We don't want the nearly invisible objects to cause of DoF effects
-				if(pass == 1)
+				if(pass == 1 && !LLPipeline::sImpostorRender)
 				{
 					LLFace*	face = params.mFace;
 					if(face)
@@ -577,7 +577,6 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, S32 pass)
 				
 				// If this alpha mesh has glow, then draw it a second time to add the destination-alpha (=glow).  Interleaving these state-changing calls could be expensive, but glow must be drawn Z-sorted with alpha.
 				if (current_shader && 
-                    !LLPipeline::sImpostorRender &&
 					draw_glow_for_this_partition &&
 					params.mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_EMISSIVE))
 				{
diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp
index 120920a4b0..66bbc6819b 100755
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -136,6 +136,16 @@ void LLDrawPoolAvatar::prerender()
 	{
 		sBufferUsage = GL_STREAM_DRAW_ARB;
 	}
+
+	if (!mDrawFace.empty())
+	{
+		const LLFace *facep = mDrawFace[0];
+		if (facep && facep->getDrawable())
+		{
+			LLVOAvatar* avatarp = (LLVOAvatar *)facep->getDrawable()->getVObj().get();
+			updateRiggedVertexBuffers(avatarp);
+		}
+	}
 }
 
 LLMatrix4& LLDrawPoolAvatar::getModelView()
diff --git a/indra/newview/llvovolume.cpp b/indra/newview/llvovolume.cpp
index 33b26494de..6b3611b796 100755
--- a/indra/newview/llvovolume.cpp
+++ b/indra/newview/llvovolume.cpp
@@ -4863,7 +4863,14 @@ void LLVolumeGeometryManager::rebuildGeom(LLSpatialGroup* group)
 
 			if (is_rigged)
 			{
+				if (!drawablep->isState(LLDrawable::RIGGED))
+				{
 				drawablep->setState(LLDrawable::RIGGED);
+
+					//first time this is drawable is being marked as rigged,
+					// do another LoD update to use avatar bounding box
+					vobj->updateLOD();
+				}
 			}
 			else
 			{
-- 
cgit v1.3