1 files changed, 349 insertions, 87 deletions

diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp
index 91394f0767..f3f0b3cce2 100755
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -63,6 +63,7 @@ F32 LLDrawPoolAvatar::sMinimumAlpha = 0.2f;
 
 
 static bool is_deferred_render = false;
+static bool is_post_deferred_render = false;
 
 extern BOOL gUseGLPick;
 
@@ -194,6 +195,9 @@ void LLDrawPoolAvatar::beginDeferredPass(S32 pass)
 	case 4:
 		beginDeferredRiggedBump();
 		break;
+	default:
+		beginDeferredRiggedMaterial(pass-5);
+		break;
 	}
 }
 
@@ -226,6 +230,9 @@ void LLDrawPoolAvatar::endDeferredPass(S32 pass)
 	case 4:
 		endDeferredRiggedBump();
 		break;
+	default:
+		endDeferredRiggedMaterial(pass-5);
+		break;
 	}
 }
 
@@ -236,7 +243,7 @@ void LLDrawPoolAvatar::renderDeferred(S32 pass)
 
 S32 LLDrawPoolAvatar::getNumPostDeferredPasses()
 {
-	return 6;
+	return 10;
 }
 
 void LLDrawPoolAvatar::beginPostDeferredPass(S32 pass)
@@ -258,9 +265,12 @@ void LLDrawPoolAvatar::beginPostDeferredPass(S32 pass)
 	case 4:
 		beginRiggedFullbrightAlpha();
 		break;
-	case 5:
+	case 9:
 		beginRiggedGlow();
 		break;
+	default:
+		beginDeferredRiggedMaterialAlpha(pass-5);
+		break;
 	}
 }
 
@@ -286,11 +296,34 @@ void LLDrawPoolAvatar::beginDeferredRiggedAlpha()
 	gPipeline.enableLightsDynamic();
 }
 
+void LLDrawPoolAvatar::beginDeferredRiggedMaterialAlpha(S32 pass)
+{
+	switch (pass)
+	{
+	case 0: pass = 1; break;
+	case 1: pass = 5; break;
+	case 2: pass = 9; break;
+	default: pass = 13; break;
+	}
+
+	pass += LLMaterial::SHADER_COUNT;
+
+	sVertexProgram = &gDeferredMaterialProgram[pass];
+
+	gPipeline.bindDeferredShader(*sVertexProgram);
+	sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
+	normal_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::BUMP_MAP);
+	specular_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::SPECULAR_MAP);
+	gPipeline.enableLightsDynamic();
+}
+
 void LLDrawPoolAvatar::endDeferredRiggedAlpha()
 {
 	LLVertexBuffer::unbind();
 	gPipeline.unbindDeferredShader(*sVertexProgram);
 	sDiffuseChannel = 0;
+	normal_channel = -1;
+	specular_channel = -1;
 	sVertexProgram = NULL;
 }
 
@@ -316,6 +349,9 @@ void LLDrawPoolAvatar::endPostDeferredPass(S32 pass)
 	case 5:
 		endRiggedGlow();
 		break;
+	default:
+		endDeferredRiggedAlpha();
+		break;
 	}
 }
 
@@ -339,17 +375,23 @@ void LLDrawPoolAvatar::renderPostDeferred(S32 pass)
 		6, //rigged fullbright shiny
 		7, //rigged alpha
 		8, //rigged fullbright alpha
-		9, //rigged glow
+		9, //rigged material alpha 1
+		10,//rigged material alpha 2
+		11,//rigged material alpha 3
+		12,//rigged material alpha 4
+		13, //rigged glow
 	};
 
-	pass = actual_pass[pass];
+	S32 p = actual_pass[pass];
 
 	if (LLPipeline::sImpostorRender)
 	{ //HACK for impostors so actual pass ends up being proper pass
-		pass -= 2;
+		p -= 2;
 	}
 
-	render(pass);
+	is_post_deferred_render = true;
+	render(p);
+	is_post_deferred_render = false;
 }
 
 
@@ -436,12 +478,10 @@ void LLDrawPoolAvatar::renderShadow(S32 pass)
 	}
 	else
 	{
-		renderRigged(avatarp, RIGGED_SIMPLE);
-		renderRigged(avatarp, RIGGED_ALPHA);
-		renderRigged(avatarp, RIGGED_FULLBRIGHT);
-		renderRigged(avatarp, RIGGED_FULLBRIGHT_SHINY);
-		renderRigged(avatarp, RIGGED_SHINY);
-		renderRigged(avatarp, RIGGED_FULLBRIGHT_ALPHA);
+		for (U32 i = 0; i < NUM_RIGGED_PASSES; ++i)
+		{
+			renderRigged(avatarp, i);
+		}
 	}
 }
 
