SL-10664, SL-10666

Fix up culling issues from perf work and fix Depth of Field rendering to get depth values properly.

Baseline for performance work.

1 files changed, 310 insertions, 322 deletions

diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 5396a8fdd2..be57e5afde 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -105,6 +105,32 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 { 
 	LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_DEFERRED);
 
+    if (LLPipeline::sRenderDeferred)
+    {
+		emissive_shader = &gDeferredEmissiveProgram;
+    }
+    else
+    {
+		if (LLPipeline::sUnderWaterRender)
+		{
+			emissive_shader = &gObjectEmissiveWaterProgram;
+		}
+		else
+		{
+			emissive_shader = &gObjectEmissiveProgram;
+		}
+    }
+
+    emissive_shader->bind();
+	if (LLPipeline::sRenderingHUDs)
+	{
+		emissive_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	}
+	else
+	{
+		emissive_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	}
+
 	if (pass == 0)
 	{
 		if (LLPipeline::sImpostorRender)
@@ -128,13 +154,13 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 		fullbright_shader->bind();
 		fullbright_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f); 
 		fullbright_shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
-	    fullbright_shader->setMinimumAlpha(LLPipeline::sImpostorRender ? 0.5f : 0.0f);
-        fullbright_shader->unbind();
+        fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, LLPipeline::sRenderingHUDs ? 1 : 0);
+		fullbright_shader->unbind();
 
 		//prime simple shader (loads shadow relevant uniforms)
 		gPipeline.bindDeferredShader(*simple_shader);
-		simple_shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));       
-        simple_shader->setMinimumAlpha(LLPipeline::sImpostorRender ? 0.5f : 0.0f);
+
+		simple_shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 	}
 	else if (!LLPipeline::sImpostorRender)
 	{
@@ -148,23 +174,6 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 		gObjectFullbrightAlphaMaskProgram.setMinimumAlpha(0.33f);
 	}
 
-
-    if (LLPipeline::sRenderDeferred)
-    {
-		emissive_shader = &gDeferredEmissiveProgram;
-    }
-    else
-    {
-		if (LLPipeline::sUnderWaterRender)
-		{
-			emissive_shader = &gObjectEmissiveWaterProgram;
-		}
-		else
-		{
-			emissive_shader = &gObjectEmissiveProgram;
-		}
-    }
-
 	deferred_render = TRUE;
 	if (mShaderLevel > 0)
 	{
@@ -279,15 +288,47 @@ void LLDrawPoolAlpha::render(S32 pass)
 			{
 				fullbright_shader->bind();
 				fullbright_shader->setMinimumAlpha(0.5f);
+                if (LLPipeline::sRenderingHUDs)
+	            {
+		            fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	            }
+	            else
+	            {
+		            fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	            }
 				simple_shader->bind();
 				simple_shader->setMinimumAlpha(0.5f);
+                if (LLPipeline::sRenderingHUDs)
+	            {
+		            simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	            }
+	            else
+	            {
+		            simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	            }
 			}				
 			else
 			{
 				fullbright_shader->bind();
 				fullbright_shader->setMinimumAlpha(0.f);
+                if (LLPipeline::sRenderingHUDs)
+	            {
+		            fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	            }
+	            else
+	            {
+		            fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	            }
 				simple_shader->bind();
 				simple_shader->setMinimumAlpha(0.f);
+                if (LLPipeline::sRenderingHUDs)
+	            {
+		            simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	            }
+	            else
+	            {
+		            simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	            }
 			}
 		}
 		else
@@ -395,320 +436,267 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, S32 pass)
 	BOOL light_enabled = TRUE;
 	
 	BOOL use_shaders = gPipeline.canUseVertexShaders();
