Second Life viewer sources 1.13.2.12

1 files changed, 1958 insertions, 0 deletions

diff --git a/linden/indra/newview/llface.cpp b/linden/indra/newview/llface.cpp
new file mode 100644
index 0000000..a6de94b
--- /dev/null
+++ b/linden/indra/newview/llface.cpp
@@ -0,0 +1,1958 @@
+/** 
+ * @file llface.cpp
+ * @brief LLFace class implementation
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "llviewerprecompiledheaders.h"
+
+#include "lldrawable.h" // lldrawable needs to be included before llface
+#include "llface.h"
+
+#include "llviewercontrol.h"
+#include "llvolume.h"
+#include "m3math.h"
+#include "v3color.h"
+
+#include "llagparray.h"
+#include "lldrawpoolsimple.h"
+#include "lldrawpoolbump.h"
+#include "llgl.h"
+#include "lllightconstants.h"
+#include "llsky.h"
+#include "llviewercamera.h"
+#include "llviewerimagelist.h"
+#include "llvosky.h"
+#include "llvovolume.h"
+#include "pipeline.h"
+
+#include "llagparray.inl"
+
+#define LL_MAX_INDICES_COUNT 1000000
+
+extern BOOL gPickFaces;
+
+BOOL LLFace::sSafeRenderSelect = TRUE; // FALSE
+
+#define DOTVEC(a,b) (a.mV[0]*b.mV[0] + a.mV[1]*b.mV[1] + a.mV[2]*b.mV[2])
+
+
+/*
+For each vertex, given:
+        B - binormal
+        T - tangent
+        N - normal
+        P - position
+
+The resulting texture coordinate <u,v> is:
+
+        u = 2(B dot P)
+        v = 2(T dot P)
+*/
+void planarProjection(LLVector2 &tc, const LLVolumeFace::VertexData &vd, const LLVector3 &mCenter, const LLVector3& vec)
+{       //DONE!
+        LLVector3 binormal;
+        float d = vd.mNormal * LLVector3(1,0,0);
+        if (d >= 0.5f || d <= -0.5f)
+        {
+                binormal = LLVector3(0,1,0);
+                if (vd.mNormal.mV[0] < 0)
+                {
+                        binormal = -binormal;
+                }
+        }
+        else
+        {
+        binormal = LLVector3(1,0,0);
+                if (vd.mNormal.mV[1] > 0)
+                {
+                        binormal = -binormal;
+                }
+        }
+        LLVector3 tangent = binormal % vd.mNormal;
+
+        tc.mV[1] = -((tangent*vec)*2 - 0.5f);
+        tc.mV[0] = 1.0f+((binormal*vec)*2 - 0.5f);
+}
+
+void sphericalProjection(LLVector2 &tc, const LLVolumeFace::VertexData &vd, const LLVector3 &mCenter, const LLVector3& vec)
+{       //BROKEN
+        /*tc.mV[0] = acosf(vd.mNormal * LLVector3(1,0,0))/3.14159f;
+        
+        tc.mV[1] = acosf(vd.mNormal * LLVector3(0,0,1))/6.284f;
+        if (vd.mNormal.mV[1] > 0)
+        {
+                tc.mV[1] = 1.0f-tc.mV[1];
+        }*/
+}
+
+void cylindricalProjection(LLVector2 &tc, const LLVolumeFace::VertexData &vd, const LLVector3 &mCenter, const LLVector3& vec)
+{       //BROKEN
+        /*LLVector3 binormal;
+        float d = vd.mNormal * LLVector3(1,0,0);
+        if (d >= 0.5f || d <= -0.5f)
+        {
+                binormal = LLVector3(0,1,0);
+        }
+        else{
+                binormal = LLVector3(1,0,0);
+        }
+        LLVector3 tangent = binormal % vd.mNormal;
+
+        tc.mV[1] = -((tangent*vec)*2 - 0.5f);
+
+        tc.mV[0] = acosf(vd.mNormal * LLVector3(1,0,0))/6.284f;
+
+        if (vd.mNormal.mV[1] < 0)
+        {
+                tc.mV[0] = 1.0f-tc.mV[0];
+        }*/
+}
+
+////////////////////
+//
+// LLFace implementation
+//
+
+void LLFace::init(LLDrawable* drawablep, LLViewerObject* objp)
+{
+        mGeneration = DIRTY;
+        mState      = GLOBAL;
+        mDrawPoolp  = NULL;
+        mGeomIndex  = -1;
+        mSkipRender = FALSE;
+        mNextFace = NULL;
+        // mCenterLocal
+        // mCenterAgent
+        mDistance       = 0.f;
+
+        mPrimType               = LLTriangles;
+        mGeomCount              = 0;
+        mIndicesCount   = 0;
+        mIndicesIndex   = -1;
+        mTexture                = NULL;
+        mTEOffset               = -1;
+
+        mBackupMem = NULL;
+
+        setDrawable(drawablep);
+        mVObjp = objp;
+
+        mReferenceIndex = -1;
+        mAlphaFade = 0.f;
+
+        mFaceColor = LLColor4(1,0,0,1);
+}
+
+
+void LLFace::destroy()
+{
+        mDrawablep = NULL;
+        mVObjp = NULL;
+
+        if (mDrawPoolp)
+        {
+                mDrawPoolp->removeFace(this);
+                mDrawPoolp = NULL;
+        }
+
+        // Remove light and blocker list references
+
+        delete[] mBackupMem;
+        mBackupMem = NULL;
+}
+
+
+// static
+void LLFace::initClass()
+{
+}
+
+void LLFace::setWorldMatrix(const LLMatrix4 &mat)
+{
+        llerrs << "Faces on this drawable are not independently modifiable\n" << llendl;
+}
+
+
+void LLFace::setDirty()
+{
+        mGeneration = DIRTY;
+}
+
+void LLFace::setPool(LLDrawPool* new_pool, LLViewerImage *texturep)
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+        
+        if (!new_pool)
+        {
+                llerrs << "Setting pool to null!" << llendl;
+        }
+
+        if (new_pool != mDrawPoolp)
+        {
+                // Remove from old pool
+                if (mDrawPoolp)
+                {
+                        mDrawPoolp->removeFace(this);
+                        mSkipRender = FALSE;
+                        mNextFace = NULL;
+
+                        // Invalidate geometry (will get rebuilt next frame)
+                        setDirty();
+                        if (mDrawablep)
+                        {
+                                gPipeline.markRebuild(mDrawablep, LLDrawable::REBUILD_ALL, TRUE);
+                        }
+                }
+                if (isState(BACKLIST))
+                {
+                        delete[] mBackupMem;
+                        mBackupMem = NULL;
+                        clearState(BACKLIST);
+                }
+                mGeomIndex = -1;
+
+                // Add to new pool
+                if (new_pool)
+                {
+                        new_pool->addFace(this);
+                }
+                mDrawPoolp = new_pool;
+
+        }
+        mTexture = texturep;
+}
+
+
+void LLFace::setTEOffset(const S32 te_offset)
+{
+        mTEOffset = te_offset;
+}
+
+
+void LLFace::setFaceColor(const LLColor4& color)
+{
+        mFaceColor = color;
+        setState(USE_FACE_COLOR);
+}
+
+void LLFace::unsetFaceColor()
+{
+        clearState(USE_FACE_COLOR);
+}
+
+void LLFace::setDrawable(LLDrawable *drawable)
+{
+        mDrawablep  = drawable;
+        mXform      = &drawable->mXform;
+}
+
+S32 LLFace::allocBackupMem()
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+        
+        S32 size = 0;
+        size += mIndicesCount * 4;
+        size += mGeomCount * mDrawPoolp->getStride();
+
+        if (mDrawPoolp->mDataMaskNIL & LLDrawPool::DATA_VERTEX_WEIGHTS_MASK)
+        {
+                size += mGeomCount * mDrawPoolp->sDataSizes[LLDrawPool::DATA_VERTEX_WEIGHTS];
+        }
+
+        if (mDrawPoolp->mDataMaskNIL & LLDrawPool::DATA_CLOTHING_WEIGHTS_MASK)
+        {
+                size += mGeomCount * mDrawPoolp->sDataSizes[LLDrawPool::DATA_CLOTHING_WEIGHTS];
+        }
+
+        delete[] mBackupMem;
+        mBackupMem = new U8[size];
+        return size;
+}
+
+
+void LLFace::setSize(const S32 num_vertices, const S32 num_indices)
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+        
+        if (getState() & SHARED_GEOM)
+        {
+                mGeomCount    = num_vertices;
+                mIndicesCount = num_indices;
+                return; // Shared, don't allocate or do anything with memory
+        }
+        if (num_vertices != (S32)mGeomCount || num_indices != (S32)mIndicesCount)
+        {
+                setDirty();
+
+                delete[] mBackupMem;
+                mBackupMem = NULL;
+                clearState(BACKLIST);
+
+                mGeomCount    = num_vertices;
+                mIndicesCount = num_indices;
+        }
+
+}
+
+BOOL LLFace::reserveIfNeeded()
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+        
+        if (getDirty())
+        {
+                if (isState(BACKLIST))
+                {
+                        llwarns << "Reserve on backlisted object!" << llendl;
+                }
+
+                if (0 == mGeomCount)
+                {
+                        //llwarns << "Reserving zero bytes for face!" << llendl;
+                        mGeomCount = 0;
+                        mIndicesCount = 0;
+                        return FALSE;
+                }
+
+                mGeomIndex        = mDrawPoolp->reserveGeom(mGeomCount);
+                // (reserveGeom() always returns a valid index)
+                mIndicesIndex = mDrawPoolp->reserveInd (mIndicesCount);
+                mGeneration   = mDrawPoolp->mGeneration;
+        }
+
+        return TRUE;
+}
+
+void LLFace::unReserve()
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+        
+        if (!(isState(SHARED_GEOM)))
+        {
+                mGeomIndex    = mDrawPoolp->unReserveGeom(mGeomIndex, mGeomCount);
+                mIndicesIndex = mDrawPoolp->unReserveInd(mIndicesIndex, mIndicesCount);
+        }
+}
+
+//============================================================================
+
+S32 LLFace::getGeometryAvatar(
+                                                LLStrider<LLVector3> &vertices,
+                                                LLStrider<LLVector3> &normals,
+                                                LLStrider<LLVector3> &binormals,
+                                                LLStrider<LLVector2> &tex_coords,
+                                                LLStrider<F32>           &vertex_weights,
+                                                LLStrider<LLVector4> &clothing_weights)
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+        
+        if (mGeomCount <= 0)
+        {
+                return -1;
+        }
+        
+        if (isState(BACKLIST))
+        {
+                if (!mBackupMem)
+                {
+                        llerrs << "No backup memory for backlist" << llendl;
+                }
+
+                vertices        = (LLVector3*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_VERTICES]);
+                normals         = (LLVector3*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_NORMALS]);
+                binormals       = (LLVector3*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_BINORMALS]);
+                tex_coords      = (LLVector2*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_TEX_COORDS0]);
+                clothing_weights = (LLVector4*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_CLOTHING_WEIGHTS]);
+                vertex_weights  = (F32*)(mBackupMem + (4 * mIndicesCount) + (mGeomCount * mDrawPoolp->getStride()));
+                tex_coords.setStride( mDrawPoolp->getStride());
+                vertices.setStride( mDrawPoolp->getStride());
+                normals.setStride( mDrawPoolp->getStride());
+                binormals.setStride( mDrawPoolp->getStride());
+                clothing_weights.setStride( mDrawPoolp->getStride());
+
+                return 0;
+        }
+        else
+        {
+                if (!reserveIfNeeded())
+                {
+                        return -1;
+                }
+
+                llassert(mGeomIndex >= 0);
+                llassert(mIndicesIndex >= 0);
+        
+                mDrawPoolp->getVertexStrider      (vertices, mGeomIndex);
+                mDrawPoolp->getNormalStrider      (normals, mGeomIndex);
+                mDrawPoolp->getBinormalStrider    (binormals, mGeomIndex);
+                mDrawPoolp->getTexCoordStrider    (tex_coords, mGeomIndex);
+                mDrawPoolp->getVertexWeightStrider(vertex_weights, mGeomIndex);
+                mDrawPoolp->getClothingWeightStrider(clothing_weights, mGeomIndex);
+
+                mDrawPoolp->setDirty();
+
+                llassert(mGeomIndex >= 0);
+                return mGeomIndex;
+        }
+}
+
+S32 LLFace::getGeometryTerrain(
+                                                LLStrider<LLVector3> &vertices,
+                                                LLStrider<LLVector3> &normals,
+                                                LLStrider<LLColor4U> &colors,
+                                                LLStrider<LLVector2> &texcoords0,
+                                                LLStrider<LLVector2> &texcoords1,
+                                                U32 *&indicesp)
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+        
+        if (mGeomCount <= 0)
+        {
+                return -1;
+        }
+        
+        if (isState(BACKLIST))
+        {
+                if (!mBackupMem)
+                {
+                        printDebugInfo();
+                        llerrs << "No backup memory for face" << llendl;
+                }
+                vertices  = (LLVector3*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_VERTICES]);
+                normals   = (LLVector3*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_NORMALS]);
+                colors   =  (LLColor4U*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_COLORS]);
+                texcoords0= (LLVector2*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_TEX_COORDS0]);
+                texcoords1= (LLVector2*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_TEX_COORDS1]);
+                texcoords0.setStride(mDrawPoolp->getStride());
+                texcoords1.setStride(mDrawPoolp->getStride());
+                vertices.setStride( mDrawPoolp->getStride());
+                normals.setStride( mDrawPoolp->getStride());
+                colors.setStride( mDrawPoolp->getStride());
+                indicesp    = (U32*)mBackupMem;
+
+                return 0;
+        }
+        else
+        {
+                if (!reserveIfNeeded())
+                {
+                        llinfos << "Get geometry failed!" << llendl;
+                        return -1;
+                }
+
+                llassert(mGeomIndex >= 0);
+                llassert(mIndicesIndex >= 0);
+        
+                mDrawPoolp->getVertexStrider(vertices, mGeomIndex);
+                mDrawPoolp->getNormalStrider(normals, mGeomIndex);
+                mDrawPoolp->getColorStrider(colors, mGeomIndex);
+                mDrawPoolp->getTexCoordStrider(texcoords0, mGeomIndex, 0);
+                mDrawPoolp->getTexCoordStrider(texcoords1, mGeomIndex, 1);
+
+                indicesp = mDrawPoolp->getIndices(mIndicesIndex);
+
+                mDrawPoolp->setDirty();
+
+                llassert(mGeomIndex >= 0);
+                return mGeomIndex;
+        }
+}
+
+S32 LLFace::getGeometry(LLStrider<LLVector3> &vertices, LLStrider<LLVector3> &normals,
+                                            LLStrider<LLVector2> &tex_coords, U32 *&indicesp)
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+        
+        if (mGeomCount <= 0)
+        {
+                return -1;
+        }
+        
+        if (isState(BACKLIST))
+        {
+                if (!mBackupMem)
+                {
+                        printDebugInfo();
+                        llerrs << "No backup memory for face" << llendl;
+                }
+                vertices  = (LLVector3*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_VERTICES]);
+                normals   = (LLVector3*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_NORMALS]);
+                tex_coords= (LLVector2*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_TEX_COORDS0]);
+                tex_coords.setStride(mDrawPoolp->getStride());
+                vertices.setStride( mDrawPoolp->getStride());
+                normals.setStride( mDrawPoolp->getStride());
+                indicesp    = (U32*)mBackupMem;
+
+                return 0;
+        }
+        else
+        {
+                if (!reserveIfNeeded())
+                {
+                        return -1;
+                }
+
+                llassert(mGeomIndex >= 0);
+                llassert(mIndicesIndex >= 0);
+        
+                mDrawPoolp->getVertexStrider(vertices,   mGeomIndex);
+                if (mDrawPoolp->mDataMaskIL & LLDrawPool::DATA_NORMALS_MASK)
+                {
+                        mDrawPoolp->getNormalStrider(normals,    mGeomIndex);
+                }
+                if (mDrawPoolp->mDataMaskIL & LLDrawPool::DATA_TEX_COORDS0_MASK)
+                {
+                        mDrawPoolp->getTexCoordStrider(tex_coords, mGeomIndex);
+                }
+
+                indicesp      =mDrawPoolp->getIndices   (mIndicesIndex);
+
+                mDrawPoolp->setDirty();
+
+                llassert(mGeomIndex >= 0);
+                return mGeomIndex;
+        }
+}
+
+S32 LLFace::getGeometryColors(LLStrider<LLVector3> &vertices, LLStrider<LLVector3> &normals,
+                                                          LLStrider<LLVector2> &tex_coords, LLStrider<LLColor4U> &colors,
+                                                          U32 *&indicesp)
+{
+        S32 res = getGeometry(vertices, normals, tex_coords, indicesp);
+        if (res >= 0)
+        {
+                getColors(colors);
+        }
+        return res;
+}
+
+S32 LLFace::getGeometryMultiTexture(
+        LLStrider<LLVector3> &vertices, 
+        LLStrider<LLVector3> &normals,
+        LLStrider<LLVector3> &binormals,
+        LLStrider<LLVector2> &tex_coords0,
+        LLStrider<LLVector2> &tex_coords1,
+        U32 *&indicesp)
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+        
+        if (mGeomCount <= 0)
+        {
+                return -1;
+        }
+        
+        if (isState(BACKLIST))
+        {
+                if (!mBackupMem)
+                {
+                        printDebugInfo();
+                        llerrs << "No backup memory for face" << llendl;
+                }
+                vertices        = (LLVector3*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_VERTICES]);
+                normals         = (LLVector3*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_NORMALS]);
+                tex_coords0     = (LLVector2*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_TEX_COORDS0]);
+                tex_coords0.setStride(  mDrawPoolp->getStride() );
+                vertices.setStride(             mDrawPoolp->getStride() );
+                normals.setStride(              mDrawPoolp->getStride() );
+                if (mDrawPoolp->mDataMaskIL & LLDrawPool::DATA_BINORMALS_MASK)
+                {
+                        binormals       = (LLVector3*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_BINORMALS]);
+                        binormals.setStride(    mDrawPoolp->getStride() );
+                }
+                if (mDrawPoolp->mDataMaskIL & LLDrawPool::DATA_TEX_COORDS1_MASK)
+                {
+                        tex_coords1     = (LLVector2*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_TEX_COORDS1]);
+                        tex_coords1.setStride(  mDrawPoolp->getStride() );
+                }
+                indicesp        = (U32*)mBackupMem;
+
+                return 0;
+        }
+        else
+        {
+                if (!reserveIfNeeded())
+                {
+                        return -1;
+                }
+
+                llassert(mGeomIndex >= 0);
+                llassert(mIndicesIndex >= 0);
+        
+                mDrawPoolp->getVertexStrider(vertices, mGeomIndex);
+                if (mDrawPoolp->mDataMaskIL & LLDrawPool::DATA_NORMALS_MASK)
+                {
+                        mDrawPoolp->getNormalStrider(normals, mGeomIndex);
+                }
+                if (mDrawPoolp->mDataMaskIL & LLDrawPool::DATA_TEX_COORDS0_MASK)
+                {
+                        mDrawPoolp->getTexCoordStrider(tex_coords0, mGeomIndex);
+                }
+                if (mDrawPoolp->mDataMaskIL & LLDrawPool::DATA_BINORMALS_MASK)
+                {
+                        mDrawPoolp->getBinormalStrider(binormals,  mGeomIndex);
+                }
+                if (mDrawPoolp->mDataMaskIL & LLDrawPool::DATA_TEX_COORDS1_MASK)
+                {
+                        mDrawPoolp->getTexCoordStrider(tex_coords1, mGeomIndex, 1);
+                }
+                indicesp = mDrawPoolp->getIndices(mIndicesIndex);
+
+                mDrawPoolp->setDirty();
+
+                llassert(mGeomIndex >= 0);
+                return mGeomIndex;
+        }
+}
+
+void LLFace::updateCenterAgent()
+{
+        mCenterAgent = mCenterLocal * getRenderMatrix();
+}
+
+void LLFace::renderForSelect() const
+{
+        if(mGeomIndex < 0 || mDrawablep.isNull())
+        {
+                return;
+        }
+        if (mVObjp->mGLName)
+        {
+                S32 name = mVObjp->mGLName;
+
+                LLColor4U color((U8)(name >> 16), (U8)(name >> 8), (U8)name);
+#if 0 // *FIX: Postponing this fix until we have texcoord pick info...
+                if (mTEOffset != -1)
+                {
+                        color.mV[VALPHA] = (U8)(getTextureEntry()->getColor().mV[VALPHA] * 255.f);
+                }
+#endif
+                glColor4ubv(color.mV);
+
+                if (mVObjp->getPCode() == LL_PCODE_VOLUME)
+                {
+                        LLVOVolume *volp;
+                        volp = (LLVOVolume *)(LLViewerObject*)mVObjp;
+                        if (volp->getNumFaces() == 1 && !volp->getVolumeChanged())
+                        {
+                                // We need to special case the coalesced face model.
+                                S32 num_vfs = volp->getVolume()->getNumFaces();
+                                S32 offset = 0;
+                                S32 i;
+                                
+                                for (i = 0; i < num_vfs; i++)
+                                {
+                                        if (gPickFaces)
+                                        {
+                                                // mask off high 4 bits (16 total possible faces)
+                                                color.mV[0] &= 0x0f;
+                                                color.mV[0] |= (i & 0x0f) << 4;
+                                                glColor4ubv(color.mV);
+                                        }
+                                        S32 count = volp->getVolume()->getVolumeFace(i).mIndices.size();
+                                        if (isState(GLOBAL))
+                                        {
+                                                glDrawElements(mPrimType, count, GL_UNSIGNED_INT, getRawIndices() + offset); 
+                                        }
+                                        else
+                                        {
+                                                glPushMatrix();
+                                                glMultMatrixf((float*)getRenderMatrix().mMatrix);
+                                                glDrawElements(mPrimType, count, GL_UNSIGNED_INT, getRawIndices() + offset); 
+                                                glPopMatrix();
+                                        }
+                                        offset += count;
+                                }
+                                // We're done, return.
+                                return;
+                        }
+
+                        // We don't have coalesced faces, do this the normal way.
+                }
+
+                if (gPickFaces && mTEOffset != -1)
+                {
+                        // mask off high 4 bits (16 total possible faces)
+                        color.mV[0] &= 0x0f;
+                        color.mV[0] |= (mTEOffset & 0x0f) << 4;
+                        glColor4ubv(color.mV);
+                }
+
+                if (mIndicesCount)
+                {
+                        if (isState(GLOBAL))
+                        {
+                                glDrawElements(mPrimType, mIndicesCount, GL_UNSIGNED_INT, getRawIndices()); 
+                        }
+                        else
+                        {
+                                glPushMatrix();
+                                glMultMatrixf((float*)getRenderMatrix().mMatrix);
+                                glDrawElements(mPrimType, mIndicesCount, GL_UNSIGNED_INT, getRawIndices()); 
+                                glPopMatrix();
+                        }
+                }
+                else if (mGeomCount > 0)
+                {
+                        if (isState(GLOBAL))
+                        {
+                                glDrawArrays(mPrimType, mGeomIndex, mGeomCount); 
+                        }
+                        else
+                        {
+                                glPushMatrix();
+                                glMultMatrixf((float*)getRenderMatrix().mMatrix);
+                                glDrawArrays(mPrimType, mGeomIndex, mGeomCount); 
+                                glPopMatrix();
+                        }
+                }
+        }
+}
+
+void LLFace::renderSelected(LLImageGL *imagep, const LLColor4& color, const S32 offset, const S32 count)
+{
+        if(mGeomIndex < 0 || mDrawablep.isNull())
+        {
+                return;
+        }
+        if (mGeomCount > 0)
+        {
+                LLGLSPipelineAlpha gls_pipeline_alpha;
+                glColor4fv(color.mV);
+
+                LLViewerImage::bindTexture(imagep);
+                if (!isState(GLOBAL))
+                {
+                        // Apply the proper transform for non-global objects.
+                        glPushMatrix();
+                        glMultMatrixf((float*)getRenderMatrix().mMatrix);
+                }
+
+                if (sSafeRenderSelect)
+                {
+                        glBegin(mPrimType);
+                        if (count)
+                        {
+                                for (S32 i = offset; i < offset + count; i++)
+                                {
+                                        LLVector2 tc = mDrawPoolp->getTexCoord(mDrawPoolp->getIndex(getIndicesStart() + i), 0);
+                                        glTexCoord2fv(tc.mV);
+                                        LLVector3 normal = mDrawPoolp->getNormal(mDrawPoolp->getIndex(getIndicesStart() + i));
+                                        glNormal3fv(normal.mV);
+                                        LLVector3 vertex = mDrawPoolp->getVertex(mDrawPoolp->getIndex(getIndicesStart() + i));
+                                        glVertex3fv(vertex.mV);
+                                }
+                        }
+                        else
+                        {
+                                for (U32 i = 0; i < getIndicesCount(); i++)
+                                {
+                                        LLVector2 tc = mDrawPoolp->getTexCoord(mDrawPoolp->getIndex(getIndicesStart() + i), 0);
+                                        glTexCoord2fv(tc.mV);
+                                        LLVector3 normal = mDrawPoolp->getNormal(mDrawPoolp->getIndex(getIndicesStart() + i));
+                                        glNormal3fv(normal.mV);
+                                        LLVector3 vertex = mDrawPoolp->getVertex(mDrawPoolp->getIndex(getIndicesStart() + i));
+                                        glVertex3fv(vertex.mV);
+                                }
+                        }
+                        glEnd();
+
+                        if( gSavedSettings.getBOOL("ShowTangentBasis") )
+                        {
+                                S32 start;
+                                S32 end;
+                                if (count)
+                                {
+                                        start = offset;
+                                        end = offset + count;
+                                }
+                                else
+                                {
+                                        start = 0;
+                                        end = getIndicesCount();
+                                }
+
+                                LLGLSNoTexture gls_no_texture;
+                                glColor4f(1, 1, 1, 1);
+                                glBegin(GL_LINES);
+                                for (S32 i = start; i < end; i++)
+                                {
+                                        LLVector3 vertex = mDrawPoolp->getVertex(mDrawPoolp->getIndex(getIndicesStart() + i));
+                                        glVertex3fv(vertex.mV);
+                                        LLVector3 normal = mDrawPoolp->getNormal(mDrawPoolp->getIndex(getIndicesStart() + i));
+                                        glVertex3fv( (vertex + normal * 0.1f).mV );
+                                }
+                                glEnd();
+
+                                if (mDrawPoolp->mDataMaskIL & LLDrawPool::DATA_BINORMALS_MASK)
+                                {
+                                        glColor4f(0, 1, 0, 1);
+                                        glBegin(GL_LINES);
+                                        for (S32 i = start; i < end; i++)
+                                        {
+                                                LLVector3 vertex = mDrawPoolp->getVertex(mDrawPoolp->getIndex(getIndicesStart() + i));
+                                                glVertex3fv(vertex.mV);
+                                                LLVector3 binormal = mDrawPoolp->getBinormal(mDrawPoolp->getIndex(getIndicesStart() + i));
+                                                glVertex3fv( (vertex + binormal * 0.1f).mV );
+                                        }
+                                        glEnd();
+                                }
+                        }
+                }
+                else
+                {
+                        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+                        glEnableClientState(GL_VERTEX_ARRAY);
+                        glEnableClientState(GL_NORMAL_ARRAY);
+                        if (count)
+                        {
+                                if (mIndicesCount > 0)
+                                {
+                                        glDrawElements(mPrimType, count, GL_UNSIGNED_INT, getRawIndices() + offset); 
+                                }
+                                else
+                                {
+                                        llerrs << "Rendering non-indexed volume face!" << llendl;
+                                        glDrawArrays(mPrimType, mGeomIndex, mGeomCount); 
+                                }
+                        }
+                        else
+                        {
+                                if (mIndicesCount > 0)
+                                {
+                                        glDrawElements(mPrimType, mIndicesCount, GL_UNSIGNED_INT, getRawIndices()); 
+                                }
+                                else
+                                {
+                                        glDrawArrays(mPrimType, mGeomIndex, mGeomCount); 
+                                }
+                        }
+                        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+                        glDisableClientState(GL_VERTEX_ARRAY);
+                        glDisableClientState(GL_NORMAL_ARRAY);
+                }
+
+                if (!isState(GLOBAL))
+                {
+                        // Restore the tranform for non-global objects
+                        glPopMatrix();
+                }
+        }
+}
+
+void LLFace::renderSelectedUV(const S32 offset, const S32 count)
+{
+        LLUUID uv_img_red_blue_id(gViewerArt.getString("uv_test1.tga"));
+        LLUUID uv_img_green_id(gViewerArt.getString("uv_test2.tga"));
+        LLViewerImage* red_blue_imagep = gImageList.getImage(uv_img_red_blue_id, TRUE, TRUE);
+        LLViewerImage* green_imagep = gImageList.getImage(uv_img_green_id, TRUE, TRUE);
+
+        LLGLSObjectSelect object_select;
+        LLGLEnable blend(GL_BLEND);
+        LLGLEnable texture(GL_TEXTURE_2D);
+
+        if (!mDrawPoolp || !getIndicesCount() || getIndicesStart() < 0)
+        {
+                return;
+        }
+        for (S32 pass = 0; pass < 2; pass++)
+        {
+                static F32 bias = 0.f;
+                static F32 factor = -10.f;
+                if (mGeomCount > 0)
+                {
+                        glColor4fv(LLColor4::white.mV);
+
+                        if (pass == 0)
+                        {
+                                LLViewerImage::bindTexture(red_blue_imagep);
+                        }
+                        else // pass == 1
+                        {
+                                glBlendFunc(GL_ONE, GL_ONE);
+                                LLViewerImage::bindTexture(green_imagep);
+                                glMatrixMode(GL_TEXTURE);
+                                glPushMatrix();
+                                glScalef(256.f, 256.f, 1.f);
+                        }
+                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+
+                        if (!isState(GLOBAL))
+                        {
+                                // Apply the proper transform for non-global objects.
+                                glMatrixMode(GL_MODELVIEW);
+                                glPushMatrix();
+                                glMultMatrixf((float*)getRenderMatrix().mMatrix);
+                        }
+
+                        glEnable(GL_POLYGON_OFFSET_FILL);
+                        glPolygonOffset(factor, bias);
+                        if (sSafeRenderSelect)
+                        {
+                                glBegin(mPrimType);
+                                if (count)
+                                {
+                                        for (S32 i = offset; i < offset + count; i++)
+                                        {
+                                                LLVector2 tc = mDrawPoolp->getTexCoord(mDrawPoolp->getIndex(getIndicesStart() + i), 0);
+                                                glTexCoord2fv(tc.mV);
+                                                LLVector3 vertex = mDrawPoolp->getVertex(mDrawPoolp->getIndex(getIndicesStart() + i));
+                                                glVertex3fv(vertex.mV);
+                                        }
+                                }
+                                else
+                                {
+                                        for (U32 i = 0; i < getIndicesCount(); i++)
+                                        {
+                                                LLVector2 tc = mDrawPoolp->getTexCoord(mDrawPoolp->getIndex(getIndicesStart() + i), 0);
+                                                glTexCoord2fv(tc.mV);
+                                                LLVector3 vertex = mDrawPoolp->getVertex(mDrawPoolp->getIndex(getIndicesStart() + i));
+                                                glVertex3fv(vertex.mV);
+                                        }
+                                }
+                                glEnd();
+                        }
+                        else
+                        {
+                                glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+                                glEnableClientState(GL_VERTEX_ARRAY);
+                                llassert(mGeomIndex >= 0);
+                                if (count)
+                                {
+                                        if (mIndicesCount > 0)
+                                        {
+                                                glDrawElements(mPrimType, count, GL_UNSIGNED_INT, getRawIndices() + offset); 
+                                        }
+                                        else
+                                        {
+                                                llerrs << "Rendering non-indexed volume face!" << llendl;
+                                                glDrawArrays(mPrimType, mGeomIndex, mGeomCount); 
+                                        }
+                                }
+                                else
+                                {
+                                        if (mIndicesCount > 0)
+                                        {
+                                                glDrawElements(mPrimType, mIndicesCount, GL_UNSIGNED_INT, getRawIndices()); 
+                                        }
+                                        else
+                                        {
+                                                glDrawArrays(mPrimType, mGeomIndex, mGeomCount); 
+                                        }
+                                }
+                                glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+                                glDisableClientState(GL_VERTEX_ARRAY);
+                        }
+
+                        glDisable(GL_POLYGON_OFFSET_FILL);
+                        if (!isState(GLOBAL))
+                        {
+                                // Restore the tranform for non-global objects
+                                glPopMatrix();
+                        }
+                        if (pass == 1)
+                        {
+                                glMatrixMode(GL_TEXTURE);
+                                glPopMatrix();
+                                glMatrixMode(GL_MODELVIEW);
+                                glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA);
+                        }
+                }
+        }
+        
+        //restore blend func
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+}
+
+
+void LLFace::printDebugInfo() const
+{
+        LLDrawPool *poolp = getPool();
+        llinfos << "Object: " << getViewerObject()->mID << llendl;
+        if (getDrawable())
+        {
+                llinfos << "Type: " << LLPrimitive::pCodeToString(getDrawable()->getVObj()->getPCode()) << llendl;
+        }
+        if (getTexture())
+        {
+                llinfos << "Texture: " << getTexture() << " Comps: " << (U32)getTexture()->getComponents() << llendl;
+        }
+        else
+        {
+                llinfos << "No texture: " << llendl;
+        }
+
+        llinfos << "Face: " << this << llendl;
+        if (isState(BACKLIST))
+        {
+                llinfos << "Backlisted!" << llendl;
+        }
+        llinfos << "State: " << getState() << llendl;
+        llinfos << "Geom Index Data:" << llendl;
+        llinfos << "--------------------" << llendl;
+        llinfos << "GI: " << mGeomIndex << " Count:" << mGeomCount << llendl;
+        llinfos << "Face Index Data:" << llendl;
+        llinfos << "--------------------" << llendl;
+        llinfos << "II: " << mIndicesIndex << " Count:" << mIndicesCount << llendl;
+        llinfos << llendl;
+
+        poolp->printDebugInfo();
+
+        S32 pool_references = 0;
+        for (std::vector<LLFace*>::iterator iter = poolp->mReferences.begin();
+                 iter != poolp->mReferences.end(); iter++)
+        {
+                LLFace *facep = *iter;
+                if (facep == this)
+                {
+                        llinfos << "Pool reference: " << pool_references << llendl;
+                        pool_references++;
+                }
+        }
+
+        if (pool_references != 1)
+        {
+                llinfos << "Incorrect number of pool references!" << llendl;
+        }
+
+
+        llinfos << "Indices:" << llendl;
+        llinfos << "--------------------" << llendl;
+
+        const U32 *indicesp = getRawIndices();
+        S32 indices_count = getIndicesCount();
+        S32 geom_start = getGeomStart();
+
+        for (S32 i = 0; i < indices_count; i++)
+        {
+                llinfos << i << ":" << indicesp[i] << ":" << (S32)(indicesp[i] - geom_start) << llendl;
+        }
+        llinfos << llendl;
+
+        llinfos << "Vertices:" << llendl;
+        llinfos << "--------------------" << llendl;
+        for (S32 i = 0; i < mGeomCount; i++)
+        {
+                llinfos << mGeomIndex + i << ":" << poolp->getVertex(mGeomIndex + i) << llendl;
+        }
+        llinfos << llendl;
+}
+
+S32 LLFace::backup()
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+        
+        if (isState(BACKLIST))
+        {
+                llwarns << "Face is already backed up in LLFace::backup!" << llendl;
+                return mGeomCount;
+        }
+        if (mGeomIndex < 0)
+        {
+                // flexible objects can cause this
+                //llwarns << "No geometry to back-up" << llendl;
+                return 0;
+        }
+        
+        S32 size = 0;
+        if (!mBackupMem)
+        {
+                size = allocBackupMem();
+        }
+        else
+        {
+                llerrs << "Memory already backed up!" << llendl;
+        }
+
+        // Need to flag this, because we can allocate a non-zero backup mem if we have indices and no geometry.
+
+        if (mGeomCount || mIndicesCount)
+        {
+                setState(BACKLIST);
+#if !RELEASE_FOR_DOWNLOAD
+                if (mGeomIndex < 0 || mIndicesIndex < 0)
+                {
+                        llerrs << "LLFace::backup" << llendl;
+                }
+#endif
+                
+                U32 *backup  = (U32*)mBackupMem;
+                S32 stride   = mDrawPoolp->getStride();
+                
+                U32 *index   = mDrawPoolp->getIndices(mIndicesIndex);
+                for (U32 i=0;i<mIndicesCount;i++)
+                {
+                        *backup++ = index[i] - mGeomIndex;
+                        index[i]  = 0;
+                }
+
+                if (!mGeomCount)
+                {
+                        return mGeomCount;
+                }
+                //
+                // Don't change the order of these unles you change the corresponding getGeometry calls that read out of
+                // backup memory, and also the other of the backup/restore pair!
+                //
+                memcpy(backup, (mDrawPoolp->mMemory.getMem() + mGeomIndex * stride), mGeomCount * stride);
+                backup += mGeomCount * stride / 4;
+
+                if (mDrawPoolp->mDataMaskNIL & LLDrawPool::DATA_CLOTHING_WEIGHTS_MASK)
+                {
+                        memcpy(backup, &mDrawPoolp->getClothingWeight(mGeomIndex), mGeomCount * sizeof(LLVector4));
+                        backup += mGeomCount*4;
+                }
+
+                if (mDrawPoolp->mDataMaskNIL & LLDrawPool::DATA_VERTEX_WEIGHTS_MASK)
+                {
+                        memcpy(backup, &mDrawPoolp->getVertexWeight(mGeomIndex), mGeomCount * sizeof(F32));
+                        backup += mGeomCount;
+                }
+
+                llassert((U8*)backup - mBackupMem == size);
+
+                unReserve();
+        }
+        return mGeomCount;
+}
+
+void LLFace::restore()
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+        
+        if (!isState(BACKLIST))
+        {
+                // flexible objects can cause this
+//              printDebugInfo();
+//              llwarns << "not backlisted for restore" << llendl;
+                return;
+        }
+        if (!mGeomCount || !mBackupMem) 
+        {
+                if (!mBackupMem)
+                {
+                        printDebugInfo();
+                        llwarns  << "no backmem for restore" << llendl;
+                }
+
+                clearState(BACKLIST);
+                return;
+        }
+
+        S32 stride     = mDrawPoolp->getStride();
+        mGeomIndex     = mDrawPoolp->reserveGeom(mGeomCount);
+        mIndicesIndex  = mDrawPoolp->reserveInd (mIndicesCount);
+        mGeneration    = mDrawPoolp->mGeneration;
+
+        llassert(mGeomIndex >= 0);
+        llassert(mIndicesIndex >= 0);
+        
+        U32 *backup  = (U32*)mBackupMem;
+        U32 *index   = mDrawPoolp->getIndices(mIndicesIndex);
+
+        for (U32 i=0;i<mIndicesCount;i++)
+        {
+                S32  ind = mGeomIndex + *backup;
+                index[i] = ind;
+                backup++;
+        }
+
+        mDrawPoolp->mMemory.copyToMem(mGeomIndex * stride, (U8 *)backup, mGeomCount * stride);
+        backup += mGeomCount * stride / 4;
+
+        //
+        // Don't change the order of these unles you change the corresponding getGeometry calls that read out of
+        // backup memory, and also the other of the backup/restore pair!
+        //
+        if (mDrawPoolp->mDataMaskNIL & LLDrawPool::DATA_CLOTHING_WEIGHTS_MASK)
+        {
+                mDrawPoolp->mClothingWeights.copyToMem(mGeomIndex, (U8 *)backup, mGeomCount);
+                backup += mGeomCount*4;
+        }
+
+        if (mDrawPoolp->mDataMaskNIL & LLDrawPool::DATA_VERTEX_WEIGHTS_MASK)
+        {
+                mDrawPoolp->mWeights.copyToMem(mGeomIndex, (U8 *)backup, mGeomCount);
+                backup += mGeomCount;
+        }
+
+        delete[] mBackupMem;
+        mBackupMem = NULL;
+        clearState(BACKLIST);
+}
+
+// Transform the texture coordinates for this face.
+static void xform(LLVector2 &tex_coord, F32 cosAng, F32 sinAng, F32 offS, F32 offT, F32 magS, F32 magT)
+{
+        // New, good way
+        F32 s = tex_coord.mV[0];
+        F32 t = tex_coord.mV[1];
+
+        // Texture transforms are done about the center of the face.
+        s -= 0.5; 
+        t -= 0.5;
+
+        // Handle rotation
+        F32 temp = s;
+        s  = s     * cosAng + t * sinAng;
+        t  = -temp * sinAng + t * cosAng;
+
+        // Then scale
+        s *= magS;
+        t *= magT;
+
+        // Then offset
+        s += offS + 0.5f; 
+        t += offT + 0.5f;
+
+        tex_coord.mV[0] = s;
+        tex_coord.mV[1] = t;
+}
+
+
+BOOL LLFace::genVolumeTriangles(const LLVolume &volume, S32 f,
+                                                                const LLMatrix4& mat, const LLMatrix3& inv_trans_mat, BOOL global_volume)
+{
+        const LLVolumeFace &vf = volume.getVolumeFace(f);
+        S32 num_vertices = (S32)vf.mVertices.size();
+        S32 num_indices = (S32)vf.mIndices.size();
+        setSize(num_vertices, num_indices);
+        
+        return genVolumeTriangles(volume, f, f, mat, inv_trans_mat, global_volume);
+}
+
+BOOL LLFace::genVolumeTriangles(const LLVolume &volume, S32 fstart, S32 fend, 
+                                                                const LLMatrix4& mat_vert, const LLMatrix3& mat_normal, const BOOL global_volume)
+{
+        LLMemType mt1(LLMemType::MTYPE_DRAWABLE);
+
+        if (!mDrawablep)
+        {
+                return TRUE;
+        }
+
+        S32 index_offset;
+        F32 r, os, ot, ms, mt, cos_ang, sin_ang;
+        LLStrider<LLVector3> vertices;
+        LLStrider<LLVector3> normals;
+        LLStrider<LLVector3> binormals;
+        LLStrider<LLVector2> tex_coords;
+        LLStrider<LLVector2> tex_coords2;
+        U32                 *indicesp = NULL;
+
+        BOOL bump = mDrawPoolp && (mDrawPoolp->mDataMaskIL & LLDrawPool::DATA_BINORMALS_MASK);
+        BOOL is_static = mDrawablep->isStatic();
+        BOOL is_global = is_static;
+        
+        if (bump)
+        {
+                index_offset = getGeometryMultiTexture(vertices, normals, binormals, tex_coords, tex_coords2, indicesp);
+        }
+        else
+        {
+                index_offset = getGeometry(vertices, normals, tex_coords, indicesp);
+        }
+        if (-1 == index_offset)
+        {
+                return TRUE;
+        }
+        
+        LLVector3 center_sum(0.f, 0.f, 0.f);
+        
+        LLVector3 render_pos;
+        
+        if (mDrawablep->isState(LLDrawable::REBUILD_TCOORD) &&
+                global_volume)
+        {
+                render_pos = mVObjp->getRenderPosition();
+        }
+        
+        setPrimType(LLTriangles);
+        
+        if (is_global)
+        {
+                setState(GLOBAL);
+        }
+        else
+        {
+                clearState(GLOBAL);
+        }
+        
+        LLVector3 min, max;
+        LLVector2 tmin, tmax;
+        
+        BOOL grab_first_vert = TRUE;
+        BOOL grab_first_tcoord = TRUE;
+        
+        for (S32 vol_face = fstart; vol_face <= fend; vol_face++)
+        {
+                const LLVolumeFace &vf = volume.getVolumeFace(vol_face);
+                S32 num_vertices = (S32)vf.mVertices.size();
+                S32 num_indices = (S32)vf.mIndices.size();
+                llassert(num_indices > 0);
+                
+                U8  bump_code;          
+                const LLTextureEntry *tep = mVObjp->getTE(vol_face);
+                
+                if (tep)
+                {
+                        bump_code = tep->getBumpmap();
+                        r  = tep->getRotation();
+                        os = tep->mOffsetS;
+                        ot = tep->mOffsetT;
+                        ms = tep->mScaleS;
+                        mt = tep->mScaleT;
+                        cos_ang = cos(r);
+                        sin_ang = sin(r);
+                }
+                else
+                {
+                        bump_code = 0;
+                        cos_ang = 1.0f;
+                        sin_ang = 0.0f;
+                        os = 0.0f;
+                        ot = 0.0f;
+                        ms = 1.0f;
+                        mt = 1.0f;
+                }
+
+                if (mDrawablep->isState(LLDrawable::REBUILD_VOLUME))
+                {
+                        // VERTICES & NORMALS                   
+                        for (S32 i = 0; i < num_vertices; i++)
+                        {
+                                LLVector3 v;
+                                v = vf.mVertices[i].mPosition * mat_vert;
+
+                                LLVector3 normal = vf.mVertices[i].mNormal * mat_normal;
+                                normal.normVec();
+                                *normals++ = normal;
+                                
+                                *vertices++ = v;
+                                
+                                if (grab_first_vert)
+                                {
+                                        grab_first_vert = FALSE;
+                                        min = max = v;
+                                }
+                                else
+                                {
+                                        for (U32 j = 0; j < 3; j++)
+                                        {
+                                                if (v.mV[j] < min.mV[j])
+                                                {
+                                                        min.mV[j] = v.mV[j];
+                                                }
+                                                if (v.mV[j] > max.mV[j])
+                                                {
+                                                        max.mV[j] = v.mV[j];
+                                                }
+                                        }
+                                }
+                        }
+                        for (S32 i = 0; i < num_indices; i++)
+                        {
+                                S32 index = vf.mIndices[i] + index_offset;
+                                llassert(index >= 0 && (i != 1 || *(indicesp-1)!=(U32)index));
+                                *indicesp++ = index;
+                        }
+                }
+
+                if ((mDrawablep->isState(LLDrawable::REBUILD_TCOORD)) ||
+                        ((bump || getTextureEntry()->getTexGen() != 0) && mDrawablep->isState(LLDrawable::REBUILD_VOLUME)))
+                {
+                        // TEX COORDS AND BINORMALS
+                        LLVector3 binormal_dir( -sin_ang, cos_ang, 0 );
+                        LLVector3 bump_s_primary_light_ray;
+                        LLVector3 bump_t_primary_light_ray;
+                        if (bump)
+                        {
+                                F32 offset_multiple; 
+                                switch( bump_code )
+                                {
+                                  case BE_NO_BUMP:
+                                        offset_multiple = 0.f;
+                                        break;
+                                  case BE_BRIGHTNESS:
+                                  case BE_DARKNESS:
+                                        if( mTexture.notNull() && mTexture->getHasGLTexture())
+                                        {
+                                                // Offset by approximately one texel
+                                                S32 cur_discard = mTexture->getDiscardLevel();
+                                                S32 max_size = llmax( mTexture->getWidth(), mTexture->getHeight() );
+                                                max_size <<= cur_discard;
+                                                const F32 ARTIFICIAL_OFFSET = 2.f;
+                                                offset_multiple = ARTIFICIAL_OFFSET / (F32)max_size;
+                                        }
+                                        else
+                                        {
+                                                offset_multiple = 1.f/256;
+                                        }
+                                        break;
+
+                                  default:  // Standard bumpmap textures.  Assumed to be 256x256
+                                        offset_multiple = 1.f / 256;
+                                        break;
+                                }
+
+                                F32 s_scale = 1.f;
+                                F32 t_scale = 1.f;
+                                if( tep )
+                                {
+                                        tep->getScale( &s_scale, &t_scale );
+                                }
+                                LLVector3   sun_ray  = gSky.getSunDirection();
+                                LLVector3   moon_ray = gSky.getMoonDirection();
+                                LLVector3& primary_light_ray = (sun_ray.mV[VZ] > 0) ? sun_ray : moon_ray;
+                                bump_s_primary_light_ray = offset_multiple * s_scale * primary_light_ray;
+                                bump_t_primary_light_ray = offset_multiple * t_scale * primary_light_ray;
+                        }
+                        
+                        for (S32 i = 0; i < num_vertices; i++)
+                        {
+                                LLVector2 tc = vf.mVertices[i].mTexCoord;
+
+                                U8 texgen = getTextureEntry()->getTexGen();
+                                if (texgen != LLTextureEntry::TEX_GEN_DEFAULT)
+                                {
+
+                                        LLVector3 vec = vf.mVertices[i].mPosition; //-vf.mCenter;
+                                        
+                                        if (global_volume)
+                                        {       
+                                                vec -= render_pos;
+                                        }
+                                        else
+                                        {
+                                                vec.scaleVec(mVObjp->getScale());
+                                        }
+
+                                        switch (texgen)
+                                        {
+                                                case LLTextureEntry::TEX_GEN_PLANAR:
+                                                        planarProjection(tc, vf.mVertices[i], vf.mCenter, vec);
+                                                        break;
+                                                case LLTextureEntry::TEX_GEN_SPHERICAL:
+                                                        sphericalProjection(tc, vf.mVertices[i], vf.mCenter, vec);
+                                                        break;
+                                                case LLTextureEntry::TEX_GEN_CYLINDRICAL:
+                                                        cylindricalProjection(tc, vf.mVertices[i], vf.mCenter, vec);
+                                                        break;
+                                                default:
+                                                        break;
+                                        }               
+                                }
+                                xform(tc, cos_ang, sin_ang, os, ot, ms, mt);
+                                *tex_coords++ = tc;
+                                if (grab_first_tcoord)
+                                {
+                                        grab_first_tcoord = FALSE;
+                                        tmin = tmax = tc;
+                                }
+                                else
+                                {
+                                        for (U32 j = 0; j < 2; j++)
+                                        {
+                                                if (tmin.mV[j] > tc.mV[j])
+                                                {
+                                                        tmin.mV[j] = tc.mV[j];
+                                                }
+                                                else if (tmax.mV[j] < tc.mV[j])
+                                                {
+                                                        tmax.mV[j] = tc.mV[j];
+                                                }
+                                        }
+                                }
+                                if (bump)
+                                {
+                                        LLVector3 tangent = vf.mVertices[i].mBinormal % vf.mVertices[i].mNormal;
+                                        LLMatrix3 tangent_to_object;
+                                        tangent_to_object.setRows(tangent, vf.mVertices[i].mBinormal, vf.mVertices[i].mNormal);
+                                        LLVector3 binormal = binormal_dir * tangent_to_object;
+
+                                        if (!global_volume)
+                                        {
+                                                binormal = binormal * mat_normal;
+                                        }
+                                        binormal.normVec();
+                                        tangent.normVec();
+                                        
+                                        tc += LLVector2( bump_s_primary_light_ray * tangent, bump_t_primary_light_ray * binormal );
+                                        *tex_coords2++ = tc;
+
+                                        *binormals++ = binormal;
+                                }
+                        }
+                }
+
+                index_offset += num_vertices;
+
+                center_sum += vf.mCenter * mat_vert;
+        }
+        
+        center_sum /= (F32)(fend-fstart+1);
+        
+        if (is_static)
+        {
+                mCenterAgent = center_sum;
+                mCenterLocal = mCenterAgent - mDrawablep->getPositionAgent();
+        }
+        else
+        {
+                mCenterLocal = center_sum;
+                updateCenterAgent();
+        }
+        
+        if (!grab_first_vert && mDrawablep->isState(LLDrawable::REBUILD_VOLUME))
+        {
+                mExtents[0] = min;
+                mExtents[1] = max;
+        }
+        
+        if (!grab_first_tcoord && mDrawablep->isState(LLDrawable::REBUILD_TCOORD))
+        {
+                mTexExtents[0] = tmin;
+                mTexExtents[1] = tmax;
+        }
+        
+        return TRUE;
+}
+
+BOOL LLFace::genLighting(const LLVolume* volume, const LLDrawable* drawablep, S32 fstart, S32 fend, 
+                                                 const LLMatrix4& mat_vert, const LLMatrix3& mat_normal, BOOL do_lighting)
+{
+        if (drawablep->isLight())
+        {
+                do_lighting = FALSE;
+        }
+        
+        if (!((mDrawPoolp->mDataMaskIL) & LLDrawPool::DATA_COLORS_MASK))
+        {
+                return FALSE;
+        }
+        if (mGeomIndex < 0)
+        {
+                return FALSE; // no geometry
+        }
+        LLStrider<LLColor4U> colorsp;
+        S32 idx = getColors(colorsp);
+        if (idx < 0)
+        {
+                return FALSE;
+        }
+        
+        for (S32 vol_face = fstart; vol_face <= fend; vol_face++)
+        {
+                const LLVolumeFace &vf = volume->getVolumeFace(vol_face);
+                S32 num_vertices = (S32)vf.mVertices.size();
+
+                if (isState(FULLBRIGHT) || !do_lighting)
+                {
+                        for (S32 i = 0; i < num_vertices; i++)
+                        {
+                                (*colorsp++).setToBlack();
+                        }
+                }
+                else
+                {
+                        for (S32 i = 0; i < num_vertices; i++)
+                        {
+                                LLVector3 vertex = vf.mVertices[i].mPosition * mat_vert;
+                                LLVector3 normal = vf.mVertices[i].mNormal * mat_normal;
+                                normal.normVec();
+                
+                                LLColor4 color;
+                                for (LLDrawable::drawable_set_t::const_iterator iter = drawablep->mLightSet.begin();
+                                         iter != drawablep->mLightSet.end(); ++iter)
+                                {
+                                        LLDrawable* light_drawable = *iter;
+                                        LLVOVolume* light = light_drawable->getVOVolume();
+                                        if (!light)
+                                        {
+                                                continue;
+                                        }
+                                        LLColor4 light_color;
+                                        light->calcLightAtPoint(vertex, normal, light_color);
+                                        color += light_color;
+                                }
+
+                                color.mV[3] = 1.0f;
+
+                                (*colorsp++).setVecScaleClamp(color);
+                        }
+                }
+        }
+        return TRUE;
+}
+
+BOOL LLFace::genShadows(const LLVolume* volume, const LLDrawable* drawablep, S32 fstart, S32 fend, 
+                                                 const LLMatrix4& mat_vert, const LLMatrix3& mat_normal, BOOL use_shadow_factor)
+{
+        if (drawablep->isLight())
+        {
+                return FALSE;
+        }
+        
+        if (!((mDrawPoolp->mDataMaskIL) & LLDrawPool::DATA_COLORS_MASK))
+        {
+                return FALSE;
+        }
+        if (mGeomIndex < 0)
+        {
+                return FALSE; // no geometry
+        }
+        LLStrider<LLColor4U> colorsp;
+        S32 idx = getColors(colorsp);
+        if (idx < 0)
+        {
+                return FALSE;
+        }
+        
+        for (S32 vol_face = fstart; vol_face <= fend; vol_face++)
+        {
+                const LLVolumeFace &vf = volume->getVolumeFace(vol_face);
+                S32 num_vertices = (S32)vf.mVertices.size();
+
+                if (isState(FULLBRIGHT))
+                {
+                        continue;
+                }
+
+                for (S32 i = 0; i < num_vertices; i++)
+                {
+                        LLVector3 vertex = vf.mVertices[i].mPosition * mat_vert;
+                        LLVector3 normal = vf.mVertices[i].mNormal * mat_normal;
+                        normal.normVec();
+                                
+                        U8 shadow;
+
+                        if (use_shadow_factor)
+                        {
+                                shadow = (U8) (drawablep->getSunShadowFactor() * 255);
+                        }
+                        else
+                        {
+                                shadow = 255;
+                        }
+                
+                        (*colorsp++).mV[3] = shadow;    
+                }
+        }
+        return TRUE;
+}
+
+BOOL LLFace::verify(const U32* indices_array) const
+{
+        BOOL ok = TRUE;
+        // First, check whether the face data fits within the pool's range.
+        if ((mGeomIndex < 0) || (mGeomIndex + mGeomCount) > (S32)getPool()->getVertexCount())
+        {
+                ok = FALSE;
+                llinfos << "Face not within pool range!" << llendl;
+        }
+
+        S32 indices_count = (S32)getIndicesCount();
+        S32 geom_start = getGeomStart();
+        S32 geom_count = mGeomCount;
+
+        if (!indices_count)
+        {
+                return TRUE;
+        }
+        
+        if (indices_count > LL_MAX_INDICES_COUNT)
+        {
+                ok = FALSE;
+                llinfos << "Face has bogus indices count" << llendl;
+        }
+        
+        const U32 *indicesp = indices_array ? indices_array + mIndicesIndex : getRawIndices();
+
+        for (S32 i = 0; i < indices_count; i++)
+        {
+                S32 delta = indicesp[i] - geom_start;
+                if (0 > delta)
+                {
+                        llwarns << "Face index too low!" << llendl;
+                        llinfos << "i:" << i << " Index:" << indicesp[i] << " GStart: " << geom_start << llendl;
+                        ok = FALSE;
+                }
+                else if (delta >= geom_count)
+                {
+                        llwarns << "Face index too high!" << llendl;
+                        llinfos << "i:" << i << " Index:" << indicesp[i] << " GEnd: " << geom_start + geom_count << llendl;
+                        ok = FALSE;
+                }
+        }
+
+        if (!ok)
+        {
+                printDebugInfo();
+        }
+        return ok;
+}
+
+
+void LLFace::setViewerObject(LLViewerObject* objp)
+{
+        mVObjp = objp;
+}
+
+void LLFace::enableLights() const
+{
+        if (isState(FULLBRIGHT|HUD_RENDER))
+        {
+                gPipeline.enableLightsFullbright(LLColor4::white);
+        }
+        else if (mDrawablep->isState(LLDrawable::LIGHTING_BUILT))
+        {
+                gPipeline.enableLightsStatic(1.f);
+        }
+        else
+        {
+                gPipeline.enableLightsDynamic(1.f);
+        }
+        if (isState(LIGHT))
+        {
+                const LLVOVolume* vovolume = (const LLVOVolume*)(mDrawablep->getVObj());
+                gPipeline.setAmbient(vovolume->getLightColor());
+        }
+}
+
+const LLColor4& LLFace::getRenderColor() const
+{
+        if (isState(USE_FACE_COLOR))
+        {
+                  return mFaceColor; // Face Color
+        }
+        else
+        {
+                const LLTextureEntry* tep = getTextureEntry();
+                return (tep ? tep->getColor() : LLColor4::white);
+        }
+}
+        
+void LLFace::renderSetColor() const
+{
+        if (!LLDrawPool::LLOverrideFaceColor::sOverrideFaceColor)
+        {
+                const LLColor4* color = &(getRenderColor());
+                
+                if ((mDrawPoolp->mVertexShaderLevel > 0) && (mDrawPoolp->getMaterialAttribIndex() != 0))
+                {
+                        glVertexAttrib4fvARB(mDrawPoolp->getMaterialAttribIndex(), color->mV);
+                }
+                else
+                {
+                        glColor4fv(color->mV);
+                }
+        }
+}
+
+S32 LLFace::pushVertices(const U32* index_array) const
+{
+        U32 indices_count = mIndicesCount;
+        S32 ret = 0;
+#if ENABLE_FACE_LINKING
+        LLFace* next = mNextFace;
+#endif
+        
+        if (mGeomCount < gGLManager.mGLMaxVertexRange && (S32) indices_count < gGLManager.mGLMaxIndexRange)
+        {
+                LLFace* current = (LLFace*) this;
+                S32 geom_count = mGeomCount;
+#if ENABLE_FACE_LINKING
+                while (current)
+                {
+                        //chop up batch into implementation recommended sizes
+                        while (next &&
+                                   (current == next ||
+                                        ((S32) (indices_count + next->mIndicesCount) < gGLManager.mGLMaxIndexRange &&
+                                         geom_count + next->mGeomCount < gGLManager.mGLMaxVertexRange)))
+                        {
+                                indices_count += next->mIndicesCount;
+                                geom_count += next->mGeomCount;
+                                next = next->mNextFace;
+                        }
+#endif
+                        if (indices_count)
+                        {
+                                glDrawRangeElements(mPrimType, current->mGeomIndex, current->mGeomIndex + geom_count, indices_count, 
+                                                                                GL_UNSIGNED_INT, index_array + current->mIndicesIndex); 
+                        }
+                        ret += (S32) indices_count;
+                        indices_count = 0;
+                        geom_count = 0;
+#if ENABLE_FACE_LINKING
+                        current = next;
+                }
+#endif
+        }
+        else
+        {
+#if ENABLE_FACE_LINKING
+                while (next)
+                {
+                        indices_count += next->mIndicesCount;
+                        next = next->mNextFace;
+                }
+#endif
+                if (indices_count)
+                {
+                        glDrawElements(mPrimType, indices_count, GL_UNSIGNED_INT, index_array + mIndicesIndex); 
+                }
+                ret += (S32) indices_count;
+        }
+        
+        return ret;
+
+}
+
+const LLMatrix4& LLFace::getRenderMatrix() const
+{
+        return mDrawablep->getRenderMatrix();
+}
+
+S32 LLFace::renderElements(const U32 *index_array) const
+{
+        S32 ret = 0;
+        
+        if (isState(GLOBAL))
+        {       
+                ret = pushVertices(index_array);
+        }
+        else
+        {
+                glPushMatrix();
+                glMultMatrixf((float*)getRenderMatrix().mMatrix);
+                ret = pushVertices(index_array);
+                glPopMatrix();
+        }
+        
+        return ret;
+}
+
+S32 LLFace::renderIndexed(const U32 *index_array) const
+{
+        if (mSkipRender)
+        {
+                return 0;
+        }
+
+        if(mGeomIndex < 0 || mDrawablep.isNull())
+        {
+                return 0;
+        }
+        
+        renderSetColor();
+        return renderElements(index_array);
+}
+
+//============================================================================
+// From llface.inl
+
+S32 LLFace::getVertices(LLStrider<LLVector3> &vertices)
+{
+        if (!mGeomCount)
+        {
+                return -1;
+        }
+        if (isState(BACKLIST))
+        {
+                if (!mBackupMem)
+                {
+                        printDebugInfo();
+                        llerrs << "No backup memory for face" << llendl;
+                }
+                vertices = (LLVector3*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_VERTICES]);
+                vertices.setStride( mDrawPoolp->getStride());
+                return 0;
+        }
+        else
+        {
+                if (mGeomIndex >= 0) // flexible objects may not have geometry
+                {
+                        mDrawPoolp->getVertexStrider(vertices, mGeomIndex);
+                        mDrawPoolp->setDirty();
+                }
+                return mGeomIndex;
+        }
+}
+
+S32 LLFace::getColors(LLStrider<LLColor4U> &colors)
+{
+        if (!mGeomCount)
+        {
+                return -1;
+        }
+        if (isState(BACKLIST))
+        {
+                llassert(mBackupMem);
+                colors   = (LLColor4U*)(mBackupMem + (4 * mIndicesCount) + mDrawPoolp->mDataOffsets[LLDrawPool::DATA_COLORS]);
+                colors.setStride( mDrawPoolp->getStride());
+                return 0;
+        }
+        else
+        {
+                llassert(mGeomIndex >= 0);
+                mDrawPoolp->getColorStrider(colors, mGeomIndex);
+                return mGeomIndex;
+        }
+}
+
+S32     LLFace::getIndices(U32*  &indicesp)
+{
+        if (isState(BACKLIST))
+        {
+                indicesp = (U32*)mBackupMem;
+                return 0;
+        }
+        else
+        {
+                indicesp = mDrawPoolp->getIndices(mIndicesIndex);
+                llassert(mGeomIndex >= 0 && indicesp[0] != indicesp[1]);
+                return mGeomIndex;
+        }
+}
+
+void LLFace::link(LLFace* facep)
+{
+#if ENABLE_FACE_LINKING
+        mNextFace = facep;
+        facep->mSkipRender = TRUE;
+#endif
+}
+
+LLVector3 LLFace::getPositionAgent() const
+{
+        if (mDrawablep->isStatic())
+        {
+                return mCenterAgent;
+        }
+        else
+        {
+                return mCenterLocal * getRenderMatrix();
+        }
+}