SL-16405 Remove “pass == <magic number>” anti-pattern from various drawpools.

1 files changed, 174 insertions, 485 deletions

diff --git a/indra/newview/lldrawpoolsimple.cpp b/indra/newview/lldrawpoolsimple.cpp
index a1d769bc83..4ada753355 100644
--- a/indra/newview/lldrawpoolsimple.cpp
+++ b/indra/newview/lldrawpoolsimple.cpp
@@ -38,83 +38,54 @@
 #include "llrender.h"
 
 static LLGLSLShader* simple_shader = NULL;
-static LLGLSLShader* fullbright_shader = NULL;
 
 static LLTrace::BlockTimerStatHandle FTM_RENDER_SIMPLE_DEFERRED("Deferred Simple");
 static LLTrace::BlockTimerStatHandle FTM_RENDER_GRASS_DEFERRED("Deferred Grass");
 
-void LLDrawPoolGlow::beginPostDeferredPass(S32 pass)
+
+static void setup_simple_shader(LLGLSLShader* shader)
 {
-    if (pass == 0)
+    shader->bind();
+
+    if (LLPipeline::sRenderingHUDs)
     {
-        gDeferredEmissiveProgram.bind();
+        shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
     }
     else
     {
-        llassert(gDeferredEmissiveProgram.mRiggedVariant);
-        gDeferredEmissiveProgram.mRiggedVariant->bind();
+        shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
     }
-
-	LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
-    if (LLPipeline::sRenderingHUDs)
-	{
-        LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 1);
-	}
-	else
-	{
-        LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 0);
-	}
 }
 
-void LLDrawPoolGlow::renderPostDeferred(S32 pass)
+static void setup_glow_shader(LLGLSLShader* shader)
 {
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_GLOW);
-	LLGLEnable blend(GL_BLEND);
-	LLGLDisable test(GL_ALPHA_TEST);
-	gGL.flush();
-	/// Get rid of z-fighting with non-glow pass.
-	LLGLEnable polyOffset(GL_POLYGON_OFFSET_FILL);
-	glPolygonOffset(-1.0f, -1.0f);
-	gGL.setSceneBlendType(LLRender::BT_ADD);
-	
-	LLGLDepthTest depth(GL_TRUE, GL_FALSE);
-	gGL.setColorMask(false, true);
-
-    if (pass == 0)
+    setup_simple_shader(shader);
+    if (LLPipeline::sRenderDeferred && !LLPipeline::sRenderingHUDs)
     {
-        pushBatches(LLRenderPass::PASS_GLOW, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+        shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
     }
     else
     {
-        pushRiggedBatches(LLRenderPass::PASS_GLOW_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+        shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.f);
     }
-	
-	gGL.setColorMask(true, false);
-	gGL.setSceneBlendType(LLRender::BT_ALPHA);	
 }
 
-void LLDrawPoolGlow::endPostDeferredPass(S32 pass)
+static void setup_fullbright_shader(LLGLSLShader* shader)
 {
-    LLGLSLShader::sCurBoundShaderPtr->unbind();
-
-	LLRenderPass::endRenderPass(pass);
+    setup_glow_shader(shader);
+    shader->uniform1f(LLViewerShaderMgr::FULLBRIGHT, 1.f);
 }
 
-S32 LLDrawPoolGlow::getNumPasses()
+
+void LLDrawPoolGlow::renderPostDeferred(S32 pass)
 {
-	if (LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_OBJECT) > 0)
-	{
-		return 2;
-	}
-	else
-	{
-		return 0;
-	}
+    LL_RECORD_BLOCK_TIME(FTM_RENDER_GLOW);
+    render(&gDeferredEmissiveProgram);
 }
 
-void LLDrawPoolGlow::render(S32 pass)
+void LLDrawPoolGlow::render(LLGLSLShader* shader)
 {
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_GLOW);
+    LL_RECORD_BLOCK_TIME(FTM_RENDER_GLOW);
 	LLGLEnable blend(GL_BLEND);
 	LLGLDisable test(GL_ALPHA_TEST);
 	gGL.flush();
@@ -123,55 +94,32 @@ void LLDrawPoolGlow::render(S32 pass)
 	glPolygonOffset(-1.0f, -1.0f);
 	gGL.setSceneBlendType(LLRender::BT_ADD);
 	