+		
+	for (LLCullResult::sg_iterator i = gPipeline.beginAlphaGroups(); i != gPipeline.endAlphaGroups(); ++i)
+	{
+		LLSpatialGroup* group = *i;
+		llassert(group);
+        if (!group)
+        {
+            continue;
+        }
+        LLSpatialPartition* partition = group->getSpatialPartition();
+		llassert(partition);        
+        if (!partition)
+        {
+            continue;
+        }
 
-    {
-        LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_GROUP_LOOP);
-
-	    for (LLCullResult::sg_iterator i = gPipeline.beginAlphaGroups(); i != gPipeline.endAlphaGroups(); ++i)
-	    {
-		    LLSpatialGroup* group = *i;
-		    llassert(group);
-		    llassert(group->getSpatialPartition());
-
-		    if (group->getSpatialPartition()->mRenderByGroup &&
-		        !group->isDead())
-		    {
-			    bool is_particle_or_hud_particle = group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_PARTICLE
-													      || group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_HUD_PARTICLE;
-
-			    bool disable_cull = is_particle_or_hud_particle;
-			    LLGLDisable cull(disable_cull ? GL_CULL_FACE : 0);
-
-			    LLSpatialGroup::drawmap_elem_t& draw_info = group->mDrawMap[LLRenderPass::PASS_ALPHA];
-
-			    for (LLSpatialGroup::drawmap_elem_t::iterator k = draw_info.begin(); k != draw_info.end(); ++k)	
-			    {
-				    LLDrawInfo& params = **k;
-
-				    if ((params.mVertexBuffer->getTypeMask() & mask) != mask)
-				    { //FIXME!
-					    LL_WARNS_ONCE() << "Missing required components, expected mask: " << mask
-									    << " present: " << (params.mVertexBuffer->getTypeMask() & mask)
-									    << ". Skipping render batch." << LL_ENDL;
-					    continue;
-				    }
-
-				    // Fix for bug - NORSPEC-271
-				    // If the face is more than 90% transparent, then don't update the Depth buffer for Dof
-				    // We don't want the nearly invisible objects to cause of DoF effects
-				    if(pass == 1 && !LLPipeline::sImpostorRender)
-				    {
-					    LLFace*	face = params.mFace;
-					    if(face)
-					    {
-						    const LLTextureEntry* tep = face->getTextureEntry();
-						    if(tep)
-						    {
-							    if(tep->getColor().mV[3] < 0.1f)
-								    continue;
-						    }
-					    }
-				    }
-
-				    LLRenderPass::applyModelMatrix(params);
-
-				    LLMaterial* mat = NULL;
-
-				    if (deferred_render)
-				    {
-					    mat = params.mMaterial;
-				    }
+		if (partition->mRenderByGroup &&
+		    !group->isDead())
+		{
+			bool is_particle_or_hud_particle = partition->mPartitionType == LLViewerRegion::PARTITION_PARTICLE
+								            || partition->mPartitionType == LLViewerRegion::PARTITION_HUD_PARTICLE;
+
+			bool draw_glow_for_this_partition = mShaderLevel > 0; // no shaders = no glow.
+
+			LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_GROUP_LOOP);
+
+			bool disable_cull = is_particle_or_hud_particle;
+			LLGLDisable cull(disable_cull ? GL_CULL_FACE : 0);
+
+			LLSpatialGroup::drawmap_elem_t& draw_info = group->mDrawMap[LLRenderPass::PASS_ALPHA];
+
+			for (LLSpatialGroup::drawmap_elem_t::iterator k = draw_info.begin(); k != draw_info.end(); ++k)	
+			{
+				LLDrawInfo& params = **k;
+
+				if ((params.mVertexBuffer->getTypeMask() & mask) != mask)
+				{ //FIXME!
+					LL_WARNS_ONCE() << "Missing required components, expected mask: " << mask
+									<< " present: " << (params.mVertexBuffer->getTypeMask() & mask)
+									<< ". Skipping render batch." << LL_ENDL;
+					continue;
+				}
+
+				// Fix for bug - NORSPEC-271
+				// If the face is more than 90% transparent, then don't update the Depth buffer for Dof
+				// We don't want the nearly invisible objects to cause of DoF effects
+				if(pass == 1 && !LLPipeline::sImpostorRender)
+				{
+					LLFace*	face = params.mFace;
+					if(face)
+					{
+						const LLTextureEntry* tep = face->getTextureEntry();
+						if(tep)
+						{
+							if(tep->getColor().mV[3] < 0.1f)
+								continue;
+						}
+					}
+				}
+
+				LLRenderPass::applyModelMatrix(params);
+
+				LLMaterial* mat = NULL;
+
+				if (deferred_render)
+				{
+					mat = params.mMaterial;
+				}
 				
-				    if (params.mFullbright)
-				    {
-					    // Turn off lighting if it hasn't already been so.
-					    if (light_enabled || !initialized_lighting)
-					    {
-						    initialized_lighting = TRUE;
-						    if (use_shaders) 
-						    {
-							    target_shader = fullbright_shader;
-						    }
-						    else
-						    {
-							    gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
-						    }
-						    light_enabled = FALSE;
-					    }
-				    }
-				    // Turn on lighting if it isn't already.
-				    else if (!light_enabled || !initialized_lighting)
-				    {
-					    initialized_lighting = TRUE;
-					    if (use_shaders) 
-					    {
-						    target_shader = simple_shader;
-					    }
-					    else
-					    {
-						    gPipeline.enableLightsDynamic();
-					    }
-					    light_enabled = TRUE;
-				    }
-
-				    if (deferred_render && mat)
-				    {
-					    U32 mask = params.mShaderMask;
-
-					    llassert(mask < LLMaterial::SHADER_COUNT);
-					    target_shader = &(gDeferredMaterialProgram[mask]);
-
-					    if (LLPipeline::sUnderWaterRender)
-					    {
-						    target_shader = &(gDeferredMaterialWaterProgram[mask]);
-					    }
-
-					    if (current_shader != target_shader)
-					    {
-                            LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_DEFERRED_SHADER_BINDS);
-						    gPipeline.bindDeferredShader(*target_shader);
-                            current_shader = target_shader;
-					    }
-				    }
-				    else if (!params.mFullbright)
-				    {
-					    target_shader = simple_shader;
-				    }
-				    else
-				    {
-					    target_shader = fullbright_shader;
-				    }
+				if (params.mFullbright)
+				{
+					// Turn off lighting if it hasn't already been so.
+					if (light_enabled || !initialized_lighting)
+					{
+						initialized_lighting = TRUE;
+						if (use_shaders) 
+						{
+							target_shader = fullbright_shader;
+						}
+						else
+						{
+							gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
+						}
+						light_enabled = FALSE;
+					}
+				}
+				// Turn on lighting if it isn't already.
+				else if (!light_enabled || !initialized_lighting)
+				{
+					initialized_lighting = TRUE;
+					if (use_shaders) 
+					{
+						target_shader = simple_shader;
+					}
+					else
+					{
+						gPipeline.enableLightsDynamic();
+					}
+					light_enabled = TRUE;
+				}
+
+				if (deferred_render && mat)
+				{
+					U32 mask = params.mShaderMask;
+
+					llassert(mask < LLMaterial::SHADER_COUNT);
+					target_shader = &(gDeferredMaterialProgram[mask]);
+
+					if (LLPipeline::sUnderWaterRender)
+					{
+						target_shader = &(gDeferredMaterialWaterProgram[mask]);
+					}
+
+					if (current_shader != target_shader)
+					{
+						gPipeline.bindDeferredShader(*target_shader);
+					}
+				}
+				else if (!params.mFullbright)
+				{
+					target_shader = simple_shader;
+				}
+				else
+				{
+					target_shader = fullbright_shader;
+				}
 				
-				    if(use_shaders && (current_shader != target_shader))
-				    {// If we need shaders, and we're not ALREADY using the proper shader, then bind it
-				    // (this way we won't rebind shaders unnecessarily).
-                        LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_SHADER_BINDS);
-
-					    current_shader = target_shader;
-					    current_shader->bind();
-				    }
-				    else if (!use_shaders && current_shader != NULL)
-				    {
-					    LLGLSLShader::bindNoShader();
-					    current_shader = NULL;
-				    }
-
-				    if (use_shaders && mat)
-				    {
-                        LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MATS);
-
-					    // We have a material.  Supply the appropriate data here.
-					    if (LLPipeline::sRenderDeferred)
-					    {
-						    current_shader->uniform4f(LLShaderMgr::SPECULAR_COLOR, params.mSpecColor.mV[0], params.mSpecColor.mV[1], params.mSpecColor.mV[2], params.mSpecColor.mV[3]);						
-						    current_shader->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, params.mEnvIntensity);
-						    current_shader->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, params.mFullbright ? 1.f : 0.f);
-
-						    if (params.mNormalMap)
-						    {
-							    params.mNormalMap->addTextureStats(params.mVSize);
-							    current_shader->bindTexture(LLShaderMgr::BUMP_MAP, params.mNormalMap);
-						    } 
-						
-						    if (params.mSpecularMap)
-						    {
-							    params.mSpecularMap->addTextureStats(params.mVSize);
-							    current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, params.mSpecularMap);
-						    } 
-					    }
-
-				    }
-                    else if (LLPipeline::sRenderDeferred && current_shader && (current_shader == simple_shader))
-				    {
-					    current_shader->uniform4f(LLShaderMgr::SPECULAR_COLOR, 1.0f, 1.0f, 1.0f, 1.0f);						
-					    current_shader->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, 0.0f);			
-					    LLViewerFetchedTexture::sFlatNormalImagep->addTextureStats(params.mVSize);
-					    current_shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep);						
-					    LLViewerFetchedTexture::sWhiteImagep->addTextureStats(params.mVSize);
-					    current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, LLViewerFetchedTexture::sWhiteImagep);
-				    }
-
-				    if (params.mGroup)
-				    {
-                        LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MESH_REBUILD);
-
-					    params.mGroup->rebuildMesh();
-				    }
-
-				    bool tex_setup = false;
-
-				    if (use_shaders && params.mTextureList.size() > 1)
-				    {
-                        LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_TEX_BINDS);
-					    for (U32 i = 0; i < params.mTextureList.size(); ++i)
-					    {
-						    if (params.mTextureList[i].notNull())
-						    {
-							    gGL.getTexUnit(i)->bind(params.mTextureList[i], TRUE);
-						    }
-					    }
-				    }
-				    else
-				    { //not batching textures or batch has only 1 texture -- might need a texture matrix
-					    if (params.mTexture.notNull())
-					    {
-                            LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_TEX_BINDS);
-
-						    params.mTexture->addTextureStats(params.mVSize);
-						    if (use_shaders && mat)
-						    {
-							    current_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, params.mTexture);
-						    }
-						    else
-						    {
-						        gGL.getTexUnit(0)->bind(params.mTexture, TRUE) ;
-						    }
+				if(use_shaders && (current_shader != target_shader))
+				{// If we need shaders, and we're not ALREADY using the proper shader, then bind it
+				// (this way we won't rebind shaders unnecessarily).
+					current_shader = target_shader;
+					current_shader->bind();
+				}
+				else if (!use_shaders && current_shader != NULL)
+				{
+					LLGLSLShader::bindNoShader();
+					current_shader = NULL;
+				}
+
+				if (use_shaders && mat)
+				{
+					// We have a material.  Supply the appropriate data here.
+					if (LLPipeline::sRenderDeferred)
+					{
+						current_shader->uniform4f(LLShaderMgr::SPECULAR_COLOR, params.mSpecColor.mV[0], params.mSpecColor.mV[1], params.mSpecColor.mV[2], params.mSpecColor.mV[3]);						
+						current_shader->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, params.mEnvIntensity);
+						current_shader->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, params.mFullbright ? 1.f : 0.f);
+
+						if (params.mNormalMap)
+						{
+							params.mNormalMap->addTextureStats(params.mVSize);
+							current_shader->bindTexture(LLShaderMgr::BUMP_MAP, params.mNormalMap);
+						} 
 						
