Try mask-based object shader configuration, instead of a bazillion hard-coded shader globals. Should be a bit more consistent. (non-deferred only, for now)

Also abuse discard in alpha shaders, instead of processing invisible fragments.

indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl

@@ -465,15 +465,21 @@ void main()
 		discard;
 	}
 #endif
-#ifdef FOR_IMPOSTOR
+/*#ifdef FOR_IMPOSTOR
 	// Insure we don't pollute depth with invis pixels in impostor rendering
 	//
 	if (final_alpha < 0.01)
 	{
 		discard;
 	}
-#endif
+#endif*/
 
+	//Always do this.
+	if (final_alpha < 0.004)
+	{
+		discard;
+	}
+	
 	vec4 pos = vec4(vary_position, 1.0);
 	
 	float shadow = 1.0;
@@ -549,7 +555,7 @@ void main()
 
 
 #ifdef FOR_IMPOSTOR
-	vec4 color = vec4(diff.rgb,final_alpha);
+	vec4 color = vec4(diff.rgb,final_alpha); //Impostor needs alpha.
 #else
 
 	vec4 gamma_diff = diff;	

indra/newview/app_settings/shaders/class1/deferred/emissiveF.glsl

@@ -42,6 +42,8 @@ void main()
 	float shadow = 1.0;
 
 	vec4 color = diffuseLookup(vary_texcoord0.xy)*vertex_color;
+	if(color.a < .01)
+		discard;
 	color.rgb = pow(color.rgb, vec3(2.2));
 	color.rgb = fullbrightAtmosTransport(color.rgb);
 

indra/newview/app_settings/shaders/class1/deferred/materialF.glsl

@@ -537,6 +537,10 @@ void main()
 #endif
 
 #if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_BLEND)
+	if(diffcol.a < .01)
+	{
+		discard;
+	}
 	vec3 gamma_diff = diffcol.rgb;
 	diffcol.rgb = srgb_to_linear(diffcol.rgb);
 #endif

indra/newview/app_settings/shaders/class1/lighting/lightAlphaMaskF.glsl

@@ -39,7 +39,7 @@ VARYING vec2 vary_texcoord0;
 
 void default_lighting() 
 {
-	vec4 color = diffuseLookup(vary_texcoord0.xy) * vertex_color;
+	vec4 color = diffuseLookup(vary_texcoord0.xy) * vertex_color; //Shader is used on alpha faces too. Need alpha component.
 	
 	if (color.a < minimum_alpha)
 	{

indra/newview/app_settings/shaders/class1/lighting/lightAlphaMaskNonIndexedF.glsl

@@ -41,15 +41,13 @@ VARYING vec2 vary_texcoord0;
 
 void default_lighting() 
 {
-	vec4 color = texture2D(diffuseMap,vary_texcoord0.xy);
+	vec4 color = texture2D(diffuseMap,vary_texcoord0.xy) * vertex_color;
 
 	if (color.a < minimum_alpha)
 	{
 		discard;
 	}
 
-	color.rgb *= vertex_color.rgb;
-	
 	color.rgb = atmosLighting(color.rgb);
 
 	color.rgb = scaleSoftClip(color.rgb);

indra/newview/app_settings/shaders/class1/lighting/lightFullbrightAlphaMaskF.glsl

@@ -40,15 +40,13 @@ VARYING vec2 vary_texcoord0;
 
 void fullbright_lighting()
 {
-	vec4 color = diffuseLookup(vary_texcoord0.xy);
+	vec4 color = diffuseLookup(vary_texcoord0.xy)  * vertex_color; //Shader is used on alpha faces too. Need alpha component.
 	
 	if (color.a < minimum_alpha)
 	{
 		discard;
 	}
 
-	color.rgb *= vertex_color.rgb;
-
 	color.rgb = pow(color.rgb, vec3(texture_gamma));
 	color.rgb = fullbrightAtmosTransport(color.rgb);
 	

indra/newview/app_settings/shaders/class1/lighting/lightFullbrightNonIndexedAlphaMaskF.glsl

@@ -42,15 +42,13 @@ VARYING vec2 vary_texcoord0;
 
 void fullbright_lighting()
 {
-	vec4 color = texture2D(diffuseMap,vary_texcoord0.xy);
+	vec4 color = texture2D(diffuseMap,vary_texcoord0.xy) * vertex_color;
 	
 	if (color.a < minimum_alpha)
 	{
 		discard;
 	}
 	
-	color.rgb *= vertex_color.rgb;
-
 	color.rgb = pow(color.rgb, vec3(texture_gamma));
 	color.rgb = fullbrightAtmosTransport(color.rgb);
 	

indra/newview/app_settings/shaders/class1/lighting/lightFullbrightWaterAlphaMaskF.glsl

@@ -41,7 +41,7 @@ VARYING vec2 vary_texcoord0;
 
 void fullbright_lighting_water()
 {
-	vec4 color = diffuseLookup(vary_texcoord0.xy) * vertex_color;
+	vec4 color = diffuseLookup(vary_texcoord0.xy)  * vertex_color; //Shader is used on alpha faces too. Need alpha component.
 
 	if (color.a < minimum_alpha)
 	{

indra/newview/app_settings/shaders/class1/lighting/lightNonIndexedF.glsl

@@ -41,6 +41,11 @@ void default_lighting()
 {
 	vec4 color = texture2D(diffuseMap,vary_texcoord0.xy) * vertex_color;
 	
+	if(color.a < .004)
+	{
+		discard;
+	}
+
 	color.rgb = atmosLighting(color.rgb);
 
 	color.rgb = scaleSoftClip(color.rgb);

indra/newview/app_settings/shaders/class1/lighting/lightWaterAlphaMaskF.glsl

@@ -39,7 +39,7 @@ VARYING vec2 vary_texcoord0;
 
 void default_lighting_water()
 {
-	vec4 color = diffuseLookup(vary_texcoord0.xy) * vertex_color;
+	vec4 color = diffuseLookup(vary_texcoord0.xy)  * vertex_color; //Shader is used on alpha faces too. Need alpha component.
 
 	if (color.a < minimum_alpha)
 	{

indra/newview/app_settings/shaders/class1/lighting/lightWaterF.glsl

@@ -39,6 +39,11 @@ void default_lighting_water()
 {
 	vec4 color = diffuseLookup(vary_texcoord0.xy) * vertex_color;
 
+	if(color.a < .004)
+	{
+		discard;
+	}
+
 	color.rgb = atmosLighting(color.rgb);
 
 	frag_color = applyWaterFog(color);

indra/newview/app_settings/shaders/class1/lighting/lightWaterNonIndexedF.glsl

@@ -41,6 +41,11 @@ void default_lighting_water()
 {
 	vec4 color = texture2D(diffuseMap,vary_texcoord0.xy) * vertex_color;
 
+	if(color.a < .004)
+	{
+		discard;
+	}
+
 	color.rgb = atmosLighting(color.rgb);
 
 	frag_color = applyWaterFog(color);

indra/newview/lldrawpoolalpha.cpp

@@ -135,27 +135,13 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 		gPipeline.mDeferredDepth.copyContents(gPipeline.mDeferredScreen, 0, 0, gPipeline.mDeferredScreen.getWidth(), gPipeline.mDeferredScreen.getHeight(),
 							0, 0, gPipeline.mDeferredDepth.getWidth(), gPipeline.mDeferredDepth.getHeight(), GL_DEPTH_BUFFER_BIT, GL_NEAREST);	
 		gPipeline.mDeferredDepth.bindTarget();
-		simple_shader = fullbright_shader = &gObjectFullbrightAlphaMaskProgram;
-		gObjectFullbrightAlphaMaskProgram.bind();
-		gObjectFullbrightAlphaMaskProgram.setMinimumAlpha(0.33f);
+		simple_shader = fullbright_shader = &gObjectFullbrightProgram[1<<SHD_ALPHA_MASK_BIT];
+		fullbright_shader->bind();
+		fullbright_shader->setMinimumAlpha(0.33f);
 	}
 
-
-    if (LLPipeline::sRenderDeferred)
-    {
-		emissive_shader = &gDeferredEmissiveProgram;
-    }
-    else
-    {
-		if (LLPipeline::sUnderWaterRender)
-		{
-			emissive_shader = &gObjectEmissiveWaterProgram;
-		}
-		else
-		{
-			emissive_shader = &gObjectEmissiveProgram;
-		}
-    }
+	llassert_always(LLPipeline::sRenderDeferred);
+	emissive_shader = &gDeferredEmissiveProgram;
 
 	deferred_render = TRUE;
 
@@ -173,7 +159,7 @@ void LLDrawPoolAlpha::endPostDeferredPass(S32 pass)
 	{
 		gPipeline.mDeferredDepth.flush();
 		gPipeline.mScreen.bindTarget();
-		gObjectFullbrightAlphaMaskProgram.unbind();
+		gObjectFullbrightProgram[1<<SHD_ALPHA_MASK_BIT].unbind();
 	}
 
 	deferred_render = FALSE;
@@ -189,25 +175,10 @@ void LLDrawPoolAlpha::beginRenderPass(S32 pass)
 {
 	LLFastTimer t(FTM_RENDER_ALPHA);
 	
-	if (LLPipeline::sImpostorRender)
-	{
-		simple_shader = &gObjectSimpleImpostorProgram;
-		fullbright_shader = &gObjectFullbrightProgram;
-		emissive_shader = &gObjectEmissiveProgram;
-	}
-	else if (LLPipeline::sUnderWaterRender)
-	{
-		simple_shader = &gObjectSimpleWaterProgram;
-		fullbright_shader = &gObjectFullbrightWaterProgram;
-		emissive_shader = &gObjectEmissiveWaterProgram;
-	}
-	else
-	{
-		simple_shader = &gObjectSimpleProgram;
-		fullbright_shader = &gObjectFullbrightProgram;
-		emissive_shader = &gObjectEmissiveProgram;
-	}
-
+	simple_shader = &gObjectSimpleProgram[1<<SHD_ALPHA_MASK_BIT | LLPipeline::sUnderWaterRender<<SHD_WATER_BIT];
+	fullbright_shader = &gObjectFullbrightProgram[1<<SHD_ALPHA_MASK_BIT | LLPipeline::sUnderWaterRender<<SHD_WATER_BIT];
+	emissive_shader = &gObjectEmissiveProgram[1<<SHD_ALPHA_MASK_BIT | LLPipeline::sUnderWaterRender<<SHD_WATER_BIT];
+	
 	// Start out with no shaders.
 	current_shader = target_shader = NULL;
 
@@ -267,20 +238,14 @@ void LLDrawPoolAlpha::render(S32 pass)
 
 		if (mVertexShaderLevel > 0)
 		{
-			if (LLPipeline::sImpostorRender)
-			{
-				fullbright_shader->bind();
-				fullbright_shader->setMinimumAlpha(0.5f);
-				simple_shader->bind();
-				simple_shader->setMinimumAlpha(0.5f);
-			}				
-			else
-			{
-				fullbright_shader->bind();
-				fullbright_shader->setMinimumAlpha(0.f);
-				simple_shader->bind();
-				simple_shader->setMinimumAlpha(0.f);
-			}
+			float min_alpha = LLPipeline::sImpostorRender ? 0.5f : 0.004f;
+			
+			fullbright_shader->bind();
+			fullbright_shader->setMinimumAlpha(min_alpha);
+			simple_shader->bind();
+			simple_shader->setMinimumAlpha(min_alpha);
+			emissive_shader->bind();
+			emissive_shader->setMinimumAlpha(min_alpha);
 		}
 		else
 		{

indra/newview/lldrawpoolavatar.cpp

@@ -731,6 +731,12 @@ void LLDrawPoolAvatar::endDeferredRigid()
 
 void LLDrawPoolAvatar::beginSkinned()
 {
+	if(!gPipeline.canUseVertexShaders())
+	{
+		sVertexProgram = NULL;
+		return;
+	}
+
 	if (sShaderLevel > 0)
 	{
 		if (LLPipeline::sUnderWaterRender)
@@ -765,12 +771,9 @@ void LLDrawPoolAvatar::beginSkinned()
 	}
 	else
 	{
-		if(gPipeline.canUseVertexShaders())
-		{
-			// software skinning, use a basic shader for windlight.
-			// TODO: find a better fallback method for software skinning.
-			sVertexProgram->bind();
-		}
+		// software skinning, use a basic shader for windlight.
+		// TODO: find a better fallback method for software skinning.
+		sVertexProgram->bind();
 	}
 
 	if (LLGLSLShader::sNoFixedFunction)
@@ -787,17 +790,12 @@ void LLDrawPoolAvatar::endSkinned()
 		sRenderingSkinned = FALSE;
 		sVertexProgram->disableTexture(LLViewerShaderMgr::BUMP_MAP);
 		gGL.getTexUnit(0)->activate();
-		sVertexProgram->unbind();
 		sShaderLevel = mVertexShaderLevel;
 	}
-	else
+
+	if(sVertexProgram)
 	{
-		if(gPipeline.canUseVertexShaders())
-		{
-			// software skinning, use a basic shader for windlight.
-			// TODO: find a better fallback method for software skinning.
-			sVertexProgram->unbind();
-		}
+		sVertexProgram->unbind();
 	}
 
 	gGL.getTexUnit(0)->activate();
@@ -805,44 +803,29 @@ void LLDrawPoolAvatar::endSkinned()
 
 void LLDrawPoolAvatar::beginRiggedSimple()
 {
-	if (sShaderLevel > 0)
+	sDiffuseChannel = 0;
+	if(!gPipeline.canUseVertexShaders())
 	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			sVertexProgram = &gSkinnedObjectSimpleWaterProgram;
-		}
-		else
-		{
-			sVertexProgram = &gSkinnedObjectSimpleProgram;
-		}
-	}
-	else
-	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			sVertexProgram = &gObjectSimpleNonIndexedWaterProgram;
-		}
-		else
-		{
-			sVertexProgram = &gObjectSimpleNonIndexedProgram;
-		}
+		sVertexProgram = NULL;
+		return;
 	}
 
-	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
-	{
-		sDiffuseChannel = 0;
-		sVertexProgram->bind();
-	}
+	sVertexProgram = &gObjectSimpleProgram[1<<SHD_ALPHA_MASK_BIT | LLPipeline::sUnderWaterRender<<SHD_WATER_BIT | 1<<SHD_NO_INDEX_BIT | (sShaderLevel>0)<<SHD_SKIN_BIT];
+	llassert_always(sVertexProgram->mProgramObject > 0);
+
+	sDiffuseChannel = 0;
+	sVertexProgram->bind();
 }
 
 void LLDrawPoolAvatar::endRiggedSimple()
 {
 	LLVertexBuffer::unbind();
-	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
-	{
-		sVertexProgram->unbind();
-		sVertexProgram = NULL;
-	}
+
+	if(!sVertexProgram)
+		return;
+
+	sVertexProgram->unbind();
+	sVertexProgram = NULL;
 }
 
 void LLDrawPoolAvatar::beginRiggedAlpha()
@@ -868,39 +851,21 @@ void LLDrawPoolAvatar::endRiggedFullbrightAlpha()
 
 void LLDrawPoolAvatar::beginRiggedGlow()
 {
-	if (sShaderLevel > 0)
+	sDiffuseChannel = 0;
+	if(!gPipeline.canUseVertexShaders())
 	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			sVertexProgram = &gSkinnedObjectEmissiveWaterProgram;
-		}
-		else
-		{
-			sVertexProgram = &gSkinnedObjectEmissiveProgram;
-		}
-	}
-	else
-	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			sVertexProgram = &gObjectEmissiveNonIndexedWaterProgram;
-		}
-		else
-		{
-			sVertexProgram = &gObjectEmissiveNonIndexedProgram;
-		}
+		sVertexProgram = NULL;
+		return;
 	}
 
-	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
-	{
-		sDiffuseChannel = 0;
-		sVertexProgram->bind();
-		sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, LLPipeline::sRenderDeferred ? 2.2f : 1.1f);
-		//F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
-		//sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
-	}
+	sVertexProgram = &gObjectEmissiveProgram[1<<SHD_ALPHA_MASK_BIT | LLPipeline::sUnderWaterRender<<SHD_WATER_BIT | 1<<SHD_NO_INDEX_BIT | (sShaderLevel>0)<<SHD_SKIN_BIT];
+	llassert_always(sVertexProgram->mProgramObject > 0);
+
+	sVertexProgram->bind();
+	sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, LLPipeline::sRenderDeferred ? 2.2f : 1.1f);
+	//F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
+	//sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 }
-
 void LLDrawPoolAvatar::endRiggedGlow()
 {
 	endRiggedFullbright();
@@ -908,165 +873,114 @@ void LLDrawPoolAvatar::endRiggedGlow()
 
 void LLDrawPoolAvatar::beginRiggedFullbright()
 {
-	if (sShaderLevel > 0)
+	sDiffuseChannel = 0;
+	if(!gPipeline.canUseVertexShaders())
 	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			sVertexProgram = &gSkinnedObjectFullbrightWaterProgram;
-		}
-		else
-		{
-			if (LLPipeline::sRenderDeferred)
-			{
-				sVertexProgram = &gDeferredSkinnedFullbrightProgram;
-			}
-			else
-			{
-			sVertexProgram = &gSkinnedObjectFullbrightProgram;
-			}
-		}
+		sVertexProgram = NULL;
+		return;
+	}
+	if (sShaderLevel > 0 && !LLPipeline::sUnderWaterRender && LLPipeline::sRenderDeferred)
+	{
+		sVertexProgram = &gDeferredSkinnedFullbrightProgram;
 	}
 	else
 	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			sVertexProgram = &gObjectFullbrightNonIndexedWaterProgram;
-		}
-		else
-		{
-			sVertexProgram = &gObjectFullbrightNonIndexedProgram;
-		}
+		sVertexProgram = &gObjectFullbrightProgram[1<<SHD_ALPHA_MASK_BIT | LLPipeline::sUnderWaterRender<<SHD_WATER_BIT | 1<<SHD_NO_INDEX_BIT | (sShaderLevel>0)<<SHD_SKIN_BIT];
 	}
+	llassert_always(sVertexProgram->mProgramObject > 0);
 
-	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
+	sVertexProgram->bind();
+	if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
 	{
-		sDiffuseChannel = 0;
-		sVertexProgram->bind();
-		if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
-		{
-			sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
-		} 
-		else 
-		{
-			sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
-			//F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
-			//sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
-		}
+		sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
+	} 
+	else 
+	{
+		sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
+		//F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
+		//sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 	}
 }
 
 void LLDrawPoolAvatar::endRiggedFullbright()
 {
 	LLVertexBuffer::unbind();
-	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
-	{
-		sVertexProgram->unbind();
-		sVertexProgram = NULL;
-	}
+
+	if(!sVertexProgram)
+		return;
+
+	sVertexProgram->unbind();
+	sVertexProgram = NULL;
 }
 
 void LLDrawPoolAvatar::beginRiggedShinySimple()
 {
-	if (sShaderLevel > 0)
+	if(!gPipeline.canUseVertexShaders())
 	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			sVertexProgram = &gSkinnedObjectShinySimpleWaterProgram;
-		}
-		else
-		{
-			sVertexProgram = &gSkinnedObjectShinySimpleProgram;
-		}
-	}
-	else
-	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			sVertexProgram = &gObjectShinyNonIndexedWaterProgram;
-		}
-		else
-		{
-			sVertexProgram = &gObjectShinyNonIndexedProgram;
-		}
+		sVertexProgram = NULL;
+		return;
 	}
 
-	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
-	{
-		sVertexProgram->bind();
-		LLDrawPoolBump::bindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
-	}
+	sVertexProgram = &gObjectSimpleProgram[1<<SHD_ALPHA_MASK_BIT | LLPipeline::sUnderWaterRender<<SHD_WATER_BIT | 1<<SHD_NO_INDEX_BIT | (sShaderLevel>0)<<SHD_SKIN_BIT | 1<<SHD_SHINY_BIT];
+	llassert_always(sVertexProgram->mProgramObject > 0);
+
+	sVertexProgram->bind();
+	LLDrawPoolBump::bindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
 }
 
 void LLDrawPoolAvatar::endRiggedShinySimple()
 {
 	LLVertexBuffer::unbind();
-	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
-	{
-		LLDrawPoolBump::unbindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
-		sVertexProgram->unbind();
-		sVertexProgram = NULL;
-	}
+
+	if(!sVertexProgram)
+		return;
+
+	LLDrawPoolBump::unbindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
+	sVertexProgram->unbind();
+	sVertexProgram = NULL;
 }
 
 void LLDrawPoolAvatar::beginRiggedFullbrightShiny()
 {
-	if (sShaderLevel > 0)
+	if(!gPipeline.canUseVertexShaders())
 	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			sVertexProgram = &gSkinnedObjectFullbrightShinyWaterProgram;
-		}
-		else
-		{
-			if (LLPipeline::sRenderDeferred)
-			{
-				sVertexProgram = &gDeferredSkinnedFullbrightShinyProgram;
-			}
-			else
-			{
-			sVertexProgram = &gSkinnedObjectFullbrightShinyProgram;
-			}
-		}
+		sVertexProgram = NULL;
+		return;
+	}
+	if (sShaderLevel > 0 && !LLPipeline::sUnderWaterRender && LLPipeline::sRenderDeferred)
+	{
+		sVertexProgram = &gDeferredSkinnedFullbrightShinyProgram;
 	}
 	else
 	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			sVertexProgram = &gObjectFullbrightShinyNonIndexedWaterProgram;
-		}
-		else
-		{
-			sVertexProgram = &gObjectFullbrightShinyNonIndexedProgram;
-		}
+		sVertexProgram = &gObjectFullbrightProgram[1<<SHD_ALPHA_MASK_BIT | LLPipeline::sUnderWaterRender<<SHD_WATER_BIT | 1<<SHD_NO_INDEX_BIT | (sShaderLevel>0)<<SHD_SKIN_BIT | 1<<SHD_SHINY_BIT];
 	}
+	llassert_always(sVertexProgram->mProgramObject > 0);
 
-
-	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
+	sVertexProgram->bind();
+	LLDrawPoolBump::bindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
+	if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
 	{
-		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);
-			//F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
-			//sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
-		}
+		sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
+	} 
+	else 
+	{
+		sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
+		//F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
+		//sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 	}
 }
 
 void LLDrawPoolAvatar::endRiggedFullbrightShiny()
 {
 	LLVertexBuffer::unbind();
-	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
-	{
-		LLDrawPoolBump::unbindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
-		sVertexProgram->unbind();
-		sVertexProgram = NULL;
-	}
+
+	if(!sVertexProgram)
+		return;
+
+	LLDrawPoolBump::unbindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
+	sVertexProgram->unbind();
+	sVertexProgram = NULL;
 }
 
 
@@ -1690,7 +1604,7 @@ void LLDrawPoolAvatar::renderRigged(LLVOAvatar* avatar, U32 type, bool glow)
 			const LLTextureEntry* te = face->getTextureEntry();
 			LLMaterial* mat = te->getMaterialParams().get();
 
-			if (mat)
+			if (mat && is_deferred_render)
 			{
 				gGL.getTexUnit(sDiffuseChannel)->bind(face->getTexture(LLRender::DIFFUSE_MAP));
 				gGL.getTexUnit(normal_channel)->bind(face->getTexture(LLRender::NORMAL_MAP));
@@ -1720,7 +1634,7 @@ void LLDrawPoolAvatar::renderRigged(LLVOAvatar* avatar, U32 type, bool glow)
 				}
 				else
 				{
-					sVertexProgram->setMinimumAlpha(0.f);
+					sVertexProgram->setMinimumAlpha(0.004f);
 				}
 
 				for (U32 i = 0; i < LLRender::NUM_TEXTURE_CHANNELS; ++i)
@@ -1735,7 +1649,19 @@ void LLDrawPoolAvatar::renderRigged(LLVOAvatar* avatar, U32 type, bool glow)
 			else
 			{
 				gGL.getTexUnit(sDiffuseChannel)->bind(face->getTexture());
-				sVertexProgram->setMinimumAlpha(0.f);
+
+				if(sVertexProgram)
+				{
+					if (mat && mat->getDiffuseAlphaMode() == LLMaterial::DIFFUSE_ALPHA_MODE_MASK)
+					{
+						sVertexProgram->setMinimumAlpha(mat->getAlphaMaskCutoff()/255.f);
+					}
+					else
+					{
+						sVertexProgram->setMinimumAlpha(0.004f);
+					}
+				}
+
 				if (normal_channel > -1)
 				{
 					LLDrawPoolBump::bindBumpMap(face, normal_channel);
@@ -1864,7 +1790,7 @@ void LLDrawPoolAvatar::renderRiggedAlpha(LLVOAvatar* avatar)
 						LLRender::BF_ONE_MINUS_SOURCE_ALPHA);
 
 		renderRigged(avatar, RIGGED_ALPHA);
-		//gGL.setSceneBlendType(LLRender::BT_ALPHA);
+		gGL.setSceneBlendType(LLRender::BT_ALPHA);
 		gGL.setColorMask(true, false);
 	}
 }
@@ -1882,7 +1808,7 @@ void LLDrawPoolAvatar::renderRiggedFullbrightAlpha(LLVOAvatar* avatar)
 						LLRender::BF_ONE_MINUS_SOURCE_ALPHA);
 
 		renderRigged(avatar, RIGGED_FULLBRIGHT_ALPHA);
-		//gGL.setSceneBlendType(LLRender::BT_ALPHA);
+		gGL.setSceneBlendType(LLRender::BT_ALPHA);
 		gGL.setColorMask(true, false);
 	}
 }

indra/newview/lldrawpoolbump.cpp

@@ -349,14 +349,7 @@ void LLDrawPoolBump::beginShiny(bool invisible)
 	
 	if (getVertexShaderLevel() > 0)
 	{
-		if (LLPipeline::sUnderWaterRender)
-		{
-			shader = &gObjectShinyWaterProgram;
-		}
-		else
-		{
-			shader = &gObjectShinyProgram;
-		}
+		shader = &gObjectSimpleProgram[LLPipeline::sUnderWaterRender<<SHD_WATER_BIT | 1<<SHD_SHINY_BIT];
 		shader->bind();
 	}
 	else
@@ -516,20 +509,13 @@ void LLDrawPoolBump::beginFullbrightShiny()
 
 	// Second pass: environment map
 	
-	if (LLPipeline::sUnderWaterRender)
+	if(!LLPipeline::sUnderWaterRender && LLPipeline::sRenderDeferred)
 	{
-		shader = &gObjectFullbrightShinyWaterProgram;
+		shader = &gDeferredFullbrightShinyProgram;
 	}
 	else
 	{
-		if (LLPipeline::sRenderDeferred)
-		{
-			shader = &gDeferredFullbrightShinyProgram;
-		}
-		else
-		{
-			shader = &gObjectFullbrightShinyProgram;
-		}
+		shader = &gObjectFullbrightProgram[LLPipeline::sUnderWaterRender<<SHD_WATER_BIT | 1<<SHD_SHINY_BIT];
 	}
 
 	LLCubeMap* cube_map = gSky.mVOSkyp ? gSky.mVOSkyp->getCubeMap() : NULL;

indra/newview/lldrawpoolsimple.cpp

@@ -108,7 +108,7 @@ void LLDrawPoolGlow::render(S32 pass)
 	//should never get here without basic shaders enabled
 	llassert(shader_level > 0);
 	
-	LLGLSLShader* shader = LLPipeline::sUnderWaterRender ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
+	LLGLSLShader* shader = &gObjectEmissiveProgram[LLPipeline::sUnderWaterRender<<SHD_WATER_BIT];
 	shader->bind();
 	if (LLPipeline::sRenderDeferred)
 	{
@@ -154,18 +154,7 @@ void LLDrawPoolSimple::beginRenderPass(S32 pass)
 {
 	LLFastTimer t(FTM_RENDER_SIMPLE);
 
-	if (LLPipeline::sImpostorRender)
-	{
-		simple_shader = &gObjectSimpleImpostorProgram;
-	}
-	else if (LLPipeline::sUnderWaterRender)
-	{
-		simple_shader = &gObjectSimpleWaterProgram;
-	}
-	else
-	{
-		simple_shader = &gObjectSimpleProgram;
-	}
+	simple_shader = &gObjectSimpleProgram[LLPipeline::sUnderWaterRender<<SHD_WATER_BIT];
 
 	if (mVertexShaderLevel > 0)
 	{
@@ -251,14 +240,7 @@ void LLDrawPoolAlphaMask::beginRenderPass(S32 pass)
 {
 	LLFastTimer t(FTM_RENDER_ALPHA_MASK);
 
-	if (LLPipeline::sUnderWaterRender)
-	{
-		simple_shader = &gObjectSimpleWaterAlphaMaskProgram;
-	}
-	else
-	{
-		simple_shader = &gObjectSimpleAlphaMaskProgram;
-	}
+	simple_shader = &gObjectSimpleProgram[1<<SHD_ALPHA_MASK_BIT | LLPipeline::sUnderWaterRender<<SHD_WATER_BIT];
 
 	if (mVertexShaderLevel > 0)
 	{
@@ -324,14 +306,7 @@ void LLDrawPoolFullbrightAlphaMask::beginRenderPass(S32 pass)
 {
 	LLFastTimer t(FTM_RENDER_ALPHA_MASK);
 
-	if (LLPipeline::sUnderWaterRender)
-	{
-		simple_shader = &gObjectFullbrightWaterAlphaMaskProgram;
-	}
-	else
-	{
-		simple_shader = &gObjectFullbrightAlphaMaskProgram;
-	}
+	simple_shader = &gObjectFullbrightProgram[1<<SHD_ALPHA_MASK_BIT | LLPipeline::sUnderWaterRender<<SHD_WATER_BIT];
 
 	if (mVertexShaderLevel > 0)
 	{
@@ -460,11 +435,7 @@ void LLDrawPoolGrass::beginRenderPass(S32 pass)
 
 	if (LLPipeline::sUnderWaterRender)
 	{
-		simple_shader = &gObjectAlphaMaskNonIndexedWaterProgram;
-	}
-	else
-	{
-		simple_shader = &gObjectAlphaMaskNonIndexedProgram;
+		simple_shader = &gObjectSimpleProgram[1<<SHD_ALPHA_MASK_BIT | LLPipeline::sUnderWaterRender<<SHD_WATER_BIT | 1<<SHD_NO_INDEX_BIT];
 	}
 
 	if (mVertexShaderLevel > 0)
@@ -592,14 +563,7 @@ void LLDrawPoolFullbright::beginRenderPass(S32 pass)
 {
 	LLFastTimer t(FTM_RENDER_FULLBRIGHT);
 	
-	if (LLPipeline::sUnderWaterRender)
-	{
-		fullbright_shader = &gObjectFullbrightWaterProgram;
-	}
-	else
-	{
-		fullbright_shader = &gObjectFullbrightProgram;
-	}
+	fullbright_shader = &gObjectFullbrightProgram[LLPipeline::sUnderWaterRender<<SHD_WATER_BIT];
 }
 
 void LLDrawPoolFullbright::endRenderPass(S32 pass)
@@ -662,12 +626,11 @@ void LLDrawPoolFullbrightAlphaMask::beginPostDeferredPass(S32 pass)
 	
 	if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
 	{
-		gObjectFullbrightAlphaMaskProgram.bind();
-		gObjectFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
+		gObjectFullbrightProgram[1<<SHD_ALPHA_MASK_BIT].bind();
+		gObjectFullbrightProgram[1<<SHD_ALPHA_MASK_BIT].uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
 	} 
 	else 
 	{	
-
 		if (LLPipeline::sUnderWaterRender)
 		{
 			gDeferredFullbrightAlphaMaskWaterProgram.bind();
@@ -696,7 +659,7 @@ void LLDrawPoolFullbrightAlphaMask::endPostDeferredPass(S32 pass)
 {
 	if (LLPipeline::sRenderingHUDs || !LLPipeline::sRenderDeferred)
 	{
-		gObjectFullbrightAlphaMaskProgram.unbind();
+		gObjectFullbrightProgram[1<<SHD_ALPHA_MASK_BIT].unbind();
 	}
 	else
 	{

indra/newview/llviewershadermgr.cpp

@@ -105,57 +105,20 @@ LLGLSLShader	gUIProgram(LLViewerShaderMgr::SHADER_INTERFACE);
 LLGLSLShader	gSolidColorProgram(LLViewerShaderMgr::SHADER_INTERFACE);
 
  //object shaders
-LLGLSLShader		gObjectSimpleProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectSimpleImpostorProgram(LLViewerShaderMgr::SHADER_OBJECT);
+LLGLSLShaderArray<LLViewerShaderMgr::SHADER_OBJECT>	gObjectSimpleProgram[1<<SHD_COUNT];
+LLGLSLShaderArray<LLViewerShaderMgr::SHADER_OBJECT>	gObjectFullbrightProgram[1<<SHD_COUNT];
+LLGLSLShaderArray<LLViewerShaderMgr::SHADER_OBJECT>	gObjectEmissiveProgram[1<<SHD_SHINY_BIT];
 LLGLSLShader		gObjectPreviewProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectSimpleWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectSimpleAlphaMaskProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectSimpleWaterAlphaMaskProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectFullbrightProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectFullbrightWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
- LLGLSLShader		gObjectEmissiveProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectEmissiveWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectFullbrightAlphaMaskProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectFullbrightWaterAlphaMaskProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectFullbrightShinyProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectFullbrightShinyWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectShinyProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectShinyWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
 LLGLSLShader		gObjectBumpProgram(LLViewerShaderMgr::SHADER_OBJECT);
 LLGLSLShader		gTreeProgram(LLViewerShaderMgr::SHADER_OBJECT);
 LLGLSLShader		gTreeWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
 LLGLSLShader		gObjectFullbrightNoColorProgram(LLViewerShaderMgr::SHADER_OBJECT);
 LLGLSLShader		gObjectFullbrightNoColorWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
 
-LLGLSLShader		gObjectSimpleNonIndexedProgram(LLViewerShaderMgr::SHADER_OBJECT);
 LLGLSLShader		gObjectSimpleNonIndexedTexGenProgram(LLViewerShaderMgr::SHADER_OBJECT);
 LLGLSLShader		gObjectSimpleNonIndexedTexGenWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectSimpleNonIndexedWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectAlphaMaskNonIndexedProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectAlphaMaskNonIndexedWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
 LLGLSLShader		gObjectAlphaMaskNoColorProgram(LLViewerShaderMgr::SHADER_OBJECT);
 LLGLSLShader		gObjectAlphaMaskNoColorWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectFullbrightNonIndexedProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectFullbrightNonIndexedWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectEmissiveNonIndexedProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectEmissiveNonIndexedWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectFullbrightShinyNonIndexedProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectFullbrightShinyNonIndexedWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectShinyNonIndexedProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gObjectShinyNonIndexedWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-
-//object hardware skinning shaders
-LLGLSLShader		gSkinnedObjectSimpleProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gSkinnedObjectFullbrightProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gSkinnedObjectEmissiveProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gSkinnedObjectFullbrightShinyProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gSkinnedObjectShinySimpleProgram(LLViewerShaderMgr::SHADER_OBJECT);
-
-LLGLSLShader		gSkinnedObjectSimpleWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gSkinnedObjectFullbrightWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gSkinnedObjectEmissiveWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gSkinnedObjectFullbrightShinyWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
-LLGLSLShader		gSkinnedObjectShinySimpleWaterProgram(LLViewerShaderMgr::SHADER_OBJECT);
 
  //environment shaders
 LLGLSLShader		gTerrainProgram(LLViewerShaderMgr::SHADER_ENVIRONMENT);
@@ -1090,7 +1053,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
 		gDeferredSkinnedDiffuseProgram.mFeatures.hasObjectSkinning = true;
 		gDeferredSkinnedDiffuseProgram.mShaderFiles.clear();
 		gDeferredSkinnedDiffuseProgram.mShaderFiles.push_back(make_pair("deferred/diffuseSkinnedV.glsl", GL_VERTEX_SHADER_ARB));
-		gDeferredSkinnedDiffuseProgram.mShaderFiles.push_back(make_pair("deferred/diffuseF.glsl", GL_FRAGMENT_SHADER_ARB));
+		gDeferredSkinnedDiffuseProgram.mShaderFiles.push_back(make_pair("deferred/diffuseAlphaMaskF.glsl", GL_FRAGMENT_SHADER_ARB));
 		gDeferredSkinnedDiffuseProgram.mShaderLevel = mVertexShaderLevel[SHADER_DEFERRED];
 		success = gDeferredSkinnedDiffuseProgram.createShader(NULL, NULL);
 	}
@@ -1880,22 +1843,6 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		unloadShaderClass(SHADER_OBJECT);
 		return TRUE;
 	}
-
-	if (success)
-	{
-		gObjectSimpleNonIndexedProgram.mName = "Non indexed Shader";
-		gObjectSimpleNonIndexedProgram.mFeatures.calculatesLighting = true;
-		gObjectSimpleNonIndexedProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectSimpleNonIndexedProgram.mFeatures.hasGamma = true;
-		gObjectSimpleNonIndexedProgram.mFeatures.hasAtmospherics = true;
-		gObjectSimpleNonIndexedProgram.mFeatures.hasLighting = true;
-		gObjectSimpleNonIndexedProgram.mFeatures.disableTextureIndex = true;
-		gObjectSimpleNonIndexedProgram.mShaderFiles.clear();
-		gObjectSimpleNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectSimpleNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectSimpleNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectSimpleNonIndexedProgram.createShader(NULL, NULL);
-	}
 	
 	if (success)
 	{
@@ -1913,24 +1860,6 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		success = gObjectSimpleNonIndexedTexGenProgram.createShader(NULL, NULL);
 	}
 	
-
-	if (success)
-	{
-		gObjectSimpleNonIndexedWaterProgram.mName = "Non indexed Water Shader";
-		gObjectSimpleNonIndexedWaterProgram.mFeatures.calculatesLighting = true;
-		gObjectSimpleNonIndexedWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectSimpleNonIndexedWaterProgram.mFeatures.hasWaterFog = true;
-		gObjectSimpleNonIndexedWaterProgram.mFeatures.hasAtmospherics = true;
-		gObjectSimpleNonIndexedWaterProgram.mFeatures.hasLighting = true;
-		gObjectSimpleNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
-		gObjectSimpleNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectSimpleNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectSimpleNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectSimpleNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectSimpleNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectSimpleNonIndexedWaterProgram.createShader(NULL, NULL);
-	}
-
 	if (success)
 	{
 		gObjectSimpleNonIndexedTexGenWaterProgram.mName = "Non indexed tex-gen Water Shader";
@@ -1948,41 +1877,6 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		success = gObjectSimpleNonIndexedTexGenWaterProgram.createShader(NULL, NULL);
 	}
 
-	if (success)
-	{
-		gObjectAlphaMaskNonIndexedProgram.mName = "Non indexed alpha mask Shader";
-		gObjectAlphaMaskNonIndexedProgram.mFeatures.calculatesLighting = true;
-		gObjectAlphaMaskNonIndexedProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectAlphaMaskNonIndexedProgram.mFeatures.hasGamma = true;
-		gObjectAlphaMaskNonIndexedProgram.mFeatures.hasAtmospherics = true;
-		gObjectAlphaMaskNonIndexedProgram.mFeatures.hasLighting = true;
-		gObjectAlphaMaskNonIndexedProgram.mFeatures.disableTextureIndex = true;
-		gObjectAlphaMaskNonIndexedProgram.mFeatures.hasAlphaMask = true;
-		gObjectAlphaMaskNonIndexedProgram.mShaderFiles.clear();
-		gObjectAlphaMaskNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/simpleNonIndexedV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectAlphaMaskNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectAlphaMaskNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectAlphaMaskNonIndexedProgram.createShader(NULL, NULL);
-	}
-	
-	if (success)
-	{
-		gObjectAlphaMaskNonIndexedWaterProgram.mName = "Non indexed alpha mask Water Shader";
-		gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.calculatesLighting = true;
-		gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.hasWaterFog = true;
-		gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.hasAtmospherics = true;
-		gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.hasLighting = true;
-		gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
-		gObjectAlphaMaskNonIndexedWaterProgram.mFeatures.hasAlphaMask = true;
-		gObjectAlphaMaskNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectAlphaMaskNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleNonIndexedV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectAlphaMaskNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectAlphaMaskNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectAlphaMaskNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectAlphaMaskNonIndexedWaterProgram.createShader(NULL, NULL);
-	}
-
 	if (success)
 	{
 		gObjectAlphaMaskNoColorProgram.mName = "No color alpha mask Shader";
@@ -2053,68 +1947,6 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		success = gTreeWaterProgram.createShader(NULL, NULL);
 	}
 
-	if (success)
-	{
-		gObjectFullbrightNonIndexedProgram.mName = "Non Indexed Fullbright Shader";
-		gObjectFullbrightNonIndexedProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectFullbrightNonIndexedProgram.mFeatures.hasGamma = true;
-		gObjectFullbrightNonIndexedProgram.mFeatures.hasTransport = true;
-		gObjectFullbrightNonIndexedProgram.mFeatures.isFullbright = true;
-		gObjectFullbrightNonIndexedProgram.mFeatures.disableTextureIndex = true;
-		gObjectFullbrightNonIndexedProgram.mShaderFiles.clear();
-		gObjectFullbrightNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectFullbrightNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectFullbrightNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectFullbrightNonIndexedProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectFullbrightNonIndexedWaterProgram.mName = "Non Indexed Fullbright Water Shader";
-		gObjectFullbrightNonIndexedWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectFullbrightNonIndexedWaterProgram.mFeatures.isFullbright = true;
-		gObjectFullbrightNonIndexedWaterProgram.mFeatures.hasWaterFog = true;		
-		gObjectFullbrightNonIndexedWaterProgram.mFeatures.hasTransport = true;
-		gObjectFullbrightNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
-		gObjectFullbrightNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectFullbrightNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectFullbrightNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectFullbrightNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectFullbrightNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectFullbrightNonIndexedWaterProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectEmissiveNonIndexedProgram.mName = "Non Indexed Emissive Shader";
-		gObjectEmissiveNonIndexedProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectEmissiveNonIndexedProgram.mFeatures.hasGamma = true;
-		gObjectEmissiveNonIndexedProgram.mFeatures.hasTransport = true;
-		gObjectEmissiveNonIndexedProgram.mFeatures.isFullbright = true;
-		gObjectEmissiveNonIndexedProgram.mFeatures.disableTextureIndex = true;
-		gObjectEmissiveNonIndexedProgram.mShaderFiles.clear();
-		gObjectEmissiveNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/emissiveV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectEmissiveNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectEmissiveNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectEmissiveNonIndexedProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectEmissiveNonIndexedWaterProgram.mName = "Non Indexed Emissive Water Shader";
-		gObjectEmissiveNonIndexedWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectEmissiveNonIndexedWaterProgram.mFeatures.isFullbright = true;
-		gObjectEmissiveNonIndexedWaterProgram.mFeatures.hasWaterFog = true;		
-		gObjectEmissiveNonIndexedWaterProgram.mFeatures.hasTransport = true;
-		gObjectEmissiveNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
-		gObjectEmissiveNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectEmissiveNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/emissiveV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectEmissiveNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectEmissiveNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectEmissiveNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectEmissiveNonIndexedWaterProgram.createShader(NULL, NULL);
-	}
-
 	if (success)
 	{
 		gObjectFullbrightNoColorProgram.mName = "Non Indexed no color Fullbright Shader";
@@ -2146,73 +1978,6 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 		success = gObjectFullbrightNoColorWaterProgram.createShader(NULL, NULL);
 	}
 
-	if (success)
-	{
-		gObjectShinyNonIndexedProgram.mName = "Non Indexed Shiny Shader";
-		gObjectShinyNonIndexedProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectShinyNonIndexedProgram.mFeatures.calculatesLighting = true;
-		gObjectShinyNonIndexedProgram.mFeatures.hasGamma = true;
-		gObjectShinyNonIndexedProgram.mFeatures.hasAtmospherics = true;
-		gObjectShinyNonIndexedProgram.mFeatures.isShiny = true;
-		gObjectShinyNonIndexedProgram.mFeatures.disableTextureIndex = true;
-		gObjectShinyNonIndexedProgram.mShaderFiles.clear();
-		gObjectShinyNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectShinyNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/shinyF.glsl", GL_FRAGMENT_SHADER_ARB));		
-		gObjectShinyNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectShinyNonIndexedProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectShinyNonIndexedWaterProgram.mName = "Non Indexed Shiny Water Shader";
-		gObjectShinyNonIndexedWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectShinyNonIndexedWaterProgram.mFeatures.calculatesLighting = true;
-		gObjectShinyNonIndexedWaterProgram.mFeatures.isShiny = true;
-		gObjectShinyNonIndexedWaterProgram.mFeatures.hasWaterFog = true;
-		gObjectShinyNonIndexedWaterProgram.mFeatures.hasAtmospherics = true;
-		gObjectShinyNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
-		gObjectShinyNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectShinyNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectShinyNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectShinyNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectShinyNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectShinyNonIndexedWaterProgram.createShader(NULL, NULL);
-	}
-	
-	if (success)
-	{
-		gObjectFullbrightShinyNonIndexedProgram.mName = "Non Indexed Fullbright Shiny Shader";
-		gObjectFullbrightShinyNonIndexedProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectFullbrightShinyNonIndexedProgram.mFeatures.isFullbright = true;
-		gObjectFullbrightShinyNonIndexedProgram.mFeatures.isShiny = true;
-		gObjectFullbrightShinyNonIndexedProgram.mFeatures.hasGamma = true;
-		gObjectFullbrightShinyNonIndexedProgram.mFeatures.hasTransport = true;
-		gObjectFullbrightShinyNonIndexedProgram.mFeatures.disableTextureIndex = true;
-		gObjectFullbrightShinyNonIndexedProgram.mShaderFiles.clear();
-		gObjectFullbrightShinyNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectFullbrightShinyNonIndexedProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectFullbrightShinyNonIndexedProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectFullbrightShinyNonIndexedProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectFullbrightShinyNonIndexedWaterProgram.mName = "Non Indexed Fullbright Shiny Water Shader";
-		gObjectFullbrightShinyNonIndexedWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectFullbrightShinyNonIndexedWaterProgram.mFeatures.isFullbright = true;
-		gObjectFullbrightShinyNonIndexedWaterProgram.mFeatures.isShiny = true;
-		gObjectFullbrightShinyNonIndexedWaterProgram.mFeatures.hasGamma = true;
-		gObjectFullbrightShinyNonIndexedWaterProgram.mFeatures.hasTransport = true;
-		gObjectFullbrightShinyNonIndexedWaterProgram.mFeatures.hasWaterFog = true;
-		gObjectFullbrightShinyNonIndexedWaterProgram.mFeatures.disableTextureIndex = true;
-		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderFiles.clear();
-		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectFullbrightShinyNonIndexedWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectFullbrightShinyNonIndexedWaterProgram.createShader(NULL, NULL);
-	}
-
 	if (success)
 	{
 		gImpostorProgram.mName = "Impostor Shader";
@@ -2244,58 +2009,131 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 
 	if (success)
 	{
-		gObjectSimpleProgram.mName = "Simple Shader";
-		gObjectSimpleProgram.mFeatures.calculatesLighting = true;
-		gObjectSimpleProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectSimpleProgram.mFeatures.hasGamma = true;
-		gObjectSimpleProgram.mFeatures.hasAtmospherics = true;
-		gObjectSimpleProgram.mFeatures.hasLighting = true;
-		gObjectSimpleProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectSimpleProgram.mShaderFiles.clear();
-		gObjectSimpleProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectSimpleProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectSimpleProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectSimpleProgram.createShader(NULL, NULL);
+		for(U32 i = 0; i < (U32)1<<SHD_COUNT; ++i)
+		{
+			bool mask = i & 1<<SHD_ALPHA_MASK_BIT;
+			bool fog = i & 1<<SHD_WATER_BIT;
+			bool no_index = i & 1<<SHD_NO_INDEX_BIT;
+			bool skin = i & 1<<SHD_SKIN_BIT;
+			bool shiny = i & 1<<SHD_SHINY_BIT;
+
+			std::string name;
+			if(shiny) name += " Shiny";
+			if(skin) name += " Skinned";
+			if(no_index) name += " Non-Indexed";
+			if(mask) name += " Alpha Mask";	
+			if(fog) name += " Water";
+
+			if(no_index && !mask)
+			{
+				llinfos << "Skipping Simple" << name << llendl;
+				llinfos << "Skipping Fullbright" << name << llendl;
+				llinfos << "Skipping Emissive" << name << llendl;
+				continue;	//all non-indexed shaders here have alphamasks;
+			}
+
+			if(skin && (!no_index || mVertexShaderLevel[SHADER_AVATAR] < 1))
+			{
+				llinfos << "Skipping Simple" << name << llendl;
+				llinfos << "Skipping Fullbright" << name << llendl;
+				llinfos << "Skipping Emissive" << name << llendl;
+				continue;	//Skins are always non-indexed.
+			}
+
+			if(shiny && mask && !skin && !no_index)
+			{
+				llinfos << "Skipping Simple" << name << llendl;
+				llinfos << "Skipping Fullbright" << name << llendl;
+				llinfos << "Skipping Emissive" << name << llendl;
+				continue;	//non-skinned indexed shiny does not support alphamasking
+			}
+
+
+
+			LLShaderFeatures features;
+			features.calculatesLighting = true;
+			features.calculatesAtmospherics = true;
+			features.hasAtmospherics = true;
+			features.hasLighting = !shiny;
+			features.mIndexedTextureChannels = 0;
+			features.hasGamma = !fog;
+			features.hasWaterFog = fog;
+			features.hasAlphaMask = mask;
+			features.disableTextureIndex = no_index;
+			features.hasObjectSkinning = skin;
+			features.isShiny = shiny;
+
+			llinfos << "Compiling Simple" << name << llendl;
+
+			gObjectSimpleProgram[i].mName = std::string("Simple") + name + " Shader";
+			gObjectSimpleProgram[i].mFeatures = features;
+			gObjectSimpleProgram[i].mShaderFiles.clear();
+			if(!shiny)
+			{
+				gObjectSimpleProgram[i].mShaderFiles.push_back(make_pair(skin ? "objects/simpleSkinnedV.glsl" : "objects/simpleV.glsl", GL_VERTEX_SHADER_ARB));
+				gObjectSimpleProgram[i].mShaderFiles.push_back(make_pair(fog ? "objects/simpleWaterF.glsl" : "objects/simpleF.glsl", GL_FRAGMENT_SHADER_ARB));
+			}
+			else
+			{
+				gObjectSimpleProgram[i].mShaderFiles.push_back(make_pair(skin ? "objects/shinySimpleSkinnedV.glsl" : "objects/shinyV.glsl", GL_VERTEX_SHADER_ARB));
+				gObjectSimpleProgram[i].mShaderFiles.push_back(make_pair(fog ? "objects/shinyWaterF.glsl" : "objects/shinyF.glsl", GL_FRAGMENT_SHADER_ARB));
+			}
+			gObjectSimpleProgram[i].mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
+			if(fog)
+				gObjectSimpleProgram[i].mShaderGroup = LLGLSLShader::SG_WATER;
+			if(!(success = gObjectSimpleProgram[i].createShader(NULL, NULL)))
+				break;
+
+			features.calculatesLighting = false;
+			features.hasLighting = false;
+			features.hasTransport = true;
+			features.hasAtmospherics = false;
+			features.isFullbright = true;
+			features.hasGamma |= (shiny && fog);
+			
+			llinfos << "Compiling Fullbright" << name << llendl;
+
+			gObjectFullbrightProgram[i].mName = std::string("Fullbright") + name + " Shader";
+			gObjectFullbrightProgram[i].mFeatures = features;
+			gObjectFullbrightProgram[i].mShaderFiles.clear();
+			if(!shiny)
+			{
+				gObjectFullbrightProgram[i].mShaderFiles.push_back(make_pair(skin ? "objects/fullbrightSkinnedV.glsl" : "objects/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
+				gObjectFullbrightProgram[i].mShaderFiles.push_back(make_pair(fog ? "objects/fullbrightWaterF.glsl" : "objects/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
+			}
+			else
+			{
+				gObjectFullbrightProgram[i].mShaderFiles.push_back(make_pair(skin ? "objects/fullbrightShinySkinnedV.glsl" : "objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER_ARB));
+				gObjectFullbrightProgram[i].mShaderFiles.push_back(make_pair(fog ? "objects/fullbrightShinyWaterF.glsl" : "objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER_ARB));
+			}
+			gObjectFullbrightProgram[i].mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
+			if(fog)
+				gObjectFullbrightProgram[i].mShaderGroup = LLGLSLShader::SG_WATER;
+			if(!(success = gObjectFullbrightProgram[i].createShader(NULL, NULL)))
+				break;
+
+			if(!shiny)
+			{
+				llinfos << "Compiling Emissive" << name << llendl;
+
+				gObjectEmissiveProgram[i].mName = std::string("Emissive") + name + " Shader";
+				gObjectEmissiveProgram[i].mFeatures = features;
+				gObjectEmissiveProgram[i].mShaderFiles.clear();
+				gObjectEmissiveProgram[i].mShaderFiles.push_back(make_pair(skin ? "objects/emissiveSkinnedV.glsl" : "objects/emissiveV.glsl", GL_VERTEX_SHADER_ARB));
+				gObjectEmissiveProgram[i].mShaderFiles.push_back(make_pair(fog ? "objects/fullbrightWaterF.glsl" : "objects/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
+				gObjectEmissiveProgram[i].mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
+				if(fog)
+					gObjectEmissiveProgram[i].mShaderGroup = LLGLSLShader::SG_WATER;
+				if(!(success = gObjectEmissiveProgram[i].createShader(NULL, NULL)))
+					break;
+			}
+			else
+			{
+				llinfos << "Skipping Emissive" << name << llendl;
+			}
+		}
 	}
 
-	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";
-		gObjectSimpleWaterProgram.mFeatures.calculatesLighting = true;
-		gObjectSimpleWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectSimpleWaterProgram.mFeatures.hasWaterFog = true;
-		gObjectSimpleWaterProgram.mFeatures.hasAtmospherics = true;
-		gObjectSimpleWaterProgram.mFeatures.hasLighting = true;
-		gObjectSimpleWaterProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectSimpleWaterProgram.mShaderFiles.clear();
-		gObjectSimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectSimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectSimpleWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectSimpleWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectSimpleWaterProgram.createShader(NULL, NULL);
-	}
-	
 	if (success)
 	{
 		gObjectBumpProgram.mName = "Bump Shader";
@@ -2318,390 +2156,6 @@ BOOL LLViewerShaderMgr::loadShadersObject()
 			gObjectBumpProgram.unbind();
 		}
 	}
-	
-	
-	if (success)
-	{
-		gObjectSimpleAlphaMaskProgram.mName = "Simple Alpha Mask Shader";
-		gObjectSimpleAlphaMaskProgram.mFeatures.calculatesLighting = true;
-		gObjectSimpleAlphaMaskProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectSimpleAlphaMaskProgram.mFeatures.hasGamma = true;
-		gObjectSimpleAlphaMaskProgram.mFeatures.hasAtmospherics = true;
-		gObjectSimpleAlphaMaskProgram.mFeatures.hasLighting = true;
-		gObjectSimpleAlphaMaskProgram.mFeatures.hasAlphaMask = true;
-		gObjectSimpleAlphaMaskProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectSimpleAlphaMaskProgram.mShaderFiles.clear();
-		gObjectSimpleAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectSimpleAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectSimpleAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectSimpleAlphaMaskProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectSimpleWaterAlphaMaskProgram.mName = "Simple Water Alpha Mask Shader";
-		gObjectSimpleWaterAlphaMaskProgram.mFeatures.calculatesLighting = true;
-		gObjectSimpleWaterAlphaMaskProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectSimpleWaterAlphaMaskProgram.mFeatures.hasWaterFog = true;
-		gObjectSimpleWaterAlphaMaskProgram.mFeatures.hasAtmospherics = true;
-		gObjectSimpleWaterAlphaMaskProgram.mFeatures.hasLighting = true;
-		gObjectSimpleWaterAlphaMaskProgram.mFeatures.hasAlphaMask = true;
-		gObjectSimpleWaterAlphaMaskProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectSimpleWaterAlphaMaskProgram.mShaderFiles.clear();
-		gObjectSimpleWaterAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/simpleV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectSimpleWaterAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectSimpleWaterAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectSimpleWaterAlphaMaskProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectSimpleWaterAlphaMaskProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectFullbrightProgram.mName = "Fullbright Shader";
-		gObjectFullbrightProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectFullbrightProgram.mFeatures.hasGamma = true;
-		gObjectFullbrightProgram.mFeatures.hasTransport = true;
-		gObjectFullbrightProgram.mFeatures.isFullbright = true;
-		gObjectFullbrightProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectFullbrightProgram.mShaderFiles.clear();
-		gObjectFullbrightProgram.mShaderFiles.push_back(make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectFullbrightProgram.mShaderFiles.push_back(make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectFullbrightProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectFullbrightProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectFullbrightWaterProgram.mName = "Fullbright Water Shader";
-		gObjectFullbrightWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectFullbrightWaterProgram.mFeatures.isFullbright = true;
-		gObjectFullbrightWaterProgram.mFeatures.hasWaterFog = true;		
-		gObjectFullbrightWaterProgram.mFeatures.hasTransport = true;
-		gObjectFullbrightWaterProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectFullbrightWaterProgram.mShaderFiles.clear();
-		gObjectFullbrightWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectFullbrightWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectFullbrightWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectFullbrightWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectFullbrightWaterProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectEmissiveProgram.mName = "Emissive Shader";
-		gObjectEmissiveProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectEmissiveProgram.mFeatures.hasGamma = true;
-		gObjectEmissiveProgram.mFeatures.hasTransport = true;
-		gObjectEmissiveProgram.mFeatures.isFullbright = true;
-		gObjectEmissiveProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectEmissiveProgram.mShaderFiles.clear();
-		gObjectEmissiveProgram.mShaderFiles.push_back(make_pair("objects/emissiveV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectEmissiveProgram.mShaderFiles.push_back(make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectEmissiveProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectEmissiveProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectEmissiveWaterProgram.mName = "Emissive Water Shader";
-		gObjectEmissiveWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectEmissiveWaterProgram.mFeatures.isFullbright = true;
-		gObjectEmissiveWaterProgram.mFeatures.hasWaterFog = true;		
-		gObjectEmissiveWaterProgram.mFeatures.hasTransport = true;
-		gObjectEmissiveWaterProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectEmissiveWaterProgram.mShaderFiles.clear();
-		gObjectEmissiveWaterProgram.mShaderFiles.push_back(make_pair("objects/emissiveV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectEmissiveWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectEmissiveWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectEmissiveWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectEmissiveWaterProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectFullbrightAlphaMaskProgram.mName = "Fullbright Alpha Mask Shader";
-		gObjectFullbrightAlphaMaskProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectFullbrightAlphaMaskProgram.mFeatures.hasGamma = true;
-		gObjectFullbrightAlphaMaskProgram.mFeatures.hasTransport = true;
-		gObjectFullbrightAlphaMaskProgram.mFeatures.isFullbright = true;
-		gObjectFullbrightAlphaMaskProgram.mFeatures.hasAlphaMask = true;
-		gObjectFullbrightAlphaMaskProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectFullbrightAlphaMaskProgram.mShaderFiles.clear();
-		gObjectFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectFullbrightAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectFullbrightAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectFullbrightAlphaMaskProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectFullbrightWaterAlphaMaskProgram.mName = "Fullbright Water Shader";
-		gObjectFullbrightWaterAlphaMaskProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectFullbrightWaterAlphaMaskProgram.mFeatures.isFullbright = true;
-		gObjectFullbrightWaterAlphaMaskProgram.mFeatures.hasWaterFog = true;		
-		gObjectFullbrightWaterAlphaMaskProgram.mFeatures.hasTransport = true;
-		gObjectFullbrightWaterAlphaMaskProgram.mFeatures.hasAlphaMask = true;
-		gObjectFullbrightWaterAlphaMaskProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectFullbrightWaterAlphaMaskProgram.mShaderFiles.clear();
-		gObjectFullbrightWaterAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/fullbrightV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectFullbrightWaterAlphaMaskProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectFullbrightWaterAlphaMaskProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectFullbrightWaterAlphaMaskProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectFullbrightWaterAlphaMaskProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectShinyProgram.mName = "Shiny Shader";
-		gObjectShinyProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectShinyProgram.mFeatures.calculatesLighting = true;
-		gObjectShinyProgram.mFeatures.hasGamma = true;
-		gObjectShinyProgram.mFeatures.hasAtmospherics = true;
-		gObjectShinyProgram.mFeatures.isShiny = true;
-		gObjectShinyProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectShinyProgram.mShaderFiles.clear();
-		gObjectShinyProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectShinyProgram.mShaderFiles.push_back(make_pair("objects/shinyF.glsl", GL_FRAGMENT_SHADER_ARB));		
-		gObjectShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectShinyProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectShinyWaterProgram.mName = "Shiny Water Shader";
-		gObjectShinyWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectShinyWaterProgram.mFeatures.calculatesLighting = true;
-		gObjectShinyWaterProgram.mFeatures.isShiny = true;
-		gObjectShinyWaterProgram.mFeatures.hasWaterFog = true;
-		gObjectShinyWaterProgram.mFeatures.hasAtmospherics = true;
-		gObjectShinyWaterProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectShinyWaterProgram.mShaderFiles.clear();
-		gObjectShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectShinyWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectShinyWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectShinyWaterProgram.createShader(NULL, NULL);
-	}
-	
-	if (success)
-	{
-		gObjectFullbrightShinyProgram.mName = "Fullbright Shiny Shader";
-		gObjectFullbrightShinyProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectFullbrightShinyProgram.mFeatures.isFullbright = true;
-		gObjectFullbrightShinyProgram.mFeatures.isShiny = true;
-		gObjectFullbrightShinyProgram.mFeatures.hasGamma = true;
-		gObjectFullbrightShinyProgram.mFeatures.hasTransport = true;
-		gObjectFullbrightShinyProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectFullbrightShinyProgram.mShaderFiles.clear();
-		gObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectFullbrightShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		success = gObjectFullbrightShinyProgram.createShader(NULL, NULL);
-	}
-
-	if (success)
-	{
-		gObjectFullbrightShinyWaterProgram.mName = "Fullbright Shiny Water Shader";
-		gObjectFullbrightShinyWaterProgram.mFeatures.calculatesAtmospherics = true;
-		gObjectFullbrightShinyWaterProgram.mFeatures.isFullbright = true;
-		gObjectFullbrightShinyWaterProgram.mFeatures.isShiny = true;
-		gObjectFullbrightShinyWaterProgram.mFeatures.hasGamma = true;
-		gObjectFullbrightShinyWaterProgram.mFeatures.hasTransport = true;
-		gObjectFullbrightShinyWaterProgram.mFeatures.hasWaterFog = true;
-		gObjectFullbrightShinyWaterProgram.mFeatures.mIndexedTextureChannels = 0;
-		gObjectFullbrightShinyWaterProgram.mShaderFiles.clear();
-		gObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyV.glsl", GL_VERTEX_SHADER_ARB));
-		gObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-		gObjectFullbrightShinyWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-		gObjectFullbrightShinyWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-		success = gObjectFullbrightShinyWaterProgram.createShader(NULL, NULL);
-	}
-
-	if (mVertexShaderLevel[SHADER_AVATAR] > 0)
-	{ //load hardware skinned attachment shaders
-		if (success)
-		{
-			gSkinnedObjectSimpleProgram.mName = "Skinned Simple Shader";
-			gSkinnedObjectSimpleProgram.mFeatures.calculatesLighting = true;
-			gSkinnedObjectSimpleProgram.mFeatures.calculatesAtmospherics = true;
-			gSkinnedObjectSimpleProgram.mFeatures.hasGamma = true;
-			gSkinnedObjectSimpleProgram.mFeatures.hasAtmospherics = true;
-			gSkinnedObjectSimpleProgram.mFeatures.hasLighting = true;
-			gSkinnedObjectSimpleProgram.mFeatures.hasObjectSkinning = true;
-			gSkinnedObjectSimpleProgram.mFeatures.hasAlphaMask = true;
-			gSkinnedObjectSimpleProgram.mFeatures.disableTextureIndex = true;
-			gSkinnedObjectSimpleProgram.mShaderFiles.clear();
-			gSkinnedObjectSimpleProgram.mShaderFiles.push_back(make_pair("objects/simpleSkinnedV.glsl", GL_VERTEX_SHADER_ARB));
-			gSkinnedObjectSimpleProgram.mShaderFiles.push_back(make_pair("objects/simpleF.glsl", GL_FRAGMENT_SHADER_ARB));
-			gSkinnedObjectSimpleProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectSimpleProgram.createShader(NULL, NULL);
-		}
-
-		if (success)
-		{
-			gSkinnedObjectFullbrightProgram.mName = "Skinned Fullbright Shader";
-			gSkinnedObjectFullbrightProgram.mFeatures.calculatesAtmospherics = true;
-			gSkinnedObjectFullbrightProgram.mFeatures.hasGamma = true;
-			gSkinnedObjectFullbrightProgram.mFeatures.hasTransport = true;
-			gSkinnedObjectFullbrightProgram.mFeatures.isFullbright = true;
-			gSkinnedObjectFullbrightProgram.mFeatures.hasObjectSkinning = true;
-			gSkinnedObjectFullbrightProgram.mFeatures.hasAlphaMask = true;			
-			gSkinnedObjectFullbrightProgram.mFeatures.disableTextureIndex = true;
-			gSkinnedObjectFullbrightProgram.mShaderFiles.clear();
-			gSkinnedObjectFullbrightProgram.mShaderFiles.push_back(make_pair("objects/fullbrightSkinnedV.glsl", GL_VERTEX_SHADER_ARB));
-			gSkinnedObjectFullbrightProgram.mShaderFiles.push_back(make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
-			gSkinnedObjectFullbrightProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectFullbrightProgram.createShader(NULL, NULL);
-		}
-
-		if (success)
-		{
-			gSkinnedObjectEmissiveProgram.mName = "Skinned Emissive Shader";
-			gSkinnedObjectEmissiveProgram.mFeatures.calculatesAtmospherics = true;
-			gSkinnedObjectEmissiveProgram.mFeatures.hasGamma = true;
-			gSkinnedObjectEmissiveProgram.mFeatures.hasTransport = true;
-			gSkinnedObjectEmissiveProgram.mFeatures.isFullbright = true;
-			gSkinnedObjectEmissiveProgram.mFeatures.hasObjectSkinning = true;
-			gSkinnedObjectEmissiveProgram.mFeatures.disableTextureIndex = true;
-			gSkinnedObjectEmissiveProgram.mShaderFiles.clear();
-			gSkinnedObjectEmissiveProgram.mShaderFiles.push_back(make_pair("objects/emissiveSkinnedV.glsl", GL_VERTEX_SHADER_ARB));
-			gSkinnedObjectEmissiveProgram.mShaderFiles.push_back(make_pair("objects/fullbrightF.glsl", GL_FRAGMENT_SHADER_ARB));
-			gSkinnedObjectEmissiveProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectEmissiveProgram.createShader(NULL, NULL);
-		}
-
-		if (success)
-		{
-			gSkinnedObjectEmissiveWaterProgram.mName = "Skinned Emissive Water Shader";
-			gSkinnedObjectEmissiveWaterProgram.mFeatures.calculatesAtmospherics = true;
-			gSkinnedObjectEmissiveWaterProgram.mFeatures.hasGamma = true;
-			gSkinnedObjectEmissiveWaterProgram.mFeatures.hasTransport = true;
-			gSkinnedObjectEmissiveWaterProgram.mFeatures.isFullbright = true;
-			gSkinnedObjectEmissiveWaterProgram.mFeatures.hasObjectSkinning = true;
-			gSkinnedObjectEmissiveWaterProgram.mFeatures.disableTextureIndex = true;
-			gSkinnedObjectEmissiveWaterProgram.mFeatures.hasWaterFog = true;
-			gSkinnedObjectEmissiveWaterProgram.mShaderFiles.clear();
-			gSkinnedObjectEmissiveWaterProgram.mShaderFiles.push_back(make_pair("objects/emissiveSkinnedV.glsl", GL_VERTEX_SHADER_ARB));
-			gSkinnedObjectEmissiveWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-			gSkinnedObjectEmissiveWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectEmissiveWaterProgram.createShader(NULL, NULL);
-		}
-
-		if (success)
-		{
-			gSkinnedObjectFullbrightShinyProgram.mName = "Skinned Fullbright Shiny Shader";
-			gSkinnedObjectFullbrightShinyProgram.mFeatures.calculatesAtmospherics = true;
-			gSkinnedObjectFullbrightShinyProgram.mFeatures.hasGamma = true;
-			gSkinnedObjectFullbrightShinyProgram.mFeatures.hasTransport = true;
-			gSkinnedObjectFullbrightShinyProgram.mFeatures.isShiny = true;
-			gSkinnedObjectFullbrightShinyProgram.mFeatures.isFullbright = true;
-			gSkinnedObjectFullbrightShinyProgram.mFeatures.hasObjectSkinning = true;
-			gSkinnedObjectFullbrightShinyProgram.mFeatures.hasAlphaMask = true;
-			gSkinnedObjectFullbrightShinyProgram.mFeatures.disableTextureIndex = true;
-			gSkinnedObjectFullbrightShinyProgram.mShaderFiles.clear();
-			gSkinnedObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinySkinnedV.glsl", GL_VERTEX_SHADER_ARB));
-			gSkinnedObjectFullbrightShinyProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyF.glsl", GL_FRAGMENT_SHADER_ARB));
-			gSkinnedObjectFullbrightShinyProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectFullbrightShinyProgram.createShader(NULL, NULL);
-		}
-
-		if (success)
-		{
-			gSkinnedObjectShinySimpleProgram.mName = "Skinned Shiny Simple Shader";
-			gSkinnedObjectShinySimpleProgram.mFeatures.calculatesLighting = true;
-			gSkinnedObjectShinySimpleProgram.mFeatures.calculatesAtmospherics = true;
-			gSkinnedObjectShinySimpleProgram.mFeatures.hasGamma = true;
-			gSkinnedObjectShinySimpleProgram.mFeatures.hasAtmospherics = true;
-			gSkinnedObjectShinySimpleProgram.mFeatures.hasObjectSkinning = true;
-			gSkinnedObjectShinySimpleProgram.mFeatures.hasAlphaMask = true;
-			gSkinnedObjectShinySimpleProgram.mFeatures.isShiny = true;
-			gSkinnedObjectShinySimpleProgram.mFeatures.disableTextureIndex = true;
-			gSkinnedObjectShinySimpleProgram.mShaderFiles.clear();
-			gSkinnedObjectShinySimpleProgram.mShaderFiles.push_back(make_pair("objects/shinySimpleSkinnedV.glsl", GL_VERTEX_SHADER_ARB));
-			gSkinnedObjectShinySimpleProgram.mShaderFiles.push_back(make_pair("objects/shinyF.glsl", GL_FRAGMENT_SHADER_ARB));
-			gSkinnedObjectShinySimpleProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectShinySimpleProgram.createShader(NULL, NULL);
-		}
-
-		if (success)
-		{
-			gSkinnedObjectSimpleWaterProgram.mName = "Skinned Simple Water Shader";
-			gSkinnedObjectSimpleWaterProgram.mFeatures.calculatesLighting = true;
-			gSkinnedObjectSimpleWaterProgram.mFeatures.calculatesAtmospherics = true;
-			gSkinnedObjectSimpleWaterProgram.mFeatures.hasGamma = true;
-			gSkinnedObjectSimpleWaterProgram.mFeatures.hasAtmospherics = true;
-			gSkinnedObjectSimpleWaterProgram.mFeatures.hasLighting = true;
-			gSkinnedObjectSimpleWaterProgram.mFeatures.disableTextureIndex = true;
-			gSkinnedObjectSimpleWaterProgram.mFeatures.hasWaterFog = true;
-			gSkinnedObjectSimpleWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-			gSkinnedObjectSimpleWaterProgram.mFeatures.hasObjectSkinning = true;
-			gSkinnedObjectSimpleWaterProgram.mFeatures.disableTextureIndex = true;
-			gSkinnedObjectSimpleWaterProgram.mShaderFiles.clear();
-			gSkinnedObjectSimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleSkinnedV.glsl", GL_VERTEX_SHADER_ARB));
-			gSkinnedObjectSimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/simpleWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-			gSkinnedObjectSimpleWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectSimpleWaterProgram.createShader(NULL, NULL);
-		}
-
-		if (success)
-		{
-			gSkinnedObjectFullbrightWaterProgram.mName = "Skinned Fullbright Water Shader";
-			gSkinnedObjectFullbrightWaterProgram.mFeatures.calculatesAtmospherics = true;
-			gSkinnedObjectFullbrightWaterProgram.mFeatures.hasGamma = true;
-			gSkinnedObjectFullbrightWaterProgram.mFeatures.hasTransport = true;
-			gSkinnedObjectFullbrightWaterProgram.mFeatures.isFullbright = true;
-			gSkinnedObjectFullbrightWaterProgram.mFeatures.hasObjectSkinning = true;
-			gSkinnedObjectFullbrightWaterProgram.mFeatures.hasAlphaMask = true;
-			gSkinnedObjectFullbrightWaterProgram.mFeatures.hasWaterFog = true;
-			gSkinnedObjectFullbrightWaterProgram.mFeatures.disableTextureIndex = true;
-			gSkinnedObjectFullbrightWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-			gSkinnedObjectFullbrightWaterProgram.mShaderFiles.clear();
-			gSkinnedObjectFullbrightWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightSkinnedV.glsl", GL_VERTEX_SHADER_ARB));
-			gSkinnedObjectFullbrightWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-			gSkinnedObjectFullbrightWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectFullbrightWaterProgram.createShader(NULL, NULL);
-		}
-
-		if (success)
-		{
-			gSkinnedObjectFullbrightShinyWaterProgram.mName = "Skinned Fullbright Shiny Water Shader";
-			gSkinnedObjectFullbrightShinyWaterProgram.mFeatures.calculatesAtmospherics = true;
-			gSkinnedObjectFullbrightShinyWaterProgram.mFeatures.hasGamma = true;
-			gSkinnedObjectFullbrightShinyWaterProgram.mFeatures.hasTransport = true;
-			gSkinnedObjectFullbrightShinyWaterProgram.mFeatures.isShiny = true;
-			gSkinnedObjectFullbrightShinyWaterProgram.mFeatures.isFullbright = true;
-			gSkinnedObjectFullbrightShinyWaterProgram.mFeatures.hasObjectSkinning = true;
-			gSkinnedObjectFullbrightShinyWaterProgram.mFeatures.hasAlphaMask = true;
-			gSkinnedObjectFullbrightShinyWaterProgram.mFeatures.hasWaterFog = true;
-			gSkinnedObjectFullbrightShinyWaterProgram.mFeatures.disableTextureIndex = true;
-			gSkinnedObjectFullbrightShinyWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-			gSkinnedObjectFullbrightShinyWaterProgram.mShaderFiles.clear();
-			gSkinnedObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinySkinnedV.glsl", GL_VERTEX_SHADER_ARB));
-			gSkinnedObjectFullbrightShinyWaterProgram.mShaderFiles.push_back(make_pair("objects/fullbrightShinyWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-			gSkinnedObjectFullbrightShinyWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectFullbrightShinyWaterProgram.createShader(NULL, NULL);
-		}
-
-		if (success)
-		{
-			gSkinnedObjectShinySimpleWaterProgram.mName = "Skinned Shiny Simple Water Shader";
-			gSkinnedObjectShinySimpleWaterProgram.mFeatures.calculatesLighting = true;
-			gSkinnedObjectShinySimpleWaterProgram.mFeatures.calculatesAtmospherics = true;
-			gSkinnedObjectShinySimpleWaterProgram.mFeatures.hasGamma = true;
-			gSkinnedObjectShinySimpleWaterProgram.mFeatures.hasAtmospherics = true;
-			gSkinnedObjectShinySimpleWaterProgram.mFeatures.hasObjectSkinning = true;
-			gSkinnedObjectShinySimpleWaterProgram.mFeatures.hasAlphaMask = true;
-			gSkinnedObjectShinySimpleWaterProgram.mFeatures.isShiny = true;
-			gSkinnedObjectShinySimpleWaterProgram.mFeatures.hasWaterFog = true;
-			gSkinnedObjectShinySimpleWaterProgram.mFeatures.disableTextureIndex = true;
-			gSkinnedObjectShinySimpleWaterProgram.mShaderGroup = LLGLSLShader::SG_WATER;
-			gSkinnedObjectShinySimpleWaterProgram.mShaderFiles.clear();
-			gSkinnedObjectShinySimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/shinySimpleSkinnedV.glsl", GL_VERTEX_SHADER_ARB));
-			gSkinnedObjectShinySimpleWaterProgram.mShaderFiles.push_back(make_pair("objects/shinyWaterF.glsl", GL_FRAGMENT_SHADER_ARB));
-			gSkinnedObjectShinySimpleWaterProgram.mShaderLevel = mVertexShaderLevel[SHADER_OBJECT];
-			success = gSkinnedObjectShinySimpleWaterProgram.createShader(NULL, NULL);
-		}
-	}
 
 	if( !success )
 	{

indra/newview/llviewershadermgr.h

@@ -32,6 +32,16 @@
 
 #define LL_DEFERRED_MULTI_LIGHT_COUNT 16
 
+enum
+{
+	SHD_ALPHA_MASK_BIT = 0,
+	SHD_WATER_BIT,
+	SHD_NO_INDEX_BIT,
+	SHD_SKIN_BIT,
+	SHD_SHINY_BIT,
+	SHD_COUNT
+};
+
 class LLViewerShaderMgr: public LLShaderMgr
 {
 public:
@@ -208,32 +218,17 @@ extern LLGLSLShader			gTwoTextureAddProgram;
 extern LLGLSLShader			gOneTextureNoColorProgram;
 
 //object shaders
-extern LLGLSLShader			gObjectSimpleProgram;
-extern LLGLSLShader			gObjectSimpleImpostorProgram;
+
+extern LLGLSLShaderArray<LLViewerShaderMgr::SHADER_OBJECT>	gObjectSimpleProgram[1<<SHD_COUNT];
+extern LLGLSLShaderArray<LLViewerShaderMgr::SHADER_OBJECT>	gObjectFullbrightProgram[1<<SHD_COUNT];
+extern LLGLSLShaderArray<LLViewerShaderMgr::SHADER_OBJECT>	gObjectEmissiveProgram[1<<SHD_SHINY_BIT];
 extern LLGLSLShader			gObjectPreviewProgram;
-extern LLGLSLShader			gObjectSimpleAlphaMaskProgram;
-extern LLGLSLShader			gObjectSimpleWaterProgram;
-extern LLGLSLShader			gObjectSimpleWaterAlphaMaskProgram;
-extern LLGLSLShader			gObjectSimpleNonIndexedProgram;
 extern LLGLSLShader			gObjectSimpleNonIndexedTexGenProgram;
 extern LLGLSLShader			gObjectSimpleNonIndexedTexGenWaterProgram;
-extern LLGLSLShader			gObjectSimpleNonIndexedWaterProgram;
-extern LLGLSLShader			gObjectAlphaMaskNonIndexedProgram;
-extern LLGLSLShader			gObjectAlphaMaskNonIndexedWaterProgram;
 extern LLGLSLShader			gObjectAlphaMaskNoColorProgram;
 extern LLGLSLShader			gObjectAlphaMaskNoColorWaterProgram;
-extern LLGLSLShader			gObjectFullbrightProgram;
-extern LLGLSLShader			gObjectFullbrightWaterProgram;
 extern LLGLSLShader			gObjectFullbrightNoColorProgram;
 extern LLGLSLShader			gObjectFullbrightNoColorWaterProgram;
-extern LLGLSLShader			gObjectEmissiveProgram;
-extern LLGLSLShader			gObjectEmissiveWaterProgram;
-extern LLGLSLShader			gObjectFullbrightAlphaMaskProgram;
-extern LLGLSLShader			gObjectFullbrightWaterAlphaMaskProgram;
-extern LLGLSLShader			gObjectFullbrightNonIndexedProgram;
-extern LLGLSLShader			gObjectFullbrightNonIndexedWaterProgram;
-extern LLGLSLShader			gObjectEmissiveNonIndexedProgram;
-extern LLGLSLShader			gObjectEmissiveNonIndexedWaterProgram;
 extern LLGLSLShader			gObjectBumpProgram;
 extern LLGLSLShader			gTreeProgram;
 extern LLGLSLShader			gTreeWaterProgram;
@@ -241,28 +236,6 @@ extern LLGLSLShader			gTreeWaterProgram;
 extern LLGLSLShader			gObjectSimpleLODProgram;
 extern LLGLSLShader			gObjectFullbrightLODProgram;
 
-extern LLGLSLShader			gObjectFullbrightShinyProgram;
-extern LLGLSLShader			gObjectFullbrightShinyWaterProgram;
-extern LLGLSLShader			gObjectFullbrightShinyNonIndexedProgram;
-extern LLGLSLShader			gObjectFullbrightShinyNonIndexedWaterProgram;
-
-extern LLGLSLShader			gObjectShinyProgram;
-extern LLGLSLShader			gObjectShinyWaterProgram;
-extern LLGLSLShader			gObjectShinyNonIndexedProgram;
-extern LLGLSLShader			gObjectShinyNonIndexedWaterProgram;
-
-extern LLGLSLShader			gSkinnedObjectSimpleProgram;
-extern LLGLSLShader			gSkinnedObjectFullbrightProgram;
-extern LLGLSLShader			gSkinnedObjectEmissiveProgram;
-extern LLGLSLShader			gSkinnedObjectFullbrightShinyProgram;
-extern LLGLSLShader			gSkinnedObjectShinySimpleProgram;
-
-extern LLGLSLShader			gSkinnedObjectSimpleWaterProgram;
-extern LLGLSLShader			gSkinnedObjectFullbrightWaterProgram;
-extern LLGLSLShader			gSkinnedObjectEmissiveWaterProgram;
-extern LLGLSLShader			gSkinnedObjectFullbrightShinyWaterProgram;
-extern LLGLSLShader			gSkinnedObjectShinySimpleWaterProgram;
-
 //environment shaders
 extern LLGLSLShader			gTerrainProgram;
 extern LLGLSLShader			gTerrainWaterProgram;