-	U32 shader_level = LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
-
-	//should never get here without basic shaders enabled
-	llassert(shader_level > 0);
-	
-	LLGLSLShader* shader = LLPipeline::sUnderWaterRender ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
-    if (pass == 1)
-    {
-        llassert(shader->mRiggedVariant);
-        shader = shader->mRiggedVariant;
-    }
-	shader->bind();
-	if (LLPipeline::sRenderDeferred)
-	{
-		shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
-	}
-	else
-	{
-		shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.f);
-	}
-
-    if (LLPipeline::sRenderingHUDs)
-	{
-		shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
-	}
-	else
-	{
-		shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
-	}
-
 	LLGLDepthTest depth(GL_TRUE, GL_FALSE);
 	gGL.setColorMask(false, true);
 
-    if (pass == 0)
-    {
-        pushBatches(LLRenderPass::PASS_GLOW, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-    }
-    else
-    {
-        pushRiggedBatches(LLRenderPass::PASS_GLOW_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-    }
-	
-	gGL.setColorMask(true, false);
-	gGL.setSceneBlendType(LLRender::BT_ALPHA);
-	
-	if (shader_level > 0 && fullbright_shader)
-	{
-		shader->unbind();
-	}
+    //first pass -- static objects
+    setup_glow_shader(shader);
+    pushBatches(LLRenderPass::PASS_GLOW, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+        
+    // second pass -- rigged objects
+    shader = shader->mRiggedVariant;
+    setup_glow_shader(shader);
+    pushRiggedBatches(LLRenderPass::PASS_GLOW_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+ 
+    gGL.setColorMask(true, false);
+    gGL.setSceneBlendType(LLRender::BT_ALPHA);	
+}
+
+S32 LLDrawPoolGlow::getNumPasses()
+{
+    return 1;
+}
+
+void LLDrawPoolGlow::render(S32 pass)
+{
+    LL_PROFILE_ZONE_SCOPED;
+    LLGLSLShader* shader = LLPipeline::sUnderWaterRender ? &gObjectEmissiveWaterProgram : &gObjectEmissiveProgram;
+    render(shader);
 }
 
 LLDrawPoolSimple::LLDrawPoolSimple() :
@@ -186,65 +134,38 @@ void LLDrawPoolSimple::prerender()
 
 S32 LLDrawPoolSimple::getNumPasses()
 {
-    return 2;
+    return 1;
 }
 
-void LLDrawPoolSimple::beginRenderPass(S32 pass)
+void LLDrawPoolSimple::render(S32 pass)
 {
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_SIMPLE);
+    LL_RECORD_BLOCK_TIME(FTM_RENDER_SIMPLE);
 
+	LLGLDisable blend(GL_BLEND);
+	
+    LLGLSLShader* shader = nullptr;
     if (LLPipeline::sImpostorRender)
     {
-        simple_shader = &gObjectSimpleImpostorProgram;
+        shader = &gObjectSimpleImpostorProgram;
     }
     else if (LLPipeline::sUnderWaterRender)
     {
-        simple_shader = &gObjectSimpleWaterProgram;
+        shader = &gObjectSimpleWaterProgram;
     }
     else
     {
-        simple_shader = &gObjectSimpleProgram;
-    }
- 
-    if (pass == 1)
-    {
-        llassert(simple_shader->mRiggedVariant);
-        simple_shader = simple_shader->mRiggedVariant;
+        shader = &gObjectSimpleProgram;
     }
 
-	simple_shader->bind();
-
-    if (LLPipeline::sRenderingHUDs)
-	{
-		simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
-	}
-	else
-	{
-		simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
-	}
-}
-
-void LLDrawPoolSimple::endRenderPass(S32 pass)
-{
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_SIMPLE);
-	stop_glerror();
-	LLRenderPass::endRenderPass(pass);
-	stop_glerror();
-	simple_shader->unbind();
-}
-
-void LLDrawPoolSimple::render(S32 pass)
-{
-	LLGLDisable blend(GL_BLEND);
-	
 	{ //render simple
-		LL_RECORD_BLOCK_TIME(FTM_RENDER_SIMPLE);
+	
 		gPipeline.enableLightsDynamic();
 
 		U32 mask = getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX;
 
-        if (pass == 0)
+        // first pass -- static objects
         {
+            setup_simple_shader(shader);
             pushBatches(LLRenderPass::PASS_SIMPLE, mask, TRUE, TRUE);
 
             if (LLPipeline::sRenderDeferred)
@@ -257,8 +178,11 @@ void LLDrawPoolSimple::render(S32 pass)
                 pushBatches(LLRenderPass::PASS_NORMSPEC, mask, TRUE, TRUE);
             }
         }
-        else
+        
+        //second pass, rigged
         {
+            shader = shader->mRiggedVariant;
+            setup_simple_shader(shader);
             pushRiggedBatches(LLRenderPass::PASS_SIMPLE_RIGGED, mask, TRUE, TRUE);
 
             if (LLPipeline::sRenderDeferred)
@@ -275,9 +199,6 @@ void LLDrawPoolSimple::render(S32 pass)
 }
 
 
-
-
-
 static LLTrace::BlockTimerStatHandle FTM_RENDER_ALPHA_MASK("Alpha Mask");
 
 LLDrawPoolAlphaMask::LLDrawPoolAlphaMask() :
@@ -290,84 +211,36 @@ void LLDrawPoolAlphaMask::prerender()
 	mShaderLevel = LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
 }
 
-void LLDrawPoolAlphaMask::beginRenderPass(S32 pass)
+void LLDrawPoolAlphaMask::render(S32 pass)
 {
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MASK);
-
+	LLGLDisable blend(GL_BLEND);
+    LL_PROFILE_ZONE_SCOPED;
+	
+    LLGLSLShader* shader = nullptr;
     if (LLPipeline::sUnderWaterRender)
     {
-        simple_shader = &gObjectSimpleWaterAlphaMaskProgram;
+        shader = &gObjectSimpleWaterAlphaMaskProgram;
     }
     else
     {
-        simple_shader = &gObjectSimpleAlphaMaskProgram;
+        shader = &gObjectSimpleAlphaMaskProgram;
     }
 
-    if (pass == 1)
-    {
-        llassert(simple_shader->mRiggedVariant);
-        simple_shader = simple_shader->mRiggedVariant;
-    }
-
-    simple_shader->bind();
-
-    if (LLPipeline::sRenderingHUDs)
-    {
-	    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
-    }
-    else
-    {
-	    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
-    }
-}
-
-void LLDrawPoolAlphaMask::endRenderPass(S32 pass)
-{
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MASK);
-	stop_glerror();
-	LLRenderPass::endRenderPass(pass);
-	stop_glerror();
-	if (mShaderLevel > 0)
-	{
-		simple_shader->unbind();
-	}
-}
-
-void LLDrawPoolAlphaMask::render(S32 pass)
-{
-	LLGLDisable blend(GL_BLEND);
-    LL_PROFILE_ZONE_SCOPED;
-	
-	
-
-	simple_shader->bind();
-	simple_shader->setMinimumAlpha(0.33f);
-
-    if (LLPipeline::sRenderingHUDs)
-	{
-		simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
-	}
-	else
-	{
-		simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
-	}
+    // render static
+    setup_simple_shader(shader);
+    pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+	pushMaskBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+	pushMaskBatches(LLRenderPass::PASS_SPECMAP_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+	pushMaskBatches(LLRenderPass::PASS_NORMMAP_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+	pushMaskBatches(LLRenderPass::PASS_NORMSPEC_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
 
-    if (pass == 0)
-    {
-		pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-		pushMaskBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-		pushMaskBatches(LLRenderPass::PASS_SPECMAP_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-		pushMaskBatches(LLRenderPass::PASS_NORMMAP_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-		pushMaskBatches(LLRenderPass::PASS_NORMSPEC_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-	}
-	else
-	{
-        pushRiggedMaskBatches(LLRenderPass::PASS_ALPHA_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-        pushRiggedMaskBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-        pushRiggedMaskBatches(LLRenderPass::PASS_SPECMAP_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-        pushRiggedMaskBatches(LLRenderPass::PASS_NORMMAP_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-        pushRiggedMaskBatches(LLRenderPass::PASS_NORMSPEC_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-	}
+    // render rigged
+    setup_simple_shader(shader->mRiggedVariant);
+    pushRiggedMaskBatches(LLRenderPass::PASS_ALPHA_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+    pushRiggedMaskBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+    pushRiggedMaskBatches(LLRenderPass::PASS_SPECMAP_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+    pushRiggedMaskBatches(LLRenderPass::PASS_NORMMAP_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+    pushRiggedMaskBatches(LLRenderPass::PASS_NORMSPEC_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
 }
 
 LLDrawPoolFullbrightAlphaMask::LLDrawPoolFullbrightAlphaMask() :
@@ -380,61 +253,27 @@ void LLDrawPoolFullbrightAlphaMask::prerender()
 	mShaderLevel = LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
 }
 
-void LLDrawPoolFullbrightAlphaMask::beginRenderPass(S32 pass)
-{
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MASK);
-
-    bool rigged = (pass == 1);
-	if (LLPipeline::sUnderWaterRender)
-	{
-        gObjectFullbrightWaterAlphaMaskProgram.bind(rigged);
-	}
-	else
-	{
-		gObjectFullbrightAlphaMaskProgram.bind(rigged);
-	}
-
-    if (LLPipeline::sRenderingHUDs)
-	{
-		LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 1);
-        LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.f);
-	}
-	else
-	{
-        LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 0);
-        if (LLPipeline::sRenderDeferred)
-        {
-            LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
-        }
-        else
-        {
-            LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
-        }
-	}
-}
-
-void LLDrawPoolFullbrightAlphaMask::endRenderPass(S32 pass)
-{
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MASK);
-	stop_glerror();
-	LLRenderPass::endRenderPass(pass);
-	stop_glerror();
-    LLGLSLShader::sCurBoundShaderPtr->unbind();
-}
-
 void LLDrawPoolFullbrightAlphaMask::render(S32 pass)
 {
 	LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MASK);
 
-    if (pass == 0)
+    LLGLSLShader* shader = nullptr;
+    if (LLPipeline::sUnderWaterRender)
     {
-        pushMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+        shader = &gObjectFullbrightWaterAlphaMaskProgram;
     }
     else
     {
-        pushRiggedMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+        shader = &gObjectFullbrightAlphaMaskProgram;
     }
-	
+
+    // render static
+    setup_fullbright_shader(shader);
+    pushMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+
+    // render rigged
+    setup_fullbright_shader(shader->mRiggedVariant);
+    pushRiggedMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
 }
 
 //===============================
@@ -443,112 +282,41 @@ void LLDrawPoolFullbrightAlphaMask::render(S32 pass)
 
 S32 LLDrawPoolSimple::getNumDeferredPasses()
 {
-    if (LLPipeline::sRenderingHUDs)
-    {
-        return 1;
-    }
-    else
-    {
-        return 2;
-    }
-}
-void LLDrawPoolSimple::beginDeferredPass(S32 pass)
-{
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_SIMPLE_DEFERRED);
-
-    mShader = &gDeferredDiffuseProgram;
-    
-    if (pass == 1)
-    {
-        llassert(mShader->mRiggedVariant != nullptr);
-        mShader = mShader->mRiggedVariant;
-    }
-    
-
-    mShader->bind();
-
-    if (LLPipeline::sRenderingHUDs)
-	{
-		mShader->uniform1i(LLShaderMgr::NO_ATMO, 1);
-	}
-	else
-	{
-		mShader->uniform1i(LLShaderMgr::NO_ATMO, 0);
-	}
-}
-
-void LLDrawPoolSimple::endDeferredPass(S32 pass)
-{
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_SIMPLE_DEFERRED);
-	LLRenderPass::endRenderPass(pass);
-
-	mShader->unbind();
+    return 1;
 }
 
 void LLDrawPoolSimple::renderDeferred(S32 pass)
 {
-    LL_PROFILE_ZONE_SCOPED;
+    LL_RECORD_BLOCK_TIME(FTM_RENDER_SIMPLE_DEFERRED);
 	LLGLDisable blend(GL_BLEND);
 	LLGLDisable alpha_test(GL_ALPHA_TEST);
 
-    if (pass == 0)
-	{ //render simple
-		LL_RECORD_BLOCK_TIME(FTM_RENDER_SIMPLE_DEFERRED);
-		pushBatches(LLRenderPass::PASS_SIMPLE, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-	}
-    else
-    {
-        //render simple rigged
-        pushRiggedBatches(LLRenderPass::PASS_SIMPLE_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-    }
+	//render static
+    setup_simple_shader(&gDeferredDiffuseProgram);
+	pushBatches(LLRenderPass::PASS_SIMPLE, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
+	
+    //render rigged
+    setup_simple_shader(gDeferredDiffuseProgram.mRiggedVariant);
+    pushRiggedBatches(LLRenderPass::PASS_SIMPLE_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
 }
 
 static LLTrace::BlockTimerStatHandle FTM_RENDER_ALPHA_MASK_DEFERRED("Deferred Alpha Mask");
 
-void LLDrawPoolAlphaMask::beginDeferredPass(S32 pass)
-{
-    if (pass == 0)
-    {
-        gDeferredDiffuseAlphaMaskProgram.bind();
-    }
-    else
-    {
-        llassert(gDeferredDiffuseAlphaMaskProgram.mRiggedVariant);
-        gDeferredDiffuseAlphaMaskProgram.mRiggedVariant->bind();
-    }
-
-}
-
-void LLDrawPoolAlphaMask::endDeferredPass(S32 pass)
-{
-    LLGLSLShader::sCurBoundShaderPtr->unbind();
-}
 
 void LLDrawPoolAlphaMask::renderDeferred(S32 pass)
 {
 	LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MASK_DEFERRED);
-	LLGLSLShader::sCurBoundShaderPtr->setMinimumAlpha(0.33f);
+    LLGLSLShader* shader = &gDeferredDiffuseAlphaMaskProgram;
 
-    if (LLPipeline::sRenderingHUDs)
-	{
-        LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 1);
-	}
-	else
-	{
-        LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 0);
-	}
+    //render static
+    setup_simple_shader(shader);
+    pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
 
-    if (pass == 0)
-    {
-        pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-    }
-    else
-    {
-        pushRiggedMaskBatches(LLRenderPass::PASS_ALPHA_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
-    }
+    //render rigged
+    setup_simple_shader(shader->mRiggedVariant);
+    pushRiggedMaskBatches(LLRenderPass::PASS_ALPHA_MASK_RIGGED, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
 }
 
-
 // grass drawpool
 LLDrawPoolGrass::LLDrawPoolGrass() :
  LLRenderPass(POOL_GRASS)
@@ -667,83 +435,31 @@ void LLDrawPoolFullbright::prerender()
 	mShaderLevel = LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_OBJECT);
 }
 
-void LLDrawPoolFullbright::beginPostDeferredPass(S32 pass)
-{
-    bool rigged = (pass == 1);
-	if (LLPipeline::sUnderWaterRender)
-	{
-		gDeferredFullbrightWaterProgram.bind(rigged);
-	}
-	else
-	{
-		gDeferredFullbrightProgram.bind(rigged);
-
-        if (LLPipeline::sRenderingHUDs)
-	    {
-            LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 1);
-	    }
-	    else
-	    {
-            LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 0);
-	    }
-	}
-}
 
 void LLDrawPoolFullbright::renderPostDeferred(S32 pass)
 {
 	LL_RECORD_BLOCK_TIME(FTM_RENDER_FULLBRIGHT);
-	
-	gGL.setSceneBlendType(LLRender::BT_ALPHA);
-	U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXTURE_INDEX;
-    if (pass == 0)
+
+    LLGLSLShader* shader = nullptr;
+    if (LLPipeline::sUnderWaterRender)
     {
-        pushBatches(LLRenderPass::PASS_FULLBRIGHT, fullbright_mask, TRUE, TRUE);
+        shader = &gDeferredFullbrightWaterProgram;
     }
     else
     {
-        pushRiggedBatches(LLRenderPass::PASS_FULLBRIGHT_RIGGED, fullbright_mask, TRUE, TRUE);
+        shader = &gDeferredFullbrightProgram;
     }
-}
 
-void LLDrawPoolFullbright::endPostDeferredPass(S32 pass)
-{
-    LLGLSLShader::sCurBoundShaderPtr->unbind();
-	LLRenderPass::endRenderPass(pass);
-}
-
-void LLDrawPoolFullbright::beginRenderPass(S32 pass)
-{
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_FULLBRIGHT);
-	
-	if (LLPipeline::sUnderWaterRender)
-	{
-		fullbright_shader = &gObjectFullbrightWaterProgram;
-	}
-	else
-	{
-		fullbright_shader = &gObjectFullbrightProgram;
-	}
-
-    if (pass == 1)
-    {
-        llassert(fullbright_shader->mRiggedVariant);
-        fullbright_shader = fullbright_shader->mRiggedVariant;
-    }
-}
-
-void LLDrawPoolFullbright::endRenderPass(S32 pass)
-{
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_FULLBRIGHT);
-	LLRenderPass::endRenderPass(pass);
-
-	stop_glerror();
-
-	if (mShaderLevel > 0)
-	{
-		fullbright_shader->unbind();
-	}
-
-	stop_glerror();
+	gGL.setSceneBlendType(LLRender::BT_ALPHA);
+	U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXTURE_INDEX;
+    
+    // render static
+    setup_fullbright_shader(shader);
+    pushBatches(LLRenderPass::PASS_FULLBRIGHT, fullbright_mask, TRUE, TRUE);
+    
+    // render rigged
+    setup_fullbright_shader(shader->mRiggedVariant);
+    pushRiggedBatches(LLRenderPass::PASS_FULLBRIGHT_RIGGED, fullbright_mask, TRUE, TRUE);
 }
 
 void LLDrawPoolFullbright::render(S32 pass)
@@ -752,102 +468,75 @@ void LLDrawPoolFullbright::render(S32 pass)
 	gGL.setSceneBlendType(LLRender::BT_ALPHA);
 
 	stop_glerror();
+    LLGLSLShader* shader = nullptr;
+    if (LLPipeline::sUnderWaterRender)
+    {
+        shader = &gObjectFullbrightWaterProgram;
+    }
+    else
+    {
+        shader = &gObjectFullbrightProgram;
+    }
 
-	if (mShaderLevel > 0)
-	{
-		fullbright_shader->bind();
-		fullbright_shader->uniform1f(LLViewerShaderMgr::FULLBRIGHT, 1.f);
-		fullbright_shader->uniform1f(LLViewerShaderMgr::TEXTURE_GAMMA, 1.f);
-
-        if (LLPipeline::sRenderingHUDs)
-	    {
-		    fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
-	    }
-	    else
-	    {
-		    fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
-	    }
-
-		U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXTURE_INDEX;
 
-        if (pass == 0)
-        {
-            pushBatches(LLRenderPass::PASS_FULLBRIGHT, fullbright_mask, TRUE, TRUE);
-            pushBatches(LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE, fullbright_mask, TRUE, TRUE);
-            pushBatches(LLRenderPass::PASS_SPECMAP_EMISSIVE, fullbright_mask, TRUE, TRUE);
-            pushBatches(LLRenderPass::PASS_NORMMAP_EMISSIVE, fullbright_mask, TRUE, TRUE);
-            pushBatches(LLRenderPass::PASS_NORMSPEC_EMISSIVE, fullbright_mask, TRUE, TRUE);
-        }
-        else
-        {
-            pushRiggedBatches(LLRenderPass::PASS_FULLBRIGHT_RIGGED, fullbright_mask, TRUE, TRUE);
-            pushRiggedBatches(LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE_RIGGED, fullbright_mask, TRUE, TRUE);
-            pushRiggedBatches(LLRenderPass::PASS_SPECMAP_EMISSIVE_RIGGED, fullbright_mask, TRUE, TRUE);
-            pushRiggedBatches(LLRenderPass::PASS_NORMMAP_EMISSIVE_RIGGED, fullbright_mask, TRUE, TRUE);
-            pushRiggedBatches(LLRenderPass::PASS_NORMSPEC_EMISSIVE_RIGGED, fullbright_mask, TRUE, TRUE);
-        }
-	}
+	U32 mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXTURE_INDEX;
 
-	stop_glerror();
+    // render static
+    setup_fullbright_shader(shader);
+    pushBatches(LLRenderPass::PASS_FULLBRIGHT, mask, TRUE, TRUE);
+    pushBatches(LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE, mask, TRUE, TRUE);
+    pushBatches(LLRenderPass::PASS_SPECMAP_EMISSIVE, mask, TRUE, TRUE);
+    pushBatches(LLRenderPass::PASS_NORMMAP_EMISSIVE, mask, TRUE, TRUE);
+    pushBatches(LLRenderPass::PASS_NORMSPEC_EMISSIVE, mask, TRUE, TRUE);
+ 
+    // render rigged
+    setup_fullbright_shader(shader->mRiggedVariant);
+    pushRiggedBatches(LLRenderPass::PASS_FULLBRIGHT_RIGGED, mask, TRUE, TRUE);
+    pushRiggedBatches(LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE_RIGGED, mask, TRUE, TRUE);
+    pushRiggedBatches(LLRenderPass::PASS_SPECMAP_EMISSIVE_RIGGED, mask, TRUE, TRUE);
+    pushRiggedBatches(LLRenderPass::PASS_NORMMAP_EMISSIVE_RIGGED, mask, TRUE, TRUE);
+    pushRiggedBatches(LLRenderPass::PASS_NORMSPEC_EMISSIVE_RIGGED, mask, TRUE, TRUE);
 }
 
 S32 LLDrawPoolFullbright::getNumPasses()
 { 
-	return 2;
+	return 1;
 }
 
-
-void LLDrawPoolFullbrightAlphaMask::beginPostDeferredPass(S32 pass)
+void LLDrawPoolFullbrightAlphaMask::renderPostDeferred(S32 pass)
 {
-    bool rigged = (pass == 1);
+	LL_RECORD_BLOCK_TIME(FTM_RENDER_FULLBRIGHT);
+    
+    LLGLSLShader* shader = nullptr;
     if (LLPipeline::sRenderingHUDs)
     {
-        gObjectFullbrightAlphaMaskProgram.bind(rigged);
-		LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
-        LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 1);
+        shader = &gObjectFullbrightAlphaMaskProgram;
     }
-	else if (LLPipeline::sRenderDeferred)
-	{
+    else if (LLPipeline::sRenderDeferred)
+    {
         if (LLPipeline::sUnderWaterRender)
-		{
-            gDeferredFullbrightAlphaMaskWaterProgram.bind(rigged);
-            LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
-            LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 1);
-		}
-		else
-		{
-			gDeferredFullbrightAlphaMaskProgram.bind(rigged);
-            LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
-            LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 0);
-		}
+        {
+            shader = &gDeferredFullbrightAlphaMaskWaterProgram;
+        }
+        else
+        {
+            shader = &gDeferredFullbrightAlphaMaskProgram;
+        }
     }
     else
     {
-		gObjectFullbrightAlphaMaskProgram.bind(rigged);
-        LLGLSLShader::sCurBoundShaderPtr->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
-        LLGLSLShader::sCurBoundShaderPtr->uniform1i(LLShaderMgr::NO_ATMO, 0);
-	}
-}
+        shader = &gObjectFullbrightAlphaMaskProgram;
+    }
 
-void LLDrawPoolFullbrightAlphaMask::renderPostDeferred(S32 pass)
-{
-	LL_RECORD_BLOCK_TIME(FTM_RENDER_FULLBRIGHT);
 	LLGLDisable blend(GL_BLEND);
 	U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXTURE_INDEX;
-    if (pass == 0)
-    {
-        pushMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, fullbright_mask, TRUE, TRUE);
-    }
-    else
-    {
-        pushRiggedMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK_RIGGED, fullbright_mask, TRUE, TRUE);
-    }
-}
-
-void LLDrawPoolFullbrightAlphaMask::endPostDeferredPass(S32 pass)
-{
-    LLGLSLShader::sCurBoundShaderPtr->unbind();
-	LLRenderPass::endRenderPass(pass);
+    
+    // render static
+    setup_fullbright_shader(shader);
+    pushMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK, fullbright_mask, TRUE, TRUE);
+    
+    // render rigged
+    setup_fullbright_shader(shader->mRiggedVariant);
+    pushRiggedMaskBatches(LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK_RIGGED, fullbright_mask, TRUE, TRUE);
 }
 
-