Merge of windlight into release (QAR-286). This includes all changes in

windlight14 which have passed QA (up through r79932).

svn merge -r 80831:80833 svn+ssh://svn.lindenlab.com/svn/linden/branches/merge_windlight14_r80620

1 files changed, 395 insertions, 135 deletions

diff --git a/indra/newview/lldrawpoolbump.cpp b/indra/newview/lldrawpoolbump.cpp
index 4de13a3d88..f4bc157168 100644
--- a/indra/newview/lldrawpoolbump.cpp
+++ b/indra/newview/lldrawpoolbump.cpp
@@ -40,17 +40,19 @@
 #include "m3math.h"
 #include "m4math.h"
 #include "v4math.h"
+#include "llglheaders.h"
+#include "llglimmediate.h"
 
 #include "llagent.h"
 #include "llcubemap.h"
 #include "lldrawable.h"
-#include "lldrawpoolsimple.h"
 #include "llface.h"
 #include "llsky.h"
 #include "lltextureentry.h"
 #include "llviewercamera.h"
 #include "llviewerimagelist.h"
 #include "pipeline.h"
+#include "llspatialpartition.h"
 #include "llglslshader.h"
 
 //#include "llimagebmp.h"
@@ -73,6 +75,10 @@ const U32 VERTEX_MASK_BUMP = LLVertexBuffer::MAP_VERTEX |LLVertexBuffer::MAP_TEX
 U32 LLDrawPoolBump::sVertexMask = VERTEX_MASK_SHINY;
 static LLCubeMap* sCubeMap = NULL;
 