-						    if (params.mTextureMatrix)
-						    {
-							    tex_setup = true;
-							    gGL.getTexUnit(0)->activate();
-							    gGL.matrixMode(LLRender::MM_TEXTURE);
-							    gGL.loadMatrix((GLfloat*) params.mTextureMatrix->mMatrix);
-							    gPipeline.mTextureMatrixOps++;
-						    }
-					    }
-					    else
-					    {
-						    gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-					    }
-				    }
-
-				    {
-					    LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_PUSH);
-
-					    LLGLEnableFunc stencil_test(GL_STENCIL_TEST, params.mSelected, &LLGLCommonFunc::selected_stencil_test);
-
-                        {
-                            LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_SETBUFFER);
-					        gGL.blendFunc((LLRender::eBlendFactor) params.mBlendFuncSrc, (LLRender::eBlendFactor) params.mBlendFuncDst, mAlphaSFactor, mAlphaDFactor);
-					        params.mVertexBuffer->setBuffer(mask & ~(params.mFullbright ? (LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2) : 0));
-                        }
-
-                        {
-                            LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_DRAW);
-					        params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
-                        }
-
-					    gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
-				    }
-				
-				    if (tex_setup)
-				    {
-					    gGL.getTexUnit(0)->activate();
-					    gGL.loadIdentity();
-					    gGL.matrixMode(LLRender::MM_MODELVIEW);
-				    }
-			    }
-		    }
-	    }
-
-        bool draw_glow_for_this_partition = mShaderLevel > 0; // no shaders = no glow.
-
-        if (use_shaders && draw_glow_for_this_partition)
-        {
-            // install glow-accumulating blend mode
-			gGL.blendFunc(LLRender::BF_ZERO, LLRender::BF_ONE, // don't touch color
-			LLRender::BF_ONE, LLRender::BF_ONE); // add to alpha (glow)
+						if (params.mSpecularMap)
+						{
+							params.mSpecularMap->addTextureStats(params.mVSize);
+							current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, params.mSpecularMap);
+						} 
+					}
+
+				} else if (LLPipeline::sRenderDeferred && current_shader && (current_shader == simple_shader))
+				{
+					current_shader->uniform4f(LLShaderMgr::SPECULAR_COLOR, 1.0f, 1.0f, 1.0f, 1.0f);						
+					current_shader->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, 0.0f);			
+					LLViewerFetchedTexture::sFlatNormalImagep->addTextureStats(params.mVSize);
+					current_shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep);						
+					LLViewerFetchedTexture::sWhiteImagep->addTextureStats(params.mVSize);
+					current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, LLViewerFetchedTexture::sWhiteImagep);
+				}
 
-			emissive_shader->bind();
+				if (params.mGroup)
+				{
+					params.mGroup->rebuildMesh();
+				}
 
-            for (LLCullResult::sg_iterator i = gPipeline.beginAlphaGroups(); i != gPipeline.endAlphaGroups(); ++i)
-	        {
-		        LLSpatialGroup* group = *i;
-		        llassert(group);
-		        llassert(group->getSpatialPartition());
+				bool tex_setup = false;
 
-                if (group->getSpatialPartition()->mRenderByGroup &&
-		            !group->isDead())
-		        {
-			        bool is_particle_or_hud_particle = group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_PARTICLE
-													      || group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_HUD_PARTICLE;
+				if (use_shaders && params.mTextureList.size() > 1)
+				{
+					for (U32 i = 0; i < params.mTextureList.size(); ++i)
+					{
+						if (params.mTextureList[i].notNull())
+						{
+							gGL.getTexUnit(i)->bind(params.mTextureList[i], TRUE);
+						}
+					}
+				}
+				else
+				{ //not batching textures or batch has only 1 texture -- might need a texture matrix
+					if (params.mTexture.notNull())
+					{
+						params.mTexture->addTextureStats(params.mVSize);
+						if (use_shaders && mat)
+						{
+							current_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, params.mTexture);
+						}
+						else
+						{
+						gGL.getTexUnit(0)->bind(params.mTexture, TRUE) ;
+						}
+						
+						if (params.mTextureMatrix)
+						{
+							tex_setup = true;
+							gGL.getTexUnit(0)->activate();
+							gGL.matrixMode(LLRender::MM_TEXTURE);
+							gGL.loadMatrix((GLfloat*) params.mTextureMatrix->mMatrix);
+							gPipeline.mTextureMatrixOps++;
+						}
+					}
+					else
+					{
+						gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+					}
+				}
 
-			
+				{
+					LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_PUSH);
 
-			        bool disable_cull = is_particle_or_hud_particle;
-			        LLGLDisable cull(disable_cull ? GL_CULL_FACE : 0);
+					LLGLEnableFunc stencil_test(GL_STENCIL_TEST, params.mSelected, &LLGLCommonFunc::selected_stencil_test);
 
-			        LLSpatialGroup::drawmap_elem_t& draw_info = group->mDrawMap[LLRenderPass::PASS_ALPHA];
+					gGL.blendFunc((LLRender::eBlendFactor) params.mBlendFuncSrc, (LLRender::eBlendFactor) params.mBlendFuncDst, mAlphaSFactor, mAlphaDFactor);
+					params.mVertexBuffer->setBuffer(mask & ~(params.mFullbright ? (LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2) : 0));
 
-			        for (LLSpatialGroup::drawmap_elem_t::iterator k = draw_info.begin(); k != draw_info.end(); ++k)	
-			        {
-				        LLDrawInfo& params = **k;
+					params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
+					gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
+				}
+				
+				// If this alpha mesh has glow, then draw it a second time to add the destination-alpha (=glow).  Interleaving these state-changing calls could be expensive, but glow must be drawn Z-sorted with alpha.
+				if (current_shader && 
+                    emissive_shader &&
+					draw_glow_for_this_partition &&
+					params.mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_EMISSIVE))
+				{
+					// install glow-accumulating blend mode
+					gGL.blendFunc(LLRender::BF_ZERO, LLRender::BF_ONE, // don't touch color
+					LLRender::BF_ONE, LLRender::BF_ONE); // add to alpha (glow)
 
-				        if ((params.mVertexBuffer->getTypeMask() & mask) != mask)
-				        { //FIXME!
-					        LL_WARNS_ONCE() << "Missing required components, expected mask: " << mask
-									        << " present: " << (params.mVertexBuffer->getTypeMask() & mask)
-									        << ". Skipping render batch." << LL_ENDL;
-					        continue;
-				        }
+					emissive_shader->bind();
+					params.mVertexBuffer->setBuffer((mask & ~LLVertexBuffer::MAP_COLOR) | LLVertexBuffer::MAP_EMISSIVE);
 
-				        LLRenderPass::applyModelMatrix(params);
-				
-				        // If this alpha mesh has glow, then draw it a second time to add the destination-alpha (=glow).  Interleaving these state-changing calls could be expensive, but glow must be drawn Z-sorted with alpha.
-				        if (emissive_shader && 
-					        draw_glow_for_this_partition &&
-					        params.mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_EMISSIVE))
-				        {
-                            LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_GLOW);
-
-					        params.mVertexBuffer->setBuffer((mask & ~LLVertexBuffer::MAP_COLOR) | LLVertexBuffer::MAP_EMISSIVE);
-					
-					        // do the actual drawing, again
-					        params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
-					        gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
-				        }
-			        }
-                }
-		    }
-
-            // restore our alpha blend mode
-		    gGL.blendFunc(mColorSFactor, mColorDFactor, mAlphaSFactor, mAlphaDFactor);
-
-            emissive_shader->unbind();
-	    }
-    }
+					// do the actual drawing, again
+					params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
+					gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
+
+					// restore our alpha blend mode
+					gGL.blendFunc(mColorSFactor, mColorDFactor, mAlphaSFactor, mAlphaDFactor);
+
+					current_shader->bind();
+				}
+			
+				if (tex_setup)
+				{
+					gGL.getTexUnit(0)->activate();
+					gGL.loadIdentity();
+					gGL.matrixMode(LLRender::MM_MODELVIEW);
+				}
+			}
+		}
+	}
 
 	gGL.setSceneBlendType(LLRender::BT_ALPHA);