36 files changed, 2883 insertions, 1378 deletions

diff --git a/linden/indra/llrender/CMakeLists.txt b/linden/indra/llrender/CMakeLists.txt
index 76858d9..0bdb55f 100644
--- a/linden/indra/llrender/CMakeLists.txt
+++ b/linden/indra/llrender/CMakeLists.txt
@@ -9,6 +9,8 @@ include(LLImage)
 include(LLMath)
 include(LLRender)
 include(LLWindow)
+include(LLXML)
+include(LLVFS)
 
 include_directories(
     ${FREETYPE_INCLUDE_DIRS}
@@ -17,19 +19,21 @@ include_directories(
     ${LLMATH_INCLUDE_DIRS}
     ${LLRENDER_INCLUDE_DIRS}
     ${LLWINDOW_INCLUDE_DIRS}
+    ${LLXML_INCLUDE_DIRS}
+    ${LLVFS_INCLUDE_DIRS}
     )
 
 set(llrender_SOURCE_FILES
     llcubemap.cpp
     llfont.cpp
     llfontgl.cpp
+    llfontbitmapcache.cpp
+    llfontregistry.cpp
     llgldbg.cpp
     llglslshader.cpp
     llimagegl.cpp
     llpostprocess.cpp
-    llrender.cpp
     llrendersphere.cpp
-    llrendertarget.cpp
     llshadermgr.cpp
     llvertexbuffer.cpp
     )
@@ -40,6 +44,8 @@ set(llrender_HEADER_FILES
     llcubemap.h
     llfontgl.h
     llfont.h
+    llfontbitmapcache.h
+    llfontregistry.h
     llgl.h
     llgldbg.h
     llglheaders.h
@@ -50,7 +56,6 @@ set(llrender_HEADER_FILES
     llpostprocess.h
     llrender.h
     llrendersphere.h
-    llrendertarget.h
     llshadermgr.h
     llvertexbuffer.h
     )
@@ -63,6 +68,7 @@ list(APPEND llrender_SOURCE_FILES ${llrender_HEADER_FILES})
 if (SERVER AND NOT WINDOWS AND NOT DARWIN)
   copy_server_sources(
       llgl
+      llrender
       )
 
 
@@ -78,6 +84,8 @@ if (SERVER AND NOT WINDOWS AND NOT DARWIN)
 else (SERVER AND NOT WINDOWS AND NOT DARWIN)
   list(APPEND llrender_SOURCE_FILES
       llgl.cpp
+      llrender.cpp
+      llrendertarget.cpp
       )
 endif (SERVER AND NOT WINDOWS AND NOT DARWIN)
 add_library (llrender ${llrender_SOURCE_FILES})
diff --git a/linden/indra/llrender/llcubemap.cpp b/linden/indra/llrender/llcubemap.cpp
index 60215f0..754d90c 100644
--- a/linden/indra/llrender/llcubemap.cpp
+++ b/linden/indra/llrender/llcubemap.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -39,7 +40,6 @@
 #include "v3dmath.h"
 #include "m3math.h"
 #include "m4math.h"
-#include "llcamera.h"
 
 #include "llrender.h"
 
@@ -85,9 +85,9 @@ void LLCubeMap::initGL()
                 // Not initialized, do stuff.
                 if (mImages[0].isNull())
                 {
-                        GLuint texname = 0;
+                        U32 texname = 0;
                         
-                        glGenTextures(1, &texname);
+                        LLImageGL::generateTextures(1, &texname);
 
                         for (int i = 0; i < 6; i++)
                         {
@@ -97,9 +97,10 @@ void LLCubeMap::initGL()
                                 mImages[i]->createGLTexture(0, mRawImages[i], texname);
                                 
                                 gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_CUBE_MAP, texname); 
-                                mImages[i]->setClampCubemap (TRUE, TRUE, TRUE);
+                                mImages[i]->setAddressMode(LLTexUnit::TAM_CLAMP);
                                 stop_glerror();
                         }
+                        gGL.getTexUnit(0)->disable();
                 }
                 disable();
         }
@@ -311,8 +312,8 @@ void LLCubeMap::restoreMatrix()
 void LLCubeMap::setReflection (void)
 {
         gGL.getTexUnit(mTextureStage)->bindManual(LLTexUnit::TT_CUBE_MAP, getGLName());
-        mImages[0]->setMipFilterNearest (FALSE, FALSE);
-        mImages[0]->setClampCubemap (TRUE, TRUE);
+        mImages[0]->setFilteringOption(LLTexUnit::TFO_ANISOTROPIC);
+        mImages[0]->setAddressMode(LLTexUnit::TAM_CLAMP);
 }
 
 LLVector3 LLCubeMap::map(U8 side, U16 v_val, U16 h_val) const
diff --git a/linden/indra/llrender/llcubemap.h b/linden/indra/llrender/llcubemap.h
index 8c83e6e..c854485 100644
--- a/linden/indra/llrender/llcubemap.h
+++ b/linden/indra/llrender/llcubemap.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
diff --git a/linden/indra/llrender/llfont.cpp b/linden/indra/llrender/llfont.cpp
index d7310bd..9245803 100644
--- a/linden/indra/llrender/llfont.cpp
+++ b/linden/indra/llrender/llfont.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -52,6 +53,8 @@
 #include "llmath.h"     // Linden math
 #include "llstring.h"
 //#include "imdebug.h"
+#include "llfontbitmapcache.h"
+#include "llgl.h"
 
 FT_Render_Mode gFontRenderMode = FT_RENDER_MODE_NORMAL;
 
@@ -124,30 +127,28 @@ void LLFontList::addAtEnd(LLFont *font)
         this->push_back(font);
 }
 
-LLFont::LLFont(LLImageRaw *imagep)
-        : mRawImagep(imagep)
+LLFont::LLFont()
 {
+        mFontBitmapCachep = new LLFontBitmapCache;
+
         mValid = FALSE;
         mAscender = 0.f;
         mDescender = 0.f;
         mLineHeight = 0.f;
-        mBitmapWidth = 0;
-        mBitmapHeight = 0;
-        mCurrentOffsetX = 1;
-        mCurrentOffsetY = 1;
-        mMaxCharWidth = 0;
-        mMaxCharHeight = 0;
-        mNumComponents = 0;
+
         mFallbackFontp = NULL;
         mIsFallback = FALSE;
         mFTFace = NULL;
+
+        mRenderGlyphCount = 0;
+        mAddGlyphCount = 0;
+
+        mPointSize = 0;
 }
 
 
 LLFont::~LLFont()
 {
-        mRawImagep = NULL; // dereferences or deletes image
-
         // Clean up freetype libs.
         if (mFTFace)
                 FT_Done_Face(mFTFace);
@@ -155,11 +156,8 @@ LLFont::~LLFont()
 
         // Delete glyph info
         std::for_each(mCharGlyphInfoMap.begin(), mCharGlyphInfoMap.end(), DeletePairedPointer());
-}
 
-void LLFont::setRawImage(LLImageRaw *imagep)
-{
-        mRawImagep = imagep; // will delete old raw image if we have one and created it
+        // mFontBitmapCachep will be cleaned up by LLPointer destructor.
 }
 
 // virtual
@@ -203,7 +201,6 @@ BOOL LLFont::loadFace(const std::string& filename, const F32 point_size, const F
         }
 
         mIsFallback = is_fallback;
-        mNumComponents = components;
         F32 pixels_per_em = (point_size / 72.f)*vert_dpi; // Size in inches * dpi
 
         error = FT_Set_Char_Size(mFTFace,    /* handle to face object           */
@@ -233,8 +230,10 @@ BOOL LLFont::loadFace(const std::string& filename, const F32 point_size, const F
         mDescender = -mFTFace->descender * pixels_per_unit;
         mLineHeight = mFTFace->height * pixels_per_unit;
 
-        mMaxCharWidth = llround(0.5f + (x_max - x_min));
-        mMaxCharHeight = llround(0.5f + (y_max - y_min));
+        S32 max_char_width = llround(0.5f + (x_max - x_min));
+        S32 max_char_height = llround(0.5f + (y_max - y_min));
+
+        mFontBitmapCachep->init(components, max_char_width, max_char_height);
 
         if (!mFTFace->charmap)
         {
@@ -242,62 +241,20 @@ BOOL LLFont::loadFace(const std::string& filename, const F32 point_size, const F
                 FT_Set_Charmap(mFTFace, mFTFace->charmaps[0]);
         }
 
-        if (mRawImagep.isNull() && !mIsFallback)
-        {
-                mRawImagep = new LLImageRaw();
-        }
-
         if (!mIsFallback)
         {
-                // Place text into bitmap, and generate all necessary positions/
-                // offsets for the individual characters.
-
-                // calc width and height for mRawImagep (holds all characters)
-                // Guess for approximately 20*20 characters
-                S32 image_width = mMaxCharWidth * 20;
-                S32 pow_iw = 2;
-                while (pow_iw < image_width)
-                {
-                        pow_iw *= 2;
-                }
-                image_width = pow_iw;
-                image_width = llmin(512, image_width); // Don't make bigger than 512x512, ever.
-                S32 image_height = image_width;
-
-                //llinfos << "Guessing texture size of " << image_width << " pixels square" << llendl;
-
-                mRawImagep->resize(image_width, image_height, components);
-
-                mBitmapWidth = image_width;
-                mBitmapHeight = image_height;
-
-                switch (components)
-                {
-                case 1:
-                        mRawImagep->clear();
-                        break;
-                case 2:
-                        mRawImagep->clear(255, 0);
-                        break;
-                }
-
-                mCurrentOffsetX = 1;
-                mCurrentOffsetY = 1;
-
                 // Add the default glyph
                 addGlyph(0, 0);
         }
 
         mName = filename;
+        mPointSize = point_size;
 
         return TRUE;
 }
 
-
-void LLFont::resetBitmap()
+void LLFont::resetBitmapCache()
 {
-        llinfos << "Rebuilding bitmap for glyph" << llendl;
-
         // Iterate through glyphs and clear the mIsRendered flag
         for (char_glyph_info_map_t::iterator iter = mCharGlyphInfoMap.begin();
                  iter != mCharGlyphInfoMap.end(); ++iter)
@@ -307,9 +264,7 @@ void LLFont::resetBitmap()
                 //not just flushing the bitmap
                 iter->second->mMetricsValid = FALSE;
         }
-        mRawImagep->clear(255, 0);
-        mCurrentOffsetX = 1;
-        mCurrentOffsetY = 1;
+        mFontBitmapCachep->reset();
 
         // Add the empty glyph`5
         addGlyph(0, 0);
@@ -340,7 +295,7 @@ BOOL LLFont::hasGlyph(const llwchar wch) const
         }
 }
 
-BOOL LLFont::addChar(const llwchar wch)
+BOOL LLFont::addChar(const llwchar wch) const
 {
         if (mFTFace == NULL)
                 return FALSE;
@@ -375,7 +330,6 @@ BOOL LLFont::addChar(const llwchar wch)
         if (iter == mCharGlyphInfoMap.end() || !(iter->second->mIsRendered))
         {
                 BOOL result = addGlyph(wch, glyph_index);
-                //imdebug("luma b=8 w=%d h=%d t=%s %p", mRawImagep->getWidth(), mRawImagep->getHeight(), mName.c_str(), mRawImagep->getData());
                 return result;
         }
         return FALSE;
@@ -395,7 +349,7 @@ void LLFont::insertGlyphInfo(llwchar wch, LLFontGlyphInfo* gi) const
         }
 }
 
-BOOL LLFont::addGlyphFromFont(LLFont *fontp, const llwchar wch, const U32 glyph_index)
+BOOL LLFont::addGlyphFromFont(const LLFont *fontp, const llwchar wch, const U32 glyph_index) const
 {
         if (mFTFace == NULL)
                 return FALSE;
@@ -405,35 +359,15 @@ BOOL LLFont::addGlyphFromFont(LLFont *fontp, const llwchar wch, const U32 glyph_
         S32 width = fontp->mFTFace->glyph->bitmap.width;
         S32 height = fontp->mFTFace->glyph->bitmap.rows;
 
-        if ((mCurrentOffsetX + width + 1) > mRawImagep->getWidth())
-        {
-                if ((mCurrentOffsetY + 2*mMaxCharHeight + 2) > mBitmapHeight)
-                {
-                        // We're out of space in this texture - clear it an all of the glyphs
-                        // and start over again.  Easier than LRU and should work just as well
-                        // (just slightly slower on the rebuild).  As long as the texture has
-                        // enough room to hold all glyphs needed for a particular frame this
-                        // shouldn't be too slow.
-
-                        resetBitmap();
-
-                        // Need to rerender the glyph, as it's been overwritten by the default glyph.
-                        fontp->renderGlyph(glyph_index);
-                        width = fontp->mFTFace->glyph->bitmap.width;
-                        height = fontp->mFTFace->glyph->bitmap.rows;
-
-                        // We should have a reasonable offset for x and y, no need to check that it's in range
-                }
-                else
-                {
-                        mCurrentOffsetX = 1;
-                        mCurrentOffsetY += mMaxCharHeight + 1;
-                }
-        }
+        S32 pos_x, pos_y;
+        S32 bitmap_num;
+        mFontBitmapCachep->nextOpenPos(width, pos_x, pos_y, bitmap_num);
+        mAddGlyphCount++;
 
         LLFontGlyphInfo* gi = new LLFontGlyphInfo(glyph_index);
-        gi->mXBitmapOffset = mCurrentOffsetX;
-        gi->mYBitmapOffset = mCurrentOffsetY;
+        gi->mXBitmapOffset = pos_x;
+        gi->mYBitmapOffset = pos_y;
+        gi->mBitmapNum = bitmap_num;
         gi->mWidth = width;
         gi->mHeight = height;
         gi->mXBearing = fontp->mFTFace->glyph->bitmap_left;
@@ -482,24 +416,25 @@ BOOL LLFont::addGlyphFromFont(LLFont *fontp, const llwchar wch, const U32 glyph_
                         buffer_row_stride = width;
                 }
 
-                switch (mNumComponents)
+                switch (mFontBitmapCachep->getNumComponents())
                 {
                 case 1:
-                        mRawImagep->setSubImage(mCurrentOffsetX,
-                                                mCurrentOffsetY,
-                                                width,
-                                                height,
-                                                buffer_data,
-                                                buffer_row_stride,
-                                                TRUE);
+                        mFontBitmapCachep->getImageRaw(bitmap_num)->setSubImage(pos_x,
+                                                                                                                                        pos_y,
+                                                                                                                                        width,
+                                                                                                                                        height,
+                                                                                                                                        buffer_data,
+                                                                                                                                        buffer_row_stride,
+                                                                                                                                        TRUE);
                         break;
                 case 2:
-                        setSubImageLuminanceAlpha(mCurrentOffsetX,
-                                                  mCurrentOffsetY,
-                                                  width,
-                                                  height,
-                                                  buffer_data,
-                                                  buffer_row_stride);
+                        setSubImageLuminanceAlpha(pos_x,        
+                                                                          pos_y,
+                                                                          bitmap_num,
+                                                                          width,
+                                                                          height,
+                                                                          buffer_data,
+                                                                          buffer_row_stride);
                         break;
                 default:
                         break;
@@ -512,11 +447,10 @@ BOOL LLFont::addGlyphFromFont(LLFont *fontp, const llwchar wch, const U32 glyph_
                 // omit it from the font-image.
         }
         
-        mCurrentOffsetX += width + 1;
         return TRUE;
 }
 
-BOOL LLFont::addGlyph(const llwchar wch, const U32 glyph_index)
+BOOL LLFont::addGlyph(const llwchar wch, const U32 glyph_index) const
 {
         return addGlyphFromFont(this, wch, glyph_index);
 }
@@ -557,7 +491,7 @@ F32 LLFont::getXAdvance(const llwchar wch) const
         if (glyph_index)
         {
                 // This font has this glyph
-                (const_cast<LLFont *>(fontp))->renderGlyph(glyph_index);
+                fontp->renderGlyph(glyph_index);
 
                 // Create the entry if it's not there
                 char_glyph_info_map_t::iterator iter2 = mCharGlyphInfoMap.find(wch);
@@ -590,11 +524,11 @@ F32 LLFont::getXAdvance(const llwchar wch) const
         }
 
         // Last ditch fallback - no glyphs defined at all.
-        return (F32)mMaxCharWidth;
+        return (F32)mFontBitmapCachep->getMaxCharWidth();
 }
 
 
-void LLFont::renderGlyph(const U32 glyph_index)
+void LLFont::renderGlyph(const U32 glyph_index) const
 {
         if (mFTFace == NULL)
                 return;
@@ -603,6 +537,9 @@ void LLFont::renderGlyph(const U32 glyph_index)
         llassert(!error);
 
         error = FT_Render_Glyph(mFTFace->glyph, gFontRenderMode);
+
+        mRenderGlyphCount++;
+        
         llassert(!error);
 }
 
@@ -627,16 +564,20 @@ F32 LLFont::getXKerning(const llwchar char_left, const llwchar char_right) const
 }
 
 void LLFont::setSubImageLuminanceAlpha(const U32 x,
-                                       const U32 y,
-                                       const U32 width,
-                                       const U32 height,
-                                       const U8 *data,
-                                       S32 stride)
+                                                                           const U32 y,
+                                                                           const U32 bitmap_num,
+                                                                           const U32 width,
+                                                                           const U32 height,
+                                                                           const U8 *data,
+                                                                           S32 stride) const
 {
+        LLImageRaw *image_raw = mFontBitmapCachep->getImageRaw(bitmap_num);
+
         llassert(!mIsFallback);
-        llassert(mRawImagep->getComponents() == 2);
+        llassert(image_raw && (image_raw->getComponents() == 2));
 
-        U8 *target = mRawImagep->getData();
+        
+        U8 *target = image_raw->getData();
 
         if (!data)
         {
@@ -649,7 +590,7 @@ void LLFont::setSubImageLuminanceAlpha(const U32 x,
         U32 i, j;
         U32 to_offset;
         U32 from_offset;
-        U32 target_width = mRawImagep->getWidth();
+        U32 target_width = image_raw->getWidth();
         for (i = 0; i < height; i++)
         {
                 to_offset = (y + i)*target_width + x;
diff --git a/linden/indra/llrender/llfont.h b/linden/indra/llrender/llfont.h
index bce8d76..b423f7d 100644
--- a/linden/indra/llrender/llfont.h
+++ b/linden/indra/llrender/llfont.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -37,6 +38,9 @@
 #include "llmemory.h"
 #include "llstl.h"
 
+#include "llimagegl.h"
+#include "llfontbitmapcache.h"
+
 class LLImageRaw;
 class LLFontManager;
 class LLFont;
@@ -80,6 +84,7 @@ public:
         S32 mYBitmapOffset; // Offset to the origin in the bitmap
         S32 mXBearing;  // Distance from baseline to left in pixels
         S32 mYBearing;  // Distance from baseline to top in pixels
+        S32 mBitmapNum; // Which bitmap in the bitmap cache contains this glyph
 };
 
 // Used for lists of fallback fonts
@@ -91,14 +96,14 @@ public:
         void addAtEnd(LLFont *font);
 };
 
-
 class LLFont
 {
 public:
-        LLFont(LLImageRaw *imagep = NULL);
+        LLFont();
         virtual ~LLFont();
 
-        // is_fallback should be true for fallback fonts that aren't used to render directly (Unicode backup, primarily)
+        // is_fallback should be true for fallback fonts that aren't used
+        // to render directly (Unicode backup, primarily)
         virtual BOOL loadFace(const std::string& filename,
                                                         const F32 point_size,
                                                         const F32 vert_dpi,
@@ -108,7 +113,6 @@ public:
         void setFallbackFont(LLFontList *fontp)         { mFallbackFontp = fontp; }
 
         void setCharToGlyphMap(llwchar wch, U32 glyph_index) const;
-        void setRawImage( LLImageRaw *imagep );
 
         // Global font metrics - in units of pixels
         virtual F32 getLineHeight() const;
@@ -145,31 +149,29 @@ public:
         const LLFontGlyphInfo &getMetrics(const llwchar wc) const;
         F32 getXAdvance(const llwchar wc) const;
         F32 getXKerning(const llwchar char_left, const llwchar char_right) const; // Get the kerning between the two characters
+        virtual void reset() = 0;
+
 protected:
         virtual BOOL hasGlyph(const llwchar wch) const;         // Has a glyph for this character
-        virtual BOOL addChar(const llwchar wch);                // Add a new character to the font if necessary
-        virtual BOOL addGlyph(const llwchar wch, const U32 glyph_index);        // Add a new glyph to the existing font
-        virtual BOOL addGlyphFromFont(LLFont *fontp, const llwchar wch, const U32 glyph_index); // Add a glyph from this font to the other (returns the glyph_index, 0 if not found)
+        virtual BOOL addChar(const llwchar wch) const;          // Add a new character to the font if necessary
+        virtual BOOL addGlyph(const llwchar wch, const U32 glyph_index) const;  // Add a new glyph to the existing font
+        virtual BOOL addGlyphFromFont(const LLFont *fontp, const llwchar wch, const U32 glyph_index) const;     // Add a glyph from this font to the other (returns the glyph_index, 0 if not found)
 
         virtual LLFontGlyphInfo* getGlyphInfo(const llwchar wch) const;
 
         void insertGlyphInfo(llwchar wch, LLFontGlyphInfo* gi) const;
-        void renderGlyph(const U32 glyph_index);
+        void renderGlyph(const U32 glyph_index) const;
+
+        void resetBitmapCache();
 
-        void resetBitmap();     // Reset bitmap to contain only the null glyph
 protected:
         std::string mName;
+        F32 mPointSize;
         F32 mAscender;                  
         F32 mDescender;
         F32 mLineHeight;
 
-        S32 mNumComponents;
-        S32 mBitmapWidth;
-        S32 mBitmapHeight;
-        S32 mMaxCharWidth;
-        S32 mMaxCharHeight;
-        S32 mCurrentOffsetX;
-        S32 mCurrentOffsetY;
+        mutable LLPointer<LLFontBitmapCache> mFontBitmapCachep;
 
         LLFT_Face mFTFace;
 
@@ -181,14 +183,14 @@ protected:
 
         BOOL mValid;
         void setSubImageLuminanceAlpha(const U32 x,
-                                       const U32 y,
-                                       const U32 width,
-                                       const U32 height,
-                                       const U8 *data,
-                                       S32 stride = 0);
-
-private:
-        LLPointer<LLImageRaw> mRawImagep;       // Bitmaps of glyphs are stored here.
+                                                                   const U32 y,
+                                                                   const U32 bitmap_num,
+                                                                   const U32 width,
+                                                                   const U32 height,
+                                                                   const U8 *data,
+                                                                   S32 stride = 0) const;
+        mutable S32 mRenderGlyphCount;
+        mutable S32 mAddGlyphCount;
 };
 
 #endif // LL_FONT_
diff --git a/linden/indra/llrender/llfontbitmapcache.cpp b/linden/indra/llrender/llfontbitmapcache.cpp
new file mode 100644
index 0000000..052510e
--- /dev/null
+++ b/linden/indra/llrender/llfontbitmapcache.cpp
@@ -0,0 +1,169 @@
+/** 
+ * @file llfontbitmapcache.cpp
+ * @brief Storage for previously rendered glyphs.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llgl.h"
+#include "llfontbitmapcache.h"
+
+LLFontBitmapCache::LLFontBitmapCache():
+        mNumComponents(0),
+        mMaxCharWidth(0),
+        mMaxCharHeight(0),
+        mBitmapWidth(0),
+        mBitmapHeight(0),
+        mCurrentOffsetX(1),
+        mCurrentOffsetY(1),
+        mCurrentBitmapNum(-1)
+{
+}
+
+LLFontBitmapCache::~LLFontBitmapCache()
+{
+}
+
+void LLFontBitmapCache::init(S32 num_components,
+                                                         S32 max_char_width,
+                                                         S32 max_char_height)
+{
+        reset();
+        
+        mNumComponents = num_components;
+        mMaxCharWidth = max_char_width;
+        mMaxCharHeight = max_char_height;
+}
+
+LLImageRaw *LLFontBitmapCache::getImageRaw(U32 bitmap_num) const
+{
+        if ((bitmap_num < 0) || (bitmap_num >= mImageRawVec.size()))
+                return NULL;
+
+        return mImageRawVec[bitmap_num];
+}
+
+LLImageGL *LLFontBitmapCache::getImageGL(U32 bitmap_num) const
+{
+        if ((bitmap_num < 0) || (bitmap_num >= mImageGLVec.size()))
+                return NULL;
+
+        return mImageGLVec[bitmap_num];
+}
+
+
+BOOL LLFontBitmapCache::nextOpenPos(S32 width, S32 &pos_x, S32 &pos_y, S32& bitmap_num)
+{
+        if ((mBitmapNum<0) || (mCurrentOffsetX + width + 1) > mBitmapWidth)
+        {
+                if ((mBitmapNum<0) || (mCurrentOffsetY + 2*mMaxCharHeight + 2) > mBitmapHeight)
+                {
+                        // We're out of space in the current image, or no image
+                        // has been allocated yet.  Make a new one.
+                        mImageRawVec.push_back(new LLImageRaw);
+                        mBitmapNum = mImageRawVec.size()-1;
+                        LLImageRaw *image_raw = getImageRaw(mBitmapNum);
+
+                        // Make corresponding GL image.
+                        mImageGLVec.push_back(new LLImageGL(FALSE));
+                        LLImageGL *image_gl = getImageGL(mBitmapNum);
+                        
+                        S32 image_width = mMaxCharWidth * 20;
+                        S32 pow_iw = 2;
+                        while (pow_iw < image_width)
+                        {
+                                pow_iw *= 2;
+                        }
+                        image_width = pow_iw;
+                        image_width = llmin(512, image_width); // Don't make bigger than 512x512, ever.
+                        S32 image_height = image_width;
+
+                        image_raw->resize(image_width, image_height, mNumComponents);
+
+                        mBitmapWidth = image_width;
+                        mBitmapHeight = image_height;
+
+                        switch (mNumComponents)
+                        {
+                                case 1:
+                                        image_raw->clear();
+                                break;
+                                case 2:
+                                        image_raw->clear(255, 0);
+                                break;
+                        }
+
+                        // Start at beginning of the new image.
+                        mCurrentOffsetX = 1;
+                        mCurrentOffsetY = 1;
+
+                        // Attach corresponding GL texture.
+                        image_gl->createGLTexture(0, image_raw);
+                        gGL.getTexUnit(0)->bind(image_gl);
+                        image_gl->setFilteringOption(LLTexUnit::TFO_POINT); // was setMipFilterNearest(TRUE, TRUE);
+                }
+                else
+                {
+                        // Move to next row in current image.
+                        mCurrentOffsetX = 1;
+                        mCurrentOffsetY += mMaxCharHeight + 1;
+                }
+        }
+
+        pos_x = mCurrentOffsetX;
+        pos_y = mCurrentOffsetY;
+        bitmap_num = mBitmapNum;
+
+        mCurrentOffsetX += width + 1;
+
+        return TRUE;
+}
+
+void LLFontBitmapCache::destroyGL()
+{
+        for (std::vector<LLPointer<LLImageGL> >::iterator it = mImageGLVec.begin();
+                 it != mImageGLVec.end(); ++it)
+        {
+                (*it)->destroyGLTexture();
+        }
+}
+
+void LLFontBitmapCache::reset()
+{
+        mImageRawVec.clear();
+        mImageGLVec.clear();
+        
+        mBitmapWidth = 0,
+        mBitmapHeight = 0,
+        mCurrentOffsetX = 0,
+        mCurrentOffsetY = 0,
+        mCurrentBitmapNum = -1;
+}
+
diff --git a/linden/indra/llrender/llfontbitmapcache.h b/linden/indra/llrender/llfontbitmapcache.h
new file mode 100644
index 0000000..4beea0d
--- /dev/null
+++ b/linden/indra/llrender/llfontbitmapcache.h
@@ -0,0 +1,79 @@
+/** 
+ * @file llfontbitmapcache.h
+ * @brief Storage for previously rendered glyphs.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLFONTBITMAPCACHE_H
+#define LL_LLFONTBITMAPCACHE_H
+
+#include <vector>
+
+// Maintain a collection of bitmaps containing rendered glyphs.
+// Generalizes the single-bitmap logic from LLFont and LLFontGL.
+class LLFontBitmapCache: public LLRefCount
+{
+public:
+        LLFontBitmapCache();
+        ~LLFontBitmapCache();
+
+        // Need to call this once, before caching any glyphs.
+        void init(S32 num_components,
+                          S32 max_char_width,
+                          S32 max_char_height);
+
+        void reset();
+
+        BOOL nextOpenPos(S32 width, S32 &posX, S32 &posY, S32 &bitmapNum);
+        
+        void destroyGL();
+        
+        LLImageRaw *getImageRaw(U32 bitmapNum = 0) const;
+        LLImageGL *getImageGL(U32 bitmapNum = 0) const;
+        
+        S32 getMaxCharWidth() const { return mMaxCharWidth; }
+        S32 getNumComponents() const { return mNumComponents; }
+        S32 getBitmapWidth() const { return mBitmapWidth; }
+        S32 getBitmapHeight() const { return mBitmapHeight; }
+
+private:
+        S32 mNumComponents;
+        S32 mBitmapWidth;
+        S32 mBitmapHeight;
+        S32 mBitmapNum;
+        S32 mMaxCharWidth;
+        S32 mMaxCharHeight;
+        S32 mCurrentOffsetX;
+        S32 mCurrentOffsetY;
+        S32 mCurrentBitmapNum;
+        std::vector<LLPointer<LLImageRaw> >     mImageRawVec;
+        std::vector<LLPointer<LLImageGL> > mImageGLVec;
+};
+
+#endif //LL_LLFONTBITMAPCACHE_H
diff --git a/linden/indra/llrender/llfontgl.cpp b/linden/indra/llrender/llfontgl.cpp
index 526f1a9..beecb6b 100644
--- a/linden/indra/llrender/llfontgl.cpp
+++ b/linden/indra/llrender/llfontgl.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -35,6 +36,8 @@
 
 #include "llfont.h"
 #include "llfontgl.h"
+#include "llfontbitmapcache.h"
+#include "llfontregistry.h"
 #include "llgl.h"
 #include "llrender.h"
 #include "v4color.h"
@@ -50,32 +53,19 @@ F32 LLFontGL::sScaleY = 1.f;
 BOOL LLFontGL::sDisplayFont = TRUE ;
 std::string LLFontGL::sAppDir;
 
-LLFontGL* LLFontGL::sMonospace = NULL;
-LLFontGL* LLFontGL::sSansSerifSmall = NULL;
-LLFontGL* LLFontGL::sSansSerif = NULL;
-LLFontGL* LLFontGL::sSansSerifBig = NULL;
-LLFontGL* LLFontGL::sSansSerifHuge = NULL;
-LLFontGL* LLFontGL::sSansSerifBold = NULL;
-LLFontList*     LLFontGL::sMonospaceFallback = NULL;
-LLFontList*     LLFontGL::sSSFallback = NULL;
-LLFontList*     LLFontGL::sSSSmallFallback = NULL;
-LLFontList*     LLFontGL::sSSBigFallback = NULL;
-LLFontList*     LLFontGL::sSSHugeFallback = NULL;
-LLFontList*     LLFontGL::sSSBoldFallback = NULL;
 LLColor4 LLFontGL::sShadowColor(0.f, 0.f, 0.f, 1.f);
+LLFontRegistry* LLFontGL::sFontRegistry = NULL;
 
 LLCoordFont LLFontGL::sCurOrigin;
 std::vector<LLCoordFont> LLFontGL::sOriginStack;
 
-LLFontGL*& gExtCharFont = LLFontGL::sSansSerif;
-
 const F32 EXT_X_BEARING = 1.f;
 const F32 EXT_Y_BEARING = 0.f;
 const F32 EXT_KERNING = 1.f;
 const F32 PIXEL_BORDER_THRESHOLD = 0.0001f;
 const F32 PIXEL_CORRECTION_DISTANCE = 0.01f;
 
-const F32 PAD_AMT = 0.5f;
+const F32 PAD_UVY = 0.5f; // half of vertical padding between glyphs in the glyph texture
 const F32 DROP_SHADOW_SOFT_STRENGTH = 0.3f;
 
 F32 llfont_round_x(F32 x)
@@ -126,7 +116,6 @@ U8 LLFontGL::getStyleFromString(const std::string &style)
 LLFontGL::LLFontGL()
         : LLFont()
 {
-        init();
         clearEmbeddedChars();
 }
 
@@ -137,32 +126,30 @@ LLFontGL::LLFontGL(const LLFontGL &source)
 
 LLFontGL::~LLFontGL()
 {
-        mImageGLp = NULL;
-        mRawImageGLp = NULL;
         clearEmbeddedChars();
 }
 
-void LLFontGL::init()
+void LLFontGL::reset()
 {
-        if (mImageGLp.isNull())
-        {
-                mImageGLp = new LLImageGL(FALSE);
-                //RN: use nearest mipmap filtering to obviate the need to do pixel-accurate positioning
-                gGL.getTexUnit(0)->bind(mImageGLp);
-                // we allow bilinear filtering to get sub-pixel positioning for drop shadows
-                //mImageGLp->setMipFilterNearest(TRUE, TRUE);
-        }
-        if (mRawImageGLp.isNull())
+        if (!mIsFallback)
         {
-                mRawImageGLp = new LLImageRaw; // Note LLFontGL owns the image, not LLFont.
+                // This is the head of the list - need to rebuild ourself and all fallbacks.
+                loadFace(mName,mPointSize,sVertDPI,sHorizDPI,mFontBitmapCachep->getNumComponents(),mIsFallback);
+                if (mFallbackFontp==NULL)
+                {
+                        llwarns << "LLFontGL::reset(), no fallback fonts present" << llendl;
+                }
+                else
+                {
+                        for (LLFontList::iterator it = mFallbackFontp->begin();
+                                 it != mFallbackFontp->end();
+                                 ++it)
+                        {
+                                (*it)->reset();
+                        }
+                }
         }
-        setRawImage( mRawImageGLp );  
-}
-
-void LLFontGL::reset()
-{
-        init();
-        resetBitmap();
+        resetBitmapCache(); 
 }
 
 // static 
@@ -219,243 +206,48 @@ std::string LLFontGL::getFontPathLocal()
         return local_path;
 }
 
-//static
-bool LLFontGL::loadFaceFallback(LLFontList *fontlistp, const std::string& fontname, const F32 point_size)
+bool findOrCreateFont(LLFontGL*& fontp, const LLFontDescriptor& desc)
 {
-        std::string local_path = getFontPathLocal();
-        std::string sys_path = getFontPathSystem();
-        
-        // The fontname string may contain multiple font file names separated by semicolons.
-        // Break it apart and try loading each one, in order.
-        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
-        boost::char_separator<char> sep(";");
-        tokenizer tokens(fontname, sep);
-        tokenizer::iterator token_iter;
-
-        for(token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
-        {
-                LLFont *fontp = new LLFont();
-                std::string font_path = local_path + *token_iter;
-                if (!fontp->loadFace(font_path, point_size, sVertDPI, sHorizDPI, 2, TRUE))
-                {
-                        font_path = sys_path + *token_iter;
-                        if (!fontp->loadFace(font_path, point_size, sVertDPI, sHorizDPI, 2, TRUE))
-                        {
-                                LL_INFOS_ONCE("ViewerImages") << "Couldn't load font " << *token_iter << LL_ENDL;
-                                delete fontp;
-                                fontp = NULL;
-                        }
-                }
-                
-                if(fontp)
-                {
-                        fontlistp->addAtEnd(fontp);
-                }
-        }
-        
-        // We want to return true if at least one fallback font loaded correctly.
-        return (fontlistp->size() > 0);
+        // Don't delete existing fonts, if any, here, because they've
+        // already been deleted by LLFontRegistry::clear()
+        fontp = LLFontGL::getFont(desc);
+        return (fontp != NULL);
 }
 
-//static
-bool LLFontGL::loadFace(LLFontGL *fontp, const std::string& fontname, const F32 point_size, LLFontList *fallback_fontp)
-{
-        std::string local_path = getFontPathLocal();
-        std::string font_path = local_path + fontname;
-        if (!fontp->loadFace(font_path, point_size, sVertDPI, sHorizDPI, 2, FALSE))
-        {
-                std::string sys_path = getFontPathSystem();
-                font_path = sys_path + fontname;
-                if (!fontp->loadFace(font_path, point_size, sVertDPI, sHorizDPI, 2, FALSE))
-                {
-                        LL_WARNS("ViewerImages") << "Couldn't load font " << fontname << LL_ENDL;
-                        return false;
-                }
-        }
-
-        fontp->setFallbackFont(fallback_fontp);
-        return true;
-}
-
-
 // static
 BOOL LLFontGL::initDefaultFonts(F32 screen_dpi, F32 x_scale, F32 y_scale,
-                                const std::string& monospace_file, F32 monospace_size,
-                                const std::string& sansserif_file,
-                                const std::string& sanserif_fallback_file, F32 ss_fallback_scale,
-                                F32 small_size, F32 medium_size, F32 big_size, F32 huge_size,
-                                const std::string& sansserif_bold_file, F32 bold_size,
-                                const std::string& app_dir)
+                                                                const std::string& app_dir,
+                                                                const std::vector<std::string>& xui_paths)
 {
-        BOOL failed = FALSE;
+        bool succ = true;
         sVertDPI = (F32)llfloor(screen_dpi * y_scale);
         sHorizDPI = (F32)llfloor(screen_dpi * x_scale);
         sScaleX = x_scale;
         sScaleY = y_scale;
         sAppDir = app_dir;
 
-        //
-        // Monospace font
-        //
-
-        if (!sMonospace)
+        // Font registry init
+        if (!sFontRegistry)
         {
-                sMonospace = new LLFontGL();
+                sFontRegistry = new LLFontRegistry(xui_paths);
+                sFontRegistry->parseFontInfo("fonts.xml");
         }
         else
         {
-                sMonospace->reset();
-        }
-
-        if (sMonospaceFallback)
-        {
-                delete sMonospaceFallback;
-        }
-        sMonospaceFallback = new LLFontList();
-        if (!loadFaceFallback(
-                        sMonospaceFallback,
-                        sanserif_fallback_file,
-                        monospace_size * ss_fallback_scale))
-        {
-                delete sMonospaceFallback;
-                sMonospaceFallback = NULL;
+                sFontRegistry->reset();
         }
 
-        failed |= !loadFace(sMonospace, monospace_file, monospace_size, sMonospaceFallback);
-
-        //
-        // Sans-serif fonts
-        //
-        if(!sSansSerifHuge)
-        {
-                sSansSerifHuge = new LLFontGL();
-        }
-        else
-        {
-                sSansSerifHuge->reset();
-        }
-
-        if (sSSHugeFallback)
-        {
-                delete sSSHugeFallback;
-        }
-        sSSHugeFallback = new LLFontList();
-        if (!loadFaceFallback(
-                        sSSHugeFallback,
-                        sanserif_fallback_file,
-                        huge_size*ss_fallback_scale))
-        {
-                delete sSSHugeFallback;
-                sSSHugeFallback = NULL;
-        }
-
-        failed |= !loadFace(sSansSerifHuge, sansserif_file, huge_size, sSSHugeFallback);
-
-
-        if(!sSansSerifBig)
-        {
-                sSansSerifBig = new LLFontGL();
-        }
-        else
-        {
-                sSansSerifBig->reset();
-        }
-
-        if (sSSBigFallback)
-        {
-                delete sSSBigFallback;
-        }
-        sSSBigFallback = new LLFontList();
-        if (!loadFaceFallback(
-                        sSSBigFallback,
-                        sanserif_fallback_file,
-                        big_size*ss_fallback_scale))
-        {
-                delete sSSBigFallback;
-                sSSBigFallback = NULL;
-        }
-
-        failed |= !loadFace(sSansSerifBig, sansserif_file, big_size, sSSBigFallback);
-
-
-        if(!sSansSerif)
-        {
-                sSansSerif = new LLFontGL();
-        }
-        else
-        {
-                sSansSerif->reset();
-        }
-
-        if (sSSFallback)
-        {
-                delete sSSFallback;
-        }
-        sSSFallback = new LLFontList();
-        if (!loadFaceFallback(
-                        sSSFallback,
-                        sanserif_fallback_file,
-                        medium_size*ss_fallback_scale))
-        {
-                delete sSSFallback;
-                sSSFallback = NULL;
-        }
-        failed |= !loadFace(sSansSerif, sansserif_file, medium_size, sSSFallback);
-
-
-        if(!sSansSerifSmall)
-        {
-                sSansSerifSmall = new LLFontGL();
-        }
-        else
-        {
-                sSansSerifSmall->reset();
-        }
-
-        if(sSSSmallFallback)
-        {
-                delete sSSSmallFallback;
-        }
-        sSSSmallFallback = new LLFontList();
-        if (!loadFaceFallback(
-                        sSSSmallFallback,
-                        sanserif_fallback_file,
-                        small_size*ss_fallback_scale))
-        {
-                delete sSSSmallFallback;
-                sSSSmallFallback = NULL;
-        }
-        failed |= !loadFace(sSansSerifSmall, sansserif_file, small_size, sSSSmallFallback);
-
-
-        //
-        // Sans-serif bold
-        //
-        if(!sSansSerifBold)
-        {
-                sSansSerifBold = new LLFontGL();
-        }
-        else
-        {
-                sSansSerifBold->reset();
-        }
-
-        if (sSSBoldFallback)
-        {
-                delete sSSBoldFallback;
-        }
-        sSSBoldFallback = new LLFontList();
-        if (!loadFaceFallback(
-                        sSSBoldFallback,
-                        sanserif_fallback_file,
-                        medium_size*ss_fallback_scale))
-        {
-                delete sSSBoldFallback;
-                sSSBoldFallback = NULL;
-        }
-        failed |= !loadFace(sSansSerifBold, sansserif_bold_file, medium_size, sSSBoldFallback);
-
-        return !failed;
+        // Force standard fonts to get generated up front.
+        // This is primarily for error detection purposes.
+        succ &= (NULL != getFontSansSerifSmall());
+        succ &= (NULL != getFontSansSerif());
+        succ &= (NULL != getFontSansSerifBig());
+        succ &= (NULL != getFontSansSerifHuge());
+        succ &= (NULL != getFontSansSerifBold());
+        succ &= (NULL != getFontMonospace());
+        succ &= (NULL != getFontExtChar());
+        
+        return succ;
 }
 
 
@@ -463,57 +255,23 @@ BOOL LLFontGL::initDefaultFonts(F32 screen_dpi, F32 x_scale, F32 y_scale,
 // static
 void LLFontGL::destroyDefaultFonts()
 {
-        delete sMonospace;
-        sMonospace = NULL;
-
-        delete sSansSerifHuge;
-        sSansSerifHuge = NULL;
-
-        delete sSansSerifBig;
-        sSansSerifBig = NULL;
-
-        delete sSansSerif;
-        sSansSerif = NULL;
-
-        delete sSansSerifSmall;
-        sSansSerifSmall = NULL;
-
-        delete sSansSerifBold;
-        sSansSerifBold = NULL;
-
-        delete sMonospaceFallback;
-        sMonospaceFallback = NULL;
-
-        delete sSSHugeFallback;
-        sSSHugeFallback = NULL;
-
-        delete sSSBigFallback;
-        sSSBigFallback = NULL;
-
-        delete sSSFallback;
-        sSSFallback = NULL;
-
-        delete sSSSmallFallback;
-        sSSSmallFallback = NULL;
-
-        delete sSSBoldFallback;
-        sSSBoldFallback = NULL;
+        // Remove the actual fonts.
+        delete sFontRegistry;
+        sFontRegistry = NULL;
 }
 
 //static 
-void LLFontGL::destroyGL()
+void LLFontGL::destroyAllGL()
 {
-        if (!sMonospace)
+        if (sFontRegistry)
         {
-                // Already all destroyed.
-                return;
+                sFontRegistry->destroyGL();
         }
-        sMonospace->mImageGLp->destroyGLTexture();
-        sSansSerifHuge->mImageGLp->destroyGLTexture();
-        sSansSerifSmall->mImageGLp->destroyGLTexture();
-        sSansSerif->mImageGLp->destroyGLTexture();
-        sSansSerifBig->mImageGLp->destroyGLTexture();
-        sSansSerifBold->mImageGLp->destroyGLTexture();
+}
+
+void LLFontGL::destroyGL()
+{
+        mFontBitmapCachep->destroyGL();
 }
 
 
@@ -532,13 +290,58 @@ BOOL LLFontGL::loadFace(const std::string& filename,
         {
                 return FALSE;
         }
-        mImageGLp->createGLTexture(0, mRawImageGLp);
-        gGL.getTexUnit(0)->bind(mImageGLp);
-        mImageGLp->setMipFilterNearest(TRUE, TRUE);
         return TRUE;
 }
 
-BOOL LLFontGL::addChar(const llwchar wch)
+//static
+LLFontGL* LLFontGL::getFontMonospace()
+{
+        return getFont(LLFontDescriptor("Monospace","Monospace",0));
+}
+
+//static
+LLFontGL* LLFontGL::getFontSansSerifSmall()
+{
+        return getFont(LLFontDescriptor("SansSerif","Small",0));
+}
+
+//static
+LLFontGL* LLFontGL::getFontSansSerif()
+{
+        return getFont(LLFontDescriptor("SansSerif","Medium",0));
+}
+
+//static
+LLFontGL* LLFontGL::getFontSansSerifBig()
+{
+        return getFont(LLFontDescriptor("SansSerif","Large",0));
+}
+
+//static 
+LLFontGL* LLFontGL::getFontSansSerifHuge()
+{
+        return getFont(LLFontDescriptor("SansSerif","Huge",0));
+}
+
+//static 
+LLFontGL* LLFontGL::getFontSansSerifBold()
+{
+        return getFont(LLFontDescriptor("SansSerif","Medium",BOLD));
+}
+
+//static
+LLFontGL* LLFontGL::getFontExtChar()
+{
+        return getFontSansSerif();
+}
+
+//static 
+LLFontGL* LLFontGL::getFont(const LLFontDescriptor& desc)
+{
+        return sFontRegistry->getFont(desc);
+}
+
+BOOL LLFontGL::addChar(const llwchar wch) const
 {
         if (!LLFont::addChar(wch))
         {
@@ -546,10 +349,12 @@ BOOL LLFontGL::addChar(const llwchar wch)
         }
 
         stop_glerror();
-        mImageGLp->setSubImage(mRawImageGLp, 0, 0, mImageGLp->getWidth(), mImageGLp->getHeight());
-        gGL.getTexUnit(0)->bind(mImageGLp);
-        mImageGLp->setMipFilterNearest(TRUE, TRUE);
-        stop_glerror();
+
+        LLFontGlyphInfo *glyph_info = getGlyphInfo(wch);
+        U32 bitmap_num = glyph_info->mBitmapNum;
+        LLImageGL *image_gl = mFontBitmapCachep->getImageGL(bitmap_num);
+        LLImageRaw *image_raw = mFontBitmapCachep->getImageRaw(bitmap_num);
+        image_gl->setSubImage(image_raw, 0, 0, image_gl->getWidth(), image_gl->getHeight());
         return TRUE;
 }
 
@@ -564,7 +369,7 @@ S32 LLFontGL::renderUTF8(const std::string &text, const S32 offset,
                                          BOOL use_ellipses) const
 {
         LLWString wstr = utf8str_to_wstring(text);
-        return render(wstr, offset, x, y, color, halign, valign, style, max_chars, max_pixels, right_x, use_ellipses);
+        return render(wstr, offset, x, y, color, halign, valign, style, max_chars, max_pixels, right_x, FALSE, use_ellipses);
 }
 
 S32 LLFontGL::render(const LLWString &wstr, 
@@ -583,30 +388,17 @@ S32 LLFontGL::render(const LLWString &wstr,
                 return wstr.length() ;
         }
 
-        gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
-
         if (wstr.empty())
         {
                 return 0;
         } 
 
+        gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
+
         S32 scaled_max_pixels = max_pixels == S32_MAX ? S32_MAX : llceil((F32)max_pixels * sScaleX);
 
-        // HACK for better bolding
-        if (style & BOLD)
-        {
-                if (this == LLFontGL::sSansSerif)
-                {
-                        return LLFontGL::sSansSerifBold->render(
-                                wstr, begin_offset,
-                                x, y,
-                                color,
-                                halign, valign, 
-                                (style & ~BOLD),
-                                max_chars, max_pixels,
-                                right_x, use_embedded);
-                }
-        }
+        // Strip off any style bits that are already accounted for by the font.
+        style = style & (~getFontDesc().getStyle());
 
         F32 drop_shadow_strength = 0.f;
         if (style & (DROP_SHADOW | DROP_SHADOW_SOFT))
@@ -623,25 +415,12 @@ S32 LLFontGL::render(const LLWString &wstr,
         gGL.pushMatrix();
         glLoadIdentity();
         gGL.translatef(floorf(sCurOrigin.mX*sScaleX), floorf(sCurOrigin.mY*sScaleY), sCurOrigin.mZ);
-        //glScalef(sScaleX, sScaleY, 1.0f);
-        
-        // avoid half pixels
-        // RN: if we're going to this trouble, might as well snap to nearest pixel all the time
-        // but the plan is to get rid of this so that fonts "just work"
-        //F32 half_pixel_distance = llabs(fmodf(sCurOrigin.mX * sScaleX, 1.f) - 0.5f);
-        //if (half_pixel_distance < PIXEL_BORDER_THRESHOLD)
-        //{
-                gGL.translatef(PIXEL_CORRECTION_DISTANCE*sScaleX, 0.f, 0.f);
-        //}
-
-        // this code would just snap to pixel grid, although it seems to introduce more jitter
-        //F32 pixel_offset_x = llround(sCurOrigin.mX * sScaleX) - (sCurOrigin.mX * sScaleX);
-        //F32 pixel_offset_y = llround(sCurOrigin.mY * sScaleY) - (sCurOrigin.mY * sScaleY);
-        //gGL.translatef(-pixel_offset_x, -pixel_offset_y, 0.f);
-
-        // scale back to native pixel size
-        //glScalef(1.f / sScaleX, 1.f / sScaleY, 1.f);
-        //glScaled(1.0 / (F64) sScaleX, 1.0 / (F64) sScaleY, 1.0f);
+
+        // this code snaps the text origin to a pixel grid to start with
+        F32 pixel_offset_x = llround((F32)sCurOrigin.mX) - (sCurOrigin.mX);
+        F32 pixel_offset_y = llround((F32)sCurOrigin.mY) - (sCurOrigin.mY);
+        gGL.translatef(-pixel_offset_x, -pixel_offset_y, 0.f);
+
         LLFastTimer t(LLFastTimer::FTM_RENDER_FONTS);
 
         gGL.color4fv( color.mV );
@@ -661,10 +440,6 @@ S32 LLFontGL::render(const LLWString &wstr,
 
         F32 cur_x, cur_y, cur_render_x, cur_render_y;
 
-        // Bind the font texture
-        
-        gGL.getTexUnit(0)->bind(mImageGLp);
-        
         // Not guaranteed to be set correctly
         gGL.setSceneBlendType(LLRender::BT_ALPHA);
         
@@ -704,17 +479,13 @@ S32 LLFontGL::render(const LLWString &wstr,
                 break;
         }
 
-        // Round properly.
-        //cur_render_y = (F32)llfloor(cur_y/sScaleY + 0.5f)*sScaleY;
-        //cur_render_x = (F32)llfloor(cur_x/sScaleX + 0.5f)*sScaleX;
-        
         cur_render_y = cur_y;
         cur_render_x = cur_x;
 
         F32 start_x = cur_x;
 
-        F32 inv_width = 1.f / mImageGLp->getWidth();
-        F32 inv_height = 1.f / mImageGLp->getHeight();
+        F32 inv_width = 1.f / mFontBitmapCachep->getBitmapWidth();
+        F32 inv_height = 1.f / mFontBitmapCachep->getBitmapHeight();
 
         const S32 LAST_CHARACTER = LLFont::LAST_CHAR_FULL;
 
@@ -733,6 +504,9 @@ S32 LLFontGL::render(const LLWString &wstr,
         }
 
 
+        // Remember last-used texture to avoid unnecesssary bind calls.
+        LLImageGL *last_bound_texture = NULL;
+
         for (i = begin_offset; i < begin_offset + length; i++)
         {
                 llwchar wch = wstr[i];
@@ -752,7 +526,7 @@ S32 LLFontGL::render(const LLWString &wstr,
 
                         if (!label.empty())
                         {
-                                ext_advance += (EXT_X_BEARING + gExtCharFont->getWidthF32( label.c_str() )) * sScaleX;
+                                ext_advance += (EXT_X_BEARING + getFontExtChar()->getWidthF32( label.c_str() )) * sScaleX;
                         }
 
                         if (start_x + scaled_max_pixels < cur_x + ext_advance)
@@ -761,9 +535,15 @@ S32 LLFontGL::render(const LLWString &wstr,
                                 break;
                         }
 
-                        gGL.getTexUnit(0)->bind(ext_image);
-                        const F32 ext_x = cur_render_x + (EXT_X_BEARING * sScaleX);
-                        const F32 ext_y = cur_render_y + (EXT_Y_BEARING * sScaleY + mAscender - mLineHeight);
+                        if (last_bound_texture != ext_image)
+                        {
+                                gGL.getTexUnit(0)->bind(ext_image);
+                                last_bound_texture = ext_image;
+                        }
+
+                        // snap origin to whole screen pixel
+                        const F32 ext_x = (F32)llround(cur_render_x + (EXT_X_BEARING * sScaleX));
+                        const F32 ext_y = (F32)llround(cur_render_y + (EXT_Y_BEARING * sScaleY + mAscender - mLineHeight));
 
                         LLRectf uv_rect(0.f, 1.f, 1.f, 0.f);
                         LLRectf screen_rect(ext_x, ext_y + ext_height, ext_x + ext_width, ext_y);
@@ -775,7 +555,7 @@ S32 LLFontGL::render(const LLWString &wstr,
                                 //glLoadIdentity();
                                 //gGL.translatef(sCurOrigin.mX, sCurOrigin.mY, 0.0f);
                                 //glScalef(sScaleX, sScaleY, 1.f);
-                                gExtCharFont->render(label, 0,
+                                getFontExtChar()->render(label, 0,
                                                                          /*llfloor*/((ext_x + (F32)ext_image->getWidth() + EXT_X_BEARING) / sScaleX), 
                                                                          /*llfloor*/(cur_y / sScaleY),
                                                                          color,
@@ -793,15 +573,12 @@ S32 LLFontGL::render(const LLWString &wstr,
                                 cur_x += EXT_KERNING * sScaleX;
                         }
                         cur_render_x = cur_x;
-
-                        // Bind the font texture
-                        gGL.getTexUnit(0)->bind(mImageGLp);
                 }
                 else
                 {
                         if (!hasGlyph(wch))
                         {
-                                (const_cast<LLFontGL*>(this))->addChar(wch);
+                                addChar(wch);
                         }
 
                         const LLFontGlyphInfo* fgi= getGlyphInfo(wch);
@@ -810,6 +587,14 @@ S32 LLFontGL::render(const LLWString &wstr,
                                 llerrs << "Missing Glyph Info" << llendl;
                                 break;
                         }
+                        // Per-glyph bitmap texture.
+                        LLImageGL *image_gl = mFontBitmapCachep->getImageGL(fgi->mBitmapNum);
+                        if (last_bound_texture != image_gl)
+                        {
+                                gGL.getTexUnit(0)->bind(image_gl);
+                                last_bound_texture = image_gl;
+                        }
+
                         if ((start_x + scaled_max_pixels) < (cur_x + fgi->mXBearing + fgi->mWidth))
                         {
                                 // Not enough room for this character.
@@ -818,15 +603,16 @@ S32 LLFontGL::render(const LLWString &wstr,
 
                         // Draw the text at the appropriate location
                         //Specify vertices and texture coordinates
-                        LLRectf uv_rect((fgi->mXBitmapOffset - PAD_AMT) * inv_width,
-                                                        (fgi->mYBitmapOffset + fgi->mHeight + PAD_AMT) * inv_height,
-                                                        (fgi->mXBitmapOffset + fgi->mWidth + PAD_AMT) * inv_width,
-                                                        (fgi->mYBitmapOffset - PAD_AMT) * inv_height);
-                        LLRectf screen_rect(cur_render_x + (F32)fgi->mXBearing - PAD_AMT,
-                                                                cur_render_y + (F32)fgi->mYBearing + PAD_AMT,
-                                                                cur_render_x + (F32)fgi->mXBearing + (F32)fgi->mWidth + PAD_AMT,
-                                                                cur_render_y + (F32)fgi->mYBearing - (F32)fgi->mHeight - PAD_AMT);
-
+                        LLRectf uv_rect((fgi->mXBitmapOffset) * inv_width,
+                                        (fgi->mYBitmapOffset + fgi->mHeight + PAD_UVY) * inv_height,
+                                        (fgi->mXBitmapOffset + fgi->mWidth) * inv_width,
+                                        (fgi->mYBitmapOffset - PAD_UVY) * inv_height);
+                        // snap glyph origin to whole screen pixel
+                        LLRectf screen_rect(llround(cur_render_x + (F32)fgi->mXBearing),
+                                            llround(cur_render_y + (F32)fgi->mYBearing),
+                                            llround(cur_render_x + (F32)fgi->mXBearing) + (F32)fgi->mWidth,
+                                            llround(cur_render_y + (F32)fgi->mYBearing) - (F32)fgi->mHeight);
+                        
                         drawGlyph(screen_rect, uv_rect, color, style, drop_shadow_strength);
 
                         chars_drawn++;
@@ -839,7 +625,7 @@ S32 LLFontGL::render(const LLWString &wstr,
                                 // Kern this puppy.
                                 if (!hasGlyph(next_char))
                                 {
-                                        (const_cast<LLFontGL*>(this))->addChar(next_char);
+                                        addChar(next_char);
                                 }
                                 cur_x += getXKerning(wch, next_char);
                         }
@@ -896,11 +682,6 @@ S32 LLFontGL::render(const LLWString &wstr,
         return chars_drawn;
 }
 
- 
-LLImageGL *LLFontGL::getImageGL() const
-{
-        return mImageGLp;
-}
 
 S32 LLFontGL::getWidth(const std::string& utf8text) const
 {
@@ -1118,59 +899,32 @@ S32	LLFontGL::firstDrawableChar(const llwchar* wchars, F32 max_pixels, S32 text_
                 llwchar wch = wchars[i];
 
                 const embedded_data_t* ext_data = getEmbeddedCharData(wch);
-                if (ext_data)
-                {
-                        F32 char_width = getEmbeddedCharAdvance(ext_data);
-
-                        if( scaled_max_pixels < (total_width + char_width) )
-                        {
-                                break;
-                        }
+                F32 char_width = ext_data ? getEmbeddedCharAdvance(ext_data) : getXAdvance(wch);
 
-                        total_width += char_width;
-
-                        drawable_chars++;
-                        if( max_chars >= 0 && drawable_chars >= max_chars )
-                        {
-                                break;
-                        }
-
-                        if ( i > 0 )
-                        {
-                                total_width += EXT_KERNING * sScaleX;
-                        }
-
-                        // Round after kerning.
-                        total_width = (F32)llfloor(total_width + 0.5f);
-                }
-                else
+                if( scaled_max_pixels < (total_width + char_width) )
                 {
-                        F32 char_width = getXAdvance(wch);
-                        if( scaled_max_pixels < (total_width + char_width) )
-                        {
-                                break;
-                        }
-
-                        total_width += char_width;
+                        break;
+                }
 
-                        drawable_chars++;
-                        if( max_chars >= 0 && drawable_chars >= max_chars )
-                        {
-                                break;
-                        }
+                total_width += char_width;
+                drawable_chars++;
 
-                        if ( i > 0 )
-                        {
-                                // Kerning
-                                total_width += getXKerning(wchars[i-1], wch);
-                        }
+                if( max_chars >= 0 && drawable_chars >= max_chars )
+                {
+                        break;
+                }
 
-                        // Round after kerning.
-                        total_width = (F32)llfloor(total_width + 0.5f);
+                if ( i > 0 )
+                {
+                        // kerning
+                        total_width += ext_data ? (EXT_KERNING * sScaleX) : getXKerning(wchars[i-1], wch);
                 }
+
+                // Round after kerning.
+                total_width = llround(total_width);
         }
 
-        return text_len - drawable_chars;
+        return start_pos - drawable_chars;
 }
 
 
@@ -1299,7 +1053,7 @@ F32 LLFontGL::getEmbeddedCharAdvance(const embedded_data_t* ext_data) const
         F32 ext_width = (F32)ext_image->getWidth();
         if( !label.empty() )
         {
-                ext_width += (EXT_X_BEARING + gExtCharFont->getWidthF32(label.c_str())) * sScaleX;
+                ext_width += (EXT_X_BEARING + getFontExtChar()->getWidthF32(label.c_str())) * sScaleX;
         }
 
         return (EXT_X_BEARING * sScaleX) + ext_width;
@@ -1312,19 +1066,19 @@ void LLFontGL::clearEmbeddedChars()
         mEmbeddedChars.clear();
 }
 
-void LLFontGL::addEmbeddedChar( llwchar wc, LLImageGL* image, const std::string& label )
+void LLFontGL::addEmbeddedChar( llwchar wc, LLImageGL* image, const std::string& label ) const
 {
         LLWString wlabel = utf8str_to_wstring(label);
         addEmbeddedChar(wc, image, wlabel);
 }
 
-void LLFontGL::addEmbeddedChar( llwchar wc, LLImageGL* image, const LLWString& wlabel )
+void LLFontGL::addEmbeddedChar( llwchar wc, LLImageGL* image, const LLWString& wlabel ) const
 {
         embedded_data_t* ext_data = new embedded_data_t(image, wlabel);
         mEmbeddedChars[wc] = ext_data;
 }
 
-void LLFontGL::removeEmbeddedChar( llwchar wc )
+void LLFontGL::removeEmbeddedChar( llwchar wc ) const
 {
         embedded_map_t::iterator iter = mEmbeddedChars.find(wc);
         if (iter != mEmbeddedChars.end())
@@ -1428,68 +1182,9 @@ void LLFontGL::drawGlyph(const LLRectf& screen_rect, const LLRectf& uv_rect, con
         gGL.end();
 }
 
-// static
 std::string LLFontGL::nameFromFont(const LLFontGL* fontp)
 {
-        if (fontp == sSansSerifHuge)
-        {
-                return std::string("SansSerifHuge");
-        }
-        else if (fontp == sSansSerifSmall)
-        {
-                return std::string("SansSerifSmall");
-        }
-        else if (fontp == sSansSerif)
-        {
-                return std::string("SansSerif");
-        }
-        else if (fontp == sSansSerifBig)
-        {
-                return std::string("SansSerifBig");
-        }
-        else if (fontp == sSansSerifBold)
-        {
-                return std::string("SansSerifBold");
-        }
-        else if (fontp == sMonospace)
-        {
-                return std::string("Monospace");
-        }
-        else
-        {
-                return std::string();
-        }
-}
-
-// static
-LLFontGL* LLFontGL::fontFromName(const std::string& font_name)
-{
-        LLFontGL* gl_font = NULL;
-        if (font_name == "SansSerifHuge")
-        {
-                gl_font = LLFontGL::sSansSerifHuge;
-        }
-        else if (font_name == "SansSerifSmall")
-        {
-                gl_font = LLFontGL::sSansSerifSmall;
-        }
-        else if (font_name == "SansSerif")
-        {
-                gl_font = LLFontGL::sSansSerif;
-        }
-        else if (font_name == "SansSerifBig")
-        {
-                gl_font = LLFontGL::sSansSerifBig;
-        }
-        else if (font_name == "SansSerifBold")
-        {
-                gl_font = LLFontGL::sSansSerifBold;
-        }
-        else if (font_name == "Monospace")
-        {
-                gl_font = LLFontGL::sMonospace;
-        }
-        return gl_font;
+        return fontp->getFontDesc().getName();
 }
 
 // static
diff --git a/linden/indra/llrender/llfontgl.h b/linden/indra/llrender/llfontgl.h
index 97bdd1a..6cb1727 100644
--- a/linden/indra/llrender/llfontgl.h
+++ b/linden/indra/llrender/llfontgl.h
@@ -18,7 +18,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -39,8 +40,16 @@
 #include "llcoord.h"
 #include "llrect.h"
 
+#include "llfontregistry.h"
+
 class LLColor4;
 
+// Key used to request a font.
+class LLFontDescriptor;
+
+// Structure used to store previously requested fonts.
+class LLFontRegistry;
+
 class LLFontGL : public LLFont
 {
 public:
@@ -85,18 +94,13 @@ public:
         LLFontGL &operator=(const LLFontGL &source);
 
         static BOOL initDefaultFonts(F32 screen_dpi, F32 x_scale, F32 y_scale,
-                                                                 const std::string& monospace_file, F32 monospace_size,
-                                                                 const std::string& sansserif_file,
-                                                                 const std::string& sansserif_fallback_file, F32 ss_fallback_scale,
-                                                                 F32 small_size, F32 medium_size, F32 large_size, F32 huge_size,
-                                                                 const std::string& sansserif_bold_file, F32 bold_size,
-                                                                 const std::string& app_dir = LLStringUtil::null);
+                                                                 const std::string& app_dir,
+                                                                 const std::vector<std::string>& xui_paths);
 
         static void     destroyDefaultFonts();
-        static void destroyGL();
+        static void destroyAllGL();
+        void destroyGL();
 
-        static bool loadFaceFallback(LLFontList *fontp, const std::string& fontname, const F32 point_size);
-        static bool loadFace(LLFontGL *fontp, const std::string& fontname, const F32 point_size, LLFontList *fallback_fontp);
         /* virtual*/ BOOL loadFace(const std::string& filename,
                                                             const F32 point_size, const F32 vert_dpi, const F32 horz_dpi,
                                                             const S32 components, BOOL is_fallback);
@@ -180,7 +184,7 @@ public:
                                                                  F32* drawn_pixels = NULL) const;
 
         // Returns the index of the first complete characters from text that can be drawn in max_pixels
-        // starting on the right side (at character start_pos).
+        // given that the character at start_pos should be the last character (or as close to last as possible).
         virtual S32     firstDrawableChar(const llwchar* wchars, F32 max_pixels, S32 text_len, S32 start_pos=S32_MAX, S32 max_chars = S32_MAX) const;
 
         // Returns the index of the character closest to pixel position x (ignoring text to the right of max_pixels and max_chars)
@@ -191,12 +195,11 @@ public:
 
         LLImageGL *getImageGL() const;
 
-        void       addEmbeddedChar( llwchar wc, LLImageGL* image, const std::string& label);
-        void       addEmbeddedChar( llwchar wc, LLImageGL* image, const LLWString& label);
-        void       removeEmbeddedChar( llwchar wc );
+        void       addEmbeddedChar( llwchar wc, LLImageGL* image, const std::string& label) const;
+        void       addEmbeddedChar( llwchar wc, LLImageGL* image, const LLWString& label) const;
+        void       removeEmbeddedChar( llwchar wc ) const;
 
         static std::string nameFromFont(const LLFontGL* fontp);
-        static LLFontGL* fontFromName(const std::string& name);
 
         static std::string nameFromHAlign(LLFontGL::HAlign align);
         static LLFontGL::HAlign hAlignFromName(const std::string& name);
@@ -227,20 +230,14 @@ public:
         static BOOL     sDisplayFont ;
         static std::string sAppDir;                     // For loading fonts
                 
-        static LLFontGL*        sMonospace;             // medium
-        static LLFontList*      sMonospaceFallback;
-
-        static LLFontGL*        sSansSerifSmall;        // small
-        static LLFontList*      sSSSmallFallback;
-        static LLFontGL*        sSansSerif;             // medium
-        static LLFontList*      sSSFallback;
-        static LLFontGL*        sSansSerifBig;          // large
-        static LLFontList*      sSSBigFallback;
-        static LLFontGL*        sSansSerifHuge; // very large
-        static LLFontList*      sSSHugeFallback;
-
-        static LLFontGL*        sSansSerifBold; // medium, bolded
-        static LLFontList*      sSSBoldFallback;
+        static LLFontGL* getFontMonospace();
+        static LLFontGL* getFontSansSerifSmall();
+        static LLFontGL* getFontSansSerif();
+        static LLFontGL* getFontSansSerifBig();
+        static LLFontGL* getFontSansSerifHuge();
+        static LLFontGL* getFontSansSerifBold();
+        static LLFontGL* getFontExtChar();
+        static LLFontGL* getFont(const LLFontDescriptor& desc);
 
         static LLColor4 sShadowColor;
 
@@ -248,19 +245,26 @@ public:
         friend class LLHUDText;
 
 protected:
-        /*virtual*/ BOOL addChar(const llwchar wch);
-        static std::string getFontPathLocal();
-        static std::string getFontPathSystem();
+        /*virtual*/ BOOL addChar(const llwchar wch) const;
 
 protected:
-        LLPointer<LLImageRaw>   mRawImageGLp;
-        LLPointer<LLImageGL>    mImageGLp;
         typedef std::map<llwchar,embedded_data_t*> embedded_map_t;
-        embedded_map_t mEmbeddedChars;
+        mutable embedded_map_t mEmbeddedChars;
         
+        LLFontDescriptor mFontDesc;
+
+        // Registry holds all instantiated fonts.
+        static LLFontRegistry* sFontRegistry;
+
 public:
+        static std::string getFontPathLocal();
+        static std::string getFontPathSystem();
+
         static LLCoordFont sCurOrigin;
         static std::vector<LLCoordFont> sOriginStack;
+
+        const LLFontDescriptor &getFontDesc() const { return mFontDesc; }
+        void setFontDesc(const LLFontDescriptor& font_desc) { mFontDesc = font_desc; }
 };
 
 #endif
diff --git a/linden/indra/llrender/llfontregistry.cpp b/linden/indra/llrender/llfontregistry.cpp
new file mode 100644
index 0000000..619228e
--- /dev/null
+++ b/linden/indra/llrender/llfontregistry.cpp
@@ -0,0 +1,651 @@
+/** 
+ * @file llfontregistry.cpp
+ * @author Brad Payne
+ * @brief Storage for fonts.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+#include "llgl.h"
+#include "llfontregistry.h"
+#include "llfontgl.h"
+#include <boost/tokenizer.hpp>
+#include "llcontrol.h"
+#include "lldir.h"
+#include "llwindow.h"
+
+extern LLControlGroup gSavedSettings;
+
+using std::string;
+using std::map;
+
+bool fontDescInitFromXML(LLXMLNodePtr node, LLFontDescriptor& desc);
+
+LLFontDescriptor::LLFontDescriptor():
+        mStyle(0)
+{
+}
+
+LLFontDescriptor::LLFontDescriptor(const std::string& name,
+                                                                   const std::string& size, 
+                                                                   const U8 style,
+                                                                   const string_vec_t& file_names):
+        mName(name),
+        mSize(size),
+        mStyle(style),
+        mFileNames(file_names)
+{
+}
+
+LLFontDescriptor::LLFontDescriptor(const std::string& name,
+                                                                   const std::string& size, 
+                                                                   const U8 style):
+        mName(name),
+        mSize(size),
+        mStyle(style)
+{
+}
+
+
+bool LLFontDescriptor::operator<(const LLFontDescriptor& b) const
+{
+        if (mName < b.mName)
+                return true;
+        else if (mName > b.mName)
+                return false;
+        
+        if (mStyle < b.mStyle)
+                return true;
+        else if (mStyle > b.mStyle)
+                return false;
+
+        if (mSize < b.mSize)
+                return true;
+        else 
+                return false;
+}
+
+static const std::string s_template_string("TEMPLATE");
+
+bool LLFontDescriptor::isTemplate() const
+{
+        return getSize() == s_template_string;
+}
+
+// Look for substring match and remove substring if matched.
+bool removeSubString(std::string& str, const std::string& substr)
+{
+        size_t pos = str.find(substr);
+        if (pos != string::npos)
+        {
+                str.replace(pos,substr.length(),(const char *)NULL, 0);
+                return true;
+        }
+        return false;
+}
+
+// Check for substring match without modifying the source string.
+bool findSubString(std::string& str, const std::string& substr)
+{
+        size_t pos = str.find(substr);
+        if (pos != string::npos)
+        {
+                return true;
+        }
+        return false;
+}
+
+
+// Normal form is
+// - raw name
+// - bold, italic style info reflected in both style and font name.
+// - other style info removed.
+// - size info moved to mSize, defaults to Medium
+// For example,
+// - "SansSerifHuge" would normalize to { "SansSerif", "Huge", 0 }
+// - "SansSerifBold" would normalize to { "SansSerifBold", "Medium", BOLD }
+LLFontDescriptor LLFontDescriptor::normalize() const
+{
+        std::string new_name(mName);
+        std::string new_size(mSize);
+        U8 new_style(mStyle);
+
+        // Only care about style to extent it can be picked up by font.
+        new_style &= (LLFontGL::BOLD | LLFontGL::ITALIC);
+
+        // All these transformations are to support old-style font specifications.
+        if (removeSubString(new_name,"Small"))
+                new_size = "Small";
+        if (removeSubString(new_name,"Big"))
+                new_size = "Large";
+        if (removeSubString(new_name,"Medium"))
+                new_size = "Medium";
+        if (removeSubString(new_name,"Large"))
+                new_size = "Large";
+        if (removeSubString(new_name,"Huge"))
+                new_size = "Huge";
+
+        // HACK - Monospace is the only one we don't remove, so
+        // name "Monospace" doesn't get taken down to ""
+        // For other fonts, there's no ambiguity between font name and size specifier.
+        if (new_size != s_template_string && new_size.empty() && findSubString(new_name,"Monospace"))
+                new_size = "Monospace";
+        if (new_size.empty())
+                new_size = "Medium";
+
+        if (removeSubString(new_name,"Bold"))
+                new_style |= LLFontGL::BOLD;
+
+        if (removeSubString(new_name,"Italic"))
+                new_style |= LLFontGL::ITALIC;
+
+        return LLFontDescriptor(new_name,new_size,new_style,getFileNames());
+}
+
+LLFontRegistry::LLFontRegistry(const string_vec_t& xui_paths)
+{
+        // Propagate this down from LLUICtrlFactory so LLRender doesn't
+        // need an upstream dependency on LLUI.
+        mXUIPaths = xui_paths;
+        
+        // This is potentially a slow directory traversal, so we want to
+        // cache the result.
+        mUltimateFallbackList = LLWindow::getDynamicFallbackFontList();
+}
+
+LLFontRegistry::~LLFontRegistry()
+{
+        clear();
+}
+
+bool LLFontRegistry::parseFontInfo(const std::string& xml_filename)
+{
+        bool success = false;  // Succeed if we find at least one XUI file
+        const string_vec_t& xml_paths = mXUIPaths;
+        for (string_vec_t::const_iterator path_it = xml_paths.begin();
+                 path_it != xml_paths.end();
+                 ++path_it)
+        {
+        
+                LLXMLNodePtr root;
+                std::string full_filename = gDirUtilp->findSkinnedFilename(*path_it, xml_filename);
+                bool parsed_file = LLXMLNode::parseFile(full_filename, root, NULL);
+
+                if (!parsed_file)
+                        continue;
+                
+                if ( root.isNull() || ! root->hasName( "fonts" ) )
+                {
+                        llwarns << "Bad font info file: "
+                                        << full_filename << llendl;
+                        continue;
+                }
+                
+                std::string root_name;
+                root->getAttributeString("name",root_name);
+                if (root->hasName("fonts"))
+                {
+                        // Expect a collection of children consisting of "font" or "font_size" entries
+                        bool init_succ = initFromXML(root);
+                        success = success || init_succ;
+                }
+        }
+        if (success)
+                dump();
+        
+        return success;
+}
+
+std::string currentOsName()
+{
+#if LL_WINDOWS
+        return "Windows";
+#elif LL_DARWIN
+        return "Mac";
+#elif LL_SDL
+        return "Linux";
+#else
+        return "";
+#endif
+}
+
+bool fontDescInitFromXML(LLXMLNodePtr node, LLFontDescriptor& desc)
+{
+        if (node->hasName("font"))
+        {
+                std::string attr_name;
+                if (node->getAttributeString("name",attr_name))
+                {
+                        desc.setName(attr_name);
+                }
+
+                std::string attr_style;
+                if (node->getAttributeString("font_style",attr_style))
+                {
+                        desc.setStyle(LLFontGL::getStyleFromString(attr_style));
+                }
+
+                desc.setSize(s_template_string);
+        }
+
+        LLXMLNodePtr child;     
+        for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+        {
+                std::string child_name;
+                child->getAttributeString("name",child_name);
+                if (child->hasName("file"))
+                {
+                        std::string font_file_name = child->getTextContents();
+                        desc.getFileNames().push_back(font_file_name);
+                }
+                else if (child->hasName("os"))
+                {
+                        if (child_name == currentOsName())
+                        {
+                                fontDescInitFromXML(child, desc);
+                        }
+                }
+        }
+        return true;
+}
+
+bool LLFontRegistry::initFromXML(LLXMLNodePtr node)
+{
+        LLXMLNodePtr child;
+        
+        for (child = node->getFirstChild(); child.notNull(); child = child->getNextSibling())
+        {
+                std::string child_name;
+                child->getAttributeString("name",child_name);
+                if (child->hasName("font"))
+                {
+                        LLFontDescriptor desc;
+                        bool font_succ = fontDescInitFromXML(child, desc);
+                        LLFontDescriptor norm_desc = desc.normalize();
+                        if (font_succ)
+                        {
+                                // if this is the first time we've seen this font name,
+                                // create a new template map entry for it.
+                                const LLFontDescriptor *match_desc = getMatchingFontDesc(desc);
+                                if (match_desc == NULL)
+                                {
+                                        // Create a new entry (with no corresponding font).
+                                        mFontMap[norm_desc] = NULL;
+                                }
+                                // otherwise, find the existing entry and combine data. 
+                                else
+                                {
+                                        // Prepend files from desc.
+                                        // A little roundabout because the map key is const,
+                                        // so we have to fetch it, make a new map key, and
+                                        // replace the old entry.
+                                        string_vec_t match_file_names = match_desc->getFileNames();
+                                        match_file_names.insert(match_file_names.begin(),
+                                                                                        desc.getFileNames().begin(),
+                                                                                        desc.getFileNames().end());
+                                        LLFontDescriptor new_desc = *match_desc;
+                                        new_desc.getFileNames() = match_file_names;
+                                        mFontMap.erase(*match_desc);
+                                        mFontMap[new_desc] = NULL;
+                                }
+                        }
+                }
+                else if (child->hasName("font_size"))
+                {
+                        std::string size_name;
+                        F32 size_value;
+                        if (child->getAttributeString("name",size_name) &&
+                                child->getAttributeF32("size",size_value))
+                        {
+                                mFontSizes[size_name] = size_value;
+                        }
+
+                }
+        }
+        return true;
+}
+
+bool LLFontRegistry::nameToSize(const std::string& size_name, F32& size)
+{
+        font_size_map_t::iterator it = mFontSizes.find(size_name);
+        if (it != mFontSizes.end())
+        {
+                size = it->second;
+                return true;
+        }
+        return false;
+}
+
+
+LLFontGL *LLFontRegistry::createFont(const LLFontDescriptor& desc)
+{
+        // Name should hold a font name recognized as a setting; the value
+        // of the setting should be a list of font files.
+        // Size should be a recognized string value
+        // Style should be a set of flags including any implied by the font name.
+
+        // First decipher the requested size.
+        LLFontDescriptor norm_desc = desc.normalize();
+        F32 point_size;
+        bool found_size = nameToSize(norm_desc.getSize(),point_size);
+        if (!found_size)
+        {
+                llwarns << "createFont unrecognized size " << norm_desc.getSize() << llendl;
+                return NULL;
+        }
+        llinfos << "createFont " << norm_desc.getName() << " size " << norm_desc.getSize() << " style " << ((S32) norm_desc.getStyle()) << llendl;
+        F32 fallback_scale = 1.0;
+
+        // Find corresponding font template (based on same descriptor with no size specified)
+        LLFontDescriptor template_desc(norm_desc);
+        template_desc.setSize(s_template_string);
+        const LLFontDescriptor *match_desc = getClosestFontTemplate(template_desc);
+        if (!match_desc)
+        {
+                llwarns << "createFont failed, no template found for "
+                                << norm_desc.getName() << " style [" << ((S32)norm_desc.getStyle()) << "]" << llendl;
+                return NULL;
+        }
+
+        // See whether this best-match font has already been instantiated in the requested size.
+        LLFontDescriptor nearest_exact_desc = *match_desc;
+        nearest_exact_desc.setSize(norm_desc.getSize());
+        font_reg_map_t::iterator it = mFontMap.find(nearest_exact_desc);
+        if (it != mFontMap.end())
+        {
+                llinfos << "-- matching font exists: " << nearest_exact_desc.getName() << " size " << nearest_exact_desc.getSize() << " style " << ((S32) nearest_exact_desc.getStyle()) << llendl;
+                return it->second;
+        }
+
+        // Build list of font names to look for.
+        // Files specified for this font come first, followed by those from the default descriptor.
+        string_vec_t file_names = match_desc->getFileNames();
+        string_vec_t default_file_names;
+        LLFontDescriptor default_desc("default",s_template_string,0);
+        const LLFontDescriptor *match_default_desc = getMatchingFontDesc(default_desc);
+        if (match_default_desc)
+        {
+                file_names.insert(file_names.end(),
+                                                  match_default_desc->getFileNames().begin(),
+                                                  match_default_desc->getFileNames().end());
+        }
+
+        // Add ultimate fallback list - generated dynamically on linux,
+        // null elsewhere.
+        file_names.insert(file_names.end(),
+                                          getUltimateFallbackList().begin(),
+                                          getUltimateFallbackList().end());
+
+        // Load fonts based on names.
+        if (file_names.empty())
+        {
+                llwarns << "createFont failed, no file names specified" << llendl;
+                return NULL;
+        }
+        LLFontList *fontlistp = new LLFontList;
+        LLFontGL *result = NULL;
+
+        // Snarf all fonts we can into fontlistp.  First will get pulled
+        // off the list and become the "head" font, set to non-fallback.
+        // Rest will consitute the fallback list.
+        BOOL is_first_found = TRUE;
+        
+        std::string local_path = LLFontGL::getFontPathLocal();
+        std::string sys_path = LLFontGL::getFontPathSystem();
+        
+        // The fontname string may contain multiple font file names separated by semicolons.
+        // Break it apart and try loading each one, in order.
+        for(string_vec_t::iterator file_name_it = file_names.begin();
+                file_name_it != file_names.end(); 
+                ++file_name_it)
+        {
+                LLFontGL *fontp = new LLFontGL;
+                std::string font_path = local_path + *file_name_it;
+                BOOL is_fallback = !is_first_found;
+                F32 extra_scale = (is_fallback)?fallback_scale:1.0;
+                if (!fontp->loadFace(font_path, extra_scale * point_size,
+                                                         LLFontGL::sVertDPI, LLFontGL::sHorizDPI, 2, is_fallback))
+                {
+                        font_path = sys_path + *file_name_it;
+
+                        if (!fontp->loadFace(font_path, extra_scale * point_size,
+                                                                 LLFontGL::sVertDPI, LLFontGL::sHorizDPI, 2, is_fallback))
+                        {
+                                LL_INFOS_ONCE("LLFontRegistry") << "Couldn't load font " << *file_name_it << LL_ENDL;
+                                delete fontp;
+                                fontp = NULL;
+                        }
+                }
+                
+                if(fontp)
+                {
+                        if (is_first_found)
+                        {
+                                result = fontp;
+                                is_first_found = false;
+                        }
+                        else
+                                fontlistp->addAtEnd(fontp);
+                }
+        }
+        if (result && !fontlistp->empty())
+        {
+                result->setFallbackFont(fontlistp);
+        }
+
+        norm_desc.setStyle(match_desc->getStyle());
+        if (result)
+                result->setFontDesc(norm_desc);
+
+        if (!result)
+        {
+                llwarns << "createFont failed in some way" << llendl;
+        }
+        mFontMap[norm_desc] = result;
+        return result;
+}
+
+void LLFontRegistry::reset()
+{
+        for (font_reg_map_t::iterator it = mFontMap.begin();
+                 it != mFontMap.end();
+                 ++it)
+        {
+                // Reset the corresponding font but preserve the entry.
+                if (it->second)
+                        it->second->reset();
+        }
+}
+
+void LLFontRegistry::clear()
+{
+        for (font_reg_map_t::iterator it = mFontMap.begin();
+                 it != mFontMap.end();
+                 ++it)
+        {
+                LLFontGL *fontp = it->second;
+                delete fontp;
+        }
+        mFontMap.clear();
+}
+
+void LLFontRegistry::destroyGL()
+{
+        for (font_reg_map_t::iterator it = mFontMap.begin();
+                 it != mFontMap.end();
+                 ++it)
+        {
+                // Reset the corresponding font but preserve the entry.
+                if (it->second)
+                        it->second->destroyGL();
+        }
+}
+
+LLFontGL *LLFontRegistry::getFont(const LLFontDescriptor& orig_desc)
+{
+        LLFontDescriptor norm_desc = orig_desc.normalize();
+
+        font_reg_map_t::iterator it = mFontMap.find(norm_desc);
+        if (it != mFontMap.end())
+                return it->second;
+        else
+        {
+                LLFontGL *fontp = createFont(orig_desc);
+                if (!fontp)
+                {
+                        llwarns << "getFont failed, name " << orig_desc.getName()
+                                        <<" style=[" << ((S32) orig_desc.getStyle()) << "]"
+                                        << " size=[" << orig_desc.getSize() << "]" << llendl;
+                }
+                return fontp;
+        }
+}
+
+const LLFontDescriptor *LLFontRegistry::getMatchingFontDesc(const LLFontDescriptor& desc)
+{
+        LLFontDescriptor norm_desc = desc.normalize();
+
+        font_reg_map_t::iterator it = mFontMap.find(norm_desc);
+        if (it != mFontMap.end())
+                return &(it->first);
+        else
+                return NULL;
+}
+
+static U32 bitCount(U8 c)
+{
+        U32 count = 0;
+        if (c & 1) 
+                count++;
+        if (c & 2)
+                count++;
+        if (c & 4)
+                count++;
+        if (c & 8)
+                count++;
+        if (c & 16)
+                count++;
+        if (c & 32)
+                count++;
+        if (c & 64)
+                count++;
+        if (c & 128)
+                count++;
+        return count;
+}
+
+// Find nearest match for the requested descriptor.
+const LLFontDescriptor *LLFontRegistry::getClosestFontTemplate(const LLFontDescriptor& desc)
+{
+        const LLFontDescriptor *exact_match_desc = getMatchingFontDesc(desc);
+        if (exact_match_desc)
+        {
+                return exact_match_desc;
+        }
+
+        LLFontDescriptor norm_desc = desc.normalize();
+
+        const LLFontDescriptor *best_match_desc = NULL;
+        for (font_reg_map_t::iterator it = mFontMap.begin();
+                 it != mFontMap.end();
+                 ++it)
+        {
+                const LLFontDescriptor* curr_desc = &(it->first);
+
+                // Ignore if not a template.
+                if (!curr_desc->isTemplate())
+                        continue;
+
+                // Ignore if font name is wrong.
+                if (curr_desc->getName() != norm_desc.getName())
+                        continue;
+
+                // Reject font if it matches any bits we don't want
+                if (curr_desc->getStyle() & ~norm_desc.getStyle())
+                {
+                        continue;
+                }
+
+                // Take if it's the first plausible candidate we've found.
+                if (!best_match_desc)
+                {
+                        best_match_desc = curr_desc;
+                        continue;
+                }
+
+                // Take if it matches more bits than anything before.
+                U8 best_style_match_bits =
+                        norm_desc.getStyle() & best_match_desc->getStyle();
+                U8 curr_style_match_bits =
+                        norm_desc.getStyle() & curr_desc->getStyle();
+                if (bitCount(curr_style_match_bits) > bitCount(best_style_match_bits))
+                {
+                        best_match_desc = curr_desc;
+                        continue;
+                }
+
+                // Tie-breaker: take if it matches bold.
+                if (curr_style_match_bits & LLFontGL::BOLD)  // Bold is requested and this descriptor matches it.
+                {
+                        best_match_desc = curr_desc;
+                        continue;
+                }
+        }
+
+        // Nothing matched.
+        return best_match_desc;
+}
+
+void LLFontRegistry::dump()
+{
+        llinfos << "LLFontRegistry dump: " << llendl;
+        for (font_size_map_t::iterator size_it = mFontSizes.begin();
+                 size_it != mFontSizes.end();
+                 ++size_it)
+        {
+                llinfos << "Size: " << size_it->first << " => " << size_it->second << llendl;
+        }
+        for (font_reg_map_t::iterator font_it = mFontMap.begin();
+                 font_it != mFontMap.end();
+                 ++font_it)
+        {
+                const LLFontDescriptor& desc = font_it->first;
+                llinfos << "Font: name=" << desc.getName()
+                                << " style=[" << ((S32)desc.getStyle()) << "]"
+                                << " size=[" << desc.getSize() << "]"
+                                << " fileNames="
+                                << llendl;
+                for (string_vec_t::const_iterator file_it=desc.getFileNames().begin();
+                         file_it != desc.getFileNames().end();
+                         ++file_it)
+                {
+                        llinfos << "  file: " << *file_it <<llendl;
+                }
+        }
+}
diff --git a/linden/indra/llrender/llfontregistry.h b/linden/indra/llrender/llfontregistry.h
new file mode 100644
index 0000000..523e184
--- /dev/null
+++ b/linden/indra/llrender/llfontregistry.h
@@ -0,0 +1,114 @@
+/** 
+ * @file llfontregistry.h
+ * @author Brad Payne
+ * @brief Storage for fonts.
+ *
+ * $LicenseInfo:firstyear=2008&license=viewergpl$
+ * 
+ * Copyright (c) 2008-2009, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLFONTREGISTRY_H
+#define LL_LLFONTREGISTRY_H
+
+#include "llxmlnode.h"
+
+class LLFontGL;
+
+typedef std::vector<std::string> string_vec_t;
+
+class LLFontDescriptor
+{
+public:
+        LLFontDescriptor();
+        LLFontDescriptor(const std::string& name, const std::string& size, const U8 style);
+        LLFontDescriptor(const std::string& name, const std::string& size, const U8 style, const string_vec_t& file_names);
+        LLFontDescriptor normalize() const;
+
+        bool operator<(const LLFontDescriptor& b) const;
+
+        bool isTemplate() const;
+        
+        const std::string& getName() const { return mName; }
+        void setName(const std::string& name) { mName = name; }
+        const std::string& getSize() const { return mSize; }
+        void setSize(const std::string& size) { mSize = size; }
+        const std::vector<std::string>& getFileNames() const { return mFileNames; }
+        std::vector<std::string>& getFileNames() { return mFileNames; }
+        const U8 getStyle() const { return mStyle; }
+        void setStyle(U8 style) { mStyle = style; }
+
+private:
+        std::string mName;
+        std::string mSize;
+        string_vec_t mFileNames;
+        U8 mStyle;
+};
+
+class LLFontRegistry
+{
+public:
+        LLFontRegistry(const string_vec_t& xui_paths);
+        ~LLFontRegistry();
+
+        // Load standard font info from XML file(s).
+        bool parseFontInfo(const std::string& xml_filename); 
+        bool initFromXML(LLXMLNodePtr node);
+
+        // Clear cached glyphs for all fonts.
+        void reset();
+
+        // Destroy all fonts.
+        void clear();
+
+        // GL cleanup
+        void destroyGL();
+                
+        LLFontGL *getFont(const LLFontDescriptor& desc);
+        const LLFontDescriptor *getMatchingFontDesc(const LLFontDescriptor& desc);
+        const LLFontDescriptor *getClosestFontTemplate(const LLFontDescriptor& desc);
+
+        bool nameToSize(const std::string& size_name, F32& size);
+
+        void dump();
+        
+        const string_vec_t& getUltimateFallbackList() const { return mUltimateFallbackList; }
+
+private:
+        LLFontGL *createFont(const LLFontDescriptor& desc);
+        typedef std::map<LLFontDescriptor,LLFontGL*> font_reg_map_t;
+        typedef std::map<std::string,F32> font_size_map_t;
+
+        // Given a descriptor, look up specific font instantiation.
+        font_reg_map_t mFontMap;
+        // Given a size name, look up the point size.
+        font_size_map_t mFontSizes;
+
+        string_vec_t mUltimateFallbackList;
+        string_vec_t mXUIPaths;
+};
+
+#endif // LL_LLFONTREGISTRY_H
diff --git a/linden/indra/llrender/llgl.cpp b/linden/indra/llrender/llgl.cpp
index a9cf073..61194c4 100644
--- a/linden/indra/llrender/llgl.cpp
+++ b/linden/indra/llrender/llgl.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -64,7 +65,7 @@ LLMatrix4 gGLObliqueProjectionInverse;
 
 LLGLNamePool::pool_list_t LLGLNamePool::sInstances;
 
-#if (LL_WINDOWS || LL_LINUX) && !LL_MESA_HEADLESS
+#if (LL_WINDOWS || LL_LINUX || LL_SOLARIS)  && !LL_MESA_HEADLESS
 // ATI prototypes
 // vertex blending prototypes
 PFNGLWEIGHTPOINTERARBPROC                       glWeightPointerARB = NULL;
@@ -132,6 +133,15 @@ PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT = NULL;
 PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT = NULL;
 PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT = NULL;
 
+// GL_EXT_framebuffer_multisample
+PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC glRenderbufferStorageMultisampleEXT = NULL;
+
+// GL_EXT_framebuffer_blit
+PFNGLBLITFRAMEBUFFEREXTPROC glBlitFramebufferEXT = NULL;
+
+// GL_ARB_draw_buffers
+PFNGLDRAWBUFFERSARBPROC glDrawBuffersARB = NULL;
+
 //shader object prototypes
 PFNGLDELETEOBJECTARBPROC glDeleteObjectARB = NULL;
 PFNGLGETHANDLEARBPROC glGetHandleARB = NULL;
@@ -174,7 +184,7 @@ PFNGLGETUNIFORMIVARBPROC glGetUniformivARB = NULL;
 PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB = NULL;
 
 // vertex shader prototypes
-#if LL_LINUX
+#if LL_LINUX || LL_SOLARIS
 PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB = NULL;
 PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB = NULL;
 PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB = NULL;
@@ -193,7 +203,7 @@ PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB = NULL;
 PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB = NULL;
 PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB = NULL;
 PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB = NULL;
-#endif // LL_LINUX
+#endif // LL_LINUX || LL_SOLARIS
 PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4nbvARB = NULL;
 PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4nivARB = NULL;
 PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4nsvARB = NULL;
@@ -201,7 +211,7 @@ PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4nubARB = NULL;
 PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4nubvARB = NULL;
 PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4nuivARB = NULL;
 PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4nusvARB = NULL;
-#if LL_LINUX
+#if LL_LINUX  || LL_SOLARIS
 PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB = NULL;
 PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB = NULL;
 PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB = NULL;
@@ -239,7 +249,7 @@ PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB = NULL;
 PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB = NULL;
 PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB = NULL;
 PFNGLISPROGRAMARBPROC glIsProgramARB = NULL;
-#endif // LL_LINUX
+#endif // LL_LINUX || LL_SOLARIS
 PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB = NULL;
 PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB = NULL;
 PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB = NULL;
@@ -248,10 +258,12 @@ PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB = NULL;
 PFNWGLSWAPINTERVALEXTPROC                       wglSwapIntervalEXT = NULL;
 #endif
 
-#if LL_LINUX
-PFNGLCOLORTABLEEXTPROC glColorTableEXT = NULL;
-#endif // LL_LINUX
-
+#if LL_LINUX_NV_GL_HEADERS
+// linux nvidia headers.  these define these differently to mesa's.  ugh.
+PFNGLACTIVETEXTUREARBPROC glActiveTextureARB = NULL;
+PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB = NULL;
+PFNGLDRAWRANGEELEMENTSPROC glDrawRangeElements = NULL;
+#endif // LL_LINUX_NV_GL_HEADERS
 #endif
 
 LLGLManager gGLManager;
@@ -265,6 +277,7 @@ LLGLManager::LLGLManager() :
         mHasMipMapGeneration(FALSE),
         mHasCompressedTextures(FALSE),
         mHasFramebufferObject(FALSE),
+        mHasFramebufferMultisample(FALSE),
 
         mHasVertexBufferObject(FALSE),
         mHasPBuffer(FALSE),
@@ -489,7 +502,7 @@ std::string LLGLManager::getGLInfoString()
         info_str += std::string("GL_RENDERER    ") + ll_safe_string((const char *)glGetString(GL_RENDERER)) + std::string("\n");
         info_str += std::string("GL_VERSION     ") + ll_safe_string((const char *)glGetString(GL_VERSION)) + std::string("\n");
 
-#if !LL_MESA_HEADLESS
+#if !LL_MESA_HEADLESS 
         all_exts = (const char *)gGLHExts.mSysExts;
         LLStringUtil::replaceChar(all_exts, ' ', '\n');
         info_str += std::string("GL_EXTENSIONS:\n") + all_exts + std::string("\n");
@@ -564,6 +577,16 @@ void LLGLManager::initExtensions()
 # else
         mHasFramebufferObject = FALSE;
 # endif
+# if GL_EXT_framebuffer_multisample
+        mHasFramebufferMultisample = TRUE;
+# else
+        mHasFramebufferMultisample = FALSE;
+# endif
+# if GL_ARB_draw_buffers
+        mHasDrawBuffers = TRUE;
+#else
+        mHasDrawBuffers = FALSE;
+# endif
         mHasMipMapGeneration = FALSE;
         mHasSeparateSpecularColor = FALSE;
         mHasAnisotropic = FALSE;
@@ -587,6 +610,8 @@ void LLGLManager::initExtensions()
         // mask out FBO support when packed_depth_stencil isn't there 'cause we need it for LLRenderTarget -Brad
         mHasFramebufferObject = ExtensionExists("GL_EXT_framebuffer_object", gGLHExts.mSysExts)
                 && ExtensionExists("GL_EXT_packed_depth_stencil", gGLHExts.mSysExts);
+        mHasFramebufferMultisample = mHasFramebufferObject && ExtensionExists("GL_EXT_framebuffer_multisample", gGLHExts.mSysExts);
+        mHasDrawBuffers = ExtensionExists("GL_ARB_draw_buffers", gGLHExts.mSysExts);
 #if !LL_DARWIN
         mHasPointParameters = !mIsATI && ExtensionExists("GL_ARB_point_parameters", gGLHExts.mSysExts);
 #endif
@@ -596,7 +621,8 @@ void LLGLManager::initExtensions()
         mHasFragmentShader = ExtensionExists("GL_ARB_fragment_shader", gGLHExts.mSysExts) && ExtensionExists("GL_ARB_shading_language_100", gGLHExts.mSysExts);
 #endif
 
-#if LL_LINUX
+#if LL_LINUX || LL_SOLARIS
+        llinfos << "initExtensions() checking shell variables to adjust features..." << llendl;
         // Our extension support for the Linux Client is very young with some
         // potential driver gotchas, so offer a semi-secret way to turn it off.
         if (getenv("LL_GL_NOEXT"))      /* Flawfinder: ignore */
@@ -606,6 +632,8 @@ void LLGLManager::initExtensions()
                 mHasCompressedTextures = FALSE;
                 mHasVertexBufferObject = FALSE;
                 mHasFramebufferObject = FALSE;
+                mHasFramebufferMultisample = FALSE;
+                mHasDrawBuffers = FALSE;
                 mHasMipMapGeneration = FALSE;
                 mHasSeparateSpecularColor = FALSE;
                 mHasAnisotropic = FALSE;
@@ -655,8 +683,11 @@ void LLGLManager::initExtensions()
                 if (strchr(blacklist,'o')) mHasFragmentShader = FALSE;//S
                 if (strchr(blacklist,'p')) mHasPointParameters = FALSE;//S
                 if (strchr(blacklist,'q')) mHasFramebufferObject = FALSE;//S
+                if (strchr(blacklist,'r')) mHasDrawBuffers = FALSE;//S
+                if (strchr(blacklist,'s')) mHasFramebufferMultisample = FALSE;
+
         }
-#endif // LL_LINUX
+#endif // LL_LINUX || LL_SOLARIS
         
         if (!mHasMultitexture)
         {
@@ -719,7 +750,7 @@ void LLGLManager::initExtensions()
         glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, (GLint*) &mGLMaxVertexRange);
         glGetIntegerv(GL_MAX_ELEMENTS_INDICES, (GLint*) &mGLMaxIndexRange);
         
-#if (LL_WINDOWS || LL_LINUX) && !LL_MESA_HEADLESS
+#if (LL_WINDOWS || LL_LINUX || LL_SOLARIS) && !LL_MESA_HEADLESS
         LL_DEBUGS("RenderInit") << "GL Probe: Getting symbols" << LL_ENDL;
         if (mHasVertexBufferObject)
         {
@@ -744,6 +775,7 @@ void LLGLManager::initExtensions()
         }
         if (mHasFramebufferObject)
         {
+                llinfos << "initExtensions() FramebufferObject-related procs..." << llendl;
                 glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glIsRenderbufferEXT");
                 glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glBindRenderbufferEXT");
                 glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glDeleteRenderbuffersEXT");
@@ -762,18 +794,33 @@ void LLGLManager::initExtensions()
                 glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGetFramebufferAttachmentParameterivEXT");
                 glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGenerateMipmapEXT");
         }
-#if !LL_LINUX
-        // This is expected to be a static symbol on Linux GL implementations
+        if (mHasFramebufferMultisample)
+        {
+                glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glRenderbufferStorageMultisampleEXT");
+                glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glBlitFramebufferEXT");
+        }
+        if (mHasDrawBuffers)
+        {
+                glDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC) GLH_EXT_GET_PROC_ADDRESS("glDrawBuffersARB");
+        }
+#if (!LL_LINUX && !LL_SOLARIS) || LL_LINUX_NV_GL_HEADERS
+        // This is expected to be a static symbol on Linux GL implementations, except if we use the nvidia headers - bah
         glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)GLH_EXT_GET_PROC_ADDRESS("glDrawRangeElements");
         if (!glDrawRangeElements)
         {
                 mGLMaxVertexRange = 0;
                 mGLMaxIndexRange = 0;
         }
-#endif // !LL_LINUX
+#endif // !LL_LINUX || LL_LINUX_NV_GL_HEADERS
+#if LL_LINUX_NV_GL_HEADERS
+        // nvidia headers are critically different from mesa-esque
+        glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)GLH_EXT_GET_PROC_ADDRESS("glActiveTextureARB");
+        glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)GLH_EXT_GET_PROC_ADDRESS("glClientActiveTextureARB");
+#endif // LL_LINUX_NV_GL_HEADERS
 
         if (mHasOcclusionQuery)
         {
+                llinfos << "initExtensions() OcclusionQuery-related procs..." << llendl;
                 glGenQueriesARB = (PFNGLGENQUERIESARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGenQueriesARB");
                 glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)GLH_EXT_GET_PROC_ADDRESS("glDeleteQueriesARB");
                 glIsQueryARB = (PFNGLISQUERYARBPROC)GLH_EXT_GET_PROC_ADDRESS("glIsQueryARB");
@@ -785,6 +832,7 @@ void LLGLManager::initExtensions()
         }
         if (mHasPointParameters)
         {
+                llinfos << "initExtensions() PointParameters-related procs..." << llendl;
                 glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)GLH_EXT_GET_PROC_ADDRESS("glPointParameterfARB");
                 glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glPointParameterfvARB");
         }
@@ -832,6 +880,7 @@ void LLGLManager::initExtensions()
         }
         if (mHasVertexShader)
         {
+                llinfos << "initExtensions() VertexShader-related procs..." << llendl;
                 glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetAttribLocationARB");
                 glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC) GLH_EXT_GET_PROC_ADDRESS("glBindAttribLocationARB");
                 glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetActiveAttribARB");
@@ -944,7 +993,7 @@ void assert_glerror()
                 {
                         // gluErrorString returns NULL for some extensions' error codes.
                         // you'll probably have to grep for the number in glext.h.
-                        LL_WARNS("RenderState") << "GL Error: UNKNOWN 0x" << std::hex << error << LL_ENDL;
+                        LL_WARNS("RenderState") << "GL Error: UNKNOWN 0x" << std::hex << error << std::dec << LL_ENDL;
                 }
                 error = glGetError();
 #endif
@@ -980,12 +1029,14 @@ void LLGLState::initClass()
 {
         sStateMap[GL_DITHER] = GL_TRUE;
         // sStateMap[GL_TEXTURE_2D] = GL_TRUE;
-
+        
         //make sure multisample defaults to disabled
         sStateMap[GL_MULTISAMPLE_ARB] = GL_FALSE;
         glDisable(GL_MULTISAMPLE_ARB);
 
-        //default vertex arrays to enabled.
+        sStateMap[GL_MULTISAMPLE_ARB] = GL_FALSE;
+        glDisable(GL_MULTISAMPLE_ARB);
+
         glEnableClientState(GL_VERTEX_ARRAY);
 }
 
@@ -1038,7 +1089,7 @@ void LLGLState::checkStates(const std::string& msg)
         
         if (src != GL_SRC_ALPHA || dst != GL_ONE_MINUS_SRC_ALPHA)
         {
-                LL_GL_ERRS << "Blend function corrupted: " << std::hex << src << " " << std::hex << dst << "  " << msg << LL_ENDL;
+                LL_GL_ERRS << "Blend function corrupted: " << std::hex << src << " " << std::hex << dst << "  " << msg << std::dec << LL_ENDL;
         }
         
         for (std::map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
@@ -1077,7 +1128,7 @@ void LLGLState::checkTextureChannels(const std::string& msg)
                 if (tex_env_mode != GL_MODULATE)
                 {
                         error = TRUE;
-                        LL_WARNS("RenderState") << "GL_TEXTURE_ENV_MODE invalid: " << std::hex << tex_env_mode << LL_ENDL;
+                        LL_WARNS("RenderState") << "GL_TEXTURE_ENV_MODE invalid: " << std::hex << tex_env_mode << std::dec << LL_ENDL;
                 }
         }
 
@@ -1093,7 +1144,8 @@ void LLGLState::checkTextureChannels(const std::string& msg)
                 "GL_TEXTURE_GEN_S",
                 "GL_TEXTURE_GEN_T",
                 "GL_TEXTURE_GEN_Q",
-                "GL_TEXTURE_GEN_R"
+                "GL_TEXTURE_GEN_R",
+                "GL_TEXTURE_RECTANGLE_ARB"
         };
 
         static GLint value[] =
@@ -1105,7 +1157,8 @@ void LLGLState::checkTextureChannels(const std::string& msg)
                 GL_TEXTURE_GEN_S,
                 GL_TEXTURE_GEN_T,
                 GL_TEXTURE_GEN_Q,
-                GL_TEXTURE_GEN_R
+                GL_TEXTURE_GEN_R,
+                GL_TEXTURE_RECTANGLE_ARB
         };
 
         GLint stackDepth = 0;
@@ -1133,7 +1186,7 @@ void LLGLState::checkTextureChannels(const std::string& msg)
                         LL_WARNS("RenderState") << "Texture matrix in channel " << i << " corrupt." << LL_ENDL;
                 }
 
-                for (S32 j = (i == 0 ? 1 : 0); j < 8; j++)
+                for (S32 j = (i == 0 ? 1 : 0); j < 9; j++)
                 {
                         if (glIsEnabled(value[j]))
                         {
@@ -1141,6 +1194,18 @@ void LLGLState::checkTextureChannels(const std::string& msg)
                                 LL_WARNS("RenderState") << "Texture channel " << i << " still has " << label[j] << " enabled." << LL_ENDL;
                         }
                 }
+
+                glh::matrix4f mat;
+                glh::matrix4f identity;
+                identity.identity();
+
+                glGetFloatv(GL_TEXTURE_MATRIX, mat.m);
+
+                if (mat != identity)
+                {
+                        error = TRUE;
+                        LL_WARNS("RenderState") << "Texture matrix " << i << " is not identity." << LL_ENDL;
+                }
         }
 
         gGL.getTexUnit(0)->activate();
@@ -1262,6 +1327,22 @@ void LLGLState::checkClientArrays(const std::string& msg, U32 data_mask)
         glClientActiveTextureARB(GL_TEXTURE0_ARB);
         gGL.getTexUnit(0)->activate();
 
+        if (gGLManager.mHasVertexShader)
+        {       //make sure vertex attribs are all disabled
+                GLint count;
+                glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &count);
+                for (GLint i = 0; i < count; i++)
+                {
+                        GLint enabled;
+                        glGetVertexAttribivARB((GLuint) i, GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB, &enabled);
+                        if (enabled)
+                        {
+                                error = TRUE;
+                                LL_WARNS("RenderState") << "GL still has vertex attrib array " << i << " enabled." << LL_ENDL;
+                        }
+                }
+        }
+
         if (error)
         {
                 LL_GL_ERRS << "GL client array corruption detected.  " << msg << LL_ENDL;
@@ -1647,6 +1728,7 @@ void LLGLNamePool::cleanupPools()
 LLGLDepthTest::LLGLDepthTest(GLboolean depth_enabled, GLboolean write_enabled, GLenum depth_func)
 : mPrevDepthEnabled(sDepthEnabled), mPrevDepthFunc(sDepthFunc), mPrevWriteEnabled(sWriteEnabled)
 {
+        stop_glerror();
         if (depth_enabled != sDepthEnabled)
         {
                 gGL.flush();
diff --git a/linden/indra/llrender/llgl.h b/linden/indra/llrender/llgl.h
index 011fd63..00ff1e2 100644
--- a/linden/indra/llrender/llgl.h
+++ b/linden/indra/llrender/llgl.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -76,7 +77,8 @@ public:
         BOOL mHasMipMapGeneration;
         BOOL mHasCompressedTextures;
         BOOL mHasFramebufferObject;
-
+        BOOL mHasFramebufferMultisample;
+        
         // ARB Extensions
         BOOL mHasVertexBufferObject;
         BOOL mHasPBuffer;
@@ -85,6 +87,7 @@ public:
         BOOL mHasFragmentShader;
         BOOL mHasOcclusionQuery;
         BOOL mHasPointParameters;
+        BOOL mHasDrawBuffers;
 
         // Other extensions.
         BOOL mHasAnisotropic;
diff --git a/linden/indra/llrender/llgldbg.cpp b/linden/indra/llrender/llgldbg.cpp
index 27b45a9..c54ab18 100644
--- a/linden/indra/llrender/llgldbg.cpp
+++ b/linden/indra/llrender/llgldbg.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
diff --git a/linden/indra/llrender/llgldbg.h b/linden/indra/llrender/llgldbg.h
index 73ab7fc..d989091 100644
--- a/linden/indra/llrender/llgldbg.h
+++ b/linden/indra/llrender/llgldbg.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
diff --git a/linden/indra/llrender/llglheaders.h b/linden/indra/llrender/llglheaders.h
index 20a420b..c7178a5 100644
--- a/linden/indra/llrender/llglheaders.h
+++ b/linden/indra/llrender/llglheaders.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -32,11 +33,215 @@
 #ifndef LL_LLGLHEADERS_H
 #define LL_LLGLHEADERS_H
 
-#if LL_MESA
+#if LL_SOLARIS
+#   if defined(__sparc)
+#      define I_NEED_OS2_H      //  avoiding BOOL conflicts
+#   endif
+#   include "GL/gl.h"
+#   if defined(__sparc)
+#      undef I_NEED_OS2_H
+#      ifdef BOOL
+#         undef BOOL            // now get rid of Xmd.h crap
+#      endif
+#   endif
+#   include "GL/glx.h"
+#   define  GL_GLEXT_PROTOTYPES 1
+#   include "GL/glext.h"
+#   include "GL/glu.h"
+#   include "GL/glx.h"
+#   define  GLX_GLXEXT_PROTOTYPES 1
+#   include "GL/glxext.h"
+//#   define  GLH_EXT_GET_PROC_ADDRESS(p) glXGetProcAddressARB((const GLubyte*)(p))
+#   define  GLH_EXT_GET_PROC_ADDRESS(p) glXGetProcAddress((const GLubyte*)(p))
+//  the X headers define 'Status'.  Undefine to avoid confusion.
+#undef Status
+
+// The __APPLE__ kludge is to make glh_extensions.h not symbol-clash horribly
+// This header is distributed with SL.  You'll find it in linden/libraries/include/GL/
+# define __APPLE__
+# include "GL/glh_extensions.h"
+# undef __APPLE__
+
+
+// GL_ARB_vertex_buffer_object
+extern PFNGLBINDBUFFERARBPROC           glBindBufferARB;
+extern PFNGLDELETEBUFFERSARBPROC        glDeleteBuffersARB;
+extern PFNGLGENBUFFERSARBPROC           glGenBuffersARB;
+extern PFNGLISBUFFERARBPROC                     glIsBufferARB;
+extern PFNGLBUFFERDATAARBPROC           glBufferDataARB;
+extern PFNGLBUFFERSUBDATAARBPROC        glBufferSubDataARB;
+extern PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB;
+extern PFNGLMAPBUFFERARBPROC            glMapBufferARB;
+extern PFNGLUNMAPBUFFERARBPROC          glUnmapBufferARB;
+extern PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB;
+extern PFNGLGETBUFFERPOINTERVARBPROC    glGetBufferPointervARB;
+
+// GL_ATI_vertex_array_object
+extern PFNGLNEWOBJECTBUFFERATIPROC                      glNewObjectBufferATI;
+extern PFNGLISOBJECTBUFFERATIPROC                       glIsObjectBufferATI;
+extern PFNGLUPDATEOBJECTBUFFERATIPROC           glUpdateObjectBufferATI;
+extern PFNGLGETOBJECTBUFFERFVATIPROC            glGetObjectBufferfvATI;
+extern PFNGLGETOBJECTBUFFERIVATIPROC            glGetObjectBufferivATI;
+extern PFNGLFREEOBJECTBUFFERATIPROC                 glFreeObjectBufferATI;
+extern PFNGLARRAYOBJECTATIPROC                          glArrayObjectATI;
+extern PFNGLVERTEXATTRIBARRAYOBJECTATIPROC      glVertexAttribArrayObjectATI;
+extern PFNGLGETARRAYOBJECTFVATIPROC                     glGetArrayObjectfvATI;
+extern PFNGLGETARRAYOBJECTIVATIPROC                     glGetArrayObjectivATI;
+extern PFNGLVARIANTARRAYOBJECTATIPROC           glVariantObjectArrayATI;
+extern PFNGLGETVARIANTARRAYOBJECTFVATIPROC      glGetVariantArrayObjectfvATI;
+extern PFNGLGETVARIANTARRAYOBJECTIVATIPROC      glGetVariantArrayObjectivATI;
+
+// GL_ARB_occlusion_query
+extern PFNGLGENQUERIESARBPROC glGenQueriesARB;
+extern PFNGLDELETEQUERIESARBPROC glDeleteQueriesARB;
+extern PFNGLISQUERYARBPROC glIsQueryARB;
+extern PFNGLBEGINQUERYARBPROC glBeginQueryARB;
+extern PFNGLENDQUERYARBPROC glEndQueryARB;
+extern PFNGLGETQUERYIVARBPROC glGetQueryivARB;
+extern PFNGLGETQUERYOBJECTIVARBPROC glGetQueryObjectivARB;
+extern PFNGLGETQUERYOBJECTUIVARBPROC glGetQueryObjectuivARB;
+
+// GL_ARB_point_parameters
+extern PFNGLPOINTPARAMETERFARBPROC glPointParameterfARB;
+extern PFNGLPOINTPARAMETERFVARBPROC glPointParameterfvARB;
+
+// GL_ARB_shader_objects
+extern PFNGLDELETEOBJECTARBPROC glDeleteObjectARB;
+extern PFNGLGETHANDLEARBPROC glGetHandleARB;
+extern PFNGLDETACHOBJECTARBPROC glDetachObjectARB;
+extern PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB;
+extern PFNGLSHADERSOURCEARBPROC glShaderSourceARB;
+extern PFNGLCOMPILESHADERARBPROC glCompileShaderARB;
+extern PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB;
+extern PFNGLATTACHOBJECTARBPROC glAttachObjectARB;
+extern PFNGLLINKPROGRAMARBPROC glLinkProgramARB;
+extern PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB;
+extern PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB;
+extern PFNGLUNIFORM1FARBPROC glUniform1fARB;
+extern PFNGLUNIFORM2FARBPROC glUniform2fARB;
+extern PFNGLUNIFORM3FARBPROC glUniform3fARB;
+extern PFNGLUNIFORM4FARBPROC glUniform4fARB;
+extern PFNGLUNIFORM1IARBPROC glUniform1iARB;
+extern PFNGLUNIFORM2IARBPROC glUniform2iARB;
+extern PFNGLUNIFORM3IARBPROC glUniform3iARB;
+extern PFNGLUNIFORM4IARBPROC glUniform4iARB;
+extern PFNGLUNIFORM1FVARBPROC glUniform1fvARB;
+extern PFNGLUNIFORM2FVARBPROC glUniform2fvARB;
+extern PFNGLUNIFORM3FVARBPROC glUniform3fvARB;
+extern PFNGLUNIFORM4FVARBPROC glUniform4fvARB;
+extern PFNGLUNIFORM1IVARBPROC glUniform1ivARB;
+extern PFNGLUNIFORM2IVARBPROC glUniform2ivARB;
+extern PFNGLUNIFORM3IVARBPROC glUniform3ivARB;
+extern PFNGLUNIFORM4IVARBPROC glUniform4ivARB;
+extern PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB;
+extern PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB;
+extern PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB;
+extern PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB;
+extern PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB;
+extern PFNGLGETINFOLOGARBPROC glGetInfoLogARB;
+extern PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB;
+extern PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB;
+extern PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB;
+extern PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB;
+extern PFNGLGETUNIFORMIVARBPROC glGetUniformivARB;
+extern PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB;
+
+// GL_ARB_vertex_shader
+extern PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB;
+extern PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB;
+extern PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB;
+extern PFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB;
+extern PFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB;
+extern PFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB;
+extern PFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB;
+extern PFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB;
+extern PFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB;
+extern PFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB;
+extern PFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB;
+extern PFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB;
+extern PFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB;
+extern PFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB;
+extern PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB;
+extern PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB;
+extern PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB;
+extern PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB;
+extern PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4nbvARB;
+extern PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4nivARB;
+extern PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4nsvARB;
+extern PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4nubARB;
+extern PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4nubvARB;
+extern PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4nuivARB;
+extern PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4nusvARB;
+extern PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB;
+extern PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB;
+extern PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB;
+extern PFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB;
+extern PFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB;
+extern PFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB;
+extern PFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB;
+extern PFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB;
+extern PFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB;
+extern PFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB;
+extern PFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB;
+extern PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB;
+extern PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB;
+extern PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB;
+extern PFNGLPROGRAMSTRINGARBPROC glProgramStringARB;
+extern PFNGLBINDPROGRAMARBPROC glBindProgramARB;
+extern PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB;
+extern PFNGLGENPROGRAMSARBPROC glGenProgramsARB;
+extern PFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB;
+extern PFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB;
+extern PFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB;
+extern PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB;
+extern PFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB;
+extern PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB;
+extern PFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB;
+extern PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB;
+extern PFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB;
+extern PFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB;
+extern PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB;
+extern PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB;
+extern PFNGLGETPROGRAMIVARBPROC glGetProgramivARB;
+extern PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB;
+extern PFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB;
+extern PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB;
+extern PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB;
+extern PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB;
+extern PFNGLISPROGRAMARBPROC glIsProgramARB;
+extern PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB;
+extern PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB;
+extern PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB;
+
+extern PFNGLCOMPRESSEDTEXIMAGE2DARBPROC glCompressedTexImage2DARB;
+extern PFNGLGETCOMPRESSEDTEXIMAGEARBPROC glGetCompressedTexImageARB;
+
+extern PFNGLCOLORTABLEEXTPROC glColorTableEXT;
+
+//GL_EXT_framebuffer_object
+extern PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT;
+extern PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT;
+extern PFNGLDELETERENDERBUFFERSEXTPROC glDeleteRenderbuffersEXT;
+extern PFNGLGENRENDERBUFFERSEXTPROC glGenRenderbuffersEXT;
+extern PFNGLRENDERBUFFERSTORAGEEXTPROC glRenderbufferStorageEXT;
+extern PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glGetRenderbufferParameterivEXT;
+extern PFNGLISFRAMEBUFFEREXTPROC glIsFramebufferEXT;
+extern PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT;
+extern PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT;
+extern PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT;
+extern PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT;
+extern PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glFramebufferTexture1DEXT;
+extern PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT;
+extern PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glFramebufferTexture3DEXT;
+extern PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT;
+extern PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT;
+extern PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT;
+
+#elif LL_MESA
 //----------------------------------------------------------------------------
 // MESA headers
 // quotes so we get libraries/.../GL/ version
-#define GL_GLEXT_PROTOTYPES
+#define GL_GLEXT_PROTOTYPES 1
 #include "GL/gl.h"
 #include "GL/glext.h"
 #include "GL/glu.h"
@@ -46,7 +251,7 @@
 # include "GL/glh_extensions.h"
 # undef __APPLE__
 
-#elif LL_LINUX
+#elif LL_LINUX 
 //----------------------------------------------------------------------------
 // Linux, MESA headers, but not necessarily assuming MESA runtime.
 // quotes so we get libraries/.../GL/ version
@@ -76,6 +281,20 @@
 #undef Status
 #endif // LL_LINUX && !LL_MESA_HEADLESS
 
+#if LL_LINUX && defined(WINGDIAPI)
+// WINGDIAPI gets set if we are using the linux nvidia gl.h header which needs
+// the functions below setting up.
+# define LL_LINUX_NV_GL_HEADERS 1
+#else
+# define LL_LINUX_NV_GL_HEADERS 0
+#endif // LL_LINUX && defined(WINGDIAPI)
+
+#if LL_LINUX_NV_GL_HEADERS
+// Missing functions when using nvidia headers:
+extern PFNGLACTIVETEXTUREARBPROC        glActiveTextureARB;
+extern PFNGLCLIENTACTIVETEXTUREARBPROC  glClientActiveTextureARB;
+extern PFNGLDRAWRANGEELEMENTSPROC       glDrawRangeElements;
+#endif // LL_LINUX_NV_GL_HEADERS
 
 // GL_ARB_vertex_buffer_object
 extern PFNGLBINDBUFFERARBPROC           glBindBufferARB;
@@ -230,8 +449,6 @@ extern PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB;
 extern PFNGLCOMPRESSEDTEXIMAGE2DARBPROC glCompressedTexImage2DARB;
 extern PFNGLGETCOMPRESSEDTEXIMAGEARBPROC glGetCompressedTexImageARB;
 
-extern PFNGLCOLORTABLEEXTPROC glColorTableEXT;
-
 //GL_EXT_framebuffer_object
 extern PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT;
 extern PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT;
@@ -251,6 +468,14 @@ extern PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT;
 extern PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT;
 extern PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT;
 
+// GL_EXT_framebuffer_multisample
+extern PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC glRenderbufferStorageMultisampleEXT;
+
+// GL_EXT_framebuffer_blit
+extern PFNGLBLITFRAMEBUFFEREXTPROC glBlitFramebufferEXT;
+
+//GL_ARB_draw_buffers
+extern PFNGLDRAWBUFFERSARBPROC glDrawBuffersARB;
 
 #elif LL_WINDOWS
 
@@ -439,6 +664,14 @@ extern PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT;
 extern PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT;
 extern PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT;
 
+// GL_EXT_framebuffer_multisample
+extern PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC glRenderbufferStorageMultisampleEXT;
+
+// GL_EXT_framebuffer_blit
+extern PFNGLBLITFRAMEBUFFEREXTPROC glBlitFramebufferEXT;
+
+//GL_ARB_draw_buffers
+extern PFNGLDRAWBUFFERSARBPROC glDrawBuffersARB;
 
 #elif LL_DARWIN
 //----------------------------------------------------------------------------
@@ -475,6 +708,8 @@ extern void glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenu
 extern void glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint *params) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
 extern void glGenerateMipmapEXT(GLenum target) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
 
+// GL_ARB_draw_buffers
+extern void glDrawBuffersARB(GLsizei n, const GLenum* bufs) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/linden/indra/llrender/llglimmediate.cpp b/linden/indra/llrender/llglimmediate.cpp
index bade1aa..17c2182 100644
--- a/linden/indra/llrender/llglimmediate.cpp
+++ b/linden/indra/llrender/llglimmediate.cpp
@@ -1,265 +1 @@
-<<<<<<< .working
 #error This file has been renamed llrender.cpp
-=======
-/** 
- * @file llglimmediate.cpp
- * @brief LLGLImmediate implementation
- *
- * $LicenseInfo:firstyear=2001&license=viewergpl$
- * 
- * Copyright (c) 2001-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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.
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "llglimmediate.h"
-#include "llvertexbuffer.h"
-
-LLGLImmediate gGL;
-
-const U32 immediate_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXCOORD;
-
-LLGLImmediate::LLGLImmediate()
-{
-        mCount = 0;
-        mMode = LLVertexBuffer::TRIANGLES;
-        mBuffer = new LLVertexBuffer(immediate_mask, 0);
-        mBuffer->allocateBuffer(4096, 0, TRUE);
-        mBuffer->getVertexStrider(mVerticesp);
-        mBuffer->getTexCoordStrider(mTexcoordsp);
-        mBuffer->getColorStrider(mColorsp);
-}
-
-void LLGLImmediate::translatef(const GLfloat& x, const GLfloat& y, const GLfloat& z)
-{
-        flush();
-        glTranslatef(x,y,z);
-}
-
-void LLGLImmediate::scalef(const GLfloat& x, const GLfloat& y, const GLfloat& z)
-{
-        flush();
-        glScalef(x,y,z);
-}
-
-void LLGLImmediate::pushMatrix()
-{
-        flush();
-        glPushMatrix();
-}
-
-void LLGLImmediate::popMatrix()
-{
-        flush();
-        glPopMatrix();
-}
-
-void LLGLImmediate::blendFunc(GLenum sfactor, GLenum dfactor)
-{
-        flush();
-        glBlendFunc(sfactor, dfactor);
-}
-
-void LLGLImmediate::begin(const GLuint& mode)
-{
-        if (mode != mMode)
-        {
-                if (mMode == LLVertexBuffer::QUADS ||
-                        mMode == LLVertexBuffer::LINES ||
-                        mMode == LLVertexBuffer::TRIANGLES ||
-                        mMode == LLVertexBuffer::POINTS)
-                {
-                        flush();
-                }
-                else if (mCount != 0)
-                {
-                        llerrs << "gGL.begin() called redundantly." << llendl;
-                }
-                
-                mMode = mode;
-        }
-}
-
-void LLGLImmediate::end()
-{ 
-        if (mCount == 0)
-        {
-                return;
-                //IMM_ERRS << "GL begin and end called with no vertices specified." << llendl;
-        }
-
-        if ((mMode != LLVertexBuffer::QUADS && 
-                mMode != LLVertexBuffer::LINES &&
-                mMode != LLVertexBuffer::TRIANGLES &&
-                mMode != LLVertexBuffer::POINTS) ||
-                mCount > 2048)
-        {
-                flush();
-        }
-}
-
-void LLGLImmediate::flush()
-{
-        if (mCount > 0)
-        {
-#if 0
-                if (!glIsEnabled(GL_VERTEX_ARRAY))
-                {
-                        llerrs << "foo 1" << llendl;
-                }
-
-                if (!glIsEnabled(GL_COLOR_ARRAY))
-                {
-                        llerrs << "foo 2" << llendl;
-                }
-
-                if (!glIsEnabled(GL_TEXTURE_COORD_ARRAY))
-                {
-                        llerrs << "foo 3" << llendl;
-                }
-
-                if (glIsEnabled(GL_NORMAL_ARRAY))
-                {
-                        llerrs << "foo 7" << llendl;
-                }
-
-                GLvoid* pointer;
-
-                glGetPointerv(GL_VERTEX_ARRAY_POINTER, &pointer);
-                if (pointer != &(mBuffer[0].v))
-                {
-                        llerrs << "foo 4" << llendl;
-                }
-
-                glGetPointerv(GL_COLOR_ARRAY_POINTER, &pointer);
-                if (pointer != &(mBuffer[0].c))
-                {
-                        llerrs << "foo 5" << llendl;
-                }
-
-                glGetPointerv(GL_TEXTURE_COORD_ARRAY_POINTER, &pointer);
-                if (pointer != &(mBuffer[0].uv))
-                {
-                        llerrs << "foo 6" << llendl;
-                }
-#endif
-                                
-                mBuffer->setBuffer(immediate_mask);
-                mBuffer->drawArrays(mMode, 0, mCount);
-
-                mVerticesp[0] = mVerticesp[mCount];
-                mTexcoordsp[0] = mTexcoordsp[mCount];
-                mColorsp[0] = mColorsp[mCount];
-                mCount = 0;
-        }
-}
-
-void LLGLImmediate::vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z)
-{ 
-        if (mCount >= 4096)
-        {
-        //      llwarns << "GL immediate mode overflow.  Some geometry not drawn." << llendl;
-                return;
-        }
-
-        mVerticesp[mCount] = LLVector3(x,y,z);
-        mCount++;
-        if (mCount < 4096)
-        {
-                mVerticesp[mCount] = mVerticesp[mCount-1];
-                mColorsp[mCount] = mColorsp[mCount-1];
-                mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
-        }
-}
-
-void LLGLImmediate::vertex2i(const GLint& x, const GLint& y)
-{
-        vertex3f((GLfloat) x, (GLfloat) y, 0);  
-}
-
-void LLGLImmediate::vertex2f(const GLfloat& x, const GLfloat& y)
-{ 
-        vertex3f(x,y,0);
-}
-
-void LLGLImmediate::vertex2fv(const GLfloat* v)
-{ 
-        vertex3f(v[0], v[1], 0);
-}
-
-void LLGLImmediate::vertex3fv(const GLfloat* v)
-{
-        vertex3f(v[0], v[1], v[2]);
-}
-
-void LLGLImmediate::texCoord2f(const GLfloat& x, const GLfloat& y)
-{ 
-        mTexcoordsp[mCount] = LLVector2(x,y);
-}
-
-void LLGLImmediate::texCoord2i(const GLint& x, const GLint& y)
-{ 
-        texCoord2f((GLfloat) x, (GLfloat) y);
-}
-
-void LLGLImmediate::texCoord2fv(const GLfloat* tc)
-{ 
-        texCoord2f(tc[0], tc[1]);
-}
-
-void LLGLImmediate::color4ub(const GLubyte& r, const GLubyte& g, const GLubyte& b, const GLubyte& a)
-{
-        mColorsp[mCount] = LLColor4U(r,g,b,a);
-}
-
-void LLGLImmediate::color4ubv(const GLubyte* c)
-{
-        color4ub(c[0], c[1], c[2], c[3]);
-}
-
-void LLGLImmediate::color4f(const GLfloat& r, const GLfloat& g, const GLfloat& b, const GLfloat& a)
-{
-        color4ub((GLubyte) (llclamp(r, 0.f, 1.f)*255),
-                (GLubyte) (llclamp(g, 0.f, 1.f)*255),
-                (GLubyte) (llclamp(b, 0.f, 1.f)*255),
-                (GLubyte) (llclamp(a, 0.f, 1.f)*255));
-}
-
-void LLGLImmediate::color4fv(const GLfloat* c)
-{ 
-        color4f(c[0],c[1],c[2],c[3]);
-}
-
-void LLGLImmediate::color3f(const GLfloat& r, const GLfloat& g, const GLfloat& b)
-{ 
-        color4f(r,g,b,1);
-}
-
-void LLGLImmediate::color3fv(const GLfloat* c)
-{ 
-        color4f(c[0],c[1],c[2],1);
-}
-
->>>>>>> .merge-right.r88690
diff --git a/linden/indra/llrender/llglimmediate.h b/linden/indra/llrender/llglimmediate.h
index 690abe0..4a7a0eb 100644
--- a/linden/indra/llrender/llglimmediate.h
+++ b/linden/indra/llrender/llglimmediate.h
@@ -1,98 +1 @@
-<<<<<<< .working
 #error This file has been renamed llrender.h
-=======
-/** 
- * @file llglimmediate.h
- * @brief LLGLImmediate definition
- *
- *      This class acts as a wrapper for OpenGL immediate calls concerning glBegin and glEnd.
- *      The goal of this class is to minimize the number of api calls due to legacy rendering
- *      code, and to define an interface for a multiple rendering API abstraction of the UI
- *      rendering.
- *
- * $LicenseInfo:firstyear=2001&license=viewergpl$
- * 
- * Copyright (c) 2001-2009, Linden Research, Inc.
- * 
- * Second Life Viewer Source Code
- * 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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.
- * $/LicenseInfo$
- */
-
-#ifndef LL_LLGLIMMEDIATE_H
-#define LL_LLGLIMMEDIATE_H
-
-#include "stdtypes.h"
-#include "llgltypes.h"
-#include "llglheaders.h"
-#include "llvertexbuffer.h"
-
-class LLGLImmediate
-{
-public:
-        LLGLImmediate();
-
-        void translatef(const GLfloat& x, const GLfloat& y, const GLfloat& z);
-        void scalef(const GLfloat& x, const GLfloat& y, const GLfloat& z);
-        void pushMatrix();
-        void popMatrix();
-        void blendFunc(GLenum sfactor, GLenum dfactor);
-        void flush();
-
-        void begin(const GLuint& mode);
-        void end();
-        void vertex2i(const GLint& x, const GLint& y);
-        void vertex2f(const GLfloat& x, const GLfloat& y);
-        void vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z);
-        void vertex2fv(const GLfloat* v);
-        void vertex3fv(const GLfloat* v);
-        
-        void texCoord2i(const GLint& x, const GLint& y);
-        void texCoord2f(const GLfloat& x, const GLfloat& y);
-        void texCoord2fv(const GLfloat* tc);
-
-        void color4ub(const GLubyte& r, const GLubyte& g, const GLubyte& b, const GLubyte& a);
-        void color4f(const GLfloat& r, const GLfloat& g, const GLfloat& b, const GLfloat& a);
-        void color4fv(const GLfloat* c);
-        void color3f(const GLfloat& r, const GLfloat& g, const GLfloat& b);
-        void color3fv(const GLfloat* c);
-        void color4ubv(const GLubyte* c);
-        
-        typedef struct
-        {
-                GLfloat v[3];
-                GLubyte c[4];
-                GLfloat uv[2];
-        } Vertex;
-
-private:
-        U32 mCount;
-        U32 mMode;
-        LLPointer<LLVertexBuffer> mBuffer;
-        LLStrider<LLVector3> mVerticesp;
-        LLStrider<LLVector2> mTexcoordsp;
-        LLStrider<LLColor4U> mColorsp;
-};
-
-extern LLGLImmediate gGL;
-
-#endif
->>>>>>> .merge-right.r88690
diff --git a/linden/indra/llrender/llglslshader.cpp b/linden/indra/llrender/llglslshader.cpp
index 6683916..08d6548 100644
--- a/linden/indra/llrender/llglslshader.cpp
+++ b/linden/indra/llrender/llglslshader.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -255,6 +256,14 @@ void LLGLSLShader::mapUniform(GLint index, const vector<string> * uniforms)
         S32 location = glGetUniformLocationARB(mProgramObject, name);
         if (location != -1)
         {
+                //chop off "[0]" so we can always access the first element
+                //of an array by the array name
+                char* is_array = strstr(name, "[0]");
+                if (is_array)
+                {
+                        is_array[0] = 0;
+                }
+
                 mUniformMap[name] = location;
                 LL_DEBUGS("ShaderLoading") << "Uniform " << name << " is at location " << location << LL_ENDL;
         
@@ -352,11 +361,17 @@ void LLGLSLShader::unbind()
 {
         if (gGLManager.mHasShaderObjects)
         {
-                for (U32 i = 0; i < mAttribute.size(); ++i)
+                stop_glerror();
+                if (gGLManager.mIsNVIDIA)
                 {
-                        vertexAttrib4f(i, 0,0,0,1);
+                        for (U32 i = 0; i < mAttribute.size(); ++i)
+                        {
+                                vertexAttrib4f(i, 0,0,0,1);
+                                stop_glerror();
+                        }
                 }
                 glUseProgramObjectARB(0);
+                stop_glerror();
         }
 }
 
@@ -389,14 +404,39 @@ S32 LLGLSLShader::disableTexture(S32 uniform, LLTexUnit::eTextureType mode)
                 return -1;
         }
         S32 index = mTexture[uniform];
-        if (index != -1)
+        if (index != -1 && gGL.getTexUnit(index)->getCurrType() != LLTexUnit::TT_NONE)
         {
-                gGL.getTexUnit(index)->activate();
+                if (gDebugGL && gGL.getTexUnit(index)->getCurrType() != mode)
+                {
+                        llerrs << "Texture channel " << index << " texture type corrupted." << llendl;
+                }
                 gGL.getTexUnit(index)->disable();
         }
         return index;
 }
 
+void LLGLSLShader::uniform1i(U32 index, GLint x)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+                        if (iter == mValue.end() || iter->second.mV[0] != x)
+                        {
+                                glUniform1iARB(mUniform[index], x);
+                                mValue[mUniform[index]] = LLVector4(x,0.f,0.f,0.f);
+                        }
+                }
+        }
+}
+
 void LLGLSLShader::uniform1f(U32 index, GLfloat x)
 {
         if (mProgramObject > 0)
@@ -488,6 +528,29 @@ void LLGLSLShader::uniform4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat
         }
 }
 
+void LLGLSLShader::uniform1iv(U32 index, U32 count, const GLint* v)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+                        LLVector4 vec(v[0],0.f,0.f,0.f);
+                        if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+                        {
+                                glUniform1ivARB(mUniform[index], count, v);
+                                mValue[mUniform[index]] = vec;
+                        }
+                }
+        }
+}
+
 void LLGLSLShader::uniform1fv(U32 index, U32 count, const GLfloat* v)
 {
         if (mProgramObject > 0)
@@ -646,6 +709,22 @@ GLint LLGLSLShader::getUniformLocation(const string& uniform)
         return -1;
 }
 
+void LLGLSLShader::uniform1i(const string& uniform, GLint v)
+{
+        GLint location = getUniformLocation(uniform);
+                                
+        if (location >= 0)
+        {
+                std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+                LLVector4 vec(v,0.f,0.f,0.f);
+                if (iter == mValue.end() || shouldChange(iter->second,vec))
+                {
+                        glUniform1iARB(location, v);
+                        mValue[location] = vec;
+                }
+        }
+}
+
 void LLGLSLShader::uniform1f(const string& uniform, GLfloat v)
 {
         GLint location = getUniformLocation(uniform);
diff --git a/linden/indra/llrender/llglslshader.h b/linden/indra/llrender/llglslshader.h
index 66c53df..166d4af 100644
--- a/linden/indra/llrender/llglslshader.h
+++ b/linden/indra/llrender/llglslshader.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -77,18 +78,22 @@ public:
         BOOL mapAttributes(const std::vector<std::string> * attributes);
         BOOL mapUniforms(const std::vector<std::string> * uniforms);
         void mapUniform(GLint index, const std::vector<std::string> * uniforms);
+        void uniform1i(U32 index, GLint i);
         void uniform1f(U32 index, GLfloat v);
         void uniform2f(U32 index, GLfloat x, GLfloat y);
         void uniform3f(U32 index, GLfloat x, GLfloat y, GLfloat z);
         void uniform4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+        void uniform1iv(U32 index, U32 count, const GLint* i);
         void uniform1fv(U32 index, U32 count, const GLfloat* v);
         void uniform2fv(U32 index, U32 count, const GLfloat* v);
         void uniform3fv(U32 index, U32 count, const GLfloat* v);
         void uniform4fv(U32 index, U32 count, const GLfloat* v);
+        void uniform1i(const std::string& uniform, GLint i);
         void uniform1f(const std::string& uniform, GLfloat v);
         void uniform2f(const std::string& uniform, GLfloat x, GLfloat y);
         void uniform3f(const std::string& uniform, GLfloat x, GLfloat y, GLfloat z);
         void uniform4f(const std::string& uniform, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+        void uniform1iv(const std::string& uniform, U32 count, const GLint* i);
         void uniform1fv(const std::string& uniform, U32 count, const GLfloat* v);
         void uniform2fv(const std::string& uniform, U32 count, const GLfloat* v);
         void uniform3fv(const std::string& uniform, U32 count, const GLfloat* v);
diff --git a/linden/indra/llrender/llglstates.h b/linden/indra/llrender/llglstates.h
index 94d136e..4a51cac 100644
--- a/linden/indra/llrender/llglstates.h
+++ b/linden/indra/llrender/llglstates.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
diff --git a/linden/indra/llrender/llgltypes.h b/linden/indra/llrender/llgltypes.h
index 5809b9c..9b0e81f 100644
--- a/linden/indra/llrender/llgltypes.h
+++ b/linden/indra/llrender/llgltypes.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
diff --git a/linden/indra/llrender/llimagegl.cpp b/linden/indra/llrender/llimagegl.cpp
index 6a142a7..cdf626e 100644
--- a/linden/indra/llrender/llimagegl.cpp
+++ b/linden/indra/llrender/llimagegl.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -62,7 +63,6 @@ BOOL LLImageGL::sGlobalUseAnisotropic	= FALSE;
 F32 LLImageGL::sLastFrameTime                   = 0.f;
 
 std::set<LLImageGL*> LLImageGL::sImageList;
-
 //**************************************************************************************
 //below are functions for debug use
 //do not delete them even though they are not currently being used.
@@ -308,21 +308,21 @@ void LLImageGL::init(BOOL usemipmaps)
 #endif
 
         mPickMask                 = NULL;
+        mTextureState       = NO_DELETE ;
         mTextureMemory    = 0;
         mLastBindTime     = 0.f;
 
         mTarget                   = GL_TEXTURE_2D;
         mBindTarget               = LLTexUnit::TT_TEXTURE;
         mUseMipMaps               = usemipmaps;
-        mHasMipMaps               = FALSE;
+        mHasMipMaps               = false;
         mAutoGenMips      = FALSE;
         mTexName          = 0;
         mIsResident       = 0;
-        mClampS                   = FALSE;
-        mClampT                   = FALSE;
-        mClampR                   = FALSE;
-        mMagFilterNearest  = FALSE;
-        mMinFilterNearest  = FALSE;
+
+        mTexOptionsDirty = true;
+        mAddressMode = LLTexUnit::TAM_WRAP;
+        mFilterOption = LLTexUnit::TFO_ANISOTROPIC;
         mWidth                          = 0;
         mHeight                         = 0;
         mComponents                     = 0;
@@ -338,6 +338,7 @@ void LLImageGL::init(BOOL usemipmaps)
         mHasExplicitFormat = FALSE;
 
         mGLTextureCreated = FALSE ;
+        mIsMask = FALSE;
 }
 
 void LLImageGL::cleanup()
@@ -468,6 +469,11 @@ bool LLImageGL::bindDefaultImage(const S32 stage) const
         return false;
 }
 
+//virtual
+void LLImageGL::forceImmediateUpdate()
+{
+        return ;
+}
 
 void LLImageGL::setExplicitFormat( LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format, BOOL swap_bytes )
 {
@@ -497,17 +503,15 @@ void LLImageGL::setImage(const LLImageRaw* imageraw)
 void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
 {
 //      LLFastTimer t1(LLFastTimer::FTM_TEMP1);
-        
+        llpushcallstacks ;
         bool is_compressed = false;
         if (mFormatPrimary >= GL_COMPRESSED_RGBA_S3TC_DXT1_EXT && mFormatPrimary <= GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
         {
                 is_compressed = true;
         }
 
-        {
 //              LLFastTimer t2(LLFastTimer::FTM_TEMP2);
-                llverify(gGL.getTexUnit(0)->bind(this));
-        }
+        gGL.getTexUnit(0)->bind(this);
         
         if (mUseMipMaps)
         {
@@ -518,6 +522,7 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
                         // are stored BEFORE the largest image
                         for (S32 d=mCurrentDiscardLevel; d<=mMaxDiscardLevel; d++)
                         {
+                                
                                 S32 w = getWidth(d);
                                 S32 h = getHeight(d);
                                 S32 gl_level = d-mCurrentDiscardLevel;
@@ -528,7 +533,7 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
                                 if (is_compressed)
                                 {
 //                                      LLFastTimer t2(LLFastTimer::FTM_TEMP4);
-                                        S32 tex_size = dataFormatBytes(mFormatPrimary, w, h);
+                                        S32 tex_size = dataFormatBytes(mFormatPrimary, w, h);
                                         glCompressedTexImage2DARB(mTarget, gl_level, mFormatPrimary, w, h, 0, tex_size, (GLvoid *)data_in);
                                         stop_glerror();
                                 }
@@ -542,7 +547,11 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
                                                 stop_glerror();
                                         }
                                                 
-                                        glTexImage2D(mTarget, gl_level, mFormatInternal, w, h, 0, mFormatPrimary, GL_UNSIGNED_BYTE, (GLvoid*)data_in);
+                                        LLImageGL::setManualImage(mTarget, gl_level, mFormatInternal, w, h, mFormatPrimary, GL_UNSIGNED_BYTE, (GLvoid*)data_in);
+                                        if (gl_level == 0)
+                                        {
+                                                analyzeAlpha(data_in, w, h);
+                                        }
                                         updatePickMask(w, h, data_in);
 
                                         if(mFormatSwapBytes)
@@ -574,10 +583,11 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
                                         S32 w = getWidth(mCurrentDiscardLevel);
                                         S32 h = getHeight(mCurrentDiscardLevel);
 
-                                        glTexImage2D(mTarget, 0, mFormatInternal,
-                                                                 w, h, 0,
+                                        LLImageGL::setManualImage(mTarget, 0, mFormatInternal,
+                                                                 w, h, 
                                                                  mFormatPrimary, mFormatType,
                                                                  data_in);
+                                        analyzeAlpha(data_in, w, h);
                                         stop_glerror();
 
                                         updatePickMask(w, h, data_in);
@@ -629,7 +639,11 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
                                                         stop_glerror();
                                                 }
 
-                                                glTexImage2D(mTarget, m, mFormatInternal, w, h, 0, mFormatPrimary, mFormatType, cur_mip_data);
+                                                LLImageGL::setManualImage(mTarget, m, mFormatInternal, w, h, mFormatPrimary, mFormatType, cur_mip_data);
+                                                if (m == 0)
+                                                {
+                                                        analyzeAlpha(data_in, w, h);
+                                                }
                                                 stop_glerror();
                                                 if (m == 0)
                                                 {
@@ -662,7 +676,7 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
                 {
                         llerrs << "Compressed Image has mipmaps but data does not (can not auto generate compressed mips)" << llendl;
                 }
-                mHasMipMaps = TRUE;
+                mHasMipMaps = true;
         }
         else
         {
@@ -683,8 +697,10 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
                                 stop_glerror();
                         }
 
-                        glTexImage2D(mTarget, 0, mFormatInternal, w, h, 0,
+                        LLImageGL::setManualImage(mTarget, 0, mFormatInternal, w, h,
                                                  mFormatPrimary, mFormatType, (GLvoid *)data_in);
+                        analyzeAlpha(data_in, w, h);
+                        
                         updatePickMask(w, h, data_in);
 
                         stop_glerror();
@@ -696,14 +712,16 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
                         }
 
                 }
-                mHasMipMaps = FALSE;
+                mHasMipMaps = false;
         }
         stop_glerror();
         mGLTextureCreated = true;
+        llpushcallstacks ;
 }
 
 BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height)
 {
+        llpushcallstacks ;
         if (!width || !height)
         {
                 return TRUE;
@@ -779,6 +797,7 @@ BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S3
 
                 glTexSubImage2D(mTarget, 0, x_pos, y_pos, 
                                                 width, height, mFormatPrimary, mFormatType, datap);
+                gGL.getTexUnit(0)->disable();
                 stop_glerror();
 
                 if(mFormatSwapBytes)
@@ -791,6 +810,7 @@ BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S3
                 stop_glerror();
                 mGLTextureCreated = true;
         }
+        llpushcallstacks ;
         return TRUE;
 }
 
@@ -815,6 +835,24 @@ BOOL LLImageGL::setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_
         }
 }
 
+// static
+void LLImageGL::generateTextures(S32 numTextures, U32 *textures)
+{
+        glGenTextures(numTextures, (GLuint*)textures);
+}
+
+// static
+void LLImageGL::deleteTextures(S32 numTextures, U32 *textures)
+{
+        glDeleteTextures(numTextures, (GLuint*)textures);
+}
+
+// static
+void LLImageGL::setManualImage(U32 target, S32 miplevel, S32 intformat, S32 width, S32 height, U32 pixformat, U32 pixtype, const void *pixels)
+{
+        glTexImage2D(target, miplevel, intformat, width, height, 0, pixformat, pixtype, pixels);
+}
+
 //create an empty GL texture: just create a texture name
 //the texture is assiciate with some image by calling glTexImage outside LLImageGL
 BOOL LLImageGL::createGLTexture()
@@ -847,6 +885,7 @@ BOOL LLImageGL::createGLTexture()
 
 BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename/*=0*/)
 {
+        llpushcallstacks ;
         if (gGLManager.mIsDisabled)
         {
                 llwarns << "Trying to create a texture while GL is disabled!" << llendl;
@@ -907,6 +946,7 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
 
 BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_hasmips, S32 usename)
 {
+        llpushcallstacks ;
         llassert(data_in);
 
         if (discard_level < 0)
@@ -923,7 +963,7 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_
                 return TRUE;
         }
         
-        GLuint old_name = mTexName;
+        U32 old_name = mTexName;
 //      S32 old_discard = mCurrentDiscardLevel;
         
         if (usename != 0)
@@ -932,7 +972,7 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_
         }
         else
         {
-                glGenTextures(1, (GLuint*)&mTexName);
+                LLImageGL::generateTextures(1, &mTexName);
                 stop_glerror();
                 {
 //                      LLFastTimer t1(LLFastTimer::FTM_TEMP6);
@@ -962,9 +1002,11 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_
 
         setImage(data_in, data_hasmips);
 
-        setClamp(mClampS, mClampT);
-        setMipFilterNearest(mMagFilterNearest);
-        
+        // Set texture options to our defaults.
+        gGL.getTexUnit(0)->setHasMipMaps(mHasMipMaps);
+        gGL.getTexUnit(0)->setTextureAddressMode(mAddressMode);
+        gGL.getTexUnit(0)->setTextureFilteringOption(mFilterOption);
+
         // things will break if we don't unbind after creation
         gGL.getTexUnit(0)->unbind(mBindTarget);
         stop_glerror();
@@ -972,16 +1014,18 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_
         if (old_name != 0)
         {
                 sGlobalTextureMemory -= mTextureMemory;
-                glDeleteTextures(1, &old_name);
+                LLImageGL::deleteTextures(1, &old_name);
                 stop_glerror();
         }
 
         mTextureMemory = getMipBytes(discard_level);
         sGlobalTextureMemory += mTextureMemory;
-                
+        setActive() ;
+
         // mark this as bound at this point, so we don't throw it out immediately
         mLastBindTime = sLastFrameTime;
 
+        llpushcallstacks ;
         return TRUE;
 }
 
@@ -1054,6 +1098,7 @@ BOOL LLImageGL::isValidForSculpt(S32 discard_level, S32 image_width, S32 image_h
 
 BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok)
 {
+        llpushcallstacks ;
         if (discard_level < 0)
         {
                 discard_level = mCurrentDiscardLevel;
@@ -1068,7 +1113,7 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
 
         //explicitly unbind texture 
         gGL.getTexUnit(0)->unbind(mBindTarget);
-        llverify(gGL.getTexUnit(0)->bind(this));        
+        llverify(gGL.getTexUnit(0)->bindManual(mBindTarget, mTexName)); 
 
         //debug code, leave it there commented.
         //checkTexSize() ;
@@ -1156,7 +1201,7 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
                 return FALSE ;
         }
         //-----------------------------------------------------------------------------------------------
-        
+        llpushcallstacks ;
         return TRUE ;
 }
 
@@ -1178,8 +1223,10 @@ void LLImageGL::destroyGLTexture()
                 sGlobalTextureMemory -= mTextureMemory;
                 mTextureMemory = 0;
 
-                glDeleteTextures(1, (GLuint*)&mTexName);
+                LLImageGL::deleteTextures(1, &mTexName);
+                mTextureState = DELETED ;               
                 mTexName = 0;
+                mCurrentDiscardLevel = -1 ; //invalidate mCurrentDiscardLevel.
                 mGLTextureCreated = FALSE ;
                 stop_glerror();
         }
@@ -1187,89 +1234,35 @@ void LLImageGL::destroyGLTexture()
 
 //----------------------------------------------------------------------------
 
-void LLImageGL::glClampCubemap (BOOL clamps, BOOL clampt, BOOL clampr)
+void LLImageGL::setAddressMode(LLTexUnit::eTextureAddressMode mode)
 {
-        glTexParameteri (GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, clamps ? GL_CLAMP_TO_EDGE : GL_REPEAT);
-        glTexParameteri (GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, clamps ? GL_CLAMP_TO_EDGE : GL_REPEAT);
-        glTexParameteri (GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, clamps ? GL_CLAMP_TO_EDGE : GL_REPEAT);
-}
-
-void LLImageGL::glClamp (BOOL clamps, BOOL clampt)
-{
-        if (mTexName != 0)
+        if (mAddressMode != mode)
         {
-                glTexParameteri (LLTexUnit::getInternalType(mBindTarget), GL_TEXTURE_WRAP_S, clamps ? GL_CLAMP_TO_EDGE : GL_REPEAT);
-                glTexParameteri (LLTexUnit::getInternalType(mBindTarget), GL_TEXTURE_WRAP_T, clampt ? GL_CLAMP_TO_EDGE : GL_REPEAT);
+                mTexOptionsDirty = true;
+                mAddressMode = mode;
         }
-}
-
-void LLImageGL::setClampCubemap (BOOL clamps, BOOL clampt, BOOL clampr)
-{
-        mClampS = clamps;
-        mClampT = clampt;
-        mClampR = clampr;
-        glClampCubemap (clamps, clampt, clampr);
-}
 
-void LLImageGL::setClamp(BOOL clamps, BOOL clampt)
-{
-        mClampS = clamps;
-        mClampT = clampt;
-        glClamp (clamps, clampt);
-}
-
-void LLImageGL::overrideClamp (BOOL clamps, BOOL clampt)
-{
-        glClamp (clamps, clampt);
-}
-
-void LLImageGL::restoreClamp (void)
-{
-        glClamp (mClampS, mClampT);
+        if (gGL.getTexUnit(gGL.getCurrentTexUnitIndex())->getCurrTexture() == mTexName)
+        {
+                gGL.getTexUnit(gGL.getCurrentTexUnitIndex())->setTextureAddressMode(mode);
+                mTexOptionsDirty = false;
+        }
 }
 
-void LLImageGL::setMipFilterNearest(BOOL mag_nearest, BOOL min_nearest)
+void LLImageGL::setFilteringOption(LLTexUnit::eTextureFilterOptions option)
 {
-        mMagFilterNearest = mag_nearest;
-        mMinFilterNearest = min_nearest;
+        if (mFilterOption != option)
+        {
+                mTexOptionsDirty = true;
+                mFilterOption = option;
+        }
 
-        if (mTexName != 0)
+        if (gGL.getTexUnit(gGL.getCurrentTexUnitIndex())->getCurrTexture() == mTexName)
         {
-                if (mMinFilterNearest)
-                {
-                        glTexParameteri(LLTexUnit::getInternalType(mBindTarget), GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-                }
-                else if (mHasMipMaps)
-                {
-                        glTexParameteri(LLTexUnit::getInternalType(mBindTarget), GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-                }
-                else
-                {
-                        glTexParameteri(LLTexUnit::getInternalType(mBindTarget), GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-                }
-                if (mMagFilterNearest)
-                {
-                        glTexParameteri(LLTexUnit::getInternalType(mBindTarget), GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-                }
-                else 
-                {
-                        glTexParameteri(LLTexUnit::getInternalType(mBindTarget), GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-                }
-                if (gGLManager.mHasAnisotropic)
-                {
-                        if (sGlobalUseAnisotropic && !mMagFilterNearest)
-                        {
-                                F32 largest_anisotropy;
-                                glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &largest_anisotropy);
-                                glTexParameterf(LLTexUnit::getInternalType(mBindTarget), GL_TEXTURE_MAX_ANISOTROPY_EXT, largest_anisotropy);
-                        }
-                        else
-                        {
-                                glTexParameterf(LLTexUnit::getInternalType(mBindTarget), GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.f);
-                        }
-                }
-                stop_glerror();
-        }       
+                gGL.getTexUnit(gGL.getCurrentTexUnitIndex())->setTextureFilteringOption(option);
+                mTexOptionsDirty = false;
+        }
+        stop_glerror();
 }
 
 BOOL LLImageGL::getIsResident(BOOL test_now)
@@ -1356,6 +1349,118 @@ void LLImageGL::setTarget(const LLGLenum target, const LLTexUnit::eTextureType b
         mBindTarget = bind_target;
 }
 
+void LLImageGL::analyzeAlpha(const void* data_in, S32 w, S32 h)
+{
+        if (mFormatType != GL_UNSIGNED_BYTE)
+        {
+                llwarns << "Cannot analyze alpha for image with format type " << std::hex << mFormatType << std::dec << llendl;
+        }
+
+        U32 stride = 0;
+        switch (mFormatPrimary)
+        {
+        case GL_LUMINANCE:
+        case GL_ALPHA:
+                stride = 1;
+                break;
+        case GL_LUMINANCE_ALPHA:
+                stride = 2;
+                break;
+        case GL_RGB:
+                //no alpha
+                mIsMask = FALSE;
+                return;
+        case GL_RGBA:
+                stride = 4;
+                break;
+        case GL_BGRA_EXT:
+                stride = 4;
+                break;
+        default:
+                llwarns << "Cannot analyze alpha of image with primary format " << std::hex << mFormatPrimary << std::dec << llendl;
+                return;
+        }
+
+        U32 length = w * h;
+        const GLubyte* current = ((const GLubyte*) data_in)+stride-1;
+        
+        S32 sample[16];
+        memset(sample, 0, sizeof(S32)*16);
+
+        for (U32 i = 0; i < length; i++)
+        {
+                ++sample[*current/16];
+                current += stride;
+        }
+
+        U32 total = 0;
+        for (U32 i = 4; i < 11; i++)
+        {
+                total += sample[i];
+        }
+
+        if (total > length/16)
+        {
+                mIsMask = FALSE;
+        }
+        else
+        {
+                mIsMask = TRUE;
+        }
+}
+
+BOOL LLImageGL::isDeleted()  
+{ 
+        return mTextureState == DELETED ; 
+}
+
+BOOL LLImageGL::isInactive()  
+{ 
+        return mTextureState == INACTIVE ; 
+}
+
+BOOL LLImageGL::isDeletionCandidate()  
+{ 
+        return mTextureState == DELETION_CANDIDATE ; 
+}
+
+void LLImageGL::setDeletionCandidate()  
+{ 
+        if(mTexName && (mTextureState == INACTIVE))
+        {
+                mTextureState = DELETION_CANDIDATE ;            
+        }
+}
+
+void LLImageGL::forceActive()
+{
+        mTextureState = ACTIVE ; 
+}
+
+void LLImageGL::setActive() 
+{ 
+        if(mTextureState != NO_DELETE)
+        {
+                mTextureState = ACTIVE ; 
+        }
+}
+
+//set the texture inactive
+void LLImageGL::setInactive()
+{
+        if(mTexName && (mTextureState == ACTIVE) && !getBoundRecently())
+        {
+                mTextureState = INACTIVE ; 
+        }
+}
+
+//set the texture to stay in memory
+void LLImageGL::setNoDelete() 
+{ 
+        mTextureState = NO_DELETE ;
+}
+
+//----------------------------------------------------------------------------
 void LLImageGL::updatePickMask(S32 width, S32 height, const U8* data_in)
 {
         if (mFormatType != GL_UNSIGNED_BYTE ||
@@ -1468,7 +1573,7 @@ BOOL LLImageGL::getMask(const LLVector2 &tc)
                         llassert(w > 0 && h > 0 && cur_mip_data);
                         U8 test = cur_mip_data[w*h*mComponents-1];
                         {
-                                glTexImage2D(mTarget, m, mFormatInternal, w, h, 0, mFormatPrimary, mFormatType, cur_mip_data);
+                                LLImageGL::setManualImage(mTarget, m, mFormatInternal, w, h, mFormatPrimary, mFormatType, cur_mip_data);
                                 stop_glerror();
                         }
                         if (prev_mip_data && prev_mip_data != rawdata)
diff --git a/linden/indra/llrender/llimagegl.h b/linden/indra/llrender/llimagegl.h
index 1965495..4f737bc 100644
--- a/linden/indra/llrender/llimagegl.h
+++ b/linden/indra/llrender/llimagegl.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -45,6 +46,7 @@
 
 class LLImageGL : public LLRefCount
 {
+        friend class LLTexUnit;
 public:
         // Size calculation
         static S32 dataFormatBits(S32 dataformat);
@@ -79,17 +81,22 @@ public:
 protected:
         virtual ~LLImageGL();
 
-private:
-        void glClamp (BOOL clamps, BOOL clampt);
-        void glClampCubemap (BOOL clamps, BOOL clampt, BOOL clampr = FALSE);
+        void analyzeAlpha(const void* data_in, S32 w, S32 h);
 
 public:
         virtual void dump();    // debugging info to llinfos
         virtual bool bindError(const S32 stage = 0) const;
         virtual bool bindDefaultImage(const S32 stage = 0) const;
+        virtual void forceImmediateUpdate() ;
 
         void setSize(S32 width, S32 height, S32 ncomponents);
 
+        // These 3 functions currently wrap glGenTextures(), glDeleteTextures(), and glTexImage2D() 
+        // for tracking purposes and will be deprecated in the future
+        static void generateTextures(S32 numTextures, U32 *textures);
+        static void deleteTextures(S32 numTextures, U32 *textures);
+        static void setManualImage(U32 target, S32 miplevel, S32 intformat, S32 width, S32 height, U32 pixformat, U32 pixtype, const void *pixels);
+
         BOOL createGLTexture() ;
         BOOL createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename = 0);
         BOOL createGLTexture(S32 discard_level, const U8* data, BOOL data_hasmips = FALSE, S32 usename = 0);
@@ -102,14 +109,9 @@ public:
         // Read back a raw image for this discard level, if it exists
         BOOL readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok); 
         void destroyGLTexture();
-        
-        void setClampCubemap (BOOL clamps, BOOL clampt, BOOL clampr = FALSE);
-        void setClamp(BOOL clamps, BOOL clampt);
-        void overrideClamp (BOOL clamps, BOOL clampt);
-        void restoreClamp (void);
-        void setMipFilterNearest(BOOL mag_nearest, BOOL min_nearest = FALSE);
+
         void setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format = 0, BOOL swap_bytes = FALSE);
-        void dontDiscard() { mDontDiscard = 1; }
+        void dontDiscard() { mDontDiscard = 1; mTextureState = NO_DELETE; }
 
         S32      getDiscardLevel() const                { return mCurrentDiscardLevel; }
         S32      getMaxDiscardLevel() const             { return mMaxDiscardLevel; }
@@ -123,15 +125,12 @@ public:
         S32  getMipBytes(S32 discard_level = -1) const;
         BOOL getBoundRecently() const;
         LLGLenum getPrimaryFormat() const { return mFormatPrimary; }
-        
-        BOOL getClampS() const { return mClampS; }
-        BOOL getClampT() const { return mClampT; }
-        BOOL getClampR() const { return mClampR; }
-        BOOL getMipFilterNearest() const { return mMagFilterNearest; }
-        
+
         BOOL getHasGLTexture() const { return mTexName != 0; }
         LLGLuint getTexName() const { return mTexName; }
 
+        BOOL getIsAlphaMask() const { return mIsMask; }
+
         BOOL getIsResident(BOOL test_now = FALSE); // not const
 
         void setTarget(const LLGLenum target, const LLTexUnit::eTextureType bind_target);
@@ -151,6 +150,27 @@ public:
         BOOL getMask(const LLVector2 &tc);
 
         void checkTexSize() const ;
+        
+        // Sets the addressing mode used to sample the texture 
+        //  (such as wrapping, mirrored wrapping, and clamp)
+        // Note: this actually gets set the next time the texture is bound.
+        void setAddressMode(LLTexUnit::eTextureAddressMode mode);
+        LLTexUnit::eTextureAddressMode getAddressMode(void) const { return mAddressMode; }
+
+        // Sets the filtering options used to sample the texture 
+        //  (such as point sampling, bilinear interpolation, mipmapping, and anisotropic filtering)
+        // Note: this actually gets set the next time the texture is bound.
+        void setFilteringOption(LLTexUnit::eTextureFilterOptions option);
+        LLTexUnit::eTextureFilterOptions getFilteringOption(void) const { return mFilterOption; }
+
+        BOOL isDeleted() ;
+        BOOL isInactive() ;
+        BOOL isDeletionCandidate();
+        void setDeletionCandidate() ;
+        void setInactive() ;
+        void setActive() ;
+        void forceActive() ;
+        void setNoDelete() ;
 
 protected:
         void init(BOOL usemipmaps);
@@ -165,9 +185,10 @@ private:
         LLPointer<LLImageRaw> mSaveData; // used for destroyGL/restoreGL
         U8* mPickMask;  //downsampled bitmap approximation of alpha channel.  NULL if no alpha channel
         S8 mUseMipMaps;
-        S8 mHasMipMaps;
         S8 mHasExplicitFormat; // If false (default), GL format is f(mComponents)
         S8 mAutoGenMips;
+
+        BOOL mIsMask;
         
         bool     mGLTextureCreated ;
         LLGLuint mTexName;
@@ -178,6 +199,7 @@ private:
 protected:
         LLGLenum mTarget;               // Normally GL_TEXTURE2D, sometimes something else (ex. cube maps)
         LLTexUnit::eTextureType mBindTarget;    // Normally TT_TEXTURE, sometimes something else (ex. cube maps)
+        bool mHasMipMaps;
         
         LLGLboolean mIsResident;
         
@@ -185,17 +207,27 @@ protected:
         S8 mMaxDiscardLevel;    
         S8 mDontDiscard;                        // Keep full res version of this image (for UI, etc)
 
-        S8 mClampS;                                     // Need to save clamp state
-        S8 mClampT;
-        S8 mClampR;
-        S8 mMagFilterNearest;           // if TRUE, set magfilter to GL_NEAREST
-        S8 mMinFilterNearest;           // if TRUE, set minfilter to GL_NEAREST
+        bool    mTexOptionsDirty;
+        LLTexUnit::eTextureAddressMode          mAddressMode;   // Defaults to TAM_WRAP
+        LLTexUnit::eTextureFilterOptions        mFilterOption;  // Defaults to TFO_TRILINEAR
+
         
         LLGLint  mFormatInternal; // = GL internalformat
         LLGLenum mFormatPrimary;  // = GL format (pixel data format)
         LLGLenum mFormatType;
         BOOL     mFormatSwapBytes;// if true, use glPixelStorei(GL_UNPACK_SWAP_BYTES, 1)
 
+protected:
+        typedef enum 
+        {
+                DELETED = 0,         //removed from memory
+                DELETION_CANDIDATE,  //ready to be removed from memory
+                INACTIVE,            //not be used for the last certain period (i.e., 30 seconds).
+                ACTIVE,              //just being used, can become inactive if not being used for a certain time (10 seconds).
+                NO_DELETE = 99       //stay in memory, can not be removed.
+        } LLGLTexureState;
+        LLGLTexureState  mTextureState ;
+        
         // STATICS
 public: 
         static std::set<LLImageGL*> sImageList;
diff --git a/linden/indra/llrender/llpostprocess.cpp b/linden/indra/llrender/llpostprocess.cpp
index 92a0854..7f4be6a 100644
--- a/linden/indra/llrender/llpostprocess.cpp
+++ b/linden/indra/llrender/llpostprocess.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -207,7 +208,7 @@ void LLPostProcess::applyShaders(void)
                 /// If any of the above shaders have been called update the frame buffer;
                 if (tweaks.useColorFilter())
                 {
-                        GLuint tex = mSceneRenderTexture->getTexName() ;
+                        U32 tex = mSceneRenderTexture->getTexName() ;
                         copyFrameBuffer(tex, screenW, screenH);
                 }
                 applyNightVisionShader();
@@ -217,7 +218,7 @@ void LLPostProcess::applyShaders(void)
                 /// If any of the above shaders have been called update the frame buffer;
                 if (tweaks.useColorFilter().asBoolean() || tweaks.useNightVisionShader().asBoolean())
                 {
-                        GLuint tex = mSceneRenderTexture->getTexName() ;
+                        U32 tex = mSceneRenderTexture->getTexName() ;
                         copyFrameBuffer(tex, screenW, screenH);
                 }
                 applyBloomShader();
@@ -359,7 +360,7 @@ void LLPostProcess::doEffects(void)
 
         /// Copy the screen buffer to the render texture
         {
-                GLuint tex = mSceneRenderTexture->getTexName() ;
+                U32 tex = mSceneRenderTexture->getTexName() ;
                 copyFrameBuffer(tex, screenW, screenH);
         }
 
@@ -385,7 +386,7 @@ void LLPostProcess::doEffects(void)
         checkError();
 }
 
-void LLPostProcess::copyFrameBuffer(GLuint & texture, unsigned int width, unsigned int height)
+void LLPostProcess::copyFrameBuffer(U32 & texture, unsigned int width, unsigned int height)
 {
         gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_RECT_TEXTURE, texture);
         glCopyTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 0, 0, width, height, 0);
@@ -502,10 +503,8 @@ void LLPostProcess::createTexture(LLPointer<LLImageGL>& texture, unsigned int wi
                 gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_RECT_TEXTURE, texture->getTexName());
                 glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 4, width, height, 0,
                         GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
-                glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
-                glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
-                glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-                glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+                gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
+                gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
         }
 }
 
@@ -522,11 +521,9 @@ void LLPostProcess::createNoiseTexture(LLPointer<LLImageGL>& texture)
         if(texture->createGLTexture())
         {
                 gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, texture->getTexName());
-                glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, NOISE_SIZE, NOISE_SIZE, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, &buffer[0]);
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR);
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR);
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+                LLImageGL::setManualImage(GL_TEXTURE_2D, 0, GL_LUMINANCE, NOISE_SIZE, NOISE_SIZE, GL_LUMINANCE, GL_UNSIGNED_BYTE, &buffer[0]);
+                gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
+                gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_WRAP);
         }
 }
 
diff --git a/linden/indra/llrender/llpostprocess.h b/linden/indra/llrender/llpostprocess.h
index b191e9d..009e4bd 100644
--- a/linden/indra/llrender/llpostprocess.h
+++ b/linden/indra/llrender/llpostprocess.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -255,7 +256,7 @@ private:
         /// OpenGL Helper Functions
         void getShaderUniforms(glslUniforms & uniforms, GLhandleARB & prog);
         void createTexture(LLPointer<LLImageGL>& texture, unsigned int width, unsigned int height);
-        void copyFrameBuffer(GLuint & texture, unsigned int width, unsigned int height);
+        void copyFrameBuffer(U32 & texture, unsigned int width, unsigned int height);
         void createNoiseTexture(LLPointer<LLImageGL>& texture);
         bool checkError(void);
         void checkShaderError(GLhandleARB shader);
diff --git a/linden/indra/llrender/llrender.cpp b/linden/indra/llrender/llrender.cpp
index ff0a2db..ba95a19 100644
--- a/linden/indra/llrender/llrender.cpp
+++ b/linden/indra/llrender/llrender.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -74,7 +75,7 @@ static GLenum sGLCompareFunc[] =
         GL_GREATER
 };
 
-const U32 immediate_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXCOORD;
+const U32 immediate_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXCOORD0;
 
 static GLenum sGLBlendFactor[] =
 {
@@ -95,7 +96,8 @@ LLTexUnit::LLTexUnit(S32 index)
 mCurrColorOp(TBO_MULT), mCurrAlphaOp(TBO_MULT),
 mCurrColorSrc1(TBS_TEX_COLOR), mCurrColorSrc2(TBS_PREV_COLOR),
 mCurrAlphaSrc1(TBS_TEX_ALPHA), mCurrAlphaSrc2(TBS_PREV_ALPHA),
-mCurrColorScale(1), mCurrAlphaScale(1), mCurrTexture(0)
+mCurrColorScale(1), mCurrAlphaScale(1), mCurrTexture(0),
+mHasMipMaps(false)
 {
         llassert_always(index < LL_NUM_TEXTURE_LAYERS);
         mIndex = index;
@@ -175,8 +177,9 @@ void LLTexUnit::disable(void)
         }
 }
 
-bool LLTexUnit::bind(const LLImageGL* texture, bool forceBind)
+bool LLTexUnit::bind(LLImageGL* texture, bool forceBind)
 {
+        stop_glerror();
         if (mIndex < 0) return false;
 
         gGL.flush();
@@ -189,14 +192,28 @@ bool LLTexUnit::bind(const LLImageGL* texture, bool forceBind)
         
         if (!texture->getTexName()) //if texture does not exist
         {
+                //if deleted, will re-generate it immediately
+                texture->forceImmediateUpdate() ;
+
                 return texture->bindDefaultImage(mIndex);
         }
-        // Disabled caching of binding state.
-        activate();
-        enable(texture->getTarget());
-        mCurrTexture = texture->getTexName();
-        glBindTexture(sGLTextureType[texture->getTarget()], mCurrTexture);
-        texture->updateBindStats();
+
+        if ((mCurrTexture != texture->getTexName()) || forceBind)
+        {
+                activate();
+                enable(texture->getTarget());
+                mCurrTexture = texture->getTexName();
+                glBindTexture(sGLTextureType[texture->getTarget()], mCurrTexture);
+                texture->updateBindStats();
+                texture->setActive() ;
+                mHasMipMaps = texture->mHasMipMaps;
+                if (texture->mTexOptionsDirty)
+                {
+                        texture->mTexOptionsDirty = false;
+                        setTextureAddressMode(texture->mAddressMode);
+                        setTextureFilteringOption(texture->mFilterOption);
+                }
+        }
         return true;
 }
 
@@ -206,8 +223,13 @@ bool LLTexUnit::bind(LLCubeMap* cubeMap)
 
         gGL.flush();
 
-        // Disabled caching of binding state.
-        if (cubeMap != NULL)
+        if (cubeMap == NULL)
+        {
+                llwarns << "NULL LLTexUnit::bind cubemap" << llendl;
+                return false;
+        }
+
+        if (mCurrTexture != cubeMap->mImages[0]->getTexName())
         {
                 if (gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps)
                 {
@@ -215,18 +237,27 @@ bool LLTexUnit::bind(LLCubeMap* cubeMap)
                         enable(LLTexUnit::TT_CUBE_MAP);
                         mCurrTexture = cubeMap->mImages[0]->getTexName();
                         glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, mCurrTexture);
+                        mHasMipMaps = cubeMap->mImages[0]->mHasMipMaps;
                         cubeMap->mImages[0]->updateBindStats();
-                        cubeMap->mImages[0]->setMipFilterNearest (FALSE, FALSE);
+                        if (cubeMap->mImages[0]->mTexOptionsDirty)
+                        {
+                                cubeMap->mImages[0]->mTexOptionsDirty = false;
+                                setTextureAddressMode(cubeMap->mImages[0]->mAddressMode);
+                                setTextureFilteringOption(cubeMap->mImages[0]->mFilterOption);
+                        }
                         return true;
                 }
                 else
                 {
-                        llwarns << "Using cube map without extension!" << llendl
+                        llwarns << "Using cube map without extension!" << llendl;
+                        return false;
                 }
         }
-        return false;
+        return true;
 }
 
+// LLRenderTarget is unavailible on the mapserver since it uses FBOs.
+#if !LL_MESA_HEADLESS
 bool LLTexUnit::bind(LLRenderTarget* renderTarget, bool bindDepth)
 {
         if (mIndex < 0) return false;
@@ -244,23 +275,26 @@ bool LLTexUnit::bind(LLRenderTarget* renderTarget, bool bindDepth)
 
         return true;
 }
+#endif // LL_MESA_HEADLESS
 
-bool LLTexUnit::bindManual(eTextureType type, U32 texture)
+bool LLTexUnit::bindManual(eTextureType type, U32 texture, bool hasMips)
 {
-        if (mIndex < 0) return false;
+        if (mIndex < 0 || mCurrTexture == texture) return false;
 
-        // Disabled caching of binding state.
         gGL.flush();
         
         activate();
         enable(type);
         mCurrTexture = texture;
         glBindTexture(sGLTextureType[type], texture);
+        mHasMipMaps = hasMips;
         return true;
 }
 
 void LLTexUnit::unbind(eTextureType type)
 {
+        stop_glerror();
+
         if (mIndex < 0) return;
 
         // Disabled caching of binding state.
@@ -276,17 +310,57 @@ void LLTexUnit::unbind(eTextureType type)
 
 void LLTexUnit::setTextureAddressMode(eTextureAddressMode mode)
 {
-        if (mIndex < 0) return;
+        if (mIndex < 0 || mCurrTexture == 0) return;
 
-        if (true)
+        activate();
+
+        glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_S, sGLAddressMode[mode]);
+        glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_T, sGLAddressMode[mode]);
+        if (mCurrTexType == TT_CUBE_MAP)
         {
-                activate();
+                glTexParameteri (GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, sGLAddressMode[mode]);
+        }
+}
+
+void LLTexUnit::setTextureFilteringOption(LLTexUnit::eTextureFilterOptions option)
+{
+        if (mIndex < 0 || mCurrTexture == 0) return;
 
-                glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_S, sGLAddressMode[mode]);
-                glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_T, sGLAddressMode[mode]);
-                if (mCurrTexType == TT_CUBE_MAP)
+        if (option == TFO_POINT)
+        {
+                glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        }
+        else
+        {
+                glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        }
+
+        if (option >= TFO_TRILINEAR && mHasMipMaps)
+        {
+                glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+        } 
+        else if (option >= TFO_BILINEAR)
+        {
+                glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        }
+        else
+        {
+                glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        }
+
+        if (gGLManager.mHasAnisotropic)
+        {
+                if (LLImageGL::sGlobalUseAnisotropic && option == TFO_ANISOTROPIC)
                 {
-                        glTexParameteri (GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, sGLAddressMode[mode]);
+                        if (gGL.mMaxAnisotropy < 1.f)
+                        {
+                                glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gGL.mMaxAnisotropy);
+                        }
+                        glTexParameterf(sGLTextureType[mCurrTexType], GL_TEXTURE_MAX_ANISOTROPY_EXT, gGL.mMaxAnisotropy);
+                }
+                else
+                {
+                        glTexParameterf(sGLTextureType[mCurrTexType], GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.f);
                 }
         }
 }
@@ -589,12 +663,13 @@ void LLTexUnit::debugTextureUnit(void)
 
 
 LLRender::LLRender()
-: mDirty(false), mCount(0), mMode(LLRender::TRIANGLES)
+: mDirty(false), mCount(0), mMode(LLRender::TRIANGLES),
+        mMaxAnisotropy(0.f) 
 {
         mBuffer = new LLVertexBuffer(immediate_mask, 0);
         mBuffer->allocateBuffer(4096, 0, TRUE);
         mBuffer->getVertexStrider(mVerticesp);
-        mBuffer->getTexCoordStrider(mTexcoordsp);
+        mBuffer->getTexCoord0Strider(mTexcoordsp);
         mBuffer->getColorStrider(mColorsp);
         
         mTexUnits.reserve(LL_NUM_TEXTURE_LAYERS);
@@ -687,7 +762,10 @@ void LLRender::setColorMask(bool writeColorR, bool writeColorG, bool writeColorB
         mCurrColorMask[2] = writeColorB;
         mCurrColorMask[3] = writeAlpha;
 
-        glColorMask(writeColorR, writeColorG, writeColorB, writeAlpha);
+        glColorMask(writeColorR ? GL_TRUE : GL_FALSE, 
+                                writeColorG ? GL_TRUE : GL_FALSE,
+                                writeColorB ? GL_TRUE : GL_FALSE,
+                                writeAlpha ? GL_TRUE : GL_FALSE);
 }
 
 void LLRender::setSceneBlendType(eBlendType type)
@@ -767,6 +845,14 @@ bool LLRender::verifyTexUnitActive(U32 unitToVerify)
         }
 }
 
+void LLRender::clearErrors()
+{
+        while (glGetError())
+        {
+                //loop until no more error flags left
+        }
+}
+
 void LLRender::begin(const GLuint& mode)
 {
         if (mode != mMode)
@@ -852,13 +938,14 @@ void LLRender::flush()
                                 
                 mBuffer->setBuffer(immediate_mask);
                 mBuffer->drawArrays(mMode, 0, mCount);
-
+                
                 mVerticesp[0] = mVerticesp[mCount];
                 mTexcoordsp[0] = mTexcoordsp[mCount];
                 mColorsp[0] = mColorsp[mCount];
                 mCount = 0;
         }
 }
+
 void LLRender::vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z)
 { 
         //the range of mVerticesp, mColorsp and mTexcoordsp is [0, 4095]
diff --git a/linden/indra/llrender/llrender.h b/linden/indra/llrender/llrender.h
index e949190..437c715 100644
--- a/linden/indra/llrender/llrender.h
+++ b/linden/indra/llrender/llrender.h
@@ -22,7 +22,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -70,6 +71,14 @@ public:
                 TAM_CLAMP                               // No texture type is currently enabled
         } eTextureAddressMode;
 
+        typedef enum
+        {       // Note: If mipmapping or anisotropic are not enabled or supported it should fall back gracefully
+                TFO_POINT = 0,                  // Equal to: min=point, mag=point, mip=none.
+                TFO_BILINEAR,                   // Equal to: min=linear, mag=linear, mip=point.
+                TFO_TRILINEAR,                  // Equal to: min=linear, mag=linear, mip=linear.
+                TFO_ANISOTROPIC                 // Equal to: min=anisotropic, max=anisotropic, mip=linear.
+        } eTextureFilterOptions;
+
         typedef enum 
         {
                 TB_REPLACE = 0,
@@ -130,30 +139,43 @@ public:
         // Sets this tex unit to be the currently active one
         void activate(void); 
 
-        // Enables this texture unit for the given texture type (automatically disables any previously enabled texture type)
+        // Enables this texture unit for the given texture type 
+        // (automatically disables any previously enabled texture type)
         void enable(eTextureType type); 
+
         // Disables the current texture unit
         void disable(void);     
         
         // Binds the LLImageGL to this texture unit 
         // (automatically enables the unit for the LLImageGL's texture type)
-        bool bind(const LLImageGL* texture, bool forceBind = false);
+        bool bind(LLImageGL* texture, bool forceBind = false);
 
         // Binds a cubemap to this texture unit 
         // (automatically enables the texture unit for cubemaps)
         bool bind(LLCubeMap* cubeMap);
 
-        // Binds a render target to this texture unit (automatically enables the texture unit for the RT's texture type)
+        // Binds a render target to this texture unit 
+        // (automatically enables the texture unit for the RT's texture type)
         bool bind(LLRenderTarget * renderTarget, bool bindDepth = false);
 
-        // Manually binds a texture to the texture unit (automatically enables the tex unit for the given texture type)
-        bool bindManual(eTextureType type, U32 texture);
+        // Manually binds a texture to the texture unit 
+        // (automatically enables the tex unit for the given texture type)
+        bool bindManual(eTextureType type, U32 texture, bool hasMips = false);
         
-        // Unbinds the currently bound texture of the given type (only if there's a texture of the given type currently bound)
+        // Unbinds the currently bound texture of the given type 
+        // (only if there's a texture of the given type currently bound)
         void unbind(eTextureType type);
 
+        // Sets the addressing mode used to sample the texture
+        // Warning: this stays set for the bound texture forever, 
+        // make sure you want to permanently change the address mode  for the bound texture.
         void setTextureAddressMode(eTextureAddressMode mode);
 
+        // Sets the filtering options used to sample the texture
+        // Warning: this stays set for the bound texture forever, 
+        // make sure you want to permanently change the filtering for the bound texture.
+        void setTextureFilteringOption(LLTexUnit::eTextureFilterOptions option);
+
         void setTextureBlendType(eTextureBlendType type);
 
         inline void setTextureColorBlend(eTextureBlendOp op, eTextureBlendSrc src1, eTextureBlendSrc src2 = TBS_PREV_COLOR)
@@ -165,6 +187,12 @@ public:
 
         static U32 getInternalType(eTextureType type);
 
+        U32 getCurrTexture(void) { return mCurrTexture; }
+
+        eTextureType getCurrType(void) { return mCurrTexType; }
+
+        void setHasMipMaps(bool hasMips) { mHasMipMaps = hasMips; }
+
 protected:
         S32                                     mIndex;
         U32                                     mCurrTexture;
@@ -178,6 +206,7 @@ protected:
         eTextureBlendSrc        mCurrAlphaSrc2;
         S32                                     mCurrColorScale;
         S32                                     mCurrAlphaScale;
+        bool                            mHasMipMaps;
         
         void debugTextureUnit(void);
         void setColorScale(S32 scale);
@@ -291,6 +320,8 @@ public:
 
         void debugTexUnits(void);
 
+        void clearErrors();
+
         struct Vertex
         {
                 GLfloat v[3];
@@ -315,6 +346,8 @@ private:
         LLStrider<LLColor4U>            mColorsp;
         std::vector<LLTexUnit*>         mTexUnits;
         LLTexUnit*                      mDummyTexUnit;
+
+        F32                             mMaxAnisotropy;
 };
 
 extern F64 gGLModelView[16];
diff --git a/linden/indra/llrender/llrendersphere.cpp b/linden/indra/llrender/llrendersphere.cpp
index 6aaa03e..e22b753 100644
--- a/linden/indra/llrender/llrendersphere.cpp
+++ b/linden/indra/llrender/llrendersphere.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
diff --git a/linden/indra/llrender/llrendersphere.h b/linden/indra/llrender/llrendersphere.h
index d48b917..617ee3e 100644
--- a/linden/indra/llrender/llrendersphere.h
+++ b/linden/indra/llrender/llrendersphere.h
@@ -2,16 +2,27 @@
  * @file llrendersphere.h
  * @brief interface for the LLRenderSphere class.
  *
- * $LicenseInfo:firstyear=2001&license=internal$
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
  * 
  * Copyright (c) 2001-2009, Linden Research, Inc.
  * 
- * The following source code is PROPRIETARY AND CONFIDENTIAL. Use of
- * this source code is governed by the Linden Lab Source Code Disclosure
- * Agreement ("Agreement") previously entered between you and Linden
- * Lab. By accessing, using, copying, modifying or distributing this
- * software, you acknowledge that you have been informed of your
- * obligations under the Agreement and agree to abide by those obligations.
+ * Second Life Viewer Source Code
+ * 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://secondlifegrid.net/programs/open_source/licensing/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://secondlifegrid.net/programs/open_source/licensing/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,
diff --git a/linden/indra/llrender/llrendertarget.cpp b/linden/indra/llrender/llrendertarget.cpp
index 392ec24..b7f3177 100644
--- a/linden/indra/llrender/llrendertarget.cpp
+++ b/linden/indra/llrender/llrendertarget.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -36,6 +37,24 @@
 #include "llgl.h"
 
 
+void check_framebuffer_status()
+{
+        if (gDebugGL)
+        {
+                GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+                switch (status)
+                {
+                case GL_FRAMEBUFFER_COMPLETE_EXT:
+                        break;
+                case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
+                        llerrs << "WTF?" << llendl;
+                        break;
+                default:
+                        llerrs << "WTF?" << llendl;
+                }
+        }
+}
+
 BOOL LLRenderTarget::sUseFBO = FALSE;
 
 LLRenderTarget::LLRenderTarget() :
@@ -47,7 +66,9 @@ LLRenderTarget::LLRenderTarget() :
         mStencil(0),
         mUseDepth(FALSE),
         mRenderDepth(FALSE),
-        mUsage(LLTexUnit::TT_TEXTURE)
+        mUsage(LLTexUnit::TT_TEXTURE),
+        mSamples(0),
+        mSampleBuffer(NULL)
 {
 }
 
@@ -56,40 +77,26 @@ LLRenderTarget::~LLRenderTarget()
         release();
 }
 
-void LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, LLTexUnit::eTextureType usage, BOOL use_fbo)
+
+void LLRenderTarget::setSampleBuffer(LLMultisampleBuffer* buffer)
+{
+        mSampleBuffer = buffer;
+}
+
+void LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, BOOL stencil, LLTexUnit::eTextureType usage, BOOL use_fbo)
 {
         stop_glerror();
         mResX = resx;
         mResY = resy;
 
+        mStencil = stencil;
         mUsage = usage;
         mUseDepth = depth;
-        release();
-
-        glGenTextures(1, (GLuint *) &mTex);
-        gGL.getTexUnit(0)->bindManual(mUsage, mTex);
-        glTexImage2D(LLTexUnit::getInternalType(mUsage), 0, color_fmt, mResX, mResY, 0, color_fmt, GL_UNSIGNED_BYTE, NULL);
-
-        glTexParameteri(LLTexUnit::getInternalType(mUsage), GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-        glTexParameteri(LLTexUnit::getInternalType(mUsage), GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-
-        if (mUsage != LLTexUnit::TT_RECT_TEXTURE)
-        {
-                glTexParameteri(LLTexUnit::getInternalType(mUsage), GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT);
-                glTexParameteri(LLTexUnit::getInternalType(mUsage), GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT);
-        }
-        else
-        {
-                // ATI doesn't support mirrored repeat for rectangular textures.
-                glTexParameteri(LLTexUnit::getInternalType(mUsage), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-                glTexParameteri(LLTexUnit::getInternalType(mUsage), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        }
 
-        stop_glerror();
+        release();
 
         if ((sUseFBO || use_fbo) && gGLManager.mHasFramebufferObject)
         {
-
                 if (depth)
                 {
                         stop_glerror();
@@ -99,37 +106,141 @@ void LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, LLT
 
                 glGenFramebuffersEXT(1, (GLuint *) &mFBO);
 
+                if (mDepth)
+                {
+                        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
+                        if (mStencil)
+                        {
+                                glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);
+                                stop_glerror();
+                                glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);
+                                stop_glerror();
+                        }
+                        else
+                        {
+                                glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, LLTexUnit::getInternalType(mUsage), mDepth, 0);
+                                stop_glerror();
+                        }
+                        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+                }
+                
                 stop_glerror();
+        }
 
-                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
+        addColorAttachment(color_fmt);
+}
 
-                stop_glerror();
+void LLRenderTarget::addColorAttachment(U32 color_fmt)
+{
+        if (color_fmt == 0)
+        {
+                return;
+        }
 
-                if (mDepth)
-                {
-                        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, LLTexUnit::getInternalType(mUsage), mDepth, 0);
-                        stop_glerror();
-                        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, LLTexUnit::getInternalType(mUsage), mDepth, 0);
-                        stop_glerror();
-                }
+        U32 offset = mTex.size();
+        if (offset >= 4 ||
+                offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers))
+        {
+                llerrs << "Too many color attachments!" << llendl;
+        }
 
-                glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
-                                                LLTexUnit::getInternalType(mUsage), mTex, 0);
-                stop_glerror();
+        U32 tex;
+        LLImageGL::generateTextures(1, &tex);
+        gGL.getTexUnit(0)->bindManual(mUsage, tex);
+
+        stop_glerror();
+
+        LLImageGL::setManualImage(LLTexUnit::getInternalType(mUsage), 0, color_fmt, mResX, mResY, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 
+        stop_glerror();
+
+        if (offset == 0)
+        {
+                gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_BILINEAR);
+        }
+        else
+        { //don't filter data attachments
+                gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
+        }
+        if (mUsage != LLTexUnit::TT_RECT_TEXTURE)
+        {
+                gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_MIRROR);
+        }
+        else
+        {
+                // ATI doesn't support mirrored repeat for rectangular textures.
+                gGL.getTexUnit(0)->setTextureAddressMode(LLTexUnit::TAM_CLAMP);
+        }
+        if (mFBO)
+        {
+                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
+                glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+offset,
+                        LLTexUnit::getInternalType(mUsage), tex, 0);
+                        stop_glerror();
+
+                check_framebuffer_status();
+                
                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
-                stop_glerror();
         }
+
+        mTex.push_back(tex);
+
 }
 
 void LLRenderTarget::allocateDepth()
 {
-        glGenTextures(1, (GLuint *) &mDepth);
-        gGL.getTexUnit(0)->bindManual(mUsage, mDepth);
-        U32 internal_type = LLTexUnit::getInternalType(mUsage);
-        glTexParameteri(internal_type, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-        glTexParameteri(internal_type, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-        glTexImage2D(internal_type, 0, GL_DEPTH24_STENCIL8_EXT, mResX, mResY, 0, GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, NULL);
+        if (mStencil)
+        {
+                //use render buffers where stencil buffers are in play
+                glGenRenderbuffersEXT(1, (GLuint *) &mDepth);
+                glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mDepth);
+                glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH24_STENCIL8_EXT, mResX, mResY);
+                glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
+        }
+        else
+        {
+                LLImageGL::generateTextures(1, &mDepth);
+                gGL.getTexUnit(0)->bindManual(mUsage, mDepth);
+                U32 internal_type = LLTexUnit::getInternalType(mUsage);
+                gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_POINT);
+                LLImageGL::setManualImage(internal_type, 0, GL_DEPTH24_STENCIL8_EXT, mResX, mResY, GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, NULL);
+        }
+}
+
+void LLRenderTarget::shareDepthBuffer(LLRenderTarget& target)
+{
+        if (!mFBO || !target.mFBO)
+        {
+                llerrs << "Cannot share depth buffer between non FBO render targets." << llendl;
+        }
+
+        if (mDepth)
+        {
+                stop_glerror();
+                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, target.mFBO);
+                stop_glerror();
+
+                if (mStencil)
+                {
+                        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);
+                        stop_glerror();
+                        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);                       
+                        stop_glerror();
+                }
+                else
+                {
+                        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, LLTexUnit::getInternalType(mUsage), mDepth, 0);
+                        stop_glerror();
+                        if (mStencil)
+                        {
+                                glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, LLTexUnit::getInternalType(mUsage), mDepth, 0);
+                                stop_glerror();
+                        }
+                }
+                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+
+                target.mUseDepth = TRUE;
+        }
 }
 
 void LLRenderTarget::release()
@@ -140,24 +251,63 @@ void LLRenderTarget::release()
                 mFBO = 0;
         }
 
-        if (mTex)
+        if (mTex.size() > 0)
         {
-                glDeleteTextures(1, (GLuint *) &mTex);
-                mTex = 0;
+                LLImageGL::deleteTextures(mTex.size(), &mTex[0]);
+                mTex.clear();
         }
 
         if (mDepth)
         {
-                glDeleteTextures(1, (GLuint *) &mDepth);
+                if (mStencil)
+                {
+                        glDeleteRenderbuffersEXT(1, (GLuint*) &mDepth);
+                        stop_glerror();
+                }
+                else
+                {
+                        LLImageGL::deleteTextures(1, &mDepth);
+                        stop_glerror();
+                }
                 mDepth = 0;
         }
+
+        mSampleBuffer = NULL;
 }
 
 void LLRenderTarget::bindTarget()
 {
         if (mFBO)
         {
-                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
+                stop_glerror();
+                if (mSampleBuffer)
+                {
+                        mSampleBuffer->bindTarget(this);
+                        stop_glerror();
+                }
+                else
+                {
+                        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
+                        stop_glerror();
+                        if (gGLManager.mHasDrawBuffers)
+                        { //setup multiple render targets
+                                GLenum drawbuffers[] = {GL_COLOR_ATTACHMENT0_EXT,
+                                                                                GL_COLOR_ATTACHMENT1_EXT,
+                                                                                GL_COLOR_ATTACHMENT2_EXT,
+                                                                                GL_COLOR_ATTACHMENT3_EXT};
+                                glDrawBuffersARB(mTex.size(), drawbuffers);
+                        }
+                        
+                        if (mTex.empty())
+                        { //no color buffer to draw to
+                                glDrawBuffer(GL_NONE);
+                                glReadBuffer(GL_NONE);
+                        }
+
+                        check_framebuffer_status();
+
+                        stop_glerror();
+                }
         }
 
         glViewport(0, 0, mResX, mResY);
@@ -172,7 +322,7 @@ void LLRenderTarget::unbindTarget()
         }
 }
 
-void LLRenderTarget::clear()
+void LLRenderTarget::clear(U32 mask_in)
 {
         U32 mask = GL_COLOR_BUFFER_BIT;
         if (mUseDepth)
@@ -181,15 +331,36 @@ void LLRenderTarget::clear()
         }
         if (mFBO)
         {
-                glClear(mask);
+                check_framebuffer_status();
+                stop_glerror();
+                glClear(mask & mask_in);
+                stop_glerror();
         }
         else
         {
                 LLGLEnable scissor(GL_SCISSOR_TEST);
                 glScissor(0, 0, mResX, mResY);
                 stop_glerror();
-                glClear(mask);
+                glClear(mask & mask_in);
+        }
+}
+
+U32 LLRenderTarget::getTexture(U32 attachment) const
+{
+        if (attachment > mTex.size()-1)
+        {
+                llerrs << "Invalid attachment index." << llendl;
+        }
+        return mTex[attachment];
+}
+
+void LLRenderTarget::bindTexture(U32 index, S32 channel)
+{
+        if (index > mTex.size()-1)
+        {
+                llerrs << "Invalid attachment index." << llendl;
         }
+        gGL.getTexUnit(channel)->bindManual(mUsage, mTex[index]);
 }
 
 void LLRenderTarget::flush(BOOL fetch_depth)
@@ -210,16 +381,87 @@ void LLRenderTarget::flush(BOOL fetch_depth)
                         gGL.getTexUnit(0)->bind(this, true);
                         glCopyTexImage2D(LLTexUnit::getInternalType(mUsage), 0, GL_DEPTH24_STENCIL8_EXT, 0, 0, mResX, mResY, 0);
                 }
+
+                gGL.getTexUnit(0)->disable();
+        }
+        else
+        {
+#if !LL_DARWIN
+
+                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+        
+                if (mSampleBuffer)
+                {
+                        LLGLEnable multisample(GL_MULTISAMPLE_ARB);
+                        stop_glerror();
+                        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
+                        stop_glerror();
+                        check_framebuffer_status();
+                        glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, mSampleBuffer->mFBO);
+                        check_framebuffer_status();
+                        
+                        stop_glerror();
+                        glBlitFramebufferEXT(0, 0, mResX, mResY, 0, 0, mResX, mResY, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT, GL_NEAREST);
+                        stop_glerror();         
+
+                        if (mTex.size() > 1)
+                        {               
+                                for (U32 i = 1; i < mTex.size(); ++i)
+                                {
+                                        glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
+                                                                                LLTexUnit::getInternalType(mUsage), mTex[i], 0);
+                                        stop_glerror();
+                                        glFramebufferRenderbufferEXT(GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, mSampleBuffer->mTex[i]);
+                                        stop_glerror();
+                                        glBlitFramebufferEXT(0, 0, mResX, mResY, 0, 0, mResX, mResY, GL_COLOR_BUFFER_BIT, GL_NEAREST);          
+                                        stop_glerror();
+                                }
+
+                                for (U32 i = 0; i < mTex.size(); ++i)
+                                {
+                                        glFramebufferTexture2DEXT(GL_DRAW_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+i,
+                                                                                LLTexUnit::getInternalType(mUsage), mTex[i], 0);
+                                        stop_glerror();
+                                        glFramebufferRenderbufferEXT(GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+i, GL_RENDERBUFFER_EXT, mSampleBuffer->mTex[i]);
+                                        stop_glerror();
+                                }
+                        }
+                }
+#endif
+
+                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+                glFlush();
+        }
+}
+
+void LLRenderTarget::copyContents(LLRenderTarget& source, S32 srcX0, S32 srcY0, S32 srcX1, S32 srcY1,
+                                                S32 dstX0, S32 dstY0, S32 dstX1, S32 dstY1, U32 mask, U32 filter)
+{
+#if !LL_DARWIN
+        if (!source.mFBO || !mFBO)
+        {
+                llerrs << "Cannot copy framebuffer contents for non FBO render targets." << llendl;
+        }
+
+        if (mSampleBuffer)
+        {
+                mSampleBuffer->copyContents(source, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
         }
         else
         {
+                glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, source.mFBO);
+                glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, mFBO);
+
+                glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+
                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
         }
+#endif
 }
 
 BOOL LLRenderTarget::isComplete() const
 {
-        return (mTex || mDepth) ? TRUE : FALSE;
+        return (!mTex.empty() || mDepth) ? TRUE : FALSE;
 }
 
 void LLRenderTarget::getViewport(S32* viewport)
@@ -230,3 +472,191 @@ void LLRenderTarget::getViewport(S32* viewport)
         viewport[3] = mResY;
 }
 
+//==================================================
+// LLMultisampleBuffer implementation
+//==================================================
+LLMultisampleBuffer::LLMultisampleBuffer()
+{
+
+}
+
+LLMultisampleBuffer::~LLMultisampleBuffer()
+{
+        releaseSampleBuffer();
+}
+
+void LLMultisampleBuffer::releaseSampleBuffer()
+{
+        if (mFBO)
+        {
+                glDeleteFramebuffersEXT(1, (GLuint *) &mFBO);
+                mFBO = 0;
+        }
+
+        if (mTex.size() > 0)
+        {
+                glDeleteRenderbuffersEXT(mTex.size(), (GLuint *) &mTex[0]);
+                mTex.clear();
+        }
+
+        if (mDepth)
+        {
+                glDeleteRenderbuffersEXT(1, (GLuint *) &mDepth);
+                mDepth = 0;
+        }
+}
+
+void LLMultisampleBuffer::bindTarget()
+{
+        bindTarget(this);
+}
+
+void LLMultisampleBuffer::bindTarget(LLRenderTarget* ref)
+{
+        if (!ref)
+        {
+                ref = this;
+        }
+
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
+        if (gGLManager.mHasDrawBuffers)
+        { //setup multiple render targets
+                GLenum drawbuffers[] = {GL_COLOR_ATTACHMENT0_EXT,
+                                                                GL_COLOR_ATTACHMENT1_EXT,
+                                                                GL_COLOR_ATTACHMENT2_EXT,
+                                                                GL_COLOR_ATTACHMENT3_EXT};
+                glDrawBuffersARB(ref->mTex.size(), drawbuffers);
+        }
+
+        check_framebuffer_status();
+
+        glViewport(0, 0, mResX, mResY);
+
+}
+
+void LLMultisampleBuffer::allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, BOOL stencil,  LLTexUnit::eTextureType usage, BOOL use_fbo )
+{
+        allocate(resx,resy,color_fmt,depth,stencil,usage,use_fbo,2);
+}
+
+void LLMultisampleBuffer::allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, BOOL stencil,  LLTexUnit::eTextureType usage, BOOL use_fbo, U32 samples )
+{
+        stop_glerror();
+        mResX = resx;
+        mResY = resy;
+
+        mUsage = usage;
+        mUseDepth = depth;
+        mStencil = stencil;
+
+        releaseSampleBuffer();
+
+        if (!gGLManager.mHasFramebufferMultisample)
+        {
+                llerrs << "Attempting to allocate unsupported render target type!" << llendl;
+        }
+
+        mSamples = samples;
+        
+        if (mSamples <= 1)
+        {
+                llerrs << "Cannot create a multisample buffer with less than 2 samples." << llendl;
+        }
+
+        stop_glerror();
+
+        if ((sUseFBO || use_fbo) && gGLManager.mHasFramebufferObject)
+        {
+
+                if (depth)
+                {
+                        stop_glerror();
+                        allocateDepth();
+                        stop_glerror();
+                }
+
+                glGenFramebuffersEXT(1, (GLuint *) &mFBO);
+
+                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
+
+                if (mDepth)
+                {
+                        glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);
+                        if (mStencil)
+                        {
+                                glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, mDepth);                       
+                        }
+                        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+                }
+                
+                stop_glerror();
+
+                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+                stop_glerror();
+        }
+
+        addColorAttachment(color_fmt);
+}
+
+void LLMultisampleBuffer::addColorAttachment(U32 color_fmt)
+{
+#if !LL_DARWIN
+        if (color_fmt == 0)
+        {
+                return;
+        }
+
+        U32 offset = mTex.size();
+        if (offset >= 4 ||
+                offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers))
+        {
+                llerrs << "Too many color attachments!" << llendl;
+        }
+
+        U32 tex;
+        glGenRenderbuffersEXT(1, &tex);
+        
+        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, tex);
+        glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, mSamples, color_fmt, mResX, mResY);
+        stop_glerror();
+
+        if (mFBO)
+        {
+                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
+                glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT+offset, GL_RENDERBUFFER_EXT, tex);
+                stop_glerror();
+                GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
+                switch (status)
+                {
+                case GL_FRAMEBUFFER_COMPLETE_EXT:
+                        break;
+                case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
+                        llerrs << "WTF?" << llendl;
+                        break;
+                default:
+                        llerrs << "WTF?" << llendl;
+                }
+
+                glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+        }
+
+        mTex.push_back(tex);
+#endif
+}
+
+void LLMultisampleBuffer::allocateDepth()
+{
+#if !LL_DARWIN
+        glGenRenderbuffersEXT(1, (GLuint* ) &mDepth);
+        glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, mDepth);
+        if (mStencil)
+        {
+                glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, mSamples, GL_DEPTH24_STENCIL8_EXT, mResX, mResY);      
+        }
+        else
+        {
+                glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, mSamples, GL_DEPTH_COMPONENT16_ARB, mResX, mResY);     
+        }
+#endif
+}
+
diff --git a/linden/indra/llrender/llrendertarget.h b/linden/indra/llrender/llrendertarget.h
index 38a41cb..d5d809b 100644
--- a/linden/indra/llrender/llrendertarget.h
+++ b/linden/indra/llrender/llrendertarget.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -32,6 +33,9 @@
 #ifndef LL_LLRENDERTARGET_H
 #define LL_LLRENDERTARGET_H
 
+// LLRenderTarget is unavailible on the mapserver since it uses FBOs.
+#if !LL_MESA_HEADLESS
+
 #include "llgl.h"
 #include "llrender.h"
 
@@ -59,6 +63,7 @@
 
 */
 
+class LLMultisampleBuffer;
 
 class LLRenderTarget
 {
@@ -67,15 +72,25 @@ public:
         static BOOL sUseFBO; 
 
         LLRenderTarget();
-        ~LLRenderTarget();
+        virtual ~LLRenderTarget();
 
         //allocate resources for rendering
         //must be called before use
         //multiple calls will release previously allocated resources
-        void allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, LLTexUnit::eTextureType usage = LLTexUnit::TT_TEXTURE, BOOL use_fbo = FALSE);
+        void allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, BOOL stencil, LLTexUnit::eTextureType usage = LLTexUnit::TT_TEXTURE, BOOL use_fbo = FALSE);
+
+        //provide this render target with a multisample resource.
+        void setSampleBuffer(LLMultisampleBuffer* buffer);
+
+        //add color buffer attachment
+        //limit of 4 color attachments per render target
+        virtual void addColorAttachment(U32 color_fmt);
 
         //allocate a depth texture
-        void allocateDepth();
+        virtual void allocateDepth();
+
+        //share depth buffer with provided render target
+        virtual void shareDepthBuffer(LLRenderTarget& target);
 
         //free any allocated resources
         //safe to call redundantly
@@ -83,14 +98,14 @@ public:
 
         //bind target for rendering
         //applies appropriate viewport
-        void bindTarget();
+        virtual void bindTarget();
 
         //unbind target for rendering
         static void unbindTarget();
         
         //clear render targer, clears depth buffer if present,
         //uses scissor rect if in copy-to-texture mode
-        void clear();
+        void clear(U32 mask = 0xFFFFFFFF);
         
         //get applied viewport
         void getViewport(S32* viewport);
@@ -103,10 +118,12 @@ public:
 
         LLTexUnit::eTextureType getUsage(void) const { return mUsage; }
 
-        U32 getTexture(void) const { return mTex; }
+        U32 getTexture(U32 attachment = 0) const;
 
         U32 getDepth(void) const { return mDepth; }
 
+        void bindTexture(U32 index, S32 channel);
+
         //flush rendering operations
         //must be called when rendering is complete
         //should be used 1:1 with bindTarget 
@@ -115,23 +132,47 @@ public:
         // the current depth texture.  A depth texture will be allocated if needed.
         void flush(BOOL fetch_depth = FALSE);
 
+        void copyContents(LLRenderTarget& source, S32 srcX0, S32 srcY0, S32 srcX1, S32 srcY1,
+                                                S32 dstX0, S32 dstY0, S32 dstX1, S32 dstY1, U32 mask, U32 filter);
+
         //Returns TRUE if target is ready to be rendered into.
         //That is, if the target has been allocated with at least
         //one renderable attachment (i.e. color buffer, depth buffer).
         BOOL isComplete() const;
 
-private:
+protected:
+        friend class LLMultisampleBuffer;
         U32 mResX;
         U32 mResY;
-        U32 mTex;
+        std::vector<U32> mTex;
         U32 mFBO;
         U32 mDepth;
-        U32 mStencil;
+        BOOL mStencil;
         BOOL mUseDepth;
         BOOL mRenderDepth;
         LLTexUnit::eTextureType mUsage;
+        U32 mSamples;
+        LLMultisampleBuffer* mSampleBuffer;
         
 };
 
+class LLMultisampleBuffer : public LLRenderTarget
+{
+public:
+        LLMultisampleBuffer();
+        virtual ~LLMultisampleBuffer();
+
+        void releaseSampleBuffer();
+
+        virtual void bindTarget();
+        void bindTarget(LLRenderTarget* ref);
+        virtual void allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, BOOL stencil, LLTexUnit::eTextureType usage, BOOL use_fbo);
+        void allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, BOOL stencil, LLTexUnit::eTextureType usage, BOOL use_fbo, U32 samples);
+        virtual void addColorAttachment(U32 color_fmt);
+        virtual void allocateDepth();
+};
+
+#endif //!LL_MESA_HEADLESS
+
 #endif
 
diff --git a/linden/indra/llrender/llshadermgr.cpp b/linden/indra/llrender/llshadermgr.cpp
index 3046d19..1286e91 100644
--- a/linden/indra/llrender/llshadermgr.cpp
+++ b/linden/indra/llrender/llshadermgr.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -363,7 +364,7 @@ GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shade
 
 
         //copy file into memory
-        while(fgets((char *)buff, 1024, file) != NULL && count < (sizeof(buff)/sizeof(buff[0]))) 
+        while( fgets((char *)buff, 1024, file) != NULL && count < LL_ARRAY_SIZE(buff) ) 
         {
                 text[count++] = (GLcharARB *)strdup((char *)buff); 
         }
diff --git a/linden/indra/llrender/llshadermgr.h b/linden/indra/llrender/llshadermgr.h
index 1f78e30..2488c7a 100644
--- a/linden/indra/llrender/llshadermgr.h
+++ b/linden/indra/llrender/llshadermgr.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
diff --git a/linden/indra/llrender/llvertexbuffer.cpp b/linden/indra/llrender/llvertexbuffer.cpp
index cb7f352..461edbe 100644
--- a/linden/indra/llrender/llvertexbuffer.cpp
+++ b/linden/indra/llrender/llvertexbuffer.cpp
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -68,8 +69,10 @@ S32 LLVertexBuffer::sTypeOffsets[LLVertexBuffer::TYPE_MAX] =
 {
         sizeof(LLVector3), // TYPE_VERTEX,
         sizeof(LLVector3), // TYPE_NORMAL,
-        sizeof(LLVector2), // TYPE_TEXCOORD,
+        sizeof(LLVector2), // TYPE_TEXCOORD0,
+        sizeof(LLVector2), // TYPE_TEXCOORD1,
         sizeof(LLVector2), // TYPE_TEXCOORD2,
+        sizeof(LLVector2), // TYPE_TEXCOORD3,
         sizeof(LLColor4U), // TYPE_COLOR,
         sizeof(LLVector3), // TYPE_BINORMAL,
         sizeof(F32),       // TYPE_WEIGHT,
@@ -102,8 +105,8 @@ void LLVertexBuffer::setupClientArrays(U32 data_mask)
                 {
                         MAP_VERTEX,
                         MAP_NORMAL,
-                        MAP_TEXCOORD,
-                        MAP_COLOR
+                        MAP_TEXCOORD0,
+                        MAP_COLOR,
                 };
                 
                 GLenum array[] =
@@ -111,7 +114,7 @@ void LLVertexBuffer::setupClientArrays(U32 data_mask)
                         GL_VERTEX_ARRAY,
                         GL_NORMAL_ARRAY,
                         GL_TEXTURE_COORD_ARRAY,
-                        GL_COLOR_ARRAY
+                        GL_COLOR_ARRAY,
                 };
 
                 for (U32 i = 0; i < 4; ++i)
@@ -122,7 +125,7 @@ void LLVertexBuffer::setupClientArrays(U32 data_mask)
                                 { //needs to be disabled
                                         glDisableClientState(array[i]);
                                 }
-                                else
+                                else if (gDebugGL)
                                 { //needs to be enabled, make sure it was (DEBUG TEMPORARY)
                                         if (i > 0 && !glIsEnabled(array[i]))
                                         {
@@ -136,29 +139,55 @@ void LLVertexBuffer::setupClientArrays(U32 data_mask)
                                 { //needs to be enabled
                                         glEnableClientState(array[i]);
                                 }
-                                else if (glIsEnabled(array[i]))
+                                else if (gDebugGL && glIsEnabled(array[i]))
                                 { //needs to be disabled, make sure it was (DEBUG TEMPORARY)
                                         llerrs << "Bad client state! " << array[i] << " enabled." << llendl;
                                 }
                         }
                 }
 
-                if (sLastMask & MAP_TEXCOORD2)
+                U32 map_tc[] = 
                 {
-                        if (!(data_mask & MAP_TEXCOORD2))
+                        MAP_TEXCOORD1,
+                        MAP_TEXCOORD2,
+                        MAP_TEXCOORD3
+                };
+
+                for (U32 i = 0; i < 3; i++)
+                {
+                        if (sLastMask & map_tc[i])
                         {
-                                glClientActiveTextureARB(GL_TEXTURE1_ARB);
+                                if (!(data_mask & map_tc[i]))
+                                {
+                                        glClientActiveTextureARB(GL_TEXTURE1_ARB+i);
+                                        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+                                        glClientActiveTextureARB(GL_TEXTURE0_ARB);
+                                }
+                        }
+                        else if (data_mask & map_tc[i])
+                        {
+                                glClientActiveTextureARB(GL_TEXTURE1_ARB+i);
+                                glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+                                glClientActiveTextureARB(GL_TEXTURE0_ARB);
+                        }
+                }
+
+                if (sLastMask & MAP_BINORMAL)
+                {
+                        if (!(data_mask & MAP_BINORMAL))
+                        {
+                                glClientActiveTextureARB(GL_TEXTURE2_ARB);
                                 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
                                 glClientActiveTextureARB(GL_TEXTURE0_ARB);
                         }
                 }
-                else if (data_mask & MAP_TEXCOORD2)
+                else if (data_mask & MAP_BINORMAL)
                 {
-                        glClientActiveTextureARB(GL_TEXTURE1_ARB);
+                        glClientActiveTextureARB(GL_TEXTURE2_ARB);
                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
                         glClientActiveTextureARB(GL_TEXTURE0_ARB);
                 }
-
+        
                 sLastMask = data_mask;
         }
 }
@@ -193,6 +222,7 @@ void LLVertexBuffer::drawRange(U32 mode, U32 start, U32 end, U32 count, U32 indi
                 return;
         }
 
+        stop_glerror();
         glDrawRangeElements(sGLMode[mode], start, end, count, GL_UNSIGNED_SHORT, 
                 ((U16*) getIndicesPointer()) + indices_offset);
         stop_glerror();
@@ -222,13 +252,14 @@ void LLVertexBuffer::draw(U32 mode, U32 count, U32 indices_offset) const
                 return;
         }
 
+        stop_glerror();
         glDrawElements(sGLMode[mode], count, GL_UNSIGNED_SHORT,
                 ((U16*) getIndicesPointer()) + indices_offset);
+        stop_glerror();
 }
 
 void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const
 {
-        
         if (first >= (U32) mRequestedNumVerts ||
                 first + count > (U32) mRequestedNumVerts)
         {
@@ -246,6 +277,7 @@ void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const
                 return;
         }
 
+        stop_glerror();
         glDrawArrays(sGLMode[mode], first, count);
         stop_glerror();
 }
@@ -766,11 +798,7 @@ U8* LLVertexBuffer::mapBuffer(S32 access)
                 stop_glerror();
                 mMappedIndexData = (U8*) glMapBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, GL_WRITE_ONLY_ARB);
                 stop_glerror();
-                /*if (sMapped)
-                {
-                        llerrs << "Mapped two VBOs at the same time!" << llendl;
-                }
-                sMapped = TRUE;*/               
+
                 if (!mMappedData)
                 {
                         //--------------------
@@ -895,14 +923,22 @@ bool LLVertexBuffer::getIndexStrider(LLStrider<U16>& strider, S32 index)
 {
         return VertexBufferStrider<U16,TYPE_INDEX>::get(*this, strider, index);
 }
-bool LLVertexBuffer::getTexCoordStrider(LLStrider<LLVector2>& strider, S32 index)
+bool LLVertexBuffer::getTexCoord0Strider(LLStrider<LLVector2>& strider, S32 index)
+{
+        return VertexBufferStrider<LLVector2,TYPE_TEXCOORD0>::get(*this, strider, index);
+}
+bool LLVertexBuffer::getTexCoord1Strider(LLStrider<LLVector2>& strider, S32 index)
 {
-        return VertexBufferStrider<LLVector2,TYPE_TEXCOORD>::get(*this, strider, index);
+        return VertexBufferStrider<LLVector2,TYPE_TEXCOORD1>::get(*this, strider, index);
 }
-bool LLVertexBuffer::getTexCoord2Strider(LLStrider<LLVector2>& strider, S32 index)
+/*bool LLVertexBuffer::getTexCoord2Strider(LLStrider<LLVector2>& strider, S32 index)
 {
         return VertexBufferStrider<LLVector2,TYPE_TEXCOORD2>::get(*this, strider, index);
 }
+bool LLVertexBuffer::getTexCoord3Strider(LLStrider<LLVector2>& strider, S32 index)
+{
+        return VertexBufferStrider<LLVector2,TYPE_TEXCOORD3>::get(*this, strider, index);
+}*/
 bool LLVertexBuffer::getNormalStrider(LLStrider<LLVector3>& strider, S32 index)
 {
         return VertexBufferStrider<LLVector3,TYPE_NORMAL>::get(*this, strider, index);
@@ -1100,24 +1136,39 @@ void LLVertexBuffer::setupVertexBuffer(U32 data_mask) const
         {
                 glNormalPointer(GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_NORMAL]));
         }
+        if (data_mask & MAP_TEXCOORD3)
+        {
+                glClientActiveTextureARB(GL_TEXTURE3_ARB);
+                glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD3]));
+                glClientActiveTextureARB(GL_TEXTURE0_ARB);
+        }
         if (data_mask & MAP_TEXCOORD2)
         {
-                glClientActiveTextureARB(GL_TEXTURE1_ARB);
+                glClientActiveTextureARB(GL_TEXTURE2_ARB);
                 glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD2]));
                 glClientActiveTextureARB(GL_TEXTURE0_ARB);
         }
-        if (data_mask & MAP_TEXCOORD)
+        if (data_mask & MAP_TEXCOORD1)
         {
-                glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD]));
+                glClientActiveTextureARB(GL_TEXTURE1_ARB);
+                glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD1]));
+                glClientActiveTextureARB(GL_TEXTURE0_ARB);
         }
-        if (data_mask & MAP_COLOR)
+        if (data_mask & MAP_BINORMAL)
         {
-                glColorPointer(4, GL_UNSIGNED_BYTE, stride, (void*)(base + mOffsets[TYPE_COLOR]));
+                glClientActiveTextureARB(GL_TEXTURE2_ARB);
+                glTexCoordPointer(3,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_BINORMAL]));
+                glClientActiveTextureARB(GL_TEXTURE0_ARB);
         }
-        if (data_mask & MAP_BINORMAL)
+        if (data_mask & MAP_TEXCOORD0)
         {
-                glVertexAttribPointerARB(6, 3, GL_FLOAT, FALSE,  stride, (void*)(base + mOffsets[TYPE_BINORMAL]));
+                glTexCoordPointer(2,GL_FLOAT, stride, (void*)(base + mOffsets[TYPE_TEXCOORD0]));
         }
+        if (data_mask & MAP_COLOR)
+        {
+                glColorPointer(4, GL_UNSIGNED_BYTE, stride, (void*)(base + mOffsets[TYPE_COLOR]));
+        }
+        
         if (data_mask & MAP_WEIGHT)
         {
                 glVertexAttribPointerARB(1, 1, GL_FLOAT, FALSE, stride, (void*)(base + mOffsets[TYPE_WEIGHT]));
diff --git a/linden/indra/llrender/llvertexbuffer.h b/linden/indra/llrender/llvertexbuffer.h
index aa1aafc..aad948e 100644
--- a/linden/indra/llrender/llvertexbuffer.h
+++ b/linden/indra/llrender/llvertexbuffer.h
@@ -17,7 +17,8 @@
  * 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://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -99,8 +100,10 @@ public:
         enum {
                 TYPE_VERTEX,
                 TYPE_NORMAL,
-                TYPE_TEXCOORD,
+                TYPE_TEXCOORD0,
+                TYPE_TEXCOORD1,
                 TYPE_TEXCOORD2,
+                TYPE_TEXCOORD3,
                 TYPE_COLOR,
                 // These use VertexAttribPointer and should possibly be made generic
                 TYPE_BINORMAL,
@@ -112,16 +115,15 @@ public:
         enum {
                 MAP_VERTEX = (1<<TYPE_VERTEX),
                 MAP_NORMAL = (1<<TYPE_NORMAL),
-                MAP_TEXCOORD = (1<<TYPE_TEXCOORD),
+                MAP_TEXCOORD0 = (1<<TYPE_TEXCOORD0),
+                MAP_TEXCOORD1 = (1<<TYPE_TEXCOORD1),
                 MAP_TEXCOORD2 = (1<<TYPE_TEXCOORD2),
+                MAP_TEXCOORD3 = (1<<TYPE_TEXCOORD3),
                 MAP_COLOR = (1<<TYPE_COLOR),
                 // These use VertexAttribPointer and should possibly be made generic
                 MAP_BINORMAL = (1<<TYPE_BINORMAL),
                 MAP_WEIGHT = (1<<TYPE_WEIGHT),
                 MAP_CLOTHWEIGHT = (1<<TYPE_CLOTHWEIGHT),
-                MAP_DRAW = 0x2000, // Buffer is in draw (read-only) mode
-                MAP_MAPPED = 0x4000, // Indicates that buffer has been mapped, but not to any type of data
-                MAP_UNMAPPED = 0x8000 // Indicates that buffer has been logically un-mapped
         };
         
 protected:
@@ -164,8 +166,8 @@ public:
         //   vb->unmapBuffer();
         bool getVertexStrider(LLStrider<LLVector3>& strider, S32 index=0);
         bool getIndexStrider(LLStrider<U16>& strider, S32 index=0);
-        bool getTexCoordStrider(LLStrider<LLVector2>& strider, S32 index=0);
-        bool getTexCoord2Strider(LLStrider<LLVector2>& strider, S32 index=0);
+        bool getTexCoord0Strider(LLStrider<LLVector2>& strider, S32 index=0);
+        bool getTexCoord1Strider(LLStrider<LLVector2>& strider, S32 index=0);
         bool getNormalStrider(LLStrider<LLVector3>& strider, S32 index=0);
         bool getBinormalStrider(LLStrider<LLVector3>& strider, S32 index=0);
         bool getColorStrider(LLStrider<LLColor4U>& strider, S32 index=0);