+static LLGLSLShader* shader = NULL;
+static S32 cube_channel = -1;
+static S32 diffuse_channel = -1;
+
 // static 
 void LLStandardBumpmap::init()
 {
@@ -158,8 +164,9 @@ void LLStandardBumpmap::destroyGL()
 ////////////////////////////////////////////////////////////////
 
 LLDrawPoolBump::LLDrawPoolBump() 
-: LLRenderPass(LLDrawPool::POOL_BUMP)
+:  LLRenderPass(LLDrawPool::POOL_BUMP)
 {
+	mShiny = FALSE;
 }
 
 
@@ -173,7 +180,25 @@ S32 LLDrawPoolBump::numBumpPasses()
 {
 	if (gSavedSettings.getBOOL("RenderObjectBump"))
 	{
-		return 2;
+		if (mVertexShaderLevel > 1)
+		{
+			if (LLPipeline::sImpostorRender)
+			{
+				return 2;
+			}
+			else
+			{
+				return 3;
+			}
+		}
+		else if (LLPipeline::sImpostorRender)
+		{
+			return 1;
+		}
+		else
+		{
+			return 2;
+		}
 	}
     else
 	{
@@ -188,12 +213,23 @@ S32 LLDrawPoolBump::getNumPasses()
 
 void LLDrawPoolBump::beginRenderPass(S32 pass)
 {
+	LLFastTimer t(LLFastTimer::FTM_RENDER_BUMP);
 	switch( pass )
 	{
 		case 0:
 			beginShiny();
 			break;
 		case 1:
+			if (mVertexShaderLevel > 1)
+			{
+				beginFullbrightShiny();
+			}
+			else 
+			{
+				beginBump();
+			}
+			break;
+		case 2:
 			beginBump();
 			break;
 		default:
@@ -213,32 +249,47 @@ void LLDrawPoolBump::render(S32 pass)
 	
 	switch( pass )
 	{
-	  case 0:
-	  {
-		  renderShiny();
-		  break;
-	  }
-	  case 1:
-	  {
-		  renderBump();
-		  break;
-	  }
-	  default:
-	  {
-		  llassert(0);
-		  break;
-	  }
+		case 0:
+			renderShiny();
+			break;
+		case 1:
+			if (mVertexShaderLevel > 1)
+			{
+				renderFullbrightShiny();
+			}
+			else 
+			{
+				renderBump(); 
+			}
+			break;
+		case 2:
+			renderBump();
+			break;
+		default:
+			llassert(0);
+			break;
 	}
 }
 
 void LLDrawPoolBump::endRenderPass(S32 pass)
 {
+	LLFastTimer t(LLFastTimer::FTM_RENDER_BUMP);
 	switch( pass )
 	{
 		case 0:
 			endShiny();
 			break;
 		case 1:
+			if (mVertexShaderLevel > 1)
+			{
+				endFullbrightShiny();
+			}
+			else 
+			{
+				endBump();
+			}
+			break;
+		case 2:
 			endBump();
 			break;
 		default:
@@ -248,36 +299,77 @@ void LLDrawPoolBump::endRenderPass(S32 pass)
 }
 
 //static
-void LLDrawPoolBump::beginShiny()
+void LLDrawPoolBump::beginShiny(bool invisible)
 {
+	LLFastTimer t(LLFastTimer::FTM_RENDER_SHINY);
+	if (!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY)|| 
+		invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY))
+	{
+		return;
+	}
+
+	mShiny = TRUE;
 	sVertexMask = VERTEX_MASK_SHINY;
 	// Second pass: environment map
 	glEnableClientState(GL_VERTEX_ARRAY);
 	glEnableClientState(GL_NORMAL_ARRAY);
 	glEnableClientState(GL_COLOR_ARRAY);
+	if (!invisible && mVertexShaderLevel > 1)
+	{
+		glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+		sVertexMask = VERTEX_MASK_SHINY | LLVertexBuffer::MAP_TEXCOORD;
+	}
+	
+	if (LLPipeline::sUnderWaterRender)
+	{
+		shader = &gObjectShinyWaterProgram;
+	}
+	else
+	{
+		shader = &gObjectShinyProgram;
+	}
 
-	LLCubeMap* cube_map = gSky.mVOSkyp->getCubeMap();
+	LLCubeMap* cube_map = gSky.mVOSkyp ? gSky.mVOSkyp->getCubeMap() : NULL;
 	if( cube_map )
 	{
-		cube_map->enable(0);
-		cube_map->setMatrix(0);
-		cube_map->bind();
-
-		if (LLShaderMgr::getVertexShaderLevel(LLShaderMgr::SHADER_OBJECT) > 0)
+		if (!invisible && LLShaderMgr::getVertexShaderLevel(LLShaderMgr::SHADER_OBJECT) > 0 )
 		{
 			LLMatrix4 mat;
 			mat.initRows(LLVector4(gGLModelView+0),
 						 LLVector4(gGLModelView+4),
 						 LLVector4(gGLModelView+8),
 						 LLVector4(gGLModelView+12));
-			gObjectShinyProgram.bind();
+			shader->bind();
 			LLVector3 vec = LLVector3(gShinyOrigin) * mat;
 			LLVector4 vec4(vec, gShinyOrigin.mV[3]);
-			glUniform4fvARB(gObjectShinyProgram.mUniform[LLShaderMgr::SHINY_ORIGIN], 1,
-				vec4.mV);
+			shader->uniform4fv(LLShaderMgr::SHINY_ORIGIN, 1, vec4.mV);			
+			if (mVertexShaderLevel > 1)
+			{
+				cube_map->setMatrix(1);
+				// Make sure that texture coord generation happens for tex unit 1, as that's the one we use for 
+				// the cube map in the one pass shiny shaders
+				cube_channel = shader->enableTexture(LLShaderMgr::ENVIRONMENT_MAP, GL_TEXTURE_CUBE_MAP_ARB);
+				cube_map->enableTexture(cube_channel);
+				cube_map->enableTextureCoords(1);
+				diffuse_channel = shader->enableTexture(LLShaderMgr::DIFFUSE_MAP);
+			}
+			else
+			{
+				cube_channel = 0;
+				diffuse_channel = -1;
+				cube_map->setMatrix(0);
+				cube_map->enable(shader->enableTexture(LLShaderMgr::ENVIRONMENT_MAP, GL_TEXTURE_CUBE_MAP_ARB));
+			}			
+			cube_map->bind();
 		}
 		else
 		{
+			cube_channel = 0;
+			diffuse_channel = -1;
+			cube_map->enable(0);
+			cube_map->setMatrix(0);
+			cube_map->bind();
+
 			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,	GL_COMBINE_ARB);
 			
 			//use RGB from texture
@@ -293,63 +385,188 @@ void LLDrawPoolBump::beginShiny()
 	}
 }
 
-void LLDrawPoolBump::renderShiny()
+void LLDrawPoolBump::renderShiny(bool invisible)
 {
 	LLFastTimer t(LLFastTimer::FTM_RENDER_SHINY);
-	
+	if (!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY)|| 
+		invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY))
+	{
+		return;
+	}
+
 	sCubeMap = NULL;
 
 	if( gSky.mVOSkyp->getCubeMap() )
 	{
 		LLGLEnable blend_enable(GL_BLEND);
-		renderStatic(LLRenderPass::PASS_SHINY, sVertexMask);
-		renderActive(LLRenderPass::PASS_SHINY, sVertexMask);
+		if (!invisible && mVertexShaderLevel > 1)
+		{
+			LLRenderPass::renderTexture(LLRenderPass::PASS_SHINY, sVertexMask);
+		}
+		else if (!invisible)
+		{
+			renderGroups(LLRenderPass::PASS_SHINY, sVertexMask);
+		}
+		else // invisible
+		{
+			renderGroups(LLRenderPass::PASS_INVISI_SHINY, sVertexMask);
+		}
 	}
 }
 
-void LLDrawPoolBump::renderActive(U32 type, U32 mask, BOOL texture)
+void LLDrawPoolBump::endShiny(bool invisible)
 {
-#if !LL_RELEASE_FOR_DOWNLOAD
-	LLGLState::checkClientArrays(mask);
-#endif
+	LLFastTimer t(LLFastTimer::FTM_RENDER_SHINY);
+	if (!invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_SHINY)|| 
+		invisible && !gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY))
+	{
+		return;
+	}
 
-	LLSpatialBridge* last_bridge = NULL;
-	glPushMatrix();
-	
-	for (LLSpatialGroup::sg_vector_t::iterator i = gPipeline.mActiveGroups.begin(); i != gPipeline.mActiveGroups.end(); ++i)
+	LLCubeMap* cube_map = gSky.mVOSkyp ? gSky.mVOSkyp->getCubeMap() : NULL;
+	if( cube_map )
 	{
-		LLSpatialGroup* group = *i;
-		if (!group->isDead() &&
-			gPipeline.hasRenderType(group->mSpatialPartition->mDrawableType) &&
-			group->mDrawMap.find(type) != group->mDrawMap.end())
+		cube_map->disable();
+		cube_map->restoreMatrix();
+
+		if (!invisible && mVertexShaderLevel > 1)
 		{
-			LLSpatialBridge* bridge = (LLSpatialBridge*) group->mSpatialPartition;
-			if (bridge != last_bridge)
+			shader->disableTexture(LLShaderMgr::ENVIRONMENT_MAP, GL_TEXTURE_CUBE_MAP_ARB);
+					
+			if (LLShaderMgr::getVertexShaderLevel(LLShaderMgr::SHADER_OBJECT) > 0)
 			{
-				glPopMatrix();
-				glPushMatrix();
-				glMultMatrixf((F32*) bridge->mDrawable->getRenderMatrix().mMatrix);
-				last_bridge = bridge;
-
-				if (LLPipeline::sDynamicReflections)
+				if (diffuse_channel != 0)
 				{
-					LLSpatialPartition* part = gPipeline.getSpatialPartition(LLPipeline::PARTITION_VOLUME);
-					LLSpatialGroup::OctreeNode* node = part->mOctree->getNodeAt(LLVector3d(bridge->mDrawable->getPositionAgent()), 32.0);
-					if (node)
-					{
-						sCubeMap = ((LLSpatialGroup*) node->getListener(0))->mReflectionMap;
-					}
+					shader->disableTexture(LLShaderMgr::DIFFUSE_MAP);
 				}
 			}
 
-			renderGroup(group,type,mask,texture);
+			shader->unbind();
+			glActiveTextureARB(GL_TEXTURE0_ARB);
+			glEnable(GL_TEXTURE_2D);
 		}
+
+		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 	}
 	