@@ -466,7 +506,7 @@ S32 LLDrawPoolAvatar::getNumDeferredPasses()
 	}
 	else
 	{
-		return 5;
+		return 21;
 	}
 }
 
@@ -850,6 +890,8 @@ void LLDrawPoolAvatar::beginRiggedGlow()
 	{
 		sDiffuseChannel = 0;
 		sVertexProgram->bind();
+
+		sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, LLPipeline::sRenderDeferred ? 2.2f : 1.1f);
 	}
 }
 
@@ -868,7 +910,14 @@ void LLDrawPoolAvatar::beginRiggedFullbright()
 		}
 		else
 		{
-			sVertexProgram = &gSkinnedObjectFullbrightProgram;
+			if (LLPipeline::sRenderDeferred)
+			{
+				sVertexProgram = &gDeferredSkinnedFullbrightProgram;
+			}
+			else
+			{
+				sVertexProgram = &gSkinnedObjectFullbrightProgram;
+			}
 		}
 	}
 	else
@@ -887,6 +936,15 @@ void LLDrawPoolAvatar::beginRiggedFullbright()
 	{
 		sDiffuseChannel = 0;
 		sVertexProgram->bind();
+
+		if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
+		{
+			sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
+		} 
+		else 
+		{
+			sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
+		}
 	}
 }
 
@@ -953,7 +1011,14 @@ void LLDrawPoolAvatar::beginRiggedFullbrightShiny()
 		}
 		else
 		{
-			sVertexProgram = &gSkinnedObjectFullbrightShinyProgram;
+			if (LLPipeline::sRenderDeferred)
+			{
+				sVertexProgram = &gDeferredSkinnedFullbrightShinyProgram;
+			}
+			else
+			{
+				sVertexProgram = &gSkinnedObjectFullbrightShinyProgram;
+			}
 		}
 	}
 	else
@@ -968,11 +1033,19 @@ void LLDrawPoolAvatar::beginRiggedFullbrightShiny()
 		}
 	}
 
-
 	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
 	{
 		sVertexProgram->bind();
 		LLDrawPoolBump::bindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
+
+		if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
+		{
+			sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
+		} 
+		else 
+		{
+			sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
+		}
 	}
 }
 
@@ -1021,6 +1094,42 @@ void LLDrawPoolAvatar::endDeferredRiggedBump()
 	sVertexProgram = NULL;
 }
 
+void LLDrawPoolAvatar::beginDeferredRiggedMaterial(S32 pass)
+{
+	if (pass == 1 ||
+		pass == 5 ||
+		pass == 9 ||
+		pass == 13)
+	{ //skip alpha passes
+		return;
+	}
+	sVertexProgram = &gDeferredMaterialProgram[pass+LLMaterial::SHADER_COUNT];
+	sVertexProgram->bind();
+	normal_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::BUMP_MAP);
+	specular_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::SPECULAR_MAP);
+	sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
+}
+
+void LLDrawPoolAvatar::endDeferredRiggedMaterial(S32 pass)
+{
+	if (pass == 1 ||
+		pass == 5 ||
+		pass == 9 ||
+		pass == 13)
+	{
+		return;
+	}
+
+	LLVertexBuffer::unbind();
+	sVertexProgram->disableTexture(LLViewerShaderMgr::BUMP_MAP);
+	sVertexProgram->disableTexture(LLViewerShaderMgr::SPECULAR_MAP);
+	sVertexProgram->disableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
+	sVertexProgram->unbind();
+	normal_channel = -1;
+	sDiffuseChannel = 0;
+	sVertexProgram = NULL;
+}
+
 void LLDrawPoolAvatar::beginDeferredSkinned()
 {
 	sShaderLevel = mVertexShaderLevel;
@@ -1155,93 +1264,190 @@ void LLDrawPoolAvatar::renderAvatars(LLVOAvatar* single_avatar, S32 pass)
 			}
 			avatarp->renderImpostor(LLColor4U(255,255,255,255), sDiffuseChannel);
 		}
+		return;
 	}
-	else if (pass == 1)
+
+	llassert(LLPipeline::sImpostorRender || !avatarp->isVisuallyMuted());
+
+	/*if (single_avatar && avatarp->mSpecialRenderMode >= 1) // 1=anim preview, 2=image preview,  3=morph view
+	{
+		gPipeline.enableLightsAvatarEdit(LLColor4(.5f, .5f, .5f, 1.f));
+	}*/
+	
+	if (pass == 1)
 	{
 		// render rigid meshes (eyeballs) first
 		avatarp->renderRigid();
+		return;
 	}
-	else if (pass >= 3 && pass <= 9)
-	{ //render rigged attachments
-		if (!avatarp->isVisuallyMuted())		// These details are skipped for visually muted (plain imposter) avatars
+
+	if (pass == 3)
+	{
+		if (is_deferred_render)
 		{
-			if (pass == 3)				// To do - use switch statement
-			{
-				if (is_deferred_render)
-				{
-					renderDeferredRiggedSimple(avatarp);
-				}
-				else
-				{
-					renderRiggedSimple(avatarp);
-				}
-			}
-			else if (pass == 4)
-			{
-				if (is_deferred_render)
-				{
-					renderDeferredRiggedBump(avatarp);
-				}
-				else
-				{
-					renderRiggedFullbright(avatarp);
-				}
-			}
-			else if (pass == 5)
-			{
-				renderRiggedShinySimple(avatarp);
-			}
-			else if (pass == 6)
-			{
-				renderRiggedFullbrightShiny(avatarp);
+			renderDeferredRiggedSimple(avatarp);
+		}
+		else
+		{
+			renderRiggedSimple(avatarp);
+
+			if (LLPipeline::sRenderDeferred)
+			{ //render "simple" materials
+				renderRigged(avatarp, RIGGED_MATERIAL);
+				renderRigged(avatarp, RIGGED_MATERIAL_ALPHA_MASK);
+				renderRigged(avatarp, RIGGED_MATERIAL_ALPHA_EMISSIVE);
+				renderRigged(avatarp, RIGGED_NORMMAP);
+				renderRigged(avatarp, RIGGED_NORMMAP_MASK);
+				renderRigged(avatarp, RIGGED_NORMMAP_EMISSIVE);	
+				renderRigged(avatarp, RIGGED_SPECMAP);
+				renderRigged(avatarp, RIGGED_SPECMAP_MASK);
+				renderRigged(avatarp, RIGGED_SPECMAP_EMISSIVE);
+				renderRigged(avatarp, RIGGED_NORMSPEC);
+				renderRigged(avatarp, RIGGED_NORMSPEC_MASK);
+				renderRigged(avatarp, RIGGED_NORMSPEC_EMISSIVE);
 			}
-			else if (pass == 7)
-			{
-				renderRiggedAlpha(avatarp);
+		}
+		return;
+	}
+
+	if (pass == 4)
+	{
+		if (is_deferred_render)
+		{
+			renderDeferredRiggedBump(avatarp);
+		}
+		else
+		{
+			renderRiggedFullbright(avatarp);
+		}
+
+		return;
+	}
+
+	if (is_deferred_render && pass >= 5 && pass <= 21)
+	{
+		S32 p = pass-5;
+
+		if (p != 1 &&
+			p != 5 &&
+			p != 9 &&
+			p != 13)
+		{
+			renderDeferredRiggedMaterial(avatarp, p);
+		}
+		return;
+	}
+
+
+
+
+	if (pass == 5)
+	{
+		renderRiggedShinySimple(avatarp);
+				
+		return;
+	}
+
+	if (pass == 6)
+	{
+		renderRiggedFullbrightShiny(avatarp);
+		return;
+	}
+
+	if (pass >= 7 && pass < 13)
+	{
+		if (pass == 7)
+		{
+			renderRiggedAlpha(avatarp);
+
+			if (LLPipeline::sRenderDeferred && !is_post_deferred_render)
+			{ //render transparent materials under water
+				LLGLEnable blend(GL_BLEND);
+
+				gGL.setColorMask(true, true);
+				gGL.blendFunc(LLRender::BF_SOURCE_ALPHA,
+								LLRender::BF_ONE_MINUS_SOURCE_ALPHA,
+								LLRender::BF_ZERO,
+								LLRender::BF_ONE_MINUS_SOURCE_ALPHA);
+
+				renderRigged(avatarp, RIGGED_MATERIAL_ALPHA);
+				renderRigged(avatarp, RIGGED_SPECMAP_BLEND);
+				renderRigged(avatarp, RIGGED_NORMMAP_BLEND);
+				renderRigged(avatarp, RIGGED_NORMSPEC_BLEND);
+
+				gGL.setColorMask(true, false);
 			}
-			else if (pass == 8)
+			return;
+		}
+
+		if (pass == 8)
+		{
+			renderRiggedFullbrightAlpha(avatarp);
+			return;
+		}
+
+		if (LLPipeline::sRenderDeferred && is_post_deferred_render)
+		{
+			S32 p = 0;
+			switch (pass)
 			{
-				renderRiggedFullbrightAlpha(avatarp);
+			case 9: p = 1; break;
+			case 10: p = 5; break;
+			case 11: p = 9; break;
+			case 12: p = 13; break;
 			}
-			else if (pass == 9)
+
 			{
-				renderRiggedGlow(avatarp);
+				LLGLEnable blend(GL_BLEND);
+				renderDeferredRiggedMaterial(avatarp, p);
 			}
+			return;
+		}
+		else if (pass == 9)
+		{
+			renderRiggedGlow(avatarp);
+			return;
 		}
 	}
-	else
+
+	if (pass == 13)
 	{
-		if ((sShaderLevel >= SHADER_LEVEL_CLOTH))
-		{
-			LLMatrix4 rot_mat;
-			LLViewerCamera::getInstance()->getMatrixToLocal(rot_mat);
-			LLMatrix4 cfr(OGL_TO_CFR_ROTATION);
-			rot_mat *= cfr;
+		renderRiggedGlow(avatarp);
+		
+		return;
+	}
+	
+	if ((sShaderLevel >= SHADER_LEVEL_CLOTH))
+	{
+		LLMatrix4 rot_mat;
+		LLViewerCamera::getInstance()->getMatrixToLocal(rot_mat);
+		LLMatrix4 cfr(OGL_TO_CFR_ROTATION);
+		rot_mat *= cfr;
 		
-			LLVector4 wind;
-			wind.setVec(avatarp->mWindVec);
-			wind.mV[VW] = 0;
-			wind = wind * rot_mat;
-			wind.mV[VW] = avatarp->mWindVec.mV[VW];
+		LLVector4 wind;
+		wind.setVec(avatarp->mWindVec);
+		wind.mV[VW] = 0;
+		wind = wind * rot_mat;
+		wind.mV[VW] = avatarp->mWindVec.mV[VW];
 
-			sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_WIND, 1, wind.mV);
-			F32 phase = -1.f * (avatarp->mRipplePhase);
+		sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_WIND, 1, wind.mV);
+		F32 phase = -1.f * (avatarp->mRipplePhase);
 
-			F32 freq = 7.f + (noise1(avatarp->mRipplePhase) * 2.f);
-			LLVector4 sin_params(freq, freq, freq, phase);
-			sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_SINWAVE, 1, sin_params.mV);
+		F32 freq = 7.f + (noise1(avatarp->mRipplePhase) * 2.f);
+		LLVector4 sin_params(freq, freq, freq, phase);
+		sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_SINWAVE, 1, sin_params.mV);
 
-			LLVector4 gravity(0.f, 0.f, -CLOTHING_GRAVITY_EFFECT, 0.f);
-			gravity = gravity * rot_mat;
-			sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_GRAVITY, 1, gravity.mV);
-		}
+		LLVector4 gravity(0.f, 0.f, -CLOTHING_GRAVITY_EFFECT, 0.f);
+		gravity = gravity * rot_mat;
+		sVertexProgram->uniform4fv(LLViewerShaderMgr::AVATAR_GRAVITY, 1, gravity.mV);
+	}
 
-		if( !single_avatar || (avatarp == single_avatar) )
-		{
-			avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE);
-		}
+	if( !single_avatar || (avatarp == single_avatar) )
+	{
+		avatarp->renderSkinned(AVATAR_RENDER_PASS_SINGLE);
 	}
 }
+
 void LLDrawPoolAvatar::getRiggedGeometry(LLFace* face, LLPointer<LLVertexBuffer>& buffer, U32 data_mask, const LLMeshSkinInfo* skin, LLVolume* volume, const LLVolumeFace& vol_face)
 {
 	face->setGeomIndex(0);
@@ -1487,9 +1693,11 @@ void LLDrawPoolAvatar::renderRigged(LLVOAvatar* avatar, U32 type, bool glow)
 		{
 			if (sShaderLevel > 0)
 			{ //upload matrix palette to shader
-				LLMatrix4 mat[64];
+				LLMatrix4 mat[32];
+
+				U32 count = llmin((U32) skin->mJointNames.size(), (U32) 32);
 
-				for (U32 i = 0; i < skin->mJointNames.size(); ++i)
+				for (U32 i = 0; i < count; ++i)
 				{
 					LLJoint* joint = avatar->getJoint(skin->mJointNames[i]);
 					if (joint)
@@ -1502,7 +1710,7 @@ void LLDrawPoolAvatar::renderRigged(LLVOAvatar* avatar, U32 type, bool glow)
 				stop_glerror();
 
 				LLDrawPoolAvatar::sVertexProgram->uniformMatrix4fv(LLViewerShaderMgr::AVATAR_MATRIX, 
-					skin->mJointNames.size(),
+					count,
 					FALSE,
 					(GLfloat*) mat[0].mMatrix);
 				
@@ -1523,10 +1731,59 @@ void LLDrawPoolAvatar::renderRigged(LLVOAvatar* avatar, U32 type, bool glow)
 				gGL.diffuseColor4f(0,0,0,face->getTextureEntry()->getGlow());
 			}*/
 
-			gGL.getTexUnit(sDiffuseChannel)->bind(face->getTexture());
-			if (normal_channel > -1)
+			const LLTextureEntry* te = face->getTextureEntry();
+			LLMaterial* mat = te->getMaterialParams().get();
+
+			if (mat)
+			{
+				gGL.getTexUnit(sDiffuseChannel)->bind(face->getTexture(LLRender::DIFFUSE_MAP));
+				gGL.getTexUnit(normal_channel)->bind(face->getTexture(LLRender::NORMAL_MAP));
+				gGL.getTexUnit(specular_channel)->bind(face->getTexture(LLRender::SPECULAR_MAP));
+
+				LLColor4 col = mat->getSpecularLightColor();
+				F32 spec = mat->getSpecularLightExponent()/255.f;
+
+				F32 env = mat->getEnvironmentIntensity()/255.f;
+
+				if (mat->getSpecularID().isNull())
+				{
+					env = te->getShiny()*0.25f;
+					col.set(env,env,env,0);
+					spec = env;
+				}
+		
+				BOOL fullbright = te->getFullbright();
+
+				sVertexProgram->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, fullbright ? 1.f : 0.f);
+				sVertexProgram->uniform4f(LLShaderMgr::SPECULAR_COLOR, col.mV[0], col.mV[1], col.mV[2], spec);
+				sVertexProgram->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, env);
+
+				if (mat->getDiffuseAlphaMode() == LLMaterial::DIFFUSE_ALPHA_MODE_MASK)
+				{
+					sVertexProgram->setMinimumAlpha(mat->getAlphaMaskCutoff()/255.f);
+				}
+				else
+				{
+					sVertexProgram->setMinimumAlpha(0.f);
+				}
+
+				for (U32 i = 0; i < LLRender::NUM_TEXTURE_CHANNELS; ++i)
+				{
+					LLViewerTexture* tex = face->getTexture(i);
+					if (tex)
+					{
+						tex->addTextureStats(avatar->getPixelArea());
+					}
+				}
+			}
+			else
 			{
-				LLDrawPoolBump::bindBumpMap(face, normal_channel);
+				gGL.getTexUnit(sDiffuseChannel)->bind(face->getTexture());
+				sVertexProgram->setMinimumAlpha(0.f);
+				if (normal_channel > -1)
+				{
+					LLDrawPoolBump::bindBumpMap(face, normal_channel);
+				}
 			}
 
 			if (face->mTextureMatrix && vobj->mTexAnimMode)
@@ -1559,6 +1816,11 @@ void LLDrawPoolAvatar::renderDeferredRiggedBump(LLVOAvatar* avatar)
 	renderRigged(avatar, RIGGED_DEFERRED_BUMP);
 }
 
+void LLDrawPoolAvatar::renderDeferredRiggedMaterial(LLVOAvatar* avatar, S32 pass)
+{
+	renderRigged(avatar, pass);
+}
+
 static LLFastTimer::DeclareTimer FTM_RIGGED_VBO("Rigged VBO");
 
 void LLDrawPoolAvatar::updateRiggedVertexBuffers(LLVOAvatar* avatar)