1 files changed, 225 insertions, 437 deletions

diff --git a/linden/indra/newview/lldrawpoolbump.cpp b/linden/indra/newview/lldrawpoolbump.cpp
index befcc70..916454c 100644
--- a/linden/indra/newview/lldrawpoolbump.cpp
+++ b/linden/indra/newview/lldrawpoolbump.cpp
@@ -37,12 +37,10 @@
 #include "m4math.h"
 
 #include "llagent.h"
-#include "llagparray.h"
 #include "llcubemap.h"
 #include "lldrawable.h"
 #include "lldrawpoolsimple.h"
 #include "llface.h"
-#include "llgl.h"
 #include "llsky.h"
 #include "lltextureentry.h"
 #include "llviewercamera.h"
@@ -64,9 +62,11 @@ LLBumpImageList gBumpImageList;
 
 const S32 STD_BUMP_LATEST_FILE_VERSION = 1;
 
-S32 LLDrawPoolBump::sBumpTex = -1;
-S32 LLDrawPoolBump::sDiffTex = -1;
-S32 LLDrawPoolBump::sEnvTex = -1;
+const U32 VERTEX_MASK_SHINY = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_COLOR;
+const U32 VERTEX_MASK_BUMP = LLVertexBuffer::MAP_VERTEX |LLVertexBuffer::MAP_TEXCOORD | LLVertexBuffer::MAP_TEXCOORD2;
+
+U32 LLDrawPoolBump::sVertexMask = VERTEX_MASK_SHINY;
+static LLCubeMap* sCubeMap = NULL;
 
 // static 
 void LLStandardBumpmap::init()
@@ -89,7 +89,7 @@ void LLStandardBumpmap::restoreGL()
         gStandardBumpmapList[LLStandardBumpmap::sStandardBumpmapCount++] = LLStandardBumpmap("Darkness");       // BE_DARKNESS
 
         std::string file_name = gDirUtilp->getExpandedFilename( LL_PATH_APP_SETTINGS, "std_bump.ini" );
-        FILE* file = LLFile::fopen( file_name.c_str(), "rt" );
+        FILE* file = LLFile::fopen( file_name.c_str(), "rt" );   /*Flawfinder: ignore*/
         if( !file )
         {
                 llwarns << "Could not open std_bump <" << file_name << ">" << llendl;
@@ -114,9 +114,10 @@ void LLStandardBumpmap::restoreGL()
         while( !feof(file) && (LLStandardBumpmap::sStandardBumpmapCount < (U32)TEM_BUMPMAP_COUNT) )
         {
                 // *NOTE: This buffer size is hard coded into scanf() below.
-                char label[2048] = "";
-                char bump_file[2048] = "";
-                fields_read = fscanf( file, "\n%2047s %2047s", label, bump_file);
+                char label[2048] = "";  /* Flawfinder: ignore */
+                char bump_file[2048] = "";      /* Flawfinder: ignore */
+                fields_read = fscanf(   /* Flawfinder: ignore */
+                        file, "\n%2047s %2047s", label, bump_file);
                 if( EOF == fields_read )
                 {
                         break;
@@ -127,7 +128,7 @@ void LLStandardBumpmap::restoreGL()
                         return;
                 }
 
-                llinfos << "Loading bumpmap: " << bump_file << " from viewerart" << llendl;
+//              llinfos << "Loading bumpmap: " << bump_file << " from viewerart" << llendl;
                 gStandardBumpmapList[LLStandardBumpmap::sStandardBumpmapCount].mLabel = label;
                 gStandardBumpmapList[LLStandardBumpmap::sStandardBumpmapCount].mImage = gImageList.getImage( LLUUID(gViewerArt.getString(bump_file)) );
                 LLStandardBumpmap::sStandardBumpmapCount++;
@@ -151,15 +152,9 @@ void LLStandardBumpmap::destroyGL()
 
 ////////////////////////////////////////////////////////////////
 
-LLDrawPoolBump::LLDrawPoolBump(LLViewerImage *texturep) :
-        LLDrawPool(POOL_BUMP, DATA_BUMP_IL_MASK | DATA_COLORS_MASK, DATA_SIMPLE_NIL_MASK),
-        mTexturep(texturep)
-{
-}
-
-LLDrawPool *LLDrawPoolBump::instancePool()
+LLDrawPoolBump::LLDrawPoolBump() 
+: LLRenderPass(LLDrawPool::POOL_BUMP)
 {
-        return new LLDrawPoolBump(mTexturep);
 }
 
 
@@ -168,51 +163,16 @@ void LLDrawPoolBump::prerender()
         mVertexShaderLevel = gPipeline.getVertexShaderLevel(LLPipeline::SHADER_OBJECT);
 }
 
-BOOL LLDrawPoolBump::match(LLFace* last_face, LLFace* facep)  
-{
-        if (gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_CHAIN_FACES) &&
-                !last_face->isState(LLFace::LIGHT | LLFace::FULLBRIGHT) &&
-                !facep->isState(LLFace::LIGHT | LLFace::FULLBRIGHT) &&
-                facep->getIndicesStart() == last_face->getIndicesStart()+last_face->getIndicesCount() &&
-                facep->getRenderColor() == last_face->getRenderColor() &&
-                facep->getTextureEntry()->getShiny() == last_face->getTextureEntry()->getShiny() &&
-                facep->getTextureEntry()->getBumpmap() == last_face->getTextureEntry()->getBumpmap())
-        {
-                if (facep->isState(LLFace::GLOBAL))
-                {
-                        if (last_face->isState(LLFace::GLOBAL))
-                        {
-                                return TRUE;
-                        }
-                }
-                else
-                {
-                        if (!last_face->isState(LLFace::GLOBAL))
-                        {
-                                if (last_face->getRenderMatrix() == facep->getRenderMatrix())
-                                {
-                                        return TRUE;
-                                }
-                        }
-                }
-        }
-        
-        return FALSE;
-}
-
 // static
 S32 LLDrawPoolBump::numBumpPasses()
 {
-        if (gPipeline.getVertexShaderLevel(LLPipeline::SHADER_OBJECT) > 0)
+        if (gSavedSettings.getBOOL("RenderObjectBump"))
         {
-                return 1; // single pass for shaders
+                return 2;
         }
-        else
+    else
         {
-                if (gSavedSettings.getBOOL("RenderObjectBump"))
-                        return 3;
-                else
-                        return 1;
+                return 0;
         }
 }
 
@@ -226,13 +186,10 @@ void LLDrawPoolBump::beginRenderPass(S32 pass)
         switch( pass )
         {
                 case 0:
-                        beginPass0(this);
+                        beginShiny();
                         break;
                 case 1:
-                        beginPass1();
-                        break;
-                case 2:
-                        beginPass2();
+                        beginBump();
                         break;
                 default:
                         llassert(0);
@@ -243,66 +200,17 @@ void LLDrawPoolBump::beginRenderPass(S32 pass)
 void LLDrawPoolBump::render(S32 pass)
 {
         LLFastTimer t(LLFastTimer::FTM_RENDER_BUMP);
-        if (!mTexturep)
-        {
-                return;
-        }
-
-        if (mDrawFace.empty())
-        {
-                return;
-        }
-
-        const U32* index_array = getRawIndices();
         
-        S32 indices = 0;
         switch( pass )
         {
           case 0:
           {
-                  stop_glerror();
-                  
-                  bindGLVertexPointer();
-                  bindGLTexCoordPointer();
-                  bindGLNormalPointer();
-                  if (gPipeline.getLightingDetail() >= 2)
-                  {
-                          bindGLColorPointer();
-                  }
-
-                  stop_glerror();
-                  
-                  LLGLState alpha_test(GL_ALPHA_TEST, FALSE);
-                  LLGLState blend(GL_BLEND, FALSE);
-                  LLViewerImage* tex = getTexture();
-                  if (tex && tex->getPrimaryFormat() == GL_ALPHA)
-                  {
-                          // Enable Invisibility Hack
-                          alpha_test.enable();
-                          blend.enable();
-                  }
-                  indices += renderPass0(this, mDrawFace, index_array, mTexturep);
+                  renderShiny();
                   break;
           }
           case 1:
           {
-                  bindGLVertexPointer();
-                  bindGLNormalPointer();
-                  indices += renderPass1(mDrawFace, index_array, mTexturep);
-                  break;
-          }
-          case 2:
-          {
-                  bindGLVertexPointer();
-                  // Texture unit 0
-                  glActiveTextureARB(GL_TEXTURE0_ARB);
-                  glClientActiveTextureARB(GL_TEXTURE0_ARB);
-                  bindGLTexCoordPointer();
-                  // Texture unit 1
-                  glActiveTextureARB(GL_TEXTURE1_ARB);
-                  glClientActiveTextureARB(GL_TEXTURE1_ARB);
-                  bindGLTexCoordPointer(1);
-                  indices += renderPass2(mDrawFace, index_array, mTexturep);
+                  renderBump();
                   break;
           }
           default:
@@ -311,7 +219,6 @@ void LLDrawPoolBump::render(S32 pass)
                   break;
           }
         }
-        mIndicesDrawn += indices;
 }
 
 void LLDrawPoolBump::endRenderPass(S32 pass)
@@ -319,13 +226,10 @@ void LLDrawPoolBump::endRenderPass(S32 pass)
         switch( pass )
         {
                 case 0:
-                        endPass0(this);
+                        endShiny();
                         break;
                 case 1:
-                        endPass1();
-                        break;
-                case 2:
-                        endPass2();
+                        endBump();
                         break;
                 default:
                         llassert(0);
@@ -334,252 +238,171 @@ void LLDrawPoolBump::endRenderPass(S32 pass)
 }
 
 //static
-void LLDrawPoolBump::beginPass0(LLDrawPool* pool)
+void LLDrawPoolBump::beginShiny()
 {
-        stop_glerror();
-        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+        sVertexMask = VERTEX_MASK_SHINY;
+        // Second pass: environment map
         glEnableClientState(GL_VERTEX_ARRAY);
         glEnableClientState(GL_NORMAL_ARRAY);
-        if (gPipeline.getLightingDetail() >= 2)
-        {
-                glEnableClientState(GL_COLOR_ARRAY);
-        }
+        glEnableClientState(GL_COLOR_ARRAY);
 
-        if (pool->getVertexShaderLevel() > 0)
+        LLCubeMap* cube_map = gSky.mVOSkyp->getCubeMap();
+        if( cube_map )
         {
-                enable_binormals(gPipeline.mObjectBumpProgram.mAttribute[LLPipeline::GLSL_BINORMAL]);
+                cube_map->enable(0);
+                cube_map->setMatrix(0);
+                cube_map->bind();
 
-                sEnvTex = gPipeline.mObjectBumpProgram.enableTexture(LLPipeline::GLSL_ENVIRONMENT_MAP, GL_TEXTURE_CUBE_MAP_ARB);
-                LLCubeMap* cube_map = gSky.mVOSkyp->getCubeMap();
-                if (sEnvTex >= 0 && cube_map)
+                if (gPipeline.getVertexShaderLevel(LLPipeline::SHADER_OBJECT) > 0)
                 {
-                        cube_map->bind();
-                        cube_map->setMatrix(1);
+                        LLMatrix4 mat;
+                        glGetFloatv(GL_MODELVIEW_MATRIX, (F32*) mat.mMatrix);
+                        gPipeline.mObjectShinyProgram.bind();
+                        LLVector3 vec = LLVector3(gPipeline.mShinyOrigin) * mat;
+                        LLVector4 vec4(vec, gPipeline.mShinyOrigin.mV[3]);
+                        glUniform4fvARB(gPipeline.mObjectShinyProgram.mUniform[LLPipeline::GLSL_SHINY_ORIGIN], 1,
+                                vec4.mV);
+                }
+                else
+                {
+                        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,  GL_COMBINE_ARB);
+                        
+                        //use RGB from texture
+                        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB,   GL_REPLACE);
+                        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB,   GL_TEXTURE);
+                        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB,  GL_SRC_COLOR);
+
+                        // use alpha from color
+                        glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB,         GL_REPLACE);
+                        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB,         GL_PRIMARY_COLOR);
+                        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB,        GL_SRC_ALPHA);
                 }
-                
-                sBumpTex = gPipeline.mObjectBumpProgram.enableTexture(LLPipeline::GLSL_BUMP_MAP);
-                sDiffTex = gPipeline.mObjectBumpProgram.enableTexture(LLPipeline::GLSL_DIFFUSE_MAP);
-                S32 scatterTex = gPipeline.mObjectBumpProgram.enableTexture(LLPipeline::GLSL_SCATTER_MAP);
-                LLViewerImage::bindTexture(gSky.mVOSkyp->getScatterMap(), scatterTex);
         }
-        stop_glerror();
 }
 
-//static
-S32 LLDrawPoolBump::renderPass0(LLDrawPool* pool, face_array_t& face_list, const U32* index_array, LLViewerImage* tex)
+void LLDrawPoolBump::renderShiny()
 {
-        if (!tex)
-        {
-                return 0;
-        }
+        LLFastTimer t(LLFastTimer::FTM_RENDER_SHINY);
         
-        if (face_list.empty())
+        sCubeMap = NULL;
+
+        if( gSky.mVOSkyp->getCubeMap() )
         {
-                return 0;
+                LLGLEnable blend_enable(GL_BLEND);
+                renderStatic(LLRenderPass::PASS_SHINY, sVertexMask);
+                renderActive(LLRenderPass::PASS_SHINY, sVertexMask);
         }
+}
 
-        stop_glerror();
+void LLDrawPoolBump::renderActive(U32 type, U32 mask, BOOL texture)
+{
+#if !LL_RELEASE_FOR_DOWNLOAD
+        LLGLState::checkClientArrays(mask);
+#endif
 
-        S32 res = 0;
-        if (pool->getVertexShaderLevel() > 0)
+        LLSpatialBridge* last_bridge = NULL;
+        glPushMatrix();
+        
+        for (LLSpatialGroup::sg_vector_t::iterator i = gPipeline.mActiveGroups.begin(); i != gPipeline.mActiveGroups.end(); ++i)
         {
-                LLFastTimer t(LLFastTimer::FTM_RENDER_BUMP);
-                pool->bindGLBinormalPointer(gPipeline.mObjectBumpProgram.mAttribute[LLPipeline::GLSL_BINORMAL]);
-                
-                LLViewerImage::bindTexture(tex, sDiffTex);
-
-                //single pass shader driven shiny/bump
-                LLGLDisable(GL_ALPHA_TEST);
-
-                LLViewerImage::sWhiteImagep->bind(sBumpTex);
-                
-                GLfloat alpha[4] =
+                LLSpatialGroup* group = *i;
+                if (!group->isDead() &&
+                        gPipeline.hasRenderType(group->mSpatialPartition->mDrawableType) &&
+                        group->mDrawMap.find(type) != group->mDrawMap.end())
                 {
-                        0.00f,
-                        0.25f,
-                        0.5f,
-                        0.75f
-                };
-
-                LLImageGL* last_bump = NULL;
-
-                for (std::vector<LLFace*>::iterator iter = face_list.begin();
-                         iter != face_list.end(); iter++)
-                {
-                        LLFace *facep = *iter;
-                        if (facep->mSkipRender)
-                        {
-                                continue;
-                        }
-                        
-                        const LLTextureEntry* te = facep->getTextureEntry();
-                        if (te)
+                        LLSpatialBridge* bridge = (LLSpatialBridge*) group->mSpatialPartition;
+                        if (bridge != last_bridge)
                         {
-                                U8 index = te->getShiny();
-                                LLColor4 col = te->getColor();
-                                
-                                gPipeline.mObjectBumpProgram.vertexAttrib4f(LLPipeline::GLSL_MATERIAL_COLOR,
-                                        col.mV[0], col.mV[1], col.mV[2], alpha[index]);
-                                gPipeline.mObjectBumpProgram.vertexAttrib4f(LLPipeline::GLSL_SPECULAR_COLOR, 
-                                        alpha[index], alpha[index], alpha[index], alpha[index]);
-
-                                LLImageGL* bump = getBumpMap(te, tex);
-                                if (bump != last_bump)
+                                glPopMatrix();
+                                glPushMatrix();
+                                glMultMatrixf((F32*) bridge->mDrawable->getRenderMatrix().mMatrix);
+                                last_bridge = bridge;
+
+                                if (LLPipeline::sDynamicReflections)
                                 {
-                                        if (bump)
+                                        LLSpatialPartition* part = gPipeline.getSpatialPartition(LLPipeline::PARTITION_VOLUME);
+                                        LLSpatialGroup::OctreeNode* node = part->mOctree->getNodeAt(LLVector3d(bridge->mDrawable->getPositionAgent()), 32.0);
+                                        if (node)
                                         {
-                                                bump->bind(sBumpTex);
-                                        }
-                                        else
-                                        {
-                                                LLViewerImage::sWhiteImagep->bind(sBumpTex);
+                                                sCubeMap = ((LLSpatialGroup*) node->getListener(0))->mReflectionMap;
                                         }
                                 }
-                                last_bump = bump;
-
-                                // Draw the geometry
-                                facep->enableLights();
-                                res += facep->renderIndexed(index_array);
-                                stop_glerror();
-                        }
-                        else
-                        {
-                                llwarns << "DrawPoolBump has face with invalid texture entry." << llendl;
                         }
-                }
-        }
-        else
-        {
-                LLFastTimer t(LLFastTimer::FTM_RENDER_SIMPLE);
-                LLViewerImage::bindTexture(tex);
-                res = LLDrawPool::drawLoop(face_list, index_array);
-        }
-        return res;
-}
-
-//static
-void LLDrawPoolBump::endPass0(LLDrawPool* pool)
-{
-        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-        glDisableClientState(GL_NORMAL_ARRAY);
-        glDisableClientState(GL_COLOR_ARRAY);
 
-        if (pool->getVertexShaderLevel() > 0)
-        {
-                gPipeline.mObjectBumpProgram.disableTexture(LLPipeline::GLSL_ENVIRONMENT_MAP, GL_TEXTURE_CUBE_MAP_ARB);
-                LLCubeMap* cube_map = gSky.mVOSkyp->getCubeMap();
-                if (sEnvTex >= 0 && cube_map)
-                {
-                        cube_map->restoreMatrix();
+                        renderGroup(group,type,mask,texture);
                 }
-                
-                gPipeline.mObjectBumpProgram.disableTexture(LLPipeline::GLSL_SCATTER_MAP);
-                gPipeline.mObjectBumpProgram.disableTexture(LLPipeline::GLSL_BUMP_MAP);
-                gPipeline.mObjectBumpProgram.disableTexture(LLPipeline::GLSL_DIFFUSE_MAP);
-
-                disable_binormals(gPipeline.mObjectBumpProgram.mAttribute[LLPipeline::GLSL_BINORMAL]);
-                
-                glActiveTextureARB(GL_TEXTURE0_ARB);
-                glEnable(GL_TEXTURE_2D);
         }
+        
+        glPopMatrix();
 }
 
 
-//static
-void LLDrawPoolBump::beginPass1()
-{
-        // Second pass: environment map
-        glEnableClientState(GL_VERTEX_ARRAY);
-        glEnableClientState(GL_NORMAL_ARRAY);
 
-        LLCubeMap* cube_map = gSky.mVOSkyp->getCubeMap();
-        if( cube_map )
-        {
-                cube_map->enable(0);
-                cube_map->setMatrix(0);
-                cube_map->bind();
-        }
-}
-
-//static
-S32 LLDrawPoolBump::renderPass1(face_array_t& face_list, const U32* index_array, LLViewerImage* tex)
-{
-        LLFastTimer t(LLFastTimer::FTM_RENDER_SHINY);
-        if (gPipeline.getVertexShaderLevel(LLPipeline::SHADER_OBJECT) > 0) //everything happens in pass0
-        {
-                return 0;
-        }
-
-        S32 res = 0;
-        if( gSky.mVOSkyp->getCubeMap() )
+void LLDrawPoolBump::renderGroup(LLSpatialGroup* group, U32 type, U32 mask, BOOL texture = TRUE)
+{                                       
+        std::vector<LLDrawInfo*>& draw_info = group->mDrawMap[type];
+        
+        for (std::vector<LLDrawInfo*>::const_iterator k = draw_info.begin(); k != draw_info.end(); ++k)
         {
-                //LLGLSPipelineAlpha gls;
-                //LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE, GL_EQUAL);
-                LLGLEnable blend_enable(GL_BLEND);
-                
-                GLfloat alpha[4] =
+                LLDrawInfo& params = **k;
+                if (LLPipeline::sDynamicReflections)
                 {
-                        0.00f,
-                        0.25f,
-                        0.5f,
-                        0.75f
-                };
-
-                for (std::vector<LLFace*>::iterator iter = face_list.begin();
-                         iter != face_list.end(); iter++)
-                {
-                        LLFace *facep = *iter;
-                        if (facep->mSkipRender)
+                        if (params.mReflectionMap.notNull())
                         {
-                                continue;
+                                params.mReflectionMap->bind();
                         }
-                        
-                        const LLTextureEntry* te = facep->getTextureEntry();
-                        if (te)
+                        else
                         {
-                                U8 index = te->getShiny();
-                                if( index > 0 )
+                                if (sCubeMap)
                                 {
-                                        LLOverrideFaceColor override_color(facep->getPool(), 1, 1, 1, alpha[index]);
-                                
-                                        // Draw the geometry
-                                        facep->enableLights();
-                                        res += facep->renderIndexed(index_array);
-                                        stop_glerror();
+                                        sCubeMap->bind();
+                                }
+                                else
+                                {
+                                        gSky.mVOSkyp->getCubeMap()->bind();
                                 }
-                        }
-                        else
-                        {
-                                llwarns << "DrawPoolBump has face with invalid texture entry." << llendl;
                         }
                 }
+                
+                params.mVertexBuffer->setBuffer(mask);
+                U32* indices_pointer = (U32*) params.mVertexBuffer->getIndicesPointer();
+                glDrawRangeElements(GL_TRIANGLES, params.mStart, params.mEnd, params.mCount,
+                                                        GL_UNSIGNED_INT, indices_pointer+params.mOffset);
+                gPipeline.mTrianglesDrawn += params.mCount/3;
         }
-        return res;
 }
 
-//static
-void LLDrawPoolBump::endPass1()
+void LLDrawPoolBump::endShiny()
 {
         LLCubeMap* cube_map = gSky.mVOSkyp->getCubeMap();
         if( cube_map )
         {
                 cube_map->disable();
                 cube_map->restoreMatrix();
+
+                if (gPipeline.getVertexShaderLevel(LLPipeline::SHADER_OBJECT) > 0)
+                {
+                        gPipeline.mObjectShinyProgram.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);
 }
 
 
 // static
-LLImageGL* LLDrawPoolBump::getBumpMap(const LLTextureEntry* te, LLViewerImage* tex)
+BOOL LLDrawPoolBump::bindBumpMap(LLDrawInfo& params)
 {
-        U32 bump_code = te->getBumpmap();
         LLImageGL* bump = NULL;
 
+        U8 bump_code = params.mBump;
+        LLViewerImage* tex = params.mTexture;
+
         switch( bump_code )
         {
         case BE_NO_BUMP:
@@ -597,28 +420,33 @@ LLImageGL* LLDrawPoolBump::getBumpMap(const LLTextureEntry* te, LLViewerImage* t
                 if( bump_code < LLStandardBumpmap::sStandardBumpmapCount )
                 {
                         bump = gStandardBumpmapList[bump_code].mImage;
+                        gBumpImageList.addTextureStats(bump_code, tex->getID(), params.mVSize, 1, 1);
                 }
                 break;
         }
 
-        return bump;
+        if (bump)
+        {
+                bump->bind(1);
+                bump->bind(0);
+                return TRUE;
+        }
+        return FALSE;
 }
 
 //static
-void LLDrawPoolBump::beginPass2()
+void LLDrawPoolBump::beginBump()
 {       
+        sVertexMask = VERTEX_MASK_BUMP;
         LLFastTimer t(LLFastTimer::FTM_RENDER_BUMP);
-        // Optional third pass: emboss bump map
+        // Optional second pass: emboss bump map
         stop_glerror();
 
         // TEXTURE UNIT 0
         // Output.rgb = texture at texture coord 0
         glActiveTextureARB(GL_TEXTURE0_ARB);
         glClientActiveTextureARB(GL_TEXTURE0_ARB);
-
-        glEnableClientState(GL_VERTEX_ARRAY);
         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-        glDisableClientState(GL_NORMAL_ARRAY);
 
         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,  GL_COMBINE_ARB);
         glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB,   GL_REPLACE);
@@ -631,14 +459,10 @@ void LLDrawPoolBump::beginPass2()
         glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB,         GL_TEXTURE);
         glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB,        GL_SRC_ALPHA);
 
-
         // TEXTURE UNIT 1
         glActiveTextureARB(GL_TEXTURE1_ARB);
         glClientActiveTextureARB(GL_TEXTURE1_ARB);
-        
-        glEnableClientState(GL_VERTEX_ARRAY);
         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
-        glDisableClientState(GL_NORMAL_ARRAY);
 
         glEnable(GL_TEXTURE_2D); // Texture unit 1
 
@@ -668,68 +492,25 @@ void LLDrawPoolBump::beginPass2()
         //              = dst.rgb + dst.rgb * (bump0 - bump1)
         glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
 //      glBlendFunc(GL_ONE, GL_ZERO);  // temp
-
+        glActiveTextureARB(GL_TEXTURE0_ARB);
         stop_glerror();
 }
 
 //static
-S32 LLDrawPoolBump::renderPass2(face_array_t& face_list, const U32* index_array, LLViewerImage* tex)
+void LLDrawPoolBump::renderBump()
 {
-        if (gPipeline.getVertexShaderLevel(LLPipeline::SHADER_OBJECT) > 0) //everything happens in pass0
-        {
-                return 0;
-        }
-
+        LLFastTimer ftm(LLFastTimer::FTM_RENDER_BUMP);
         LLGLDisable fog(GL_FOG);
         LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE, GL_EQUAL);
         LLGLEnable tex2d(GL_TEXTURE_2D);
         LLGLEnable blend(GL_BLEND);
-        S32 res = 0;
-
-        LLImageGL* last_bump = NULL;
-
-        for (std::vector<LLFace*>::iterator iter = face_list.begin();
-                 iter != face_list.end(); iter++)
-        {
-                LLFace *facep = *iter;
-                if (facep->mSkipRender)
-                {
-                        continue;
-                }
-                LLOverrideFaceColor override_color(facep->getPool(), 1,1,1,1);
-        
-                const LLTextureEntry* te = facep->getTextureEntry();
-                LLImageGL* bump = getBumpMap(te, tex);
-                
-                if( bump )
-                {
-                        if( bump != last_bump )
-                        {
-                                last_bump = bump;
-
-                                // Texture unit 0
-                                bump->bind(0);
-                                stop_glerror();
-
-                                // Texture unit 1
-                                bump->bind(1);
-                                stop_glerror();
-                        }
-
-                        // Draw the geometry
-                        res += facep->renderIndexed(index_array);
-                        stop_glerror();
-                }
-                else
-                {
-//                      llwarns << "Skipping invalid bump code " << (S32) te->getBumpmap() << llendl;
-                }
-        }
-        return res;
+        glColor4f(1,1,1,1);
+        renderBump(LLRenderPass::PASS_BUMP, sVertexMask);
+        renderBumpActive(LLRenderPass::PASS_BUMP, sVertexMask);
 }
 
 //static
-void LLDrawPoolBump::endPass2()
+void LLDrawPoolBump::endBump()
 {
         // Disable texture unit 1
         glActiveTextureARB(GL_TEXTURE1_ARB);
@@ -747,67 +528,6 @@ void LLDrawPoolBump::endPass2()
         glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
 }
 
-
-void LLDrawPoolBump::renderForSelect()
-{
-        if (mDrawFace.empty() || !mMemory.count())
-        {
-                return;
-        }
-
-        glEnableClientState ( GL_VERTEX_ARRAY );
-
-        bindGLVertexPointer();
-
-        for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
-                 iter != mDrawFace.end(); iter++)
-        {
-                LLFace *facep = *iter;
-                if (facep->getDrawable() && !facep->getDrawable()->isDead() && (facep->getViewerObject()->mGLName))
-                {
-                        facep->renderForSelect();
-                }
-        }
-}
-
-
-void LLDrawPoolBump::renderFaceSelected(LLFace *facep, 
-                                                                                LLImageGL *image, 
-                                                                                const LLColor4 &color,
-                                                                                const S32 index_offset, const S32 index_count)
-{
-        facep->renderSelected(image, color, index_offset, index_count);
-}
-
-
-void LLDrawPoolBump::dirtyTexture(const LLViewerImage *texturep)
-{
-        if (mTexturep == texturep)
-        {
-                for (std::vector<LLFace*>::iterator iter = mReferences.begin();
-                         iter != mReferences.end(); iter++)
-                {
-                        LLFace *facep = *iter;
-                        gPipeline.markTextured(facep->getDrawable());
-                }
-        }
-}
-
-LLViewerImage *LLDrawPoolBump::getTexture()
-{
-        return mTexturep;
-}
-
-LLViewerImage *LLDrawPoolBump::getDebugTexture()
-{
-        return mTexturep;
-}
-
-LLColor3 LLDrawPoolBump::getDebugColor() const
-{
-        return LLColor3(1.f, 1.f, 0.f);
-}
-
 ////////////////////////////////////////////////////////////////
 // List of one-component bump-maps created from other texures.
 
@@ -1131,25 +851,93 @@ void LLBumpImageList::onSourceLoaded( BOOL success, LLViewerImage *src_vi, LLIma
         }
 }
 
-S32 LLDrawPoolBump::getMaterialAttribIndex()
+void LLDrawPoolBump::renderBumpActive(U32 type, U32 mask)
 {
-        return gPipeline.mObjectBumpProgram.mAttribute[LLPipeline::GLSL_MATERIAL_COLOR];
+#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();
 }
 
-// virtual
-void LLDrawPoolBump::enableShade()
-{
-        glDisableClientState(GL_COLOR_ARRAY);
+void LLDrawPoolBump::renderBump(U32 type, U32 mask)
+{       
+#if !LL_RELEASE_FOR_DOWNLOAD
+        LLGLState::checkClientArrays(mask);
+#endif
+
+        std::vector<LLDrawInfo*>& draw_info = gPipeline.mRenderMap[type];
+
+        for (std::vector<LLDrawInfo*>::iterator i = draw_info.begin(); i != draw_info.end(); ++i)
+        {
+                LLDrawInfo& params = **i;
+
+                if (LLDrawPoolBump::bindBumpMap(params))
+                {
+                        pushBatch(params, mask, FALSE);
+                }
+        }
 }
 
-// virtual
-void LLDrawPoolBump::disableShade()
-{
-        glEnableClientState(GL_COLOR_ARRAY);
+void LLDrawPoolBump::renderGroupBump(LLSpatialGroup* group, U32 type, U32 mask)
+{                                       
+        const std::vector<LLDrawInfo*>& draw_info = group->mDrawMap[type];
+        
+        for (std::vector<LLDrawInfo*>::const_iterator k = draw_info.begin(); k != draw_info.end(); ++k)
+        {
+                LLDrawInfo& params = **k;
+                
+                if (LLDrawPoolBump::bindBumpMap(params))
+                {
+                        pushBatch(params, mask, FALSE);
+                }
+        }
 }
 
-// virtual
-void LLDrawPoolBump::setShade(F32 shade)
+void LLDrawPoolBump::pushBatch(LLDrawInfo& params, U32 mask, BOOL texture)
 {
-        glColor4f(0,0,0,shade);
+        if (params.mTextureMatrix)
+        {
+                glActiveTextureARB(GL_TEXTURE1_ARB);
+                glMatrixMode(GL_TEXTURE);
+                glLoadMatrixf((GLfloat*) params.mTextureMatrix->mMatrix);
+                glActiveTextureARB(GL_TEXTURE0_ARB);
+                glLoadMatrixf((GLfloat*) params.mTextureMatrix->mMatrix);
+        }
+        params.mVertexBuffer->setBuffer(mask);
+        U32* indices_pointer = (U32*) params.mVertexBuffer->getIndicesPointer();
+        glDrawRangeElements(GL_TRIANGLES, params.mStart, params.mEnd, params.mCount,
+                                                GL_UNSIGNED_INT, indices_pointer+params.mOffset);
+        gPipeline.mTrianglesDrawn += params.mCount/3;
+        if (params.mTextureMatrix)
+        {
+                glActiveTextureARB(GL_TEXTURE1_ARB);
+                glLoadIdentity();
+                glActiveTextureARB(GL_TEXTURE0_ARB);
+                glLoadIdentity();
+                glMatrixMode(GL_MODELVIEW);
+        }
 }