-	glPopMatrix();
+	LLImageGL::unbindTexture(0, GL_TEXTURE_2D);
+	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+	glDisableClientState(GL_NORMAL_ARRAY);
+	glDisableClientState(GL_COLOR_ARRAY);
+	if (!invisible && mVertexShaderLevel > 1)
+	{
+		glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	}
+
+	diffuse_channel = -1;
+	cube_channel = 0;
+	mShiny = FALSE;
 }
 
+void LLDrawPoolBump::beginFullbrightShiny()
+{
+	LLFastTimer t(LLFastTimer::FTM_RENDER_SHINY);
+	if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_FULLBRIGHT_SHINY))
+	{
+		return;
+	}
+
+	sVertexMask = VERTEX_MASK_SHINY | LLVertexBuffer::MAP_TEXCOORD;
+
+	// Second pass: environment map
+	glEnableClientState(GL_VERTEX_ARRAY);
+	glEnableClientState(GL_NORMAL_ARRAY);
+	glEnableClientState(GL_COLOR_ARRAY);
+	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+	
+	if (LLPipeline::sUnderWaterRender)
+	{
+		shader = &gObjectShinyWaterProgram;
+	}
+	else
+	{
+		shader = &gObjectFullbrightShinyProgram;
+	}
 
+	LLCubeMap* cube_map = gSky.mVOSkyp ? gSky.mVOSkyp->getCubeMap() : NULL;
+	if( cube_map )
+	{
+		LLMatrix4 mat;
+		mat.initRows(LLVector4(gGLModelView+0),
+					 LLVector4(gGLModelView+4),
+					 LLVector4(gGLModelView+8),
+					 LLVector4(gGLModelView+12));
+		shader->bind();
+		LLVector3 vec = LLVector3(gShinyOrigin) * mat;
+		LLVector4 vec4(vec, gShinyOrigin.mV[3]);
+		shader->uniform4fv(LLShaderMgr::SHINY_ORIGIN, 1, vec4.mV);			
+
+		cube_map->setMatrix(1);
+		// Make sure that texture coord generation happens for tex unit 1, as that's the one we use for 
+		// the cube map in the one pass shiny shaders
+		cube_channel = shader->enableTexture(LLShaderMgr::ENVIRONMENT_MAP, GL_TEXTURE_CUBE_MAP_ARB);
+		cube_map->enableTexture(cube_channel);
+		cube_map->enableTextureCoords(1);
+		diffuse_channel = shader->enableTexture(LLShaderMgr::DIFFUSE_MAP);
+
+		cube_map->bind();
+	}
+	mShiny = TRUE;
+}
+
+void LLDrawPoolBump::renderFullbrightShiny()
+{
+	LLFastTimer t(LLFastTimer::FTM_RENDER_SHINY);
+	if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_FULLBRIGHT_SHINY))
+	{
+		return;
+	}
+
+	sCubeMap = NULL;
+
+	if( gSky.mVOSkyp->getCubeMap() )
+	{
+		LLGLEnable blend_enable(GL_BLEND);
+		LLRenderPass::renderTexture(LLRenderPass::PASS_FULLBRIGHT_SHINY, sVertexMask);
+	}
+}
+
+void LLDrawPoolBump::endFullbrightShiny()
+{
+	LLFastTimer t(LLFastTimer::FTM_RENDER_SHINY);
+	if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_FULLBRIGHT_SHINY))
+	{
+		return;
+	}
+
+	LLCubeMap* cube_map = gSky.mVOSkyp ? gSky.mVOSkyp->getCubeMap() : NULL;
+	if( cube_map )
+	{
+		cube_map->disable();
+		cube_map->restoreMatrix();
+
+		if (diffuse_channel != 0)
+		{
+			shader->disableTexture(LLShaderMgr::DIFFUSE_MAP);
+		}
+		glActiveTextureARB(GL_TEXTURE0_ARB);
+		glEnable(GL_TEXTURE_2D);
+
+		shader->unbind();
+
+		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+	}
+	
+	LLImageGL::unbindTexture(0, GL_TEXTURE_2D);
+	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+	glDisableClientState(GL_NORMAL_ARRAY);
+	glDisableClientState(GL_COLOR_ARRAY);
+	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+	diffuse_channel = -1;
+	cube_channel = 0;
+	mShiny = FALSE;
+}
 
 void LLDrawPoolBump::renderGroup(LLSpatialGroup* group, U32 type, U32 mask, BOOL texture = TRUE)
 {					
@@ -366,6 +583,11 @@ void LLDrawPoolBump::renderGroup(LLSpatialGroup* group, U32 type, U32 mask, BOOL
 			}
 			else
 			{
+				if (params.mModelMatrix)
+				{
+					sCubeMap = gPipeline.findReflectionMap(params.mModelMatrix->getTranslation());	
+				}
+
 				if (sCubeMap)
 				{
 					sCubeMap->bind();
@@ -377,34 +599,14 @@ void LLDrawPoolBump::renderGroup(LLSpatialGroup* group, U32 type, U32 mask, BOOL
 			}
 		}
 		
+		applyModelMatrix(params);
+
 		params.mVertexBuffer->setBuffer(mask);
-		U32* indices_pointer = (U32*) params.mVertexBuffer->getIndicesPointer();
+		U16* indices_pointer = (U16*) params.mVertexBuffer->getIndicesPointer();
 		glDrawRangeElements(GL_TRIANGLES, params.mStart, params.mEnd, params.mCount,
-							GL_UNSIGNED_INT, indices_pointer+params.mOffset);
-		gPipeline.mTrianglesDrawn += params.mCount/3;
-	}
-}
-
-void LLDrawPoolBump::endShiny()
-{
-	LLCubeMap* cube_map = gSky.mVOSkyp->getCubeMap();
-	if( cube_map )
-	{
-		cube_map->disable();
-		cube_map->restoreMatrix();
-
-		if (LLShaderMgr::getVertexShaderLevel(LLShaderMgr::SHADER_OBJECT) > 0)
-		{
-			gObjectShinyProgram.unbind();
-		}
-
-		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,		GL_MODULATE);
+							GL_UNSIGNED_SHORT, indices_pointer+params.mOffset);
+		gPipeline.addTrianglesDrawn(params.mCount/3);
 	}
-	
-	LLImageGL::unbindTexture(0, GL_TEXTURE_2D);
-	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-	glDisableClientState(GL_NORMAL_ARRAY);
-	glDisableClientState(GL_COLOR_ARRAY);
 }
 
 
@@ -450,6 +652,11 @@ BOOL LLDrawPoolBump::bindBumpMap(LLDrawInfo& params)
 //static
 void LLDrawPoolBump::beginBump()
 {	
+	if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
+	{
+		return;
+	}
+
 	sVertexMask = VERTEX_MASK_BUMP;
 	LLFastTimer t(LLFastTimer::FTM_RENDER_BUMP);
 	// Optional second pass: emboss bump map
@@ -503,28 +710,41 @@ void LLDrawPoolBump::beginBump()
 	//		= 2 * ((1 + bump0 - bump1) / 2) * dst   [0 - 2 * dst]
 	//		= (1 + bump0 - bump1) * dst.rgb
 	//		= dst.rgb + dst.rgb * (bump0 - bump1)
-	glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
-//	glBlendFunc(GL_ONE, GL_ZERO);  // temp
+	gGL.blendFunc(GL_DST_COLOR, GL_SRC_COLOR);
+//	gGL.blendFunc(GL_ONE, GL_ZERO);  // temp
 	glActiveTextureARB(GL_TEXTURE0_ARB);
 	stop_glerror();
+
+	LLViewerImage::unbindTexture(1, GL_TEXTURE_2D);
 }
 
 //static
 void LLDrawPoolBump::renderBump()
 {
+	if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
+	{
+		return;
+	}
+
 	LLFastTimer ftm(LLFastTimer::FTM_RENDER_BUMP);
 	LLGLDisable fog(GL_FOG);
-	LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE, GL_EQUAL);
-	LLGLEnable tex2d(GL_TEXTURE_2D);
+	LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE, GL_LEQUAL);
 	LLGLEnable blend(GL_BLEND);
 	glColor4f(1,1,1,1);
+	/// Get rid of z-fighting with non-bump pass.
+	LLGLEnable polyOffset(GL_POLYGON_OFFSET_FILL);
+	glPolygonOffset(-1.0f, -1.0f);
 	renderBump(LLRenderPass::PASS_BUMP, sVertexMask);
-	renderBumpActive(LLRenderPass::PASS_BUMP, sVertexMask);
 }
 
 //static
 void LLDrawPoolBump::endBump()
 {
+	if (!gPipeline.hasRenderBatches(LLRenderPass::PASS_BUMP))
+	{
+		return;
+	}
+
 	// Disable texture unit 1
 	glActiveTextureARB(GL_TEXTURE1_ARB);
 	glClientActiveTextureARB(GL_TEXTURE1_ARB);
@@ -538,7 +758,7 @@ void LLDrawPoolBump::endBump()
 	glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 	glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 	
-	glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
+	gGL.blendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 }
 
 ////////////////////////////////////////////////////////////////
@@ -864,47 +1084,16 @@ void LLBumpImageList::onSourceLoaded( BOOL success, LLViewerImage *src_vi, LLIma
 	}
 }
 
-void LLDrawPoolBump::renderBumpActive(U32 type, U32 mask)
-{
-#if !LL_RELEASE_FOR_DOWNLOAD
-	LLGLState::checkClientArrays(mask);
-#endif
-
-	LLSpatialBridge* last_bridge = NULL;
-	glPushMatrix();
-	
-	for (LLSpatialGroup::sg_vector_t::iterator i = gPipeline.mActiveGroups.begin(); i != gPipeline.mActiveGroups.end(); ++i)
-	{
-		LLSpatialGroup* group = *i;
-		if (!group->isDead() && 
-			group->mSpatialPartition->mRenderByGroup &&
-			group->mDrawMap.find(type) != group->mDrawMap.end())
-		{
-			LLSpatialBridge* bridge = (LLSpatialBridge*) group->mSpatialPartition;
-			if (bridge != last_bridge)
-			{
-				glPopMatrix();
-				glPushMatrix();
-				glMultMatrixf((F32*) bridge->mDrawable->getRenderMatrix().mMatrix);
-				last_bridge = bridge;
-			}
-
-			renderGroupBump(group,type,mask);
-		}
-	}
-	
-	glPopMatrix();
-}
-
 void LLDrawPoolBump::renderBump(U32 type, U32 mask)
 {	
 #if !LL_RELEASE_FOR_DOWNLOAD
 	LLGLState::checkClientArrays(mask);
 #endif
 
-	LLSpatialGroup::drawmap_elem_t& draw_info = gPipeline.mRenderMap[type];	
+	LLCullResult::drawinfo_list_t::iterator begin = gPipeline.beginRenderMap(type);
+	LLCullResult::drawinfo_list_t::iterator end = gPipeline.endRenderMap(type);
 
-	for (LLSpatialGroup::drawmap_elem_t::iterator i = draw_info.begin(); i != draw_info.end(); ++i)	
+	for (LLCullResult::drawinfo_list_t::iterator i = begin; i != end; ++i)	
 	{
 		LLDrawInfo& params = **i;
 
@@ -932,25 +1121,96 @@ void LLDrawPoolBump::renderGroupBump(LLSpatialGroup* group, U32 type, U32 mask)
 
 void LLDrawPoolBump::pushBatch(LLDrawInfo& params, U32 mask, BOOL texture)
 {
+	applyModelMatrix(params);
+
 	if (params.mTextureMatrix)
 	{
-		glActiveTextureARB(GL_TEXTURE1_ARB);
-		glMatrixMode(GL_TEXTURE);
-		glLoadMatrixf((GLfloat*) params.mTextureMatrix->mMatrix);
-		glActiveTextureARB(GL_TEXTURE0_ARB);
+		if (mShiny)
+		{
+			glActiveTextureARB(GL_TEXTURE0_ARB);
+			glMatrixMode(GL_TEXTURE);
+		}
+		else
+		{
+			glActiveTextureARB(GL_TEXTURE1_ARB);
+			glMatrixMode(GL_TEXTURE);
+			glLoadMatrixf((GLfloat*) params.mTextureMatrix->mMatrix);
+			gPipeline.mTextureMatrixOps++;
+			glActiveTextureARB(GL_TEXTURE0_ARB);
+		}
+
 		glLoadMatrixf((GLfloat*) params.mTextureMatrix->mMatrix);
+		gPipeline.mTextureMatrixOps++;
+	}
+
+	if (mShiny && mVertexShaderLevel > 1 && texture)
+	{
+		if (params.mTexture.notNull())
+		{
+			params.mTexture->bind(diffuse_channel);
+			params.mTexture->addTextureStats(params.mVSize);
+		}
+		else
+		{
+			LLImageGL::unbindTexture(0);
+		}
+
+		if (LLPipeline::sDynamicReflections)
+		{
+			LLCubeMap* cube_map = params.mReflectionMap;
+
+			if (!cube_map && params.mModelMatrix)
+			{
+				cube_map = gPipeline.findReflectionMap(params.mModelMatrix->getTranslation());
+			}
+
+			if (cube_map)
+			{
+				cube_map->enableTexture(cube_channel);
+				cube_map->bind();
+			}	
+		}
 	}
+	
 	params.mVertexBuffer->setBuffer(mask);
-	U32* indices_pointer = (U32*) params.mVertexBuffer->getIndicesPointer();
+	U16* indices_pointer = (U16*) params.mVertexBuffer->getIndicesPointer();
 	glDrawRangeElements(GL_TRIANGLES, params.mStart, params.mEnd, params.mCount,
-						GL_UNSIGNED_INT, indices_pointer+params.mOffset);
-	gPipeline.mTrianglesDrawn += params.mCount/3;
+						GL_UNSIGNED_SHORT, indices_pointer+params.mOffset);
+	gPipeline.addTrianglesDrawn(params.mCount/3);
+
 	if (params.mTextureMatrix)
 	{
-		glActiveTextureARB(GL_TEXTURE1_ARB);
-		glLoadIdentity();
-		glActiveTextureARB(GL_TEXTURE0_ARB);
+		if (mShiny)
+		{
+			glActiveTextureARB(GL_TEXTURE0_ARB);
+		}
+		else
+		{
+			glActiveTextureARB(GL_TEXTURE1_ARB);
+			glLoadIdentity();
+			glActiveTextureARB(GL_TEXTURE0_ARB);
+		}
 		glLoadIdentity();
 		glMatrixMode(GL_MODELVIEW);
 	}
 }
+
+void LLDrawPoolInvisible::render(S32 pass)
+{ //render invisiprims
+	LLFastTimer t(LLFastTimer::FTM_RENDER_INVISIBLE);
+  
+	U32 invisi_mask = LLVertexBuffer::MAP_VERTEX;
+	glStencilMask(0);
+	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
+	pushBatches(LLRenderPass::PASS_INVISIBLE, invisi_mask, FALSE);
+	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
+	glStencilMask(0xFFFFFFFF);
+
+	if (gPipeline.hasRenderBatches(LLRenderPass::PASS_INVISI_SHINY))
+	{
+		beginShiny(true);
+		renderShiny(true);
+		endShiny(true);
+	}
+}
+