Second Life viewer sources 1.13.2.12

25 files changed, 6497 insertions, 0 deletions

diff --git a/linden/indra/llrender/files.darwin.lst b/linden/indra/llrender/files.darwin.lst
new file mode 100644
index 0000000..2d27570
--- /dev/null
+++ b/linden/indra/llrender/files.darwin.lst
@@ -0,0 +1 @@
+llrender/llagpmempoolapple.cpp
diff --git a/linden/indra/llrender/files.lst b/linden/indra/llrender/files.lst
new file mode 100644
index 0000000..e7b3cec
--- /dev/null
+++ b/linden/indra/llrender/files.lst
@@ -0,0 +1,8 @@
+llrender/llagpmempoolarb.cpp
+llrender/llagpmempool.cpp
+llrender/llfont.cpp
+llrender/llfontgl.cpp
+llrender/llgldbg.cpp
+llrender/llimagegl.cpp
+llrender/llvertexprogramgl.cpp
+llrender/text_out.cpp
diff --git a/linden/indra/llrender/llagpmempool.cpp b/linden/indra/llrender/llagpmempool.cpp
new file mode 100644
index 0000000..39cd3e8
--- /dev/null
+++ b/linden/indra/llrender/llagpmempool.cpp
@@ -0,0 +1,194 @@
+/** 
+ * @file llagpmempool.cpp
+ * @brief LLAGPMemPool base class
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "linden_common.h"
+
+#include "llagpmempool.h"
+#include "llgl.h"
+
+#include "llagpmempoolarb.h"
+#include "llagpmempoolnv.h"
+#include "llagpmempoolati.h"
+
+#if LL_DARWIN
+#include "llagpmempoolapple.h"
+#endif // LL_DARWIN
+
+//static
+S32 LLAGPMemPool::LLFreeBlock::sNumBlocks = 0;
+
+LLAGPMemPool::LLAGPMemPool()
+{
+        mSize = 0;
+        mTotalAllocated = 0;
+}
+
+LLAGPMemPool::~LLAGPMemPool()
+{
+        mFreeList.deleteAll();
+}
+
+LLAGPMemPool *LLAGPMemPool::createPool(const U32 size, const BOOL use_vbo)
+{
+        if (gGLManager.mHasVertexBufferObject && use_vbo)
+        { 
+                return new LLAGPMemPoolARB(size);
+        }
+#if LL_WINDOWS  // *FIX: linux can use these, too, with some work.
+        if (gGLManager.mHasNVFence)
+        {
+                return new LLAGPMemPoolNV(size);
+        }
+        else if (gGLManager.mHasATIVAO)
+        {
+                return new LLAGPMemPoolATI(size);
+        }
+        else
+#elif LL_DARWIN
+        if (gGLManager.mHasAPPLEFence && gGLManager.mHasAPPLEVertexArrayRange)
+        { 
+                return new LLAGPMemPoolAPPLE(size);
+        }
+        else
+#endif
+        {
+                // No AGP memory allocation at all!
+                return NULL;
+        }
+}
+
+
+LLAGPMemBlock *LLAGPMemPool::allocBlock(const S32 size)
+{
+        S32 aligned_size = size;
+        if (size & 0x0f)
+        {
+                aligned_size += 16 - (size & 0x0f);
+        }
+        
+        if (aligned_size > (mSize - mTotalAllocated))
+        {
+                // We're totally out of AGP memory, bail.
+                return NULL;
+        }
+
+        LLFreeBlock *free_block = mFreeList.getFirst();
+
+        while (free_block && free_block->mSize < aligned_size)
+        {
+                free_block = free_block->getNext();
+        }
+
+        U32 offset = 0;
+
+        if (free_block)
+        {
+                if (free_block->mSize == aligned_size)
+                {
+                        free_block->unlink();
+                        offset = free_block->mOffset;
+                        delete free_block;
+                }
+                else
+                {
+                        offset = free_block->mOffset + free_block->mSize - aligned_size;
+                        free_block->mSize -= aligned_size;
+                        if (0 == free_block->mSize)
+                        {
+                                free_block->unlink();
+                        }
+                }
+        }
+        else
+        {
+                //llwarns << "LLAGPMemPool unable to allocate " << size << " bytes" << llendl;
+                return NULL;
+        }
+
+        mTotalAllocated += aligned_size;
+        return createBlock(offset, aligned_size);
+}
+
+
+void LLAGPMemPool::freeBlock(LLAGPMemBlock *blockp)
+{
+        if (!blockp->getSize())
+        {
+                return;
+        }
+
+        LLFreeBlock *prev_free = NULL;
+        LLFreeBlock *cur_free = mFreeList.getFirst();
+
+        while (cur_free && blockp->getOffset() > (U32)cur_free->mOffset)
+        {
+                prev_free = cur_free;
+                cur_free = cur_free->getNext();
+        }
+
+        LLFreeBlock *new_free = new LLFreeBlock(blockp->getOffset(), blockp->getSize());
+
+        if (prev_free)
+        {
+                prev_free->append(*new_free);
+                coalesce(new_free);
+                coalesce(prev_free);
+        }
+        else
+        {
+                mFreeList.append(*new_free);
+                coalesce(new_free);
+        }
+        mTotalAllocated -= blockp->getSize();
+}
+
+void LLAGPMemPool::coalesce(LLFreeBlock *free_block)
+{
+        LLFreeBlock *next = free_block->getNext();
+
+        if (next && (free_block->mOffset + free_block->mSize == next->mOffset))
+        {
+                free_block->mSize += next->mSize;
+
+                next->unlink();
+                delete next;
+
+                coalesce(free_block);
+        }
+}
+
+void LLAGPMemPool::printFreeList()
+{
+        LLFreeBlock *cur_block = mFreeList.getFirst();
+        while (cur_block)
+        {
+                llinfos << "Cur block begin: " << cur_block->mOffset << llendl;
+                llinfos << "Cur block end:   " << cur_block->mOffset + cur_block->mSize << llendl;
+                cur_block = cur_block->getNext();
+        }
+}
+
diff --git a/linden/indra/llrender/llagpmempool.h b/linden/indra/llrender/llagpmempool.h
new file mode 100644
index 0000000..f992876
--- /dev/null
+++ b/linden/indra/llrender/llagpmempool.h
@@ -0,0 +1,121 @@
+/** 
+ * @file llagpmempool.h
+ * @brief LLAGPMemPool base class
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_LLAGPMEMPOOL_H
+#define LL_LLAGPMEMPOOL_H
+
+#include "stdtypes.h"
+#include "lldlinked.h"
+
+// Raw memory handling abstraction, which handles interaction with
+// the nVidia and ATI AGP extensions.
+
+// Minimum size we allow allocation for, in order to allow AGP usage...
+const S32 MIN_AGP_SIZE = 8000000;
+
+class LLAGPMemBlock;
+
+class LLAGPMemPool
+{
+public:
+        LLAGPMemPool();
+        virtual ~LLAGPMemPool();
+
+        virtual LLAGPMemBlock *allocBlock(const S32 size);
+        virtual void freeBlock(LLAGPMemBlock *blockp);
+
+        virtual void flush() = 0;
+        virtual void dump() = 0;
+        virtual void enable() = 0;
+        virtual void disable() = 0;
+        virtual void bind() = 0;
+
+        virtual S32    getSize()                { return mSize; }
+
+        S32 getTotalAllocated() const   { return mTotalAllocated; }
+        static LLAGPMemPool *createPool(const U32 size, const BOOL use_vbo);
+
+        struct LLFreeBlock: public LLDLinked<LLFreeBlock>
+        {
+                S32  mOffset;
+                S32  mSize;
+                LLFreeBlock(const S32 offset, const S32 size) { mOffset = offset; mSize = size; sNumBlocks++; }
+                ~LLFreeBlock() { sNumBlocks--; }
+
+                static S32 sNumBlocks;
+        };
+
+        // Fencing (for nVidia and Apple) - default is to do nothing (ATI, ARB do not need fencing)
+        virtual U32  createFence() { return 0; }
+        virtual void deleteFence(const U32 fence) {}
+        virtual void sendFence(U32 fence) {}
+        virtual void waitFence(U32 fence) {}
+
+        void printFreeList();
+protected:
+
+        void coalesce(LLFreeBlock *free_block);
+        virtual LLAGPMemBlock *createBlock(const U32 offset, const U32 size) = 0;
+        LLDLinked<LLFreeBlock> mFreeList;
+
+        S32 mSize;
+        S32 mTotalAllocated;
+};
+
+// An AGP memory block, which contains all the info needed to
+// copy data in/out.
+class LLAGPMemBlock
+{
+public:
+        LLAGPMemBlock(LLAGPMemPool *mem_poolp) : mMemPoolp(mem_poolp) {}
+        virtual ~LLAGPMemBlock()                                        {}
+        virtual void copy     (void *source, const U32 size_bytes) = 0;
+        virtual void copyColor(void *source, const U32 size_bytes) = 0;
+
+        virtual void bindGLVertexPointer(const U32 stride, const U32 offset) = 0;
+        virtual void bindGLNormalPointer(const U32 stride, const U32 offset) = 0;
+        virtual void bindGLBinormalPointer(const S32 index, const U32 stride, const U32 offset) = 0;
+        virtual void bindGLColorPointer(const U32 stride, const U32 offset) = 0;
+        virtual void bindGLTexCoordPointer(const U32 stride, const U32 offset) = 0;
+        virtual void bindGLVertexWeightPointer(const S32 index, const U32 stride, const U32 offset) = 0;
+        virtual void bindGLVertexClothingWeightPointer(const S32 index, const U32 stride, const U32 offset) = 0;
+
+        virtual BOOL hasMappedMem() const = 0;
+        virtual U8*     getMappedMem() = 0;
+
+        virtual U32  createFence() = 0;
+        virtual void deleteFence(const U32 fence) = 0;
+        virtual void sendFence(U32 fence) = 0;
+        virtual void waitFence(U32 fence) = 0;
+
+        virtual U32 getOffset() const = 0;
+        virtual U32 getSize() const = 0;
+protected:
+        LLAGPMemPool *mMemPoolp;
+};
+
+#endif // LL_LLAGPMEMPOOL_H
diff --git a/linden/indra/llrender/llagpmempoolapple.cpp b/linden/indra/llrender/llagpmempoolapple.cpp
new file mode 100644
index 0000000..9aa4993
--- /dev/null
+++ b/linden/indra/llrender/llagpmempoolapple.cpp
@@ -0,0 +1,314 @@
+/** 
+ * @file llagpmempoolapple.cpp
+ * @brief LLAGPMemPoolAPPLE base class
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifdef LL_DARWIN
+
+#include "linden_common.h"
+
+#include "llagpmempoolapple.h"
+#include "llgl.h"
+
+#include "llglheaders.h"
+
+LLAGPMemPoolAPPLE::LLAGPMemPoolAPPLE(S32 request) : LLAGPMemPool()
+{
+        llinfos << "Creating LLAGPMemPoolAPPLE" << llendl;
+        stop_glerror();
+        if (!gGLManager.mHasAPPLEFence || !gGLManager.mHasAPPLEVertexArrayRange)
+        {
+                llerrs << "necessary extensions not present!" << llendl;
+        }
+        
+        // No special allocation is necessary for the Apple extensions
+        mBase    = (U8*)::malloc(request);
+        mSize     = request;
+
+        if (mBase)
+        {
+                mFreeList.append(*(new LLFreeBlock(0,mSize)));
+        }
+        else
+        {
+                mSize = 0;
+        }
+
+        flush_glerror();
+}
+
+LLAGPMemBlockAPPLE::~LLAGPMemBlockAPPLE()
+{
+        mMemPoolp->freeBlock(this); 
+}
+ 
+LLAGPMemBlock *LLAGPMemPoolAPPLE::createBlock(const U32 offset, const U32 size)
+{
+        return new LLAGPMemBlockAPPLE(this, mBase, offset, size);
+}
+
+LLAGPMemPoolAPPLE::~LLAGPMemPoolAPPLE()
+{       
+        if (mBase)
+        {
+                // MBW -- This really belongs in a call which is the opposite of bind()...
+                glVertexArrayRangeAPPLE(0, 0);
+                ::free(mBase);
+        }
+}
+
+void LLAGPMemPoolAPPLE::bind()
+{
+        if(mBase)
+        {
+                glVertexArrayRangeAPPLE(mSize, mBase);
+        }
+}
+
+void LLAGPMemPoolAPPLE::enable()
+{
+        glEnableClientState(GL_VERTEX_ARRAY_RANGE_APPLE);
+}
+
+void LLAGPMemPoolAPPLE::disable()
+{
+        glDisableClientState(GL_VERTEX_ARRAY_RANGE_APPLE);
+}
+
+void LLAGPMemPoolAPPLE::flush()
+{
+        if(mBase)
+        {
+                glFlushVertexArrayRangeAPPLE(mSize, mBase);
+        }
+}
+
+void LLAGPMemPoolAPPLE::dump()
+{
+        LLFreeBlock *prev = 0;
+        LLFreeBlock *block = mFreeList.getFirst();
+
+        int d=0;
+
+        int i=0;
+        while (block)
+        {
+                i++;
+                if (prev)
+                {
+                        d = (S32)block->mOffset - ((S32)prev->mOffset + prev->mSize);
+                }
+                else d = 0;
+
+                prev  = block;
+                block = block->getNext();
+        }
+}
+
+
+U32  LLAGPMemPoolAPPLE::createFence()
+{
+        U32 fence;
+    glGenFencesAPPLE(1, (GLuint*)&fence);
+        glSetFenceAPPLE(fence);
+    glFinishFenceAPPLE(fence);
+        return fence;
+}
+
+
+void  LLAGPMemPoolAPPLE::deleteFence(const U32 fence)
+{
+    glDeleteFencesAPPLE(1, (GLuint*)&fence);
+}
+
+
+void LLAGPMemPoolAPPLE::sendFence(U32 fence)
+{
+    glSetFenceAPPLE(fence);
+}
+
+
+void LLAGPMemPoolAPPLE::waitFence(U32 fence)
+{
+    if(!glTestFenceAPPLE(fence))
+    {
+        glFinishFenceAPPLE(fence);
+        }
+}
+
+
+/////////////////////////////
+//
+// LLAGPMemBlockAPPLE
+//
+// APPLE Implementation of an AGP memory block
+//
+
+LLAGPMemBlockAPPLE::LLAGPMemBlockAPPLE(LLAGPMemPool *mem_poolp, U8 *baseptr, S32 offset, const U32 size) : LLAGPMemBlock(mem_poolp)
+{
+        mMemp = baseptr + offset;
+        mOffset = offset;
+        mSize = size;
+}
+
+
+void LLAGPMemBlockAPPLE::bindGLVertexPointer(const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty vertex array" << llendl;
+        }
+        glVertexPointer(3, GL_FLOAT, stride, mMemp + offset);
+}
+
+void LLAGPMemBlockAPPLE::bindGLNormalPointer(const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty normal array" << llendl;
+        }
+        glNormalPointer(GL_FLOAT, stride, mMemp + offset);
+}
+
+
+void LLAGPMemBlockAPPLE::bindGLColorPointer(const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty color array" << llendl;
+        }
+        glColorPointer(4, GL_UNSIGNED_BYTE, stride, mMemp + offset);
+}
+
+
+void LLAGPMemBlockAPPLE::bindGLTexCoordPointer(const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty texcoord array" << llendl;
+        }
+        glTexCoordPointer(2, GL_FLOAT, stride, mMemp + offset);
+}
+
+
+void LLAGPMemBlockAPPLE::bindGLBinormalPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty vertex weight array" << llendl;
+        }
+
+        if (index > 0) glVertexAttribPointerARB(index, 3, GL_FLOAT, FALSE, stride, (F32 *)(mMemp + offset));
+}
+
+void LLAGPMemBlockAPPLE::bindGLVertexWeightPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty vertex weight array" << llendl;
+        }
+
+        if (index > 0) glVertexAttribPointerARB(index, 1, GL_FLOAT, FALSE, 0, (F32 *)(mMemp + offset));
+}
+
+void LLAGPMemBlockAPPLE::bindGLVertexClothingWeightPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty vertex weight array" << llendl;
+        }
+        set_vertex_clothing_weights(index, stride, (LLVector4 *)(mMemp + offset));
+}
+
+U8* LLAGPMemBlockAPPLE::getMappedMem()
+{
+        return mMemp;
+}
+
+
+void LLAGPMemBlockAPPLE::copy(void *mem, const U32 size)
+{
+        if (!mMemp || !mem)
+        {
+                return;
+        }
+        llassert(size <= mSize);
+
+        memcpy( mMemp, mem, size );
+        
+        glFlushVertexArrayRangeAPPLE(size, mMemp);
+}
+
+void LLAGPMemBlockAPPLE::copyColor(void *mem, const U32 size)
+{
+        if (!mMemp || !mem)
+        {
+                return;
+        }
+        llassert(size <= mSize);
+
+        memcpy( mMemp, mem, size );
+        
+        glFlushVertexArrayRangeAPPLE(size, mMemp);
+}
+
+
+
+U32  LLAGPMemBlockAPPLE::createFence()
+{
+        U32 fence;
+    glGenFencesAPPLE(1, (GLuint*)&fence);
+        glSetFenceAPPLE(fence);
+    glFinishFenceAPPLE(fence);
+        return fence;
+}
+
+void  LLAGPMemBlockAPPLE::deleteFence(const U32 fence)
+{
+    glDeleteFencesAPPLE(1, (GLuint*)&fence);
+}
+
+void LLAGPMemBlockAPPLE::sendFence(U32 fence)
+{
+    glSetFenceAPPLE(fence);
+}
+
+void LLAGPMemBlockAPPLE::waitFence(U32 fence)
+{
+    if(!glTestFenceAPPLE(fence))
+    {
+        glFinishFenceAPPLE(fence);
+        }
+}
+
+// MBW -- May want this at some point...
+#if 0
+void LLAGPMemBlockAPPLE::flush()
+{
+        glFlushVertexArrayRangeAPPLE(mSize, mMemp);
+}
+#endif
+
+#endif // LL_DARWIN
diff --git a/linden/indra/llrender/llagpmempoolapple.h b/linden/indra/llrender/llagpmempoolapple.h
new file mode 100644
index 0000000..4a72a28
--- /dev/null
+++ b/linden/indra/llrender/llagpmempoolapple.h
@@ -0,0 +1,95 @@
+/** 
+ * @file llagpmempoolapple.h
+ * @brief LLAGPMemPoolAPPLE base class
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_LLAGPMEMPOOLAPPLE_H
+#define LL_LLAGPMEMPOOLAPPLE_H
+
+#include "llagpmempool.h"
+
+#if LL_DARWIN
+class LLAGPMemPoolAPPLE : public LLAGPMemPool
+{
+public:
+        LLAGPMemPoolAPPLE(S32 request);
+        virtual ~LLAGPMemPoolAPPLE();
+
+        /*virtual*/ void flush();
+        /*virtual*/ void dump();
+        /*virtual*/ void enable();
+        /*virtual*/ void disable();
+        /*virtual*/ void bind();
+
+        /*virtual*/ U32  createFence();
+        /*virtual*/ void deleteFence(const U32 fence);
+        /*virtual*/ void sendFence(U32 fence);
+        /*virtual*/ void waitFence(U32 fence);
+
+protected:
+        /*virtual*/ LLAGPMemBlock *createBlock(const U32 offset, const U32 size);
+
+protected:
+        U8 *mBase;
+};
+
+class LLAGPMemBlockAPPLE : public LLAGPMemBlock
+{
+public:
+        LLAGPMemBlockAPPLE(LLAGPMemPool *mem_poolp, U8 *baseptr, const S32 offset, const U32 size);
+        virtual ~LLAGPMemBlockAPPLE();
+
+        /*virtual*/ void copy     (void *source, const U32 size_bytes);
+        /*virtual*/ void copyColor(void *source, const U32 size_bytes);
+        /*virtual*/ void free();
+
+        /*virtual*/ void bindGLVertexPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLNormalPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLBinormalPointer(const S32 index, const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLColorPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLTexCoordPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLVertexWeightPointer(const S32 index, const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLVertexClothingWeightPointer(const S32 index, const U32 stride, const U32 offset);
+
+        /*virtual*/ U32 getOffset()        const { return mOffset; }
+        /*virtual*/ U32 getSize()          const { return mSize; }
+
+        /*virtual*/ BOOL hasMappedMem() const           { return TRUE; }
+        /*virtual*/ U8*  getMappedMem();
+        /*virtual*/ U32  createFence();
+        /*virtual*/ void deleteFence(const U32 fence);
+        /*virtual*/ void sendFence(U32 fence);
+        /*virtual*/ void waitFence(U32 fence);
+
+private:
+        U8 *mMemp;
+        U32 mOffset; // Offset from base
+        U32 mSize;
+        friend class LLAGPMemPoolAPPLE;
+};
+
+#endif // LL_DARWIN
+
+#endif // LL_LLAGPMEMPOOLAPPLE_H
diff --git a/linden/indra/llrender/llagpmempoolarb.cpp b/linden/indra/llrender/llagpmempoolarb.cpp
new file mode 100644
index 0000000..ab97c97
--- /dev/null
+++ b/linden/indra/llrender/llagpmempoolarb.cpp
@@ -0,0 +1,230 @@
+/** 
+ * @file llagpmempoolarb.cpp
+ * @brief LLAGPMemPoolARB base class
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "linden_common.h"
+#include "llagpmempoolarb.h"
+#include "llgl.h"
+
+#include "llglheaders.h"
+
+LLAGPMemPoolARB::LLAGPMemPoolARB(S32 request) : LLAGPMemPool()
+{
+        llinfos << "Creating LLAGPMemPoolARB" << llendl;
+        stop_glerror();
+        if (!gGLManager.mHasVertexBufferObject)
+        {
+                llerrs << "No ARB vertex buffer object extension!" << llendl;
+        }
+
+        mName = 0;
+
+        mSize = request;
+        flush_glerror();
+}
+
+
+LLAGPMemPoolARB::~LLAGPMemPoolARB()
+{
+}
+
+
+LLAGPMemBlock* LLAGPMemPoolARB::allocBlock(const S32 size) 
+{
+        return allocBlock(size, GL_ARRAY_BUFFER_ARB); 
+}
+
+LLAGPMemBlock *LLAGPMemPoolARB::allocBlock(const S32 size, U32 target)
+{
+        S32 aligned_size = size;
+        if (size & 0x0f)
+        {
+                aligned_size += 16 - (size & 0x0f);
+        }
+        
+        if (aligned_size > (mSize - mTotalAllocated))
+        {
+                // We're totally out of AGP memory, bail.
+                return (LLAGPMemBlock *)0;
+        }
+
+        mTotalAllocated += aligned_size;
+        return createBlock(0, aligned_size, target);
+}
+
+
+void LLAGPMemPoolARB::freeBlock(LLAGPMemBlock *blockp)
+{
+        if (!blockp->getSize())
+        {
+                return;
+        }
+        LLAGPMemBlockARB *arb_blockp = (LLAGPMemBlockARB*)blockp;
+        U32 name[1];
+        name[0] = arb_blockp->getName();
+        stop_glerror();
+        glDeleteBuffersARB(1, (GLuint*)name);
+        stop_glerror();
+        mTotalAllocated -= blockp->getSize();
+}
+
+LLAGPMemBlock *LLAGPMemPoolARB::createBlock(const U32 offset, const U32 size)
+{
+        return createBlock(offset, size, GL_ARRAY_BUFFER_ARB);
+}
+
+LLAGPMemBlock *LLAGPMemPoolARB::createBlock(const U32 offset, const U32 size, const U32 target)
+{
+        U32 name[1];
+        stop_glerror();
+        glGenBuffersARB(1, (GLuint*)name);
+        stop_glerror();
+        return new LLAGPMemBlockARB(this, name[0], offset, size, target);
+}
+
+void LLAGPMemPoolARB::disable()
+{
+}
+
+void LLAGPMemPoolARB::dump()
+{
+}
+
+
+/////////////////////////////
+//
+// LLAGPMemBlockARB
+//
+// ARB ImplementARBon of an AGP memory block
+//
+
+LLAGPMemBlockARB::LLAGPMemBlockARB(LLAGPMemPool *mem_poolp, const U32 name, const U32 offset, const U32 size, U32 target) :
+        LLAGPMemBlock(mem_poolp), mTarget(target)
+{
+        llassert(name > 0);
+        mName = name;
+        stop_glerror();
+        glBindBufferARB(mTarget, mName);
+        stop_glerror();
+        
+        glBufferDataARB(mTarget, size, NULL, GL_DYNAMIC_DRAW_ARB);
+        
+        stop_glerror();
+        glBindBufferARB(mTarget, 0);
+        stop_glerror();
+        mSize = size;
+}
+
+
+void LLAGPMemBlockARB::bindGLVertexPointer(const U32 stride, const U32 offset)
+{
+        stop_glerror();
+        glBindBufferARB(mTarget, mName);
+        glVertexPointer(3, GL_FLOAT, stride, (GLvoid*)((intptr_t)offset));
+        glBindBufferARB(mTarget, 0);
+}
+
+
+void LLAGPMemBlockARB::bindGLNormalPointer(const U32 stride, const U32 offset)
+{
+        stop_glerror();
+        glBindBufferARB(mTarget, mName);
+        glNormalPointer(GL_FLOAT, stride, (GLvoid*)((intptr_t)offset));
+        glBindBufferARB(mTarget, 0);
+        stop_glerror();
+}
+
+
+void LLAGPMemBlockARB::bindGLColorPointer(const U32 stride, const U32 offset)
+{
+        stop_glerror();
+        glBindBufferARB(mTarget, mName);
+        glColorPointer(4, GL_UNSIGNED_BYTE, stride, (GLvoid*)((intptr_t)offset));
+        glBindBufferARB(mTarget, 0);
+        stop_glerror();
+}
+
+
+void LLAGPMemBlockARB::bindGLTexCoordPointer(const U32 stride, const U32 offset)
+{
+        stop_glerror();
+        glBindBufferARB(mTarget, mName);
+        glTexCoordPointer(2, GL_FLOAT, stride, (GLvoid*)((intptr_t)offset));
+        glBindBufferARB(mTarget, 0);
+        stop_glerror();
+}
+
+
+void LLAGPMemBlockARB::bindGLVertexWeightPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        stop_glerror();
+        glBindBufferARB(mTarget, mName);
+        set_vertex_weights(index, (F32*)(intptr_t)offset);
+        glBindBufferARB(mTarget, 0);
+        stop_glerror();
+}
+
+void LLAGPMemBlockARB::bindGLBinormalPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        stop_glerror();
+        glBindBufferARB(mTarget, mName);
+        set_binormals(index, stride, (LLVector3*)(intptr_t)offset);
+        glBindBufferARB(mTarget, 0);
+        stop_glerror();
+}
+
+
+void LLAGPMemBlockARB::bindGLVertexClothingWeightPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        return;
+}
+
+
+void LLAGPMemBlockARB::copy(void *mem, const U32 size)
+{
+        stop_glerror();
+        llassert(size <= mSize);
+        glBindBufferARB(mTarget, mName);
+        glBufferSubDataARB(mTarget, 0, size, mem);
+        glBindBufferARB(mTarget, 0);
+        stop_glerror();
+}
+
+void LLAGPMemBlockARB::copyColor(void *mem, const U32 size)
+{
+        stop_glerror();
+        llassert(size <= mSize);
+        glBindBufferARB(mTarget, mName);
+        glBufferSubDataARB(mTarget, 0, size, mem);
+        glBindBufferARB(mTarget, 0);
+        stop_glerror();
+}
+
+
+U8*     LLAGPMemBlockARB::getMappedMem()
+{
+        return NULL;
+}
diff --git a/linden/indra/llrender/llagpmempoolarb.h b/linden/indra/llrender/llagpmempoolarb.h
new file mode 100644
index 0000000..7358862
--- /dev/null
+++ b/linden/indra/llrender/llagpmempoolarb.h
@@ -0,0 +1,103 @@
+/** 
+ * @file llagpmempoolarb.h
+ * @brief LLAGPMemPoolARB base class
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_LLAGPMEMPOOLARB_H
+#define LL_LLAGPMEMPOOLARB_H
+
+#include "llagpmempool.h"
+
+class LLAGPMemPoolARB : public LLAGPMemPool
+{
+public:
+        LLAGPMemPoolARB(S32 request);
+        virtual ~LLAGPMemPoolARB();
+
+        /*virtual*/ LLAGPMemBlock* allocBlock(const S32 size);
+        LLAGPMemBlock *allocBlock(const S32 size, U32 target);
+        /*virtual*/ void freeBlock(LLAGPMemBlock *blockp);
+
+        void bind() {}
+
+        void enable() {}
+
+        /*virtual*/ void disable();
+
+        void flush() {}
+
+        // No point in these being inline, is there?  They're virtual functions anyway...
+        /*virtual*/ inline LLAGPMemBlock *alloc(S32 size);
+        /*virtual*/ inline void free(LLAGPMemBlock *block);
+        /*virtual*/ inline void dump();
+protected:
+        /*virtual*/ LLAGPMemBlock *createBlock(const U32 offset, const U32 size);
+        LLAGPMemBlock *createBlock(const U32 offset, const U32 size, const U32 target);
+
+protected:
+        U32  mName;
+};
+
+class LLAGPMemBlockARB : public LLAGPMemBlock
+{
+public:
+        LLAGPMemBlockARB(LLAGPMemPool *mem_poolp, const U32 name, const U32 offset, const U32 size, U32 target);
+        virtual ~LLAGPMemBlockARB() { mMemPoolp->freeBlock(this); };
+
+        /*virtual*/ void copy     (void *source, const U32 size_bytes);
+        /*virtual*/ void copyColor(void *source, const U32 size_bytes);
+        /*virtual*/ void free();
+
+        /*virtual*/ void bind();
+        /*virtual*/ void unbind();
+
+        /*virtual*/ void bindGLVertexPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLNormalPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLBinormalPointer(const S32 index, const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLColorPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLTexCoordPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLVertexWeightPointer(const S32 index, const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLVertexClothingWeightPointer(const S32 index, const U32 stride, const U32 offset);
+
+        /*virtual*/ U32 getOffset()        const { return 0; }
+        /*virtual*/ U32 getSize()          const { return mSize; }
+
+        /*virtual*/ BOOL hasMappedMem() const           { return FALSE; }
+        /*virtual*/ U8* getMappedMem();
+        /*virtual*/ U32  createFence() { return 0; } 
+        /*virtual*/ void deleteFence(const U32 fence) {}
+        /*virtual*/ void sendFence(U32 fence) { }
+        /*virtual*/ void waitFence(U32 fence) { }
+
+        U32 getName() const                                     {       return mName; }
+private:
+        U32 mName;
+        U32 mSize;
+        U32 mTarget;
+
+        friend class LLAGPMemPoolARB;
+};
+
+#endif // LL_LLAGPMEMPOOLARB_H
diff --git a/linden/indra/llrender/llagpmempoolati.cpp b/linden/indra/llrender/llagpmempoolati.cpp
new file mode 100644
index 0000000..f29db95
--- /dev/null
+++ b/linden/indra/llrender/llagpmempoolati.cpp
@@ -0,0 +1,160 @@
+/** 
+ * @file llagpmempoolati.cpp
+ * @brief LLAGPMemPoolATI base class
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "linden_common.h"
+
+#include "llagpmempoolati.h"
+#include "llgl.h"
+
+#include "llglheaders.h"
+
+LLAGPMemPoolATI::LLAGPMemPoolATI(S32 request) : LLAGPMemPool()
+{
+        llinfos << "Creating LLAGPMemPoolATI" << llendl;
+        stop_glerror();
+        if (!gGLManager.mHasATIVAO)
+        {
+                llerrs << "No ATI AGI memory extension!" << llendl;
+        }
+
+        mName = 0;
+
+        // More than 4MB of agp available
+        while (!mName && (request > 0))
+        {
+                mName = glNewObjectBufferATI(request, NULL, GL_DYNAMIC_ATI);
+                mSize     = request;
+                request >>= 1;
+        }
+
+        if (mName)
+        {
+                mFreeList.append(*(new LLFreeBlock(0, mSize)));
+        }
+        else
+        {
+                llinfos << "Unable to allocate AGP memory!" << llendl;
+                mSize = 0;
+        }
+        flush_glerror();
+}
+
+
+LLAGPMemPoolATI::~LLAGPMemPoolATI()
+{
+        if (mName)
+        {
+                glFreeObjectBufferATI(mName);
+        } 
+}
+
+
+LLAGPMemBlock *LLAGPMemPoolATI::createBlock(const U32 offset, const U32 size)
+{
+        return new LLAGPMemBlockATI(this, mName, offset, size);
+}
+
+
+void LLAGPMemPoolATI::dump()
+{
+}
+
+
+/////////////////////////////
+//
+// LLAGPMemBlockATI
+//
+// ATI Implementation of an AGP memory block
+//
+
+LLAGPMemBlockATI::LLAGPMemBlockATI(LLAGPMemPool *mem_poolp, const U32 name, const U32 offset, const U32 size) :
+        LLAGPMemBlock(mem_poolp)
+{
+        mName = name;
+        mOffset = offset;
+        mSize = size;
+}
+
+
+void LLAGPMemBlockATI::bindGLVertexPointer(const U32 stride, const U32 offset)
+{
+        glArrayObjectATI(GL_VERTEX_ARRAY, 3, GL_FLOAT, stride, mName, mOffset + offset);
+}
+
+
+void LLAGPMemBlockATI::bindGLNormalPointer(const U32 stride, const U32 offset)
+{
+        glArrayObjectATI(GL_NORMAL_ARRAY, 3, GL_FLOAT, stride, mName, mOffset + offset);
+}
+
+
+void LLAGPMemBlockATI::bindGLColorPointer(const U32 stride, const U32 offset)
+{
+        glArrayObjectATI(GL_COLOR_ARRAY, 4, GL_UNSIGNED_BYTE, stride, mName, mOffset + offset);
+}
+
+
+void LLAGPMemBlockATI::bindGLTexCoordPointer(const U32 stride, const U32 offset)
+{
+        glArrayObjectATI(GL_TEXTURE_COORD_ARRAY, 2, GL_FLOAT, stride, mName, mOffset + offset);
+}
+
+
+void LLAGPMemBlockATI::bindGLBinormalPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        glVertexAttribArrayObjectATI(index, 3, GL_FLOAT, FALSE, stride, mName, mOffset + offset);
+}
+
+
+void LLAGPMemBlockATI::bindGLVertexWeightPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        //glArrayObjectATI(GL_WEIGHT_ARRAY_ARB, 1, GL_FLOAT, stride, mName, mOffset + offset);
+        glVertexAttribArrayObjectATI(index, 1, GL_FLOAT, FALSE, stride, mName, mOffset + offset);
+}
+
+void LLAGPMemBlockATI::bindGLVertexClothingWeightPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        glVertexAttribArrayObjectATI(index, 4, GL_FLOAT, FALSE, stride, mName, mOffset + offset);
+}
+
+U8* LLAGPMemBlockATI::getMappedMem()
+{
+        return NULL;
+}
+
+void LLAGPMemBlockATI::copy(void *mem, const U32 size)
+{
+        llassert(size <= mSize);
+        glUpdateObjectBufferATI(mName, mOffset, size, mem, GL_PRESERVE_ATI);
+}
+
+void LLAGPMemBlockATI::copyColor(void *mem, const U32 size)
+{
+        llassert(size <= mSize);
+        glUpdateObjectBufferATI(mName, mOffset, size, mem, GL_PRESERVE_ATI);
+}
+
diff --git a/linden/indra/llrender/llagpmempoolati.h b/linden/indra/llrender/llagpmempoolati.h
new file mode 100644
index 0000000..67803f6
--- /dev/null
+++ b/linden/indra/llrender/llagpmempoolati.h
@@ -0,0 +1,92 @@
+/** 
+ * @file llagpmempoolati.h
+ * @brief LLAGPMemPoolATI base class
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_LLAGPMEMPOOLATI_H
+#define LL_LLAGPMEMPOOLATI_H
+
+#include "llagpmempool.h"
+
+class LLAGPMemPoolATI : public LLAGPMemPool
+{
+public:
+        LLAGPMemPoolATI(S32 request);
+        virtual ~LLAGPMemPoolATI();
+
+        void bind() {}
+
+        void enable() {}
+
+        void disable() {}
+
+        void flush() {}
+
+        // No point in these being inline, is there?  They're virtual functions anyway...
+        /*virtual*/ inline LLAGPMemBlock *alloc(S32 size);
+        /*virtual*/ inline void free(LLAGPMemBlock *block);
+        /*virtual*/ inline void dump();
+protected:
+        /*virtual*/ LLAGPMemBlock *createBlock(const U32 offset, const U32 size);
+
+protected:
+        U32  mName;
+};
+
+class LLAGPMemBlockATI : public LLAGPMemBlock
+{
+public:
+        LLAGPMemBlockATI(LLAGPMemPool *mem_poolp, const U32 name, const U32 offset, const U32 size);
+        virtual ~LLAGPMemBlockATI() { mMemPoolp->freeBlock(this); };
+
+        /*virtual*/ void copy     (void *source, const U32 size_bytes);
+        /*virtual*/ void copyColor(void *source, const U32 size_bytes);
+        /*virtual*/ void free();
+        /*virtual*/ void bindGLVertexPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLNormalPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLBinormalPointer(const S32 index, const U32 stride,const U32 offset);
+        /*virtual*/ void bindGLColorPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLTexCoordPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLVertexWeightPointer(const S32 index, const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLVertexClothingWeightPointer(const S32 index, const U32 stride, const U32 offset);
+
+        /*virtual*/ U32 getOffset()        const { return mOffset; }
+        /*virtual*/ U32 getSize()          const { return mSize; }
+
+        /*virtual*/ BOOL hasMappedMem() const           { return TRUE; }
+        /*virtual*/ U8*  getMappedMem();
+        /*virtual*/ U32  createFence() { return 0; } 
+        /*virtual*/ void deleteFence(const U32 fence) {}
+        /*virtual*/ void sendFence(U32 fence) { }
+        /*virtual*/ void waitFence(U32 fence) { }
+private:
+        U32 mName;
+        U32 mOffset;
+        U32 mSize;
+
+        friend class LLAGPMemPoolATI;
+};
+
+#endif // LL_LLAGPMEMPOOLATI_H
diff --git a/linden/indra/llrender/llagpmempoolnv.cpp b/linden/indra/llrender/llagpmempoolnv.cpp
new file mode 100644
index 0000000..8bbaef9
--- /dev/null
+++ b/linden/indra/llrender/llagpmempoolnv.cpp
@@ -0,0 +1,320 @@
+/** 
+ * @file llagpmempoolnv.cpp
+ * @brief LLAGPMemPoolNV base class
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "linden_common.h"
+
+#ifndef LL_LINUX
+
+#include "llagpmempoolnv.h"
+#include "llgl.h"
+
+#include "llglheaders.h"
+
+#if LL_WINDOWS
+//#define LL_USE_NEW_MEM_OPS 1
+#endif
+#if LL_USE_NEW_MEM_OPS
+#include "new_mem_ops.h"
+#endif
+
+BOOL LLAGPMemPoolNV::sWriteOK = TRUE;
+
+LLAGPMemPoolNV::LLAGPMemPoolNV(int request) : LLAGPMemPool()
+{
+        llinfos << "Creating LLAGPMemPoolNV" << llendl;
+        stop_glerror();
+        if (!gGLManager.mHasNVFence)
+        {
+                llerrs << "wglAllocateMemoryNV not defined!" << llendl;
+        }
+
+        mBase = 0;
+
+        if (!mBase)
+        {
+                // More than 4MB of AGP available
+                while (!mBase && (request > 0))
+                {
+                        // Stupid arbitrary nVidia magic numbers.
+                        // read freq, write freq, priority
+                        // AGP: 0.0, 0.1, 0.5
+                        // Video: 0.0, 0.1, 1.0
+                        mBase    = (U8*)wglAllocateMemoryNV(request, 0.0f, 0.1f, 0.5f);
+                        mSize     = request;
+                        request >>= 1;
+                }
+        }
+
+        if (mBase)
+        {
+                mFreeList.append(*(new LLFreeBlock(0,mSize)));
+        }
+        else
+        {
+                mSize = 0;
+        }
+
+        sWriteOK = TRUE;
+        flush_glerror();
+}
+
+
+LLAGPMemBlock *LLAGPMemPoolNV::createBlock(const U32 offset, const U32 size)
+{
+        return new LLAGPMemBlockNV(this, mBase, offset, size);
+}
+
+LLAGPMemPoolNV::~LLAGPMemPoolNV()
+{
+        if (mBase)
+        {
+                wglFreeMemoryNV(mBase);
+        }
+}
+
+void LLAGPMemPoolNV::bind()
+{
+        glVertexArrayRangeNV(mSize, mBase);
+}
+
+void LLAGPMemPoolNV::enable()
+{
+        glEnableClientState(GL_VERTEX_ARRAY_RANGE_NV);
+        sWriteOK = FALSE;
+}
+
+void LLAGPMemPoolNV::disable()
+{
+        glDisableClientState(GL_VERTEX_ARRAY_RANGE_NV);
+        sWriteOK = TRUE;
+}
+
+void LLAGPMemPoolNV::flush()
+{
+        glFlushVertexArrayRangeNV();
+}
+
+U32  LLAGPMemPoolNV::createFence()
+{
+        U32 fence;
+    glGenFencesNV(1, &fence);
+        glSetFenceNV(fence, GL_ALL_COMPLETED_NV);
+    glFinishFenceNV(fence);
+        return fence;
+}
+
+void LLAGPMemPoolNV::deleteFence(const U32 fence)
+{
+        glDeleteFencesNV(1, &fence);
+}
+
+void LLAGPMemPoolNV::sendFence(U32 fence)
+{
+    glSetFenceNV(fence, GL_ALL_COMPLETED_NV);
+}
+
+void LLAGPMemPoolNV::waitFence(U32 fence)
+{
+    if(!glTestFenceNV(fence))
+    {
+        glFinishFenceNV(fence);
+        }
+}
+
+
+//static
+BOOL LLAGPMemPoolNV::isWriteOK()
+{
+        return sWriteOK;
+}
+
+void LLAGPMemPoolNV::dump()
+{
+        LLFreeBlock *prev = 0;
+        LLFreeBlock *block = mFreeList.getFirst();
+
+        int d=0;
+
+        int i=0;
+        while (block)
+        {
+                i++;
+                if (prev)
+                {
+                        d = (S32)block->mOffset - ((S32)prev->mOffset + prev->mSize);
+                }
+                else d = 0;
+
+                prev  = block;
+                block = block->getNext();
+        }
+}
+
+
+LLAGPMemBlockNV::LLAGPMemBlockNV(LLAGPMemPool *mem_poolp, U8 *baseptr, S32 offset, const U32 size) : LLAGPMemBlock(mem_poolp)
+{
+        mMemp = baseptr + offset;
+        mOffset = offset;
+        mSize = size;
+}
+
+extern U8* gAGPVertices;
+
+void LLAGPMemBlockNV::bindGLVertexPointer(const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty vertex array" << llendl;
+        }
+        glVertexPointer(3, GL_FLOAT, stride, mMemp + offset);
+}
+
+void LLAGPMemBlockNV::bindGLNormalPointer(const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty normal array" << llendl;
+        }
+        glNormalPointer(GL_FLOAT, stride, mMemp + offset);
+}
+
+
+void LLAGPMemBlockNV::bindGLColorPointer(const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty color array" << llendl;
+        }
+        glColorPointer(4, GL_UNSIGNED_BYTE, stride, mMemp + offset);
+}
+
+
+void LLAGPMemBlockNV::bindGLTexCoordPointer(const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty texcoord array" << llendl;
+        }
+        glTexCoordPointer(2, GL_FLOAT, stride, mMemp + offset);
+}
+
+
+void LLAGPMemBlockNV::bindGLBinormalPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty vertex weight array" << llendl;
+        }
+
+        glVertexAttribPointerARB(index, 3, GL_FLOAT, FALSE, stride, (F32 *)(mMemp + offset));
+}
+
+void LLAGPMemBlockNV::bindGLVertexWeightPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty vertex weight array" << llendl;
+        }
+
+        glVertexAttribPointerARB(index, 1, GL_FLOAT, FALSE, 0, (F32 *)(mMemp + offset));
+}
+
+void LLAGPMemBlockNV::bindGLVertexClothingWeightPointer(const S32 index, const U32 stride, const U32 offset)
+{
+        if (!mMemp)
+        {
+                llerrs << "Binding empty vertex weight array" << llendl;
+        }
+        set_vertex_clothing_weights(index, stride, (LLVector4 *)(mMemp + offset));
+}
+
+U8* LLAGPMemBlockNV::getMappedMem()
+{
+        return mMemp;
+}
+
+void LLAGPMemBlockNV::copy(void *mem, const U32 size)
+{
+        if (!mMemp || !mem)
+        {
+                return;
+        }
+        llassert(LLAGPMemPoolNV::isWriteOK());
+        llassert(size <= mSize);
+
+#if LL_USE_NEW_MEM_OPS
+        inline_new_memcpy( mMemp, mem, size );
+#else
+        memcpy( mMemp, mem, size );
+#endif
+}
+
+void LLAGPMemBlockNV::copyColor(void *mem, const U32 size)
+{
+        if (!mMemp || !mem)
+        {
+                return;
+        }
+        llassert(LLAGPMemPoolNV::isWriteOK());
+        llassert(size <= mSize);
+
+#if LL_USE_NEW_MEM_OPS
+        inline_new_memcpy( mMemp, mem, size );
+#else
+        memcpy( mMemp, mem, size );
+#endif
+}
+
+
+U32  LLAGPMemBlockNV::createFence()
+{
+        U32 fence;
+    glGenFencesNV(1, &fence);
+        glSetFenceNV(fence, GL_ALL_COMPLETED_NV);
+    glFinishFenceNV(fence);
+        return fence;
+}
+
+void LLAGPMemBlockNV::deleteFence(const U32 fence)
+{
+        glDeleteFencesNV(1, &fence);
+}
+
+void LLAGPMemBlockNV::sendFence(U32 fence)
+{
+    glSetFenceNV(fence, GL_ALL_COMPLETED_NV);
+}
+
+void LLAGPMemBlockNV::waitFence(U32 fence)
+{
+    if(!glTestFenceNV(fence))
+    {
+        glFinishFenceNV(fence);
+        }
+}
+
+#endif //LL_LINUX
diff --git a/linden/indra/llrender/llagpmempoolnv.h b/linden/indra/llrender/llagpmempoolnv.h
new file mode 100644
index 0000000..cffe397
--- /dev/null
+++ b/linden/indra/llrender/llagpmempoolnv.h
@@ -0,0 +1,95 @@
+/** 
+ * @file llagpmempoolnv.h
+ * @brief LLAGPMemPoolNV base class
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_LLAGPMEMPOOLNV_H
+#define LL_LLAGPMEMPOOLNV_H
+
+#include "llagpmempool.h"
+
+class LLAGPMemPoolNV : public LLAGPMemPool
+{
+public:
+        LLAGPMemPoolNV(int request);
+        virtual ~LLAGPMemPoolNV();
+
+        /*virtual*/ void flush();
+        /*virtual*/ void dump();
+        /*virtual*/ void enable();
+        /*virtual*/ void disable();
+        /*virtual*/ void bind();
+
+        static BOOL isWriteOK();
+
+        /*virtual*/ U32  createFence();
+        /*virtual*/ void deleteFence(const U32 fence);
+        /*virtual*/ void sendFence(U32 fence);
+        /*virtual*/ void waitFence(U32 fence);
+protected:
+        /*virtual*/ LLAGPMemBlock *createBlock(const U32 offset, const U32 size);
+
+protected:
+        U8 *mBase;
+
+        static BOOL sWriteOK;
+};
+
+class LLAGPMemBlockNV : public LLAGPMemBlock
+{
+public:
+        LLAGPMemBlockNV(LLAGPMemPool *mem_poolp, U8 *baseptr, const S32 offset, const U32 size);
+        virtual ~LLAGPMemBlockNV() { mMemPoolp->freeBlock(this); };
+
+        /*virtual*/ void copy     (void *source, const U32 size_bytes);
+        /*virtual*/ void copyColor(void *source, const U32 size_bytes);
+        /*virtual*/ void free();
+
+        /*virtual*/ void bindGLVertexPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLNormalPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLBinormalPointer(const S32 index, const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLColorPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLTexCoordPointer(const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLVertexWeightPointer(const S32 index, const U32 stride, const U32 offset);
+        /*virtual*/ void bindGLVertexClothingWeightPointer(const S32 index, const U32 stride, const U32 offset);
+
+        /*virtual*/ U32 getOffset()        const { return mOffset; }
+        /*virtual*/ U32 getSize()          const { return mSize; }
+
+        /*virtual*/ BOOL hasMappedMem() const           { return TRUE; }
+        /*virtual*/ U8*  getMappedMem();
+        /*virtual*/ U32  createFence();
+        /*virtual*/ void deleteFence(const U32 fence);
+        /*virtual*/ void sendFence(U32 fence);
+        /*virtual*/ void waitFence(U32 fence);
+
+private:
+        U8 *mMemp;
+        U32 mOffset; // Offset from base
+        U32 mSize;
+        friend class LLAGPMemPoolNV;
+};
+
+#endif // LL_LLAGPMEMPOOLNV_H
diff --git a/linden/indra/llrender/llfont.cpp b/linden/indra/llrender/llfont.cpp
new file mode 100644
index 0000000..c64744e
--- /dev/null
+++ b/linden/indra/llrender/llfont.cpp
@@ -0,0 +1,627 @@
+/** 
+ * @file llfont.cpp
+ * @brief Font library wrapper
+ *
+ * Copyright (c) 2002-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "linden_common.h"
+
+#include "llfont.h"
+
+// Freetype stuff
+#if LL_LINUX   // I had to do some work to avoid the system-installed FreeType headers... --ryan.
+#include "llfreetype2/freetype/ft2build.h"
+#else
+#include <ft2build.h>
+#endif
+
+// For some reason, this won't work if it's not wrapped in the ifdef
+#ifdef FT_FREETYPE_H
+#include FT_FREETYPE_H
+#endif
+
+#include "llerror.h"
+#include "llimage.h"
+//#include "llimagej2c.h"
+#include "llmath.h"     // Linden math
+#include "llstring.h"
+//#include "imdebug.h"
+
+FT_Render_Mode gFontRenderMode = FT_RENDER_MODE_NORMAL;
+
+LLFontManager *gFontManagerp = NULL;
+
+FT_Library gFTLibrary = NULL;
+
+//static
+void LLFontManager::initClass()
+{
+        gFontManagerp = new LLFontManager;
+}
+
+//static
+void LLFontManager::cleanupClass()
+{
+        delete gFontManagerp;
+        gFontManagerp = NULL;
+}
+
+LLFontManager::LLFontManager()
+{
+        int error;
+        error = FT_Init_FreeType(&gFTLibrary);
+        if (error)
+        {
+                // Clean up freetype libs.
+                llerrs << "Freetype initialization failure!" << llendl;
+                FT_Done_FreeType(gFTLibrary);
+        }
+}
+
+
+LLFontManager::~LLFontManager()
+{
+        FT_Done_FreeType(gFTLibrary);
+}
+
+
+LLFontGlyphInfo::LLFontGlyphInfo(U32 index)
+{
+        mGlyphIndex = index;
+        mXBitmapOffset = 0; // Offset to the origin in the bitmap
+        mYBitmapOffset = 0; // Offset to the origin in the bitmap
+        mXBearing = 0;          // Distance from baseline to left in pixels
+        mYBearing = 0;          // Distance from baseline to top in pixels
+        mWidth = 0;                     // In pixels
+        mHeight = 0;            // In pixels
+        mXAdvance = 0.f;        // In pixels
+        mYAdvance = 0.f;        // In pixels
+        mIsRendered = FALSE;
+}
+
+LLFontList::LLFontList()
+{
+}
+
+LLFontList::~LLFontList()
+{
+        LLFontList::iterator iter;
+        for(iter = this->begin(); iter != this->end(); iter++)
+        {
+                delete *iter;
+                // The (now dangling) pointers in the vector will be cleaned up when the vector is deleted by the superclass destructor.
+        }
+}
+void LLFontList::addAtEnd(LLFont *font)
+{
+        // Purely a convenience function
+        this->push_back(font);
+}
+
+LLFont::LLFont(LLImageRaw *imagep)
+        : mRawImagep(imagep)
+{
+        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;
+}
+
+
+LLFont::~LLFont()
+{
+        mRawImagep = NULL; // dereferences or deletes image
+
+        // Clean up freetype libs.
+        FT_Done_Face(mFTFace);
+        mFTFace = NULL;
+
+        // 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
+}
+
+// virtual
+F32 LLFont::getLineHeight() const
+{
+        return mLineHeight;
+}
+
+// virtual
+F32 LLFont::getAscenderHeight() const
+{
+        return mAscender;
+}
+
+// virtual
+F32 LLFont::getDescenderHeight() const
+{
+        return mDescender;
+}
+
+BOOL LLFont::loadFace(const std::string& filename, const F32 point_size, const F32 vert_dpi, const F32 horz_dpi, const S32 components, BOOL is_fallback)
+{
+        int error;
+        error = FT_New_Face( gFTLibrary,
+                         filename.c_str(),
+                         0,
+                         &mFTFace );
+
+    if (error)
+        {
+                return FALSE;
+        }
+
+        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           */
+                                                        0,       /* char_width in 1/64th of points  */
+                                                        (S32)(point_size*64),   /* char_height in 1/64th of points */
+                                                        (U32)horz_dpi,     /* horizontal device resolution    */
+                                                        (U32)vert_dpi);   /* vertical device resolution      */
+
+        if (error)
+        {
+                // Clean up freetype libs.
+                FT_Done_Face(mFTFace);
+                return FALSE;
+        }
+
+        F32 y_max, y_min, x_max, x_min;
+        F32 ems_per_unit = 1.f/ mFTFace->units_per_EM;
+        F32 pixels_per_unit = pixels_per_em * ems_per_unit;
+
+        // Get size of bbox in pixels
+        y_max = mFTFace->bbox.yMax * pixels_per_unit;
+        y_min = mFTFace->bbox.yMin * pixels_per_unit;
+        x_max = mFTFace->bbox.xMax * pixels_per_unit;
+        x_min = mFTFace->bbox.xMin * pixels_per_unit;
+        mAscender = mFTFace->ascender * pixels_per_unit;
+        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));
+
+        if (!mFTFace->charmap)
+        {
+                //llinfos << " no unicode encoding, set whatever encoding there is..." << llendl;
+                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;
+
+        return TRUE;
+}
+
+
+void LLFont::resetBitmap()
+{
+        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)
+        {
+                iter->second->mIsRendered = FALSE;
+        }
+
+        mCurrentOffsetX = 1;
+        mCurrentOffsetY = 1;
+
+        // Add the empty glyph
+        addGlyph(0, 0);
+}
+
+LLFontGlyphInfo* LLFont::getGlyphInfo(const llwchar wch) const
+{
+        char_glyph_info_map_t::iterator iter = mCharGlyphInfoMap.find(wch);
+        if (iter != mCharGlyphInfoMap.end())
+        {
+                return iter->second;
+        }
+        return NULL;
+}
+
+
+BOOL LLFont::hasGlyph(const llwchar wch) const
+{
+        llassert(!mIsFallback);
+        const LLFontGlyphInfo* gi = getGlyphInfo(wch);
+        if (gi && gi->mIsRendered)
+        {
+                return TRUE;
+        }
+        else
+        {
+                return FALSE;
+        }
+}
+
+BOOL LLFont::addChar(const llwchar wch)
+{
+        llassert(!mIsFallback);
+        //lldebugs << "Adding new glyph for " << wch << " to font" << llendl;
+
+        FT_UInt glyph_index;
+
+        // Initialize char to glyph map
+        glyph_index = FT_Get_Char_Index(mFTFace, wch);
+        if (glyph_index == 0)
+        {
+                // Try looking it up in the backup Unicode font
+                if (mFallbackFontp)
+                {
+                        //llinfos << "Trying to add glyph from fallback font!" << llendl
+                        LLFontList::iterator iter;
+                        for(iter = mFallbackFontp->begin(); iter != mFallbackFontp->end(); iter++)
+                        {
+                                glyph_index = FT_Get_Char_Index((*iter)->mFTFace, wch);
+                                if (glyph_index)
+                                {
+                                        addGlyphFromFont(*iter, wch, glyph_index);
+                                        return TRUE;
+                                }
+                        }
+                }
+        }
+        
+        char_glyph_info_map_t::iterator iter = mCharGlyphInfoMap.find(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;
+}
+
+void LLFont::insertGlyphInfo(llwchar wch, LLFontGlyphInfo* gi) const
+{
+        char_glyph_info_map_t::iterator iter = mCharGlyphInfoMap.find(wch);
+        if (iter != mCharGlyphInfoMap.end())
+        {
+                delete iter->second;
+                iter->second = gi;
+        }
+        else
+        {
+                mCharGlyphInfoMap[wch] = gi;
+        }
+}
+
+BOOL LLFont::addGlyphFromFont(LLFont *fontp, const llwchar wch, const U32 glyph_index)
+{
+        llassert(!mIsFallback);
+        fontp->renderGlyph(glyph_index);
+        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;
+                }
+        }
+
+        LLFontGlyphInfo* gi = new LLFontGlyphInfo(glyph_index);
+        gi->mXBitmapOffset = mCurrentOffsetX;
+        gi->mYBitmapOffset = mCurrentOffsetY;
+        gi->mWidth = width;
+        gi->mHeight = height;
+        gi->mXBearing = fontp->mFTFace->glyph->bitmap_left;
+        gi->mYBearing = fontp->mFTFace->glyph->bitmap_top;
+        // Convert these from 26.6 units to float pixels.
+        gi->mXAdvance = fontp->mFTFace->glyph->advance.x / 64.f;
+        gi->mYAdvance = fontp->mFTFace->glyph->advance.y / 64.f;
+        gi->mIsRendered = TRUE;
+
+        insertGlyphInfo(wch, gi);
+
+        llassert(fontp->mFTFace->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO
+            || fontp->mFTFace->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY);
+
+        if (fontp->mFTFace->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO
+            || fontp->mFTFace->glyph->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY)
+        {
+                U8 *buffer_data = fontp->mFTFace->glyph->bitmap.buffer;
+                S32 buffer_row_stride = fontp->mFTFace->glyph->bitmap.pitch;
+                U8 *tmp_graydata = NULL;
+
+                if (fontp->mFTFace->glyph->bitmap.pixel_mode
+                    == FT_PIXEL_MODE_MONO)
+                {
+                        // need to expand 1-bit bitmap to 8-bit graymap.
+                        tmp_graydata = new U8[width * height];
+                        S32 xpos, ypos;
+                        for (ypos = 0; ypos < height; ++ypos)
+                        {
+                                S32 bm_row_offset = buffer_row_stride * ypos;
+                                for (xpos = 0; xpos < width; ++xpos)
+                                {
+                                        U32 bm_col_offsetbyte = xpos / 8;
+                                        U32 bm_col_offsetbit = 7 - (xpos % 8);
+                                        U32 bit =
+                                        !!(buffer_data[bm_row_offset
+                                                       + bm_col_offsetbyte
+                                           ] & (1 << bm_col_offsetbit) );
+                                        tmp_graydata[width*ypos + xpos] =
+                                                255 * bit;
+                                }
+                        }
+                        // use newly-built graymap.
+                        buffer_data = tmp_graydata;
+                        buffer_row_stride = width;
+                }
+
+                switch (mNumComponents)
+                {
+                case 1:
+                        mRawImagep->setSubImage(mCurrentOffsetX,
+                                                mCurrentOffsetY,
+                                                width,
+                                                height,
+                                                buffer_data,
+                                                buffer_row_stride,
+                                                TRUE);
+                        break;
+                case 2:
+                        setSubImageLuminanceAlpha(mCurrentOffsetX,
+                                                  mCurrentOffsetY,
+                                                  width,
+                                                  height,
+                                                  buffer_data,
+                                                  buffer_row_stride);
+                        break;
+                default:
+                        break;
+                }
+
+                if (tmp_graydata)
+                        delete[] tmp_graydata;
+        } else {
+                // we don't know how to handle this pixel format from FreeType;
+                // omit it from the font-image.
+        }
+        
+        mCurrentOffsetX += width + 1;
+        return TRUE;
+}
+
+BOOL LLFont::addGlyph(const llwchar wch, const U32 glyph_index)
+{
+        return addGlyphFromFont(this, wch, glyph_index);
+}
+
+
+F32 LLFont::getXAdvance(const llwchar wch) const
+{
+        llassert(!mIsFallback);
+        U32 glyph_index;
+
+        // Return existing info only if it is current
+        LLFontGlyphInfo* gi = getGlyphInfo(wch);
+        if (gi && gi->mIsRendered)
+        {
+                return gi->mXAdvance;
+        }
+
+        const LLFont* fontp = this;
+        
+        // Initialize char to glyph map
+        glyph_index = FT_Get_Char_Index(mFTFace, wch);
+        if (glyph_index == 0 && mFallbackFontp)
+        {
+                LLFontList::iterator iter;
+                for(iter = mFallbackFontp->begin(); (iter != mFallbackFontp->end()) && (glyph_index == 0); iter++)
+                {
+                        glyph_index = FT_Get_Char_Index((*iter)->mFTFace, wch);
+                        if(glyph_index)
+                        {
+                                fontp = *iter;
+                        }
+                }
+        }
+        
+        if (glyph_index)
+        {
+                // This font has this glyph
+                (const_cast<LLFont *>(fontp))->renderGlyph(glyph_index);
+
+                // Create the entry if it's not there
+                char_glyph_info_map_t::iterator iter2 = mCharGlyphInfoMap.find(wch);
+                if (iter2 == mCharGlyphInfoMap.end())
+                {
+                        gi = new LLFontGlyphInfo(glyph_index);
+                        insertGlyphInfo(wch, gi);
+                }
+                else
+                {
+                        gi = iter2->second;
+                }
+                
+                gi->mWidth = fontp->mFTFace->glyph->bitmap.width;
+                gi->mHeight = fontp->mFTFace->glyph->bitmap.rows;
+
+                // Convert these from 26.6 units to float pixels.
+                gi->mXAdvance = fontp->mFTFace->glyph->advance.x / 64.f;
+                gi->mYAdvance = fontp->mFTFace->glyph->advance.y / 64.f;
+                return gi->mXAdvance;
+        }
+        else
+        {
+                gi = get_if_there(mCharGlyphInfoMap, (llwchar)0, (LLFontGlyphInfo*)NULL);
+                if (gi)
+                {
+                        return gi->mXAdvance;
+                }
+        }
+
+        // Last ditch fallback - no glyphs defined at all.
+        return (F32)mMaxCharWidth;
+}
+
+
+void LLFont::renderGlyph(const U32 glyph_index)
+{
+        int error = FT_Load_Glyph(mFTFace, glyph_index, FT_LOAD_DEFAULT );
+        llassert(!error);
+
+        error = FT_Render_Glyph(mFTFace->glyph, gFontRenderMode);
+        llassert(!error);
+}
+
+
+F32 LLFont::getXKerning(const llwchar char_left, const llwchar char_right) const
+{
+        llassert(!mIsFallback);
+        LLFontGlyphInfo* left_glyph_info = get_if_there(mCharGlyphInfoMap, char_left, (LLFontGlyphInfo*)NULL);
+        U32 left_glyph = left_glyph_info ? left_glyph_info->mGlyphIndex : 0;
+        // Kern this puppy.
+        LLFontGlyphInfo* right_glyph_info = get_if_there(mCharGlyphInfoMap, char_right, (LLFontGlyphInfo*)NULL);
+        U32 right_glyph = right_glyph_info ? right_glyph_info->mGlyphIndex : 0;
+
+        FT_Vector  delta;
+
+        llverify(!FT_Get_Kerning(mFTFace, left_glyph, right_glyph, ft_kerning_unfitted, &delta));
+
+        return delta.x*(1.f/64.f);
+}
+
+void LLFont::setSubImageLuminanceAlpha(const U32 x,
+                                       const U32 y,
+                                       const U32 width,
+                                       const U32 height,
+                                       const U8 *data,
+                                       S32 stride)
+{
+        llassert(!mIsFallback);
+        llassert(mRawImagep->getComponents() == 2);
+
+        U8 *target = mRawImagep->getData();
+
+        if (!data)
+        {
+                return;
+        }
+
+        if (0 == stride)
+                stride = width;
+
+        U32 i, j;
+        U32 to_offset;
+        U32 from_offset;
+        U32 target_width = mRawImagep->getWidth();
+        for (i = 0; i < height; i++)
+        {
+                to_offset = (y + i)*target_width + x;
+                from_offset = (height - 1 - i)*stride;
+                for (j = 0; j < width; j++)
+                {
+                        *(target + to_offset*2 + 1) = *(data + from_offset);
+                        to_offset++;
+                        from_offset++;
+                }
+        }
+}
diff --git a/linden/indra/llrender/llfont.h b/linden/indra/llrender/llfont.h
new file mode 100644
index 0000000..dadeafd
--- /dev/null
+++ b/linden/indra/llrender/llfont.h
@@ -0,0 +1,188 @@
+/** 
+ * @file llfont.h
+ * @brief Font library wrapper
+ *
+ * Copyright (c) 2002-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_LLFONT_H
+#define LL_LLFONT_H
+
+#include <map>
+//#include "lllocalidhashmap.h"
+#include "llmemory.h"
+
+class LLImageRaw;
+class LLFontManager;
+class LLFont;
+
+// Hack.  FT_Face is just a typedef for a pointer to a struct,
+// but there's no simple forward declarations file for FreeType, 
+// and the main include file is 200K.  
+// We'll forward declare the struct here.  JC
+struct FT_FaceRec_;
+typedef struct FT_FaceRec_* LLFT_Face;
+
+extern LLFontManager *gFontManagerp;
+
+class LLFontManager
+{
+public:
+        static void initClass();
+        static void cleanupClass();
+        
+public:
+        LLFontManager();
+        virtual ~LLFontManager();
+};
+
+class LLFontGlyphInfo
+{
+public:
+        LLFontGlyphInfo(U32 index);
+public:
+        U32 mGlyphIndex;
+        // Metrics
+        S32 mWidth;                     // In pixels
+        S32 mHeight;            // In pixels
+        F32 mXAdvance;          // In pixels
+        F32 mYAdvance;          // In pixels
+
+        // Information for actually rendering
+        BOOL mIsRendered;       // We actually have rendered this glyph
+        S32 mXBitmapOffset; // Offset to the origin in the bitmap
+        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
+};
+
+// Used for lists of fallback fonts
+class LLFontList : public std::vector<LLFont*>
+{
+public:
+        LLFontList();
+        ~LLFontList();
+        void addAtEnd(LLFont *font);
+};
+
+
+class LLFont
+{
+public:
+        LLFont(LLImageRaw *imagep = NULL);
+        virtual ~LLFont();
+
+        // 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,
+                                                        const F32 horz_dpi,
+                                                        const S32 components,
+                                                        BOOL is_fallback);
+        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;
+        virtual F32 getAscenderHeight() const;
+        virtual F32 getDescenderHeight() const;
+
+
+// For a lowercase "g":
+//
+//      ------------------------------
+//                           ^     ^
+//                                               |     |
+//                              xxx x    |Ascender
+//                 x   x     |     |
+//      ---------   xxxx-------------- Baseline
+//      ^                      x         |     |
+//  | descender    x     |     |
+//      v                       xxxx     v     |LineHeight
+//  -----------------------    |
+//                             v
+//      ------------------------------
+
+        enum
+        {
+                FIRST_CHAR = 32, 
+                NUM_CHARS = 127 - 32, 
+                LAST_CHAR_BASIC = 127,
+
+                // Need full 8-bit ascii range for spanish
+                NUM_CHARS_FULL = 255 - 32,
+                LAST_CHAR_FULL = 255
+        };
+
+        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
+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 LLFontGlyphInfo* getGlyphInfo(const llwchar wch) const;
+
+        void insertGlyphInfo(llwchar wch, LLFontGlyphInfo* gi) const;
+        void renderGlyph(const U32 glyph_index);
+
+        void resetBitmap();     // Reset bitmap to contain only the null glyph
+protected:
+        std::string mName;
+        F32 mAscender;                  
+        F32 mDescender;
+        F32 mLineHeight;
+
+        S32 mNumComponents;
+        S32 mBitmapWidth;
+        S32 mBitmapHeight;
+        S32 mMaxCharWidth;
+        S32 mMaxCharHeight;
+        S32 mCurrentOffsetX;
+        S32 mCurrentOffsetY;
+
+        LLFT_Face mFTFace;
+
+        BOOL mIsFallback;
+        LLFontList *mFallbackFontp; // A list of fallback fonts to look for glyphs in (for Unicode chars)
+
+        typedef std::map<llwchar, LLFontGlyphInfo*> char_glyph_info_map_t;
+        mutable char_glyph_info_map_t mCharGlyphInfoMap; // Information about glyph location in bitmap
+
+        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.
+};
+
+#endif // LL_FONT_
diff --git a/linden/indra/llrender/llfontgl.cpp b/linden/indra/llrender/llfontgl.cpp
new file mode 100644
index 0000000..2774e8d
--- /dev/null
+++ b/linden/indra/llrender/llfontgl.cpp
@@ -0,0 +1,1453 @@
+/** 
+ * @file llfontgl.cpp
+ * @brief Wrapper around FreeType
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "linden_common.h"
+
+#include <boost/tokenizer.hpp>
+
+#include "llfont.h"
+#include "llfontgl.h"
+#include "llgl.h"
+#include "v4color.h"
+
+const S32 BOLD_OFFSET = 1;
+
+// static class members
+F32 LLFontGL::sVertDPI = 96.f;
+F32 LLFontGL::sHorizDPI = 96.f;
+F32 LLFontGL::sScaleX = 1.f;
+F32 LLFontGL::sScaleY = 1.f;
+LLString 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::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);
+
+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;
+
+F32 llfont_round_x(F32 x)
+{
+        //return llfloor((x-LLFontGL::sCurOrigin.mX)/LLFontGL::sScaleX+0.5f)*LLFontGL::sScaleX+LLFontGL::sCurOrigin.mX;
+        //return llfloor(x/LLFontGL::sScaleX+0.5f)*LLFontGL::sScaleY;
+        return x;
+}
+
+F32 llfont_round_y(F32 y)
+{
+        //return llfloor((y-LLFontGL::sCurOrigin.mY)/LLFontGL::sScaleY+0.5f)*LLFontGL::sScaleY+LLFontGL::sCurOrigin.mY;
+        //return llfloor(y+0.5f);
+        return y;
+}
+
+// static
+U8 LLFontGL::getStyleFromString(const LLString &style)
+{
+        S32 ret = 0;
+        if (style.find("NORMAL") != style.npos)
+        {
+                ret |= NORMAL;
+        }
+        if (style.find("BOLD") != style.npos)
+        {
+                ret |= BOLD;
+        }
+        if (style.find("ITALIC") != style.npos)
+        {
+                ret |= ITALIC;
+        }
+        if (style.find("UNDERLINE") != style.npos)
+        {
+                ret |= UNDERLINE;
+        }
+        return ret;
+}
+
+LLFontGL::LLFontGL()
+        : LLFont()
+{
+        init();
+        clearEmbeddedChars();
+}
+
+LLFontGL::LLFontGL(const LLFontGL &source)
+{
+        llerrs << "Not implemented!" << llendl;
+}
+
+LLFontGL::~LLFontGL()
+{
+        mImageGLp = NULL;
+        mRawImageGLp = NULL;
+        clearEmbeddedChars();
+}
+
+void LLFontGL::init()
+{
+        if (mImageGLp.isNull())
+        {
+                mImageGLp = new LLImageGL(FALSE);
+                //RN: use nearest mipmap filtering to obviate the need to do pixel-accurate positioning
+                mImageGLp->bind();
+                mImageGLp->setMipFilterNearest(TRUE, TRUE);
+        }
+        if (mRawImageGLp.isNull())
+        {
+                mRawImageGLp = new LLImageRaw; // Note LLFontGL owns the image, not LLFont.
+        }
+        setRawImage( mRawImageGLp );  
+}
+
+void LLFontGL::reset()
+{
+        init();
+        resetBitmap();
+}
+
+// static 
+LLString LLFontGL::getFontPathSystem()
+{
+        LLString system_path;
+
+        // Try to figure out where the system's font files are stored.
+        char *system_root = NULL;
+#if LL_WINDOWS
+        system_root = getenv("SystemRoot");
+        if (!system_root)
+        {
+                llwarns << "SystemRoot not found, attempting to load fonts from default path." << llendl;
+        }
+#endif
+
+        if (system_root)
+        {
+                system_path = llformat("%s/fonts/", system_root);
+        }
+        else
+        {
+#if LL_WINDOWS
+                // HACK for windows 98/Me
+                system_path = "/WINDOWS/FONTS/";
+#elif LL_DARWIN
+                // HACK for Mac OS X
+                system_path = "/System/Library/Fonts/";
+#endif
+        }
+        return system_path;
+}
+
+
+// static 
+LLString LLFontGL::getFontPathLocal()
+{
+        LLString local_path;
+
+        // Backup files if we can't load from system fonts directory.
+        // We could store this in an end-user writable directory to allow
+        // end users to switch fonts.
+        if (LLFontGL::sAppDir.length())
+        {
+                // use specified application dir to look for fonts
+                local_path = LLFontGL::sAppDir + "/fonts/";
+        }
+        else
+        {
+                // assume working directory is executable directory
+                local_path = "./fonts/";
+        }
+        return local_path;
+}
+
+//static
+bool LLFontGL::loadFaceFallback(LLFontList *fontlistp, const LLString& fontname, const F32 point_size)
+{
+        LLString local_path = getFontPathLocal();
+        LLString 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();
+                LLString font_path = local_path + *token_iter;
+                if (!fontp->loadFace(font_path.c_str(), point_size, sVertDPI, sHorizDPI, 2, TRUE))
+                {
+                        font_path = sys_path + *token_iter;
+                        if (!fontp->loadFace(font_path.c_str(), point_size, sVertDPI, sHorizDPI, 2, TRUE))
+                        {
+                                llwarns << "Couldn't load font " << *token_iter << llendl;
+                                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);
+}
+
+//static
+bool LLFontGL::loadFace(LLFontGL *fontp, const LLString& fontname, const F32 point_size, LLFontList *fallback_fontp)
+{
+        LLString local_path = getFontPathLocal();
+        LLString font_path = local_path + fontname;
+        if (!fontp->loadFace(font_path.c_str(), point_size, sVertDPI, sHorizDPI))
+        {
+                LLString sys_path = getFontPathSystem();
+                font_path = sys_path + fontname;
+                if (!fontp->loadFace(font_path.c_str(), point_size, sVertDPI, sHorizDPI))
+                {
+                        llwarns << "Couldn't load font " << fontname << llendl;
+                        return false;
+                }
+        }
+
+        fontp->setFallbackFont(fallback_fontp);
+        return true;
+}
+
+
+// static
+BOOL LLFontGL::initDefaultFonts(F32 screen_dpi, F32 x_scale, F32 y_scale,
+                                                                const LLString& monospace_file, F32 monospace_size,
+                                                                const LLString& sansserif_file,
+                                                                const LLString& sanserif_fallback_file, F32 ss_fallback_scale,
+                                                                F32 small_size, F32 medium_size, F32 big_size, F32 huge_size,
+                                                                const LLString& sansserif_bold_file, F32 bold_size,
+                                                                const LLString& app_dir)
+{
+        BOOL failed = FALSE;
+        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)
+        {
+                sMonospace = new LLFontGL();
+        }
+        else
+        {
+                sMonospace->reset();
+        }
+
+        failed |= !loadFace(sMonospace, monospace_file, monospace_size, NULL);
+
+        //
+        // Sans-serif fonts
+        //
+        if(!sSansSerifHuge)
+        {
+                sSansSerifHuge = new LLFontGL();
+        }
+        else
+        {
+                sSansSerifHuge->reset();
+        }
+
+        if (!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)
+        {
+                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)
+        {
+                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)
+        {
+                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)
+        {
+                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;
+}
+
+
+
+// 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 sSSHugeFallback;
+        sSSHugeFallback = NULL;
+
+        delete sSSBigFallback;
+        sSSBigFallback = NULL;
+
+        delete sSSFallback;
+        sSSFallback = NULL;
+
+        delete sSSSmallFallback;
+        sSSSmallFallback = NULL;
+
+        delete sSSBoldFallback;
+        sSSBoldFallback = NULL;
+}
+
+//static 
+void LLFontGL::destroyGL()
+{
+        if (!sMonospace)
+        {
+                // Already all destroyed.
+                return;
+        }
+        sMonospace->mImageGLp->destroyGLTexture();
+        sSansSerifHuge->mImageGLp->destroyGLTexture();
+        sSansSerifSmall->mImageGLp->destroyGLTexture();
+        sSansSerif->mImageGLp->destroyGLTexture();
+        sSansSerifBig->mImageGLp->destroyGLTexture();
+        sSansSerifBold->mImageGLp->destroyGLTexture();
+}
+
+
+
+LLFontGL &LLFontGL::operator=(const LLFontGL &source)
+{
+        llerrs << "Not implemented" << llendl;
+        return *this;
+}
+
+BOOL LLFontGL::loadFace(const LLString& filename, const F32 point_size, const F32 vert_dpi, const F32 horz_dpi)
+{
+        if (!LLFont::loadFace(filename, point_size, vert_dpi, horz_dpi, 2, FALSE))
+        {
+                return FALSE;
+        }
+        mImageGLp->createGLTexture(0, mRawImageGLp);
+        mImageGLp->bind();
+        mImageGLp->setMipFilterNearest(TRUE, TRUE);
+        return TRUE;
+}
+
+BOOL LLFontGL::addChar(const llwchar wch)
+{
+        if (!LLFont::addChar(wch))
+        {
+                return FALSE;
+        }
+
+        stop_glerror();
+        mImageGLp->setSubImage(mRawImageGLp, 0, 0, mImageGLp->getWidth(), mImageGLp->getHeight());
+        mImageGLp->bind();
+        mImageGLp->setMipFilterNearest(TRUE, TRUE);
+        stop_glerror();
+        return TRUE;
+}
+
+
+S32 LLFontGL::renderUTF8(const LLString &text, const S32 offset, 
+                                         const F32 x, const F32 y,
+                                         const LLColor4 &color,
+                                         const HAlign halign, const VAlign valign,
+                                         U8 style,
+                                         const S32 max_chars, const S32 max_pixels,
+                                         F32* right_x,
+                                         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);
+}
+
+S32 LLFontGL::render(const LLWString &wstr, 
+                                         const S32 begin_offset,
+                                         const F32 x, const F32 y,
+                                         const LLColor4 &color,
+                                         const HAlign halign, const VAlign valign,
+                                         U8 style,
+                                         const S32 max_chars, S32 max_pixels,
+                                         F32* right_x,
+                                         BOOL use_embedded,
+                                         BOOL use_ellipses) const
+{
+        LLGLEnable texture_2d(GL_TEXTURE_2D);
+        
+        if (wstr.empty())
+        {
+                return 0;
+        } 
+
+        if (style & DROP_SHADOW)
+        {
+                LLColor4 shadow_color = sShadowColor;
+                shadow_color[3] = color[3];
+                render(wstr, begin_offset,
+                                x + 1.f / sScaleX, 
+                                y - 1.f / sScaleY,
+                                shadow_color,
+                                halign, 
+                                valign,
+                                style & (~DROP_SHADOW),
+                                max_chars,
+                                max_pixels,
+                                right_x,
+                                use_embedded,
+                                use_ellipses);
+        }
+
+        S32 scaled_max_pixels = max_pixels == S32_MAX ? S32_MAX : llceil((F32)max_pixels * sScaleX);
+
+        BOOL render_bold = FALSE;
+
+        // 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);
+                }
+                else
+                {
+                        render_bold = TRUE;
+                }
+        }
+
+        glPushMatrix();
+        glLoadIdentity();
+        glTranslatef(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)
+        //{
+                glTranslatef(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);
+        //glTranslatef(-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);
+        LLFastTimer t(LLFastTimer::FTM_RENDER_FONTS);
+
+        glColor4fv( color.mV );
+
+        S32 chars_drawn = 0;
+        S32 i;
+        S32 length;
+
+        if (-1 == max_chars)
+        {
+                length = (S32)wstr.length() - begin_offset;
+        }
+        else
+        {
+                length = llmin((S32)wstr.length() - begin_offset, max_chars );
+        }
+
+        F32 cur_x, cur_y, cur_render_x, cur_render_y;
+        F32 slant_offset;
+
+        slant_offset = ((style & ITALIC) ? ( -mAscender * 0.25f) : 0.f);
+
+        // Bind the font texture
+        
+        mImageGLp->bind(0);
+        
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Not guaranteed to be set correctly
+        
+        cur_x = ((F32)x * sScaleX);
+        cur_y = ((F32)y * sScaleY);
+
+        // Offset y by vertical alignment.
+        switch (valign)
+        {
+        case TOP:
+                cur_y -= mAscender;
+                break;
+        case BOTTOM:
+                cur_y += mDescender;
+                break;
+        case VCENTER:
+                cur_y -= ((mAscender - mDescender)/2.f);
+                break;
+        case BASELINE:
+                // Baseline, do nothing.
+                break;
+        default:
+                break;
+        }
+
+        switch (halign)
+        {
+        case LEFT:
+                break;
+        case RIGHT:
+                cur_x -= (F32)getWidth(wstr.c_str(), 0, length) * sScaleX;
+                break;
+        case HCENTER:
+            cur_x -= llmin(scaled_max_pixels, llround(getWidthF32(wstr.c_str(), 0, length) * sScaleX)) / 2;
+                break;
+        default:
+                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();
+
+        const S32 LAST_CHARACTER = LLFont::LAST_CHAR_FULL;
+
+
+        BOOL draw_ellipses = FALSE;
+        if (use_ellipses)
+        {
+                // check for too long of a string
+                if (getWidthF32(wstr.c_str(), 0, max_chars) > scaled_max_pixels)
+                {
+                        const LLWString dots(utf8str_to_wstring(LLString("...")));
+                        scaled_max_pixels = llmax(0, scaled_max_pixels - llround(getWidthF32(dots.c_str())));
+                        draw_ellipses = TRUE;
+                }
+        }
+
+
+        glBegin(GL_QUADS);
+        for (i = begin_offset; i < begin_offset + length; i++)
+        {
+                llwchar wch = wstr[i];
+
+                // Handle embedded characters first, if they're enabled.
+                // Embedded characters are a hack for notecards
+                const embedded_data_t* ext_data = use_embedded ? getEmbeddedCharData(wch) : NULL;
+                if (ext_data)
+                {
+                        LLImageGL* ext_image = ext_data->mImage;
+                        const LLWString& label = ext_data->mLabel;
+
+                        F32 ext_height = (F32)ext_image->getHeight() * sScaleY;
+
+                        F32 ext_width = (F32)ext_image->getWidth() * sScaleX;
+                        F32 ext_advance = (EXT_X_BEARING * sScaleX) + ext_width;
+
+                        if (!label.empty())
+                        {
+                                ext_advance += (EXT_X_BEARING + gExtCharFont->getWidthF32( label.c_str() )) * sScaleX;
+                        }
+
+                        if (start_x + scaled_max_pixels < cur_x + ext_advance)
+                        {
+                                // Not enough room for this character.
+                                break;
+                        }
+
+                        glEnd();
+
+                        glColor3f(1.f, 1.f, 1.f);
+
+                        ext_image->bind();
+                        const F32 ext_x = cur_render_x + (EXT_X_BEARING * sScaleX);
+                        const F32 ext_y = cur_render_y + (EXT_Y_BEARING * sScaleY + mAscender - mLineHeight);
+
+                        glBegin(GL_QUADS);
+                        {
+                                S32 num_passes = render_bold ? 2 : 1;
+                                for (S32 pass = 0; pass < num_passes; pass++)
+                                {
+                                        glTexCoord2f(1.f, 1.f);
+                                        glVertex2f(llfont_round_x(ext_x + ext_width  + (F32)(pass * BOLD_OFFSET)), 
+                                                                llfont_round_y(ext_y + ext_height));
+
+                                        glTexCoord2f(0.f, 1.f);
+                                        glVertex2f(llfont_round_x(ext_x + (F32)(pass * BOLD_OFFSET)), 
+                                                                llfont_round_y(ext_y + ext_height));
+
+                                        glTexCoord2f(0.f, 0.f);
+                                        glVertex2f(llfont_round_x(ext_x + (F32)(pass * BOLD_OFFSET)), llfont_round_y(ext_y));
+
+                                        glTexCoord2f(1.f, 0.f);
+                                        glVertex2f(llfont_round_x(ext_x + ext_width + (F32)(pass * BOLD_OFFSET)), 
+                                                                llfont_round_y(ext_y));
+                                }
+                        }
+                        glEnd();
+
+                        if (!label.empty())
+                        {
+                                glPushMatrix();
+                                //glLoadIdentity();
+                                //glTranslatef(sCurOrigin.mX, sCurOrigin.mY, 0.0f);
+                                //glScalef(sScaleX, sScaleY, 1.f);
+                                gExtCharFont->render(label, 0,
+                                                                         /*llfloor*/((ext_x + (F32)ext_image->getWidth() + EXT_X_BEARING) / sScaleX), 
+                                                                         /*llfloor*/(cur_y / sScaleY),
+                                                                         color,
+                                                                         halign, BASELINE, NORMAL, S32_MAX, S32_MAX, NULL,
+                                                                         TRUE );
+                                glPopMatrix();
+                        }
+
+                        glColor4fv(color.mV);
+
+                        chars_drawn++;
+                        cur_x += ext_advance;
+                        if (((i + 1) < length) && wstr[i+1])
+                        {
+                                cur_x += EXT_KERNING * sScaleX;
+                        }
+                        cur_render_x = cur_x;
+
+                        // Bind the font texture
+                        mImageGLp->bind();
+                        glBegin(GL_QUADS);
+                }
+                else
+                {
+                        if (!hasGlyph(wch))
+                        {
+                                glEnd();
+                                (const_cast<LLFontGL*>(this))->addChar(wch);
+                                glBegin(GL_QUADS);
+                        }
+
+                        const LLFontGlyphInfo* fgi= getGlyphInfo(wch);
+                        if (!fgi)
+                        {
+                                llerrs << "Missing Glyph Info" << llendl;
+                        }
+                        if ((start_x + scaled_max_pixels) < (cur_x + fgi->mXBearing + fgi->mWidth))
+                        {
+                                // Not enough room for this character.
+                                break;
+                        }
+
+                        // Draw the text at the appropriate location
+                        //Specify vertices and texture coordinates
+                        S32 num_passes = render_bold ? 2 : 1;
+                        for (S32 pass = 0; pass < num_passes; pass++)
+                        {
+                                glTexCoord2f((fgi->mXBitmapOffset - PAD_AMT) * inv_width,
+                                        (fgi->mYBitmapOffset + fgi->mHeight + PAD_AMT) * inv_height);
+                                glVertex2f(llfont_round_x(cur_render_x + (F32)fgi->mXBearing + (F32)(pass * BOLD_OFFSET) - PAD_AMT),
+                                        llfont_round_y(cur_render_y + (F32)fgi->mYBearing + PAD_AMT));
+                                glTexCoord2f((fgi->mXBitmapOffset - PAD_AMT) * inv_width,
+                                        (fgi->mYBitmapOffset - PAD_AMT) * inv_height);
+                                glVertex2f(llfont_round_x(cur_render_x + (F32)fgi->mXBearing + slant_offset + (F32)(pass * BOLD_OFFSET) - PAD_AMT),
+                                        llfont_round_y(cur_render_y + (F32)fgi->mYBearing - (F32)fgi->mHeight - PAD_AMT));
+                                glTexCoord2f((fgi->mXBitmapOffset + fgi->mWidth + PAD_AMT) * inv_width,
+                                        (fgi->mYBitmapOffset - PAD_AMT) * inv_height);
+                                glVertex2f(llfont_round_x(cur_render_x + (F32)fgi->mXBearing + slant_offset + (F32)fgi->mWidth + (F32)(pass * BOLD_OFFSET) + PAD_AMT),
+                                        llfont_round_y(cur_render_y + (F32)fgi->mYBearing - (F32)fgi->mHeight - PAD_AMT));
+                                glTexCoord2f((fgi->mXBitmapOffset + fgi->mWidth + PAD_AMT) * inv_width,
+                                        (fgi->mYBitmapOffset + fgi->mHeight + PAD_AMT) * inv_height);
+                                glVertex2f(llfont_round_x(cur_render_x + (F32)fgi->mXBearing + (F32)fgi->mWidth + (F32)(pass * BOLD_OFFSET) + PAD_AMT),
+                                        llfont_round_y(cur_render_y + (F32)fgi->mYBearing + PAD_AMT));
+                        }
+
+                        chars_drawn++;
+
+                        cur_x += fgi->mXAdvance;
+                        cur_y += fgi->mYAdvance;
+                        llwchar next_char = wstr[i+1];
+                        if (next_char && (next_char < LAST_CHARACTER))
+                        {
+                                // Kern this puppy.
+                                if (!hasGlyph(next_char))
+                                {
+                                        glEnd();
+                                        (const_cast<LLFontGL*>(this))->addChar(next_char);
+                                        glBegin(GL_QUADS);
+                                }
+                                cur_x += getXKerning(wch, next_char);
+                        }
+
+                        // Round after kerning.
+                        // Must do this to cur_x, not just to cur_render_x, otherwise you
+                        // will squish sub-pixel kerned characters too close together.
+                        // For example, "CCCCC" looks bad.
+                        cur_x = (F32)llfloor(cur_x + 0.5f);
+                        //cur_y = (F32)llfloor(cur_y + 0.5f);
+
+                        cur_render_x = cur_x;
+                        cur_render_y = cur_y;
+                }
+        }
+
+        glEnd();
+
+        if (right_x)
+        {
+                *right_x = cur_x / sScaleX;
+        }
+
+        if (style & UNDERLINE)
+        {
+                LLGLSNoTexture no_texture;
+                glBegin(GL_LINES);
+                glVertex2f(start_x, cur_y - (mDescender));
+                glVertex2f(cur_x, cur_y - (mDescender));
+                glEnd();
+        }
+
+        // *FIX: get this working in all alignment cases, etc.
+        if (draw_ellipses)
+        {
+                // recursively render ellipses at end of string
+                // we've already reserved enough room
+                glPushMatrix();
+                //glLoadIdentity();
+                //glTranslatef(sCurOrigin.mX, sCurOrigin.mY, 0.0f);
+                //glScalef(sScaleX, sScaleY, 1.f);
+                renderUTF8("...", 
+                                0,
+                                cur_x / sScaleX, (F32)y,
+                                color,
+                                LEFT, valign,
+                                style,
+                                S32_MAX, max_pixels,
+                                right_x,
+                                FALSE); 
+                glPopMatrix();
+        }
+
+        glPopMatrix();
+
+        return chars_drawn;
+}
+
+ 
+LLImageGL *LLFontGL::getImageGL() const
+{
+        return mImageGLp;
+}
+
+S32 LLFontGL::getWidth(const LLString& utf8text) const
+{
+        LLWString wtext = utf8str_to_wstring(utf8text);
+        return getWidth(wtext.c_str(), 0, S32_MAX);
+}
+
+S32 LLFontGL::getWidth(const llwchar* wchars) const
+{
+        return getWidth(wchars, 0, S32_MAX);
+}
+
+S32 LLFontGL::getWidth(const LLString& utf8text, const S32 begin_offset, const S32 max_chars) const
+{
+        LLWString wtext = utf8str_to_wstring(utf8text);
+        return getWidth(wtext.c_str(), begin_offset, max_chars);
+}
+
+S32 LLFontGL::getWidth(const llwchar* wchars, const S32 begin_offset, const S32 max_chars, BOOL use_embedded) const
+{
+        F32 width = getWidthF32(wchars, begin_offset, max_chars, use_embedded);
+        return llround(width);
+}
+
+F32 LLFontGL::getWidthF32(const LLString& utf8text) const
+{
+        LLWString wtext = utf8str_to_wstring(utf8text);
+        return getWidthF32(wtext.c_str(), 0, S32_MAX);
+}
+
+F32 LLFontGL::getWidthF32(const llwchar* wchars) const
+{
+        return getWidthF32(wchars, 0, S32_MAX);
+}
+
+F32 LLFontGL::getWidthF32(const LLString& utf8text, const S32 begin_offset, const S32 max_chars ) const
+{
+        LLWString wtext = utf8str_to_wstring(utf8text);
+        return getWidthF32(wtext.c_str(), begin_offset, max_chars);
+}
+
+F32 LLFontGL::getWidthF32(const llwchar* wchars, const S32 begin_offset, const S32 max_chars, BOOL use_embedded) const
+{
+        const S32 LAST_CHARACTER = LLFont::LAST_CHAR_FULL;
+
+        F32 cur_x = 0;
+        const S32 max_index = begin_offset + max_chars;
+        for (S32 i = begin_offset; i < max_index; i++)
+        {
+                const llwchar wch = wchars[i];
+                if (wch == 0)
+                {
+                        break; // done
+                }
+                const embedded_data_t* ext_data = use_embedded ? getEmbeddedCharData(wch) : NULL;
+                if (ext_data)
+                {
+                        // Handle crappy embedded hack
+                        cur_x += getEmbeddedCharAdvance(ext_data);
+
+                        if( ((i+1) < max_chars) && (i+1 < max_index))
+                        {
+                                cur_x += EXT_KERNING * sScaleX;
+                        }
+                }
+                else
+                {
+                        cur_x += getXAdvance(wch);
+                        llwchar next_char = wchars[i+1];
+
+                        if (((i + 1) < max_chars) 
+                                && next_char 
+                                && (next_char < LAST_CHARACTER))
+                        {
+                                // Kern this puppy.
+                                cur_x += getXKerning(wch, next_char);
+                        }
+                }
+                // Round after kerning.
+                cur_x = (F32)llfloor(cur_x + 0.5f);
+        }
+
+        return cur_x / sScaleX;
+}
+
+
+
+// Returns the max number of complete characters from text (up to max_chars) that can be drawn in max_pixels
+S32 LLFontGL::maxDrawableChars(const llwchar* wchars, F32 max_pixels, S32 max_chars,
+                                                           BOOL end_on_word_boundary, const BOOL use_embedded,
+                                                           F32* drawn_pixels) const
+{
+        if (!wchars || !wchars[0] || max_chars == 0)
+        {
+                return 0;
+        }
+        
+        llassert(max_pixels >= 0.f);
+        llassert(max_chars >= 0);
+        
+        BOOL clip = FALSE;
+        F32 cur_x = 0;
+        F32 drawn_x = 0;
+
+        S32 start_of_last_word = 0;
+        BOOL in_word = FALSE;
+
+        F32 scaled_max_pixels = (F32)llceil(max_pixels * sScaleX);
+
+        S32 i;
+        for (i=0; (i < max_chars); i++)
+        {
+                llwchar wch = wchars[i];
+
+                if(wch == 0)
+                {
+                        // Null terminator.  We're done.
+                        break;
+                }
+                        
+                const embedded_data_t* ext_data = use_embedded ? getEmbeddedCharData(wch) : NULL;
+                if (ext_data)
+                {
+                        if (in_word)
+                        {
+                                in_word = FALSE;
+                        }
+                        else
+                        {
+                                start_of_last_word = i;
+                        }
+                        cur_x += getEmbeddedCharAdvance(ext_data);
+                        
+                        if (scaled_max_pixels < cur_x)
+                        {
+                                clip = TRUE;
+                                break;
+                        }
+                        
+                        if (((i+1) < max_chars) && wchars[i+1])
+                        {
+                                cur_x += EXT_KERNING * sScaleX;
+                        }
+
+                        if( scaled_max_pixels < cur_x )
+                        {
+                                clip = TRUE;
+                                break;
+                        }
+                }
+                else
+                {
+                        if (in_word)
+                        {
+                                if (iswspace(wch))
+                                {
+                                        in_word = FALSE;
+                                }
+                        }
+                        else
+                        {
+                                start_of_last_word = i;
+                                if (!iswspace(wch))
+                                {
+                                        in_word = TRUE;
+                                }
+                        }
+
+                        cur_x += getXAdvance(wch);
+                        
+                        if (scaled_max_pixels < cur_x)
+                        {
+                                clip = TRUE;
+                                break;
+                        }
+
+                        if (((i+1) < max_chars) && wchars[i+1])
+                        {
+                                // Kern this puppy.
+                                cur_x += getXKerning(wch, wchars[i+1]);
+                        }
+                }
+                // Round after kerning.
+                cur_x = (F32)llfloor(cur_x + 0.5f);
+                drawn_x = cur_x;
+        }
+
+        if( clip && end_on_word_boundary && (start_of_last_word != 0) )
+        {
+                i = start_of_last_word;
+        }
+        if (drawn_pixels)
+        {
+                *drawn_pixels = drawn_x;
+        }
+        return i;
+}
+
+
+S32     LLFontGL::firstDrawableChar(const llwchar* wchars, F32 max_pixels, S32 text_len, S32 start_pos, S32 max_chars) const
+{
+        if (!wchars || !wchars[0] || max_chars == 0)
+        {
+                return 0;
+        }
+        
+        F32 total_width = 0.0;
+        S32 drawable_chars = 0;
+
+        F32 scaled_max_pixels = max_pixels * sScaleX;
+
+        S32 start = llmin(start_pos, text_len - 1);
+        for (S32 i = start; i >= 0; i--)
+        {
+                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;
+                        }
+
+                        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
+                {
+                        F32 char_width = getXAdvance(wch);
+                        if( scaled_max_pixels < (total_width + char_width) )
+                        {
+                                break;
+                        }
+
+                        total_width += char_width;
+
+                        drawable_chars++;
+                        if( max_chars >= 0 && drawable_chars >= max_chars )
+                        {
+                                break;
+                        }
+
+                        if ( i > 0 )
+                        {
+                                // Kerning
+                                total_width += getXKerning(wchars[i-1], wch);
+                        }
+
+                        // Round after kerning.
+                        total_width = (F32)llfloor(total_width + 0.5f);
+                }
+        }
+
+        return text_len - drawable_chars;
+}
+
+
+S32 LLFontGL::charFromPixelOffset(const llwchar* wchars, const S32 begin_offset, F32 target_x, F32 max_pixels, S32 max_chars, BOOL round, BOOL use_embedded) const
+{
+        if (!wchars || !wchars[0] || max_chars == 0)
+        {
+                return 0;
+        }
+        
+        F32 cur_x = 0;
+        S32 pos = 0;
+
+        target_x *= sScaleX;
+
+        // max_chars is S32_MAX by default, so make sure we don't get overflow
+        const S32 max_index = begin_offset + llmin(S32_MAX - begin_offset, max_chars);
+
+        F32 scaled_max_pixels = max_pixels * sScaleX;
+
+        for (S32 i = begin_offset; (i < max_index); i++)
+        {
+                llwchar wch = wchars[i];
+                if (!wch)
+                {
+                        break; // done
+                }
+                const embedded_data_t* ext_data = use_embedded ? getEmbeddedCharData(wch) : NULL;
+                if (ext_data)
+                {
+                        F32 ext_advance = getEmbeddedCharAdvance(ext_data);
+
+                        if (round)
+                        {
+                                // Note: if the mouse is on the left half of the character, the pick is to the character's left
+                                // If it's on the right half, the pick is to the right.
+                                if (target_x  < cur_x + ext_advance/2)
+                                {
+                                        break;
+                                }
+                        }
+                        else
+                        {
+                                if (target_x  < cur_x + ext_advance)
+                                {
+                                        break;
+                                }
+                        }
+
+                        if (scaled_max_pixels < cur_x + ext_advance)
+                        {
+                                break;
+                        }
+
+                        pos++;
+                        cur_x += ext_advance;
+
+                        if (((i + 1) < max_index)
+                                && (wchars[(i + 1)]))
+                        {
+                                cur_x += EXT_KERNING * sScaleX;
+                        }
+                        // Round after kerning.
+                        cur_x = (F32)llfloor(cur_x + 0.5f);
+                }
+                else
+                {
+                        F32 char_width = getXAdvance(wch);
+
+                        if (round)
+                        {
+                                // Note: if the mouse is on the left half of the character, the pick is to the character's left
+                                // If it's on the right half, the pick is to the right.
+                                if (target_x  < cur_x + char_width*0.5f)
+                                {
+                                        break;
+                                }
+                        }
+                        else if (target_x  < cur_x + char_width)
+                        {
+                                break;
+                        }
+
+                        if (scaled_max_pixels < cur_x + char_width)
+                        {
+                                break;
+                        }
+
+                        pos++;
+                        cur_x += char_width;
+
+                        if (((i + 1) < max_index)
+                                && (wchars[(i + 1)]))
+                        {
+                                llwchar next_char = wchars[i + 1];
+                                // Kern this puppy.
+                                cur_x += getXKerning(wch, next_char);
+                        }
+
+                        // Round after kerning.
+                        cur_x = (F32)llfloor(cur_x + 0.5f);
+                }
+        }
+
+        return pos;
+}
+
+
+const LLFontGL::embedded_data_t* LLFontGL::getEmbeddedCharData(const llwchar wch) const
+{
+        // Handle crappy embedded hack
+        embedded_map_t::const_iterator iter = mEmbeddedChars.find(wch);
+        if (iter != mEmbeddedChars.end())
+        {
+                return iter->second;
+        }
+        return NULL;
+}
+
+
+F32 LLFontGL::getEmbeddedCharAdvance(const embedded_data_t* ext_data) const
+{
+        const LLWString& label = ext_data->mLabel;
+        LLImageGL* ext_image = ext_data->mImage;
+
+        F32 ext_width = (F32)ext_image->getWidth();
+        if( !label.empty() )
+        {
+                ext_width += (EXT_X_BEARING + gExtCharFont->getWidthF32(label.c_str())) * sScaleX;
+        }
+
+        return (EXT_X_BEARING * sScaleX) + ext_width;
+}
+
+
+void LLFontGL::clearEmbeddedChars()
+{
+        for_each(mEmbeddedChars.begin(), mEmbeddedChars.end(), DeletePairedPointer());
+        mEmbeddedChars.clear();
+}
+
+void LLFontGL::addEmbeddedChar( llwchar wc, LLImageGL* image, const LLString& label )
+{
+        LLWString wlabel = utf8str_to_wstring(label);
+        addEmbeddedChar(wc, image, wlabel);
+}
+
+void LLFontGL::addEmbeddedChar( llwchar wc, LLImageGL* image, const LLWString& wlabel )
+{
+        embedded_data_t* ext_data = new embedded_data_t(image, wlabel);
+        mEmbeddedChars[wc] = ext_data;
+}
+
+void LLFontGL::removeEmbeddedChar( llwchar wc )
+{
+        embedded_map_t::iterator iter = mEmbeddedChars.find(wc);
+        if (iter != mEmbeddedChars.end())
+        {
+                delete iter->second;
+                mEmbeddedChars.erase(wc);
+        }
+}
+
+// static
+LLString LLFontGL::nameFromFont(const LLFontGL* fontp)
+{
+        if (fontp == sSansSerifHuge)
+        {
+                return LLString("SansSerifHude");
+        }
+        else if (fontp == sSansSerifSmall)
+        {
+                return LLString("SansSerifSmall");
+        }
+        else if (fontp == sSansSerif)
+        {
+                return LLString("SansSerif");
+        }
+        else if (fontp == sSansSerifBig)
+        {
+                return LLString("SansSerifBig");
+        }
+        else if (fontp == sSansSerifBold)
+        {
+                return LLString("SansSerifBold");
+        }
+        else if (fontp == sMonospace)
+        {
+                return LLString("Monospace");
+        }
+        else
+        {
+                return LLString();
+        }
+}
+
+// static
+LLFontGL* LLFontGL::fontFromName(const LLString& 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;
+}
+
+// static
+LLString LLFontGL::nameFromHAlign(LLFontGL::HAlign align)
+{
+        if (align == LEFT)                      return LLString("left");
+        else if (align == RIGHT)        return LLString("right");
+        else if (align == HCENTER)      return LLString("center");
+        else return LLString();
+}
+
+// static
+LLFontGL::HAlign LLFontGL::hAlignFromName(const LLString& name)
+{
+        LLFontGL::HAlign gl_hfont_align = LLFontGL::LEFT;
+        if (name == "left")
+        {
+                gl_hfont_align = LLFontGL::LEFT;
+        }
+        else if (name == "right")
+        {
+                gl_hfont_align = LLFontGL::RIGHT;
+        }
+        else if (name == "center")
+        {
+                gl_hfont_align = LLFontGL::HCENTER;
+        }
+        //else leave left
+        return gl_hfont_align;
+}
+
+// static
+LLString LLFontGL::nameFromVAlign(LLFontGL::VAlign align)
+{
+        if (align == TOP)                       return LLString("top");
+        else if (align == VCENTER)      return LLString("center");
+        else if (align == BASELINE)     return LLString("baseline");
+        else if (align == BOTTOM)       return LLString("bottom");
+        else return LLString();
+}
+
+// static
+LLFontGL::VAlign LLFontGL::vAlignFromName(const LLString& name)
+{
+        LLFontGL::VAlign gl_vfont_align = LLFontGL::BASELINE;
+        if (name == "top")
+        {
+                gl_vfont_align = LLFontGL::TOP;
+        }
+        else if (name == "center")
+        {
+                gl_vfont_align = LLFontGL::VCENTER;
+        }
+        else if (name == "baseline")
+        {
+                gl_vfont_align = LLFontGL::BASELINE;
+        }
+        else if (name == "bottom")
+        {
+                gl_vfont_align = LLFontGL::BOTTOM;
+        }
+        //else leave baseline
+        return gl_vfont_align;
+}
diff --git a/linden/indra/llrender/llfontgl.h b/linden/indra/llrender/llfontgl.h
new file mode 100644
index 0000000..bcb8dfb
--- /dev/null
+++ b/linden/indra/llrender/llfontgl.h
@@ -0,0 +1,252 @@
+/** 
+ * @file llfontgl.h
+ * @author Doug Soo
+ * @brief Wrapper around FreeType
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_LLFONTGL_H
+#define LL_LLFONTGL_H
+
+#include "llfont.h"
+#include "llimagegl.h"
+#include "v2math.h"
+#include "llcoord.h"
+
+class LLColor4;
+
+class LLFontGL : public LLFont
+{
+public:
+        enum HAlign
+        {
+                // Horizontal location of x,y coord to render.
+                LEFT = 0,               // Left align
+                RIGHT = 1,              // Right align
+                HCENTER = 2,    // Center
+        };
+
+        enum VAlign
+        {
+                // Vertical location of x,y coord to render.
+                TOP = 3,                // Top align
+                VCENTER = 4,    // Center
+                BASELINE = 5,   // Baseline
+                BOTTOM = 6              // Bottom
+        };
+
+        enum StyleFlags
+        {
+                // text style to render.  May be combined (these are bit flags)
+                NORMAL = 0,     
+                BOLD = 1,
+                ITALIC = 2,
+                UNDERLINE = 4,
+                DROP_SHADOW = 8
+        };
+        
+        // Takes a string with potentially several flags, i.e. "NORMAL|BOLD|ITALIC"
+        static U8 getStyleFromString(const LLString &style);
+
+        LLFontGL();
+        LLFontGL(const LLFontGL &source);
+        ~LLFontGL();
+
+        void init(); // Internal init, or reinitialization
+        void reset(); // Reset a font after GL cleanup.  ONLY works on an already loaded font.
+
+        LLFontGL &operator=(const LLFontGL &source);
+
+        static BOOL initDefaultFonts(F32 screen_dpi, F32 x_scale, F32 y_scale,
+                                                                 const LLString& monospace_file, F32 monospace_size,
+                                                                 const LLString& sansserif_file,
+                                                                 const LLString& sansserif_fallback_file, F32 ss_fallback_scale,
+                                                                 F32 small_size, F32 medium_size, F32 large_size, F32 huge_size,
+                                                                 const LLString& sansserif_bold_file, F32 bold_size,
+                                                                 const LLString& app_dir = LLString::null);
+
+        static void     destroyDefaultFonts();
+        static void destroyGL();
+
+        static bool loadFaceFallback(LLFontList *fontp, const LLString& fontname, const F32 point_size);
+        static bool loadFace(LLFontGL *fontp, const LLString& fontname, const F32 point_size, LLFontList *fallback_fontp);
+        BOOL loadFace(const LLString& filename, const F32 point_size, const F32 vert_dpi, const F32 horz_dpi);
+
+
+        S32 renderUTF8(const LLString &text, const S32 begin_offset,
+                                   S32 x, S32 y,
+                                   const LLColor4 &color) const
+        {
+                return renderUTF8(text, begin_offset, (F32)x, (F32)y, color,
+                                                  LEFT, BASELINE, NORMAL,
+                                                  S32_MAX, S32_MAX, NULL, FALSE);
+        }
+        
+        S32 renderUTF8(const LLString &text, const S32 begin_offset,
+                                   S32 x, S32 y,
+                                   const LLColor4 &color,
+                                   HAlign halign, VAlign valign, U8 style = NORMAL) const
+        {
+                return renderUTF8(text, begin_offset, (F32)x, (F32)y, color,
+                                                  halign, valign, style,
+                                                  S32_MAX, S32_MAX, NULL, FALSE);
+        }
+        
+        // renderUTF8 does a conversion, so is slower!
+        S32 renderUTF8(const LLString &text,
+                S32 begin_offset,
+                F32 x, F32 y,
+                const LLColor4 &color,
+                HAlign halign, 
+                VAlign valign,
+                U8 style,
+                S32 max_chars,
+                S32 max_pixels, 
+                F32* right_x,
+                BOOL use_ellipses) const;
+
+        S32 render(const LLWString &text, const S32 begin_offset,
+                           F32 x, F32 y,
+                           const LLColor4 &color) const
+        {
+                return render(text, begin_offset, x, y, color,
+                                          LEFT, BASELINE, NORMAL,
+                                          S32_MAX, S32_MAX, NULL, FALSE, FALSE);
+        }
+        
+
+        S32 render(const LLWString &text,
+                S32 begin_offset,
+                F32 x, F32 y,
+                const LLColor4 &color,
+                HAlign halign = LEFT, 
+                VAlign valign = BASELINE,
+                U8 style = NORMAL,
+                S32 max_chars = S32_MAX,
+                S32 max_pixels = S32_MAX, 
+                F32* right_x=NULL,
+                BOOL use_embedded = FALSE,
+                BOOL use_ellipses = FALSE) const;
+
+        // font metrics - override for LLFont that returns units of virtual pixels
+        /*virtual*/ F32 getLineHeight() const           { return (F32)llround(mLineHeight / sScaleY); }
+        /*virtual*/ F32 getAscenderHeight() const       { return (F32)llround(mAscender / sScaleY); }
+        /*virtual*/ F32 getDescenderHeight() const      { return (F32)llround(mDescender / sScaleY); }
+        
+        virtual S32 getWidth(const LLString& utf8text) const;
+        virtual S32 getWidth(const llwchar* wchars) const;
+        virtual S32 getWidth(const LLString& utf8text, const S32 offset, const S32 max_chars ) const;
+        virtual S32 getWidth(const llwchar* wchars, const S32 offset, const S32 max_chars, BOOL use_embedded = FALSE) const;
+
+        virtual F32 getWidthF32(const LLString& utf8text) const;
+        virtual F32 getWidthF32(const llwchar* wchars) const;
+        virtual F32 getWidthF32(const LLString& text, const S32 offset, const S32 max_chars ) const;
+        virtual F32 getWidthF32(const llwchar* wchars, const S32 offset, const S32 max_chars, BOOL use_embedded = FALSE ) const;
+
+        // The following are called often, frequently with large buffers, so do not use a string interface
+        
+        // Returns the max number of complete characters from text (up to max_chars) that can be drawn in max_pixels
+        virtual S32     maxDrawableChars(const llwchar* wchars, F32 max_pixels, S32 max_chars = S32_MAX,
+                                                                 BOOL end_on_word_boundary = FALSE, const BOOL use_embedded = FALSE,
+                                                                 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).
+        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)
+        virtual S32 charFromPixelOffset(const llwchar* wchars, const S32 char_offset,
+                                                                        F32 x, F32 max_pixels=F32_MAX, S32 max_chars = S32_MAX,
+                                                                        BOOL round = TRUE, BOOL use_embedded = FALSE) const;
+
+
+        LLImageGL *getImageGL() const;
+
+        void       addEmbeddedChar( llwchar wc, LLImageGL* image, const LLString& label);
+        void       addEmbeddedChar( llwchar wc, LLImageGL* image, const LLWString& label);
+        void       removeEmbeddedChar( llwchar wc );
+
+        static LLString nameFromFont(const LLFontGL* fontp);
+        static LLFontGL* fontFromName(const LLString& name);
+
+        static LLString nameFromHAlign(LLFontGL::HAlign align);
+        static LLFontGL::HAlign hAlignFromName(const LLString& name);
+
+        static LLString nameFromVAlign(LLFontGL::VAlign align);
+        static LLFontGL::VAlign vAlignFromName(const LLString& name);
+
+protected:
+        struct embedded_data_t
+        {
+                embedded_data_t(LLImageGL* image, const LLWString& label) : mImage(image), mLabel(label) {}
+                LLPointer<LLImageGL> mImage;
+                LLWString                        mLabel;
+        };
+        const embedded_data_t* getEmbeddedCharData(const llwchar wch) const;
+        F32 getEmbeddedCharAdvance(const embedded_data_t* ext_data) const;
+        void clearEmbeddedChars();
+
+public:
+        static F32 sVertDPI;
+        static F32 sHorizDPI;
+        static F32 sScaleX;
+        static F32 sScaleY;
+        static LLString sAppDir;                        // For loading fonts
+                
+        static LLFontGL*        sMonospace;             // medium
+
+        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 LLColor4 sShadowColor;
+
+        friend class LLTextBillboard;
+        friend class LLHUDText;
+
+protected:
+        /*virtual*/ BOOL addChar(const llwchar wch);
+        static LLString getFontPathLocal();
+        static LLString getFontPathSystem();
+
+protected:
+        LLPointer<LLImageRaw>   mRawImageGLp;
+        LLPointer<LLImageGL>    mImageGLp;
+        typedef std::map<llwchar,embedded_data_t*> embedded_map_t;
+        embedded_map_t mEmbeddedChars;
+        
+public:
+        static LLCoordFont sCurOrigin;
+        static std::vector<LLCoordFont> sOriginStack;
+};
+
+#endif
diff --git a/linden/indra/llrender/llgldbg.cpp b/linden/indra/llrender/llgldbg.cpp
new file mode 100644
index 0000000..4d9f5f9
--- /dev/null
+++ b/linden/indra/llrender/llgldbg.cpp
@@ -0,0 +1,224 @@
+/** 
+ * @file llgldbg.cpp
+ * @brief Definitions for OpenGL debugging support
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+// This file sets some global GL parameters, and implements some 
+// useful functions for GL operations.
+
+#include "linden_common.h"
+
+#include "llgldbg.h"
+
+#include "llgl.h"
+#include "llglheaders.h"
+
+
+//------------------------------------------------------------------------
+// cmstr()
+//------------------------------------------------------------------------
+char *cmstr(int i)
+{
+        switch( i )
+        {
+        case GL_EMISSION: return "GL_EMISSION";
+        case GL_AMBIENT: return "GL_AMBIENT";
+        case GL_DIFFUSE: return "GL_DIFFUSE";
+        case GL_SPECULAR: return "GL_SPECULAR";
+        case GL_AMBIENT_AND_DIFFUSE: return "GL_AMBIENT_AND_DIFFUSE";
+        }
+        return "UNKNOWN";
+}
+
+//------------------------------------------------------------------------
+// facestr()
+//------------------------------------------------------------------------
+char *facestr(int i)
+{
+        switch( i )
+        {
+        case GL_FRONT: return "GL_FRONT";
+        case GL_BACK: return "GL_BACK";
+        case GL_FRONT_AND_BACK: return "GL_FRONT_AND_BACK";
+        }
+        return "UNKNOWN";
+}
+
+//------------------------------------------------------------------------
+// boolstr()
+//------------------------------------------------------------------------
+const char *boolstr(int b)
+{
+        return b ? "GL_TRUE" : "GL_FALSE";
+}
+
+//------------------------------------------------------------------------
+// fv4()
+//------------------------------------------------------------------------
+char *fv4(F32 *f)
+{
+        static char str[128];
+        sprintf(str, "%8.3f %8.3f %8.3f %8.3f", f[0], f[1], f[2], f[3]);
+        return str;
+}
+
+//------------------------------------------------------------------------
+// fv3()
+//------------------------------------------------------------------------
+char *fv3(F32 *f)
+{
+        static char str[128];
+        sprintf(str, "%8.3f, %8.3f, %8.3f", f[0], f[1], f[2]);
+        return str;
+}
+
+//------------------------------------------------------------------------
+// fv1()
+//------------------------------------------------------------------------
+char *fv1(F32 *f)
+{
+        static char str[128];
+        sprintf(str, "%8.3f", f[0]);
+        return str;
+}
+
+//------------------------------------------------------------------------
+// llgl_dump()
+//------------------------------------------------------------------------
+void llgl_dump()
+{
+        int i;
+        F32 fv[16];
+        GLboolean b;
+
+        llinfos << "==========================" << llendl;
+        llinfos << "OpenGL State" << llendl;
+        llinfos << "==========================" << llendl;
+
+        llinfos << "-----------------------------------" << llendl;
+        llinfos << "Current Values" << llendl;
+        llinfos << "-----------------------------------" << llendl;
+
+        glGetFloatv(GL_CURRENT_COLOR, fv);
+        llinfos << "GL_CURRENT_COLOR          : " << fv4(fv) << llendl;
+
+        glGetFloatv(GL_CURRENT_NORMAL, fv);
+        llinfos << "GL_CURRENT_NORMAL          : " << fv3(fv) << llendl;
+
+        llinfos << "-----------------------------------" << llendl;
+        llinfos << "Lighting" << llendl;
+        llinfos << "-----------------------------------" << llendl;
+
+        llinfos << "GL_LIGHTING                : " << boolstr(glIsEnabled(GL_LIGHTING)) << llendl;
+
+        llinfos << "GL_COLOR_MATERIAL          : " << boolstr(glIsEnabled(GL_COLOR_MATERIAL)) << llendl;
+
+        glGetIntegerv(GL_COLOR_MATERIAL_PARAMETER, (GLint*)&i);
+        llinfos << "GL_COLOR_MATERIAL_PARAMETER: " << cmstr(i) << llendl;
+
+        glGetIntegerv(GL_COLOR_MATERIAL_FACE, (GLint*)&i);
+        llinfos << "GL_COLOR_MATERIAL_FACE     : " << facestr(i) << llendl;
+
+        fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
+        glGetMaterialfv(GL_FRONT, GL_AMBIENT, fv);
+        llinfos << "GL_AMBIENT material        : " << fv4(fv) << llendl;
+
+        fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
+        glGetMaterialfv(GL_FRONT, GL_DIFFUSE, fv);
+        llinfos << "GL_DIFFUSE material        : " << fv4(fv) << llendl;
+
+        fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
+        glGetMaterialfv(GL_FRONT, GL_SPECULAR, fv);
+        llinfos << "GL_SPECULAR material       : " << fv4(fv) << llendl;
+
+        fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
+        glGetMaterialfv(GL_FRONT, GL_EMISSION, fv);
+        llinfos << "GL_EMISSION material       : " << fv4(fv) << llendl;
+
+        fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
+        glGetMaterialfv(GL_FRONT, GL_SHININESS, fv);
+        llinfos << "GL_SHININESS material      : " << fv1(fv) << llendl;
+
+        fv[0] = fv[1] = fv[2] = fv[3] = 12345.6789f;
+        glGetFloatv(GL_LIGHT_MODEL_AMBIENT, fv);
+        llinfos << "GL_LIGHT_MODEL_AMBIENT     : " << fv4(fv) << llendl;
+
+        glGetBooleanv(GL_LIGHT_MODEL_LOCAL_VIEWER, &b);
+        llinfos << "GL_LIGHT_MODEL_LOCAL_VIEWER: " << boolstr(b) << llendl;
+
+        glGetBooleanv(GL_LIGHT_MODEL_TWO_SIDE, &b);
+        llinfos << "GL_LIGHT_MODEL_TWO_SIDE    : " << boolstr(b) << llendl;
+
+        for (int l=0; l<8; l++)
+        {
+        b = glIsEnabled(GL_LIGHT0+l);
+        llinfos << "GL_LIGHT" << l << "                  : " << boolstr(b) << llendl;
+
+        if (!b)
+                continue;
+
+        glGetLightfv(GL_LIGHT0+l, GL_AMBIENT, fv);
+        llinfos << "  GL_AMBIENT light         : " << fv4(fv) << llendl;
+
+        glGetLightfv(GL_LIGHT0+l, GL_DIFFUSE, fv);
+        llinfos << "  GL_DIFFUSE light         : " << fv4(fv) << llendl;
+
+        glGetLightfv(GL_LIGHT0+l, GL_SPECULAR, fv);
+        llinfos << "  GL_SPECULAR light        : " << fv4(fv) << llendl;
+
+        glGetLightfv(GL_LIGHT0+l, GL_POSITION, fv);
+        llinfos << "  GL_POSITION light        : " << fv4(fv) << llendl;
+
+        glGetLightfv(GL_LIGHT0+l, GL_CONSTANT_ATTENUATION, fv);
+        llinfos << "  GL_CONSTANT_ATTENUATION  : " << fv1(fv) << llendl;
+
+        glGetLightfv(GL_LIGHT0+l, GL_QUADRATIC_ATTENUATION, fv);
+        llinfos << "  GL_QUADRATIC_ATTENUATION : " << fv1(fv) << llendl;
+
+        glGetLightfv(GL_LIGHT0+l, GL_SPOT_DIRECTION, fv);
+        llinfos << "  GL_SPOT_DIRECTION        : " << fv4(fv) << llendl;
+
+        glGetLightfv(GL_LIGHT0+l, GL_SPOT_EXPONENT, fv);
+        llinfos << "  GL_SPOT_EXPONENT         : " << fv1(fv) << llendl;
+
+        glGetLightfv(GL_LIGHT0+l, GL_SPOT_CUTOFF, fv);
+        llinfos << "  GL_SPOT_CUTOFF           : " << fv1(fv) << llendl;
+        }
+
+        llinfos << "-----------------------------------" << llendl;
+        llinfos << "Pixel Operations" << llendl;
+        llinfos << "-----------------------------------" << llendl;
+
+        llinfos << "GL_ALPHA_TEST              : " << boolstr(glIsEnabled(GL_ALPHA_TEST)) << llendl;
+        llinfos << "GL_DEPTH_TEST              : " << boolstr(glIsEnabled(GL_DEPTH_TEST)) << llendl;
+
+        glGetBooleanv(GL_DEPTH_WRITEMASK, &b);
+        llinfos << "GL_DEPTH_WRITEMASK         : " << boolstr(b) << llendl;
+        
+        llinfos << "GL_BLEND                   : " << boolstr(glIsEnabled(GL_BLEND)) << llendl;
+        llinfos << "GL_DITHER                  : " << boolstr(glIsEnabled(GL_DITHER)) << llendl;
+}
+
+// End
diff --git a/linden/indra/llrender/llgldbg.h b/linden/indra/llrender/llgldbg.h
new file mode 100644
index 0000000..39be147
--- /dev/null
+++ b/linden/indra/llrender/llgldbg.h
@@ -0,0 +1,35 @@
+/** 
+ * @file llgldbg.h
+ * @brief Definitions for OpenGL debugging support
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_LLGLDBG_H
+#define LL_LLGLDBG_H
+
+// Dumps the current OpenGL state to the console.
+void llgl_dump();
+
+
+#endif // LL_LLGLDBG_H
diff --git a/linden/indra/llrender/llimagegl.cpp b/linden/indra/llrender/llimagegl.cpp
new file mode 100644
index 0000000..5ea7322
--- /dev/null
+++ b/linden/indra/llrender/llimagegl.cpp
@@ -0,0 +1,1224 @@
+/** 
+ * @file llimagegl.cpp
+ * @brief Generic GL image handler
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+
+// TODO: create 2 classes for images w/ and w/o discard levels?
+
+#include "linden_common.h"
+
+#include "llimagegl.h"
+
+#include "llerror.h"
+#include "llimage.h"
+
+#include "llmath.h"
+#include "llgl.h"
+
+//----------------------------------------------------------------------------
+
+const F32 MIN_TEXTURE_LIFETIME = 10.f;
+
+//statics
+LLGLuint LLImageGL::sCurrentBoundTextures[MAX_GL_TEXTURE_UNITS] = { 0 };
+
+S32 LLImageGL::sGlobalTextureMemory             = 0;
+S32 LLImageGL::sBoundTextureMemory              = 0;
+S32 LLImageGL::sCurBoundTextureMemory   = 0;
+S32 LLImageGL::sCount                                   = 0;
+
+BOOL LLImageGL::sGlobalUseAnisotropic   = FALSE;
+F32 LLImageGL::sLastFrameTime                   = 0.f;
+
+std::set<LLImageGL*> LLImageGL::sImageList;
+
+//----------------------------------------------------------------------------
+
+//static
+S32 LLImageGL::dataFormatBits(S32 dataformat)
+{
+        switch (dataformat)
+        {
+          case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:        return 4;
+          case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:        return 8;
+          case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:        return 8;
+          case GL_LUMINANCE:                                            return 8;
+          case GL_ALPHA:                                                        return 8;
+          case GL_COLOR_INDEX:                                          return 8;
+          case GL_LUMINANCE_ALPHA:                                      return 16;
+          case GL_RGB:                                                          return 24;
+          case GL_RGB8:                                                         return 24;
+          case GL_RGBA:                                                         return 32;
+          case GL_BGRA:                                                         return 32;              // Used for QuickTime media textures on the Mac
+          default:
+                llerrs << "LLImageGL::Unknown format: " << dataformat << llendl;
+                return 0;
+        }
+}
+
+//static
+S32 LLImageGL::dataFormatBytes(S32 dataformat, S32 width, S32 height)
+{
+        if (dataformat >= GL_COMPRESSED_RGB_S3TC_DXT1_EXT &&
+                dataformat <= GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
+        {
+                if (width < 4) width = 4;
+                if (height < 4) height = 4;
+        }
+        S32 bytes ((width*height*dataFormatBits(dataformat)+7)>>3);
+        S32 aligned = (bytes+3)&~3;
+        return aligned;
+}
+
+//static
+S32 LLImageGL::dataFormatComponents(S32 dataformat)
+{
+        switch (dataformat)
+        {
+          case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:        return 3;
+          case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:        return 4;
+          case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:        return 4;
+          case GL_LUMINANCE:                                            return 1;
+          case GL_ALPHA:                                                        return 1;
+          case GL_COLOR_INDEX:                                          return 1;
+          case GL_LUMINANCE_ALPHA:                                      return 2;
+          case GL_RGB:                                                          return 3;
+          case GL_RGBA:                                                         return 4;
+          case GL_BGRA:                                                         return 4;               // Used for QuickTime media textures on the Mac
+          default:
+                llerrs << "LLImageGL::Unknown format: " << dataformat << llendl;
+                return 0;
+        }
+}
+
+//----------------------------------------------------------------------------
+
+// static
+void LLImageGL::bindExternalTexture(LLGLuint gl_name, S32 stage, LLGLenum bind_target )
+{
+        glActiveTextureARB(GL_TEXTURE0_ARB + stage);
+        glClientActiveTextureARB(GL_TEXTURE0_ARB + stage);
+        glBindTexture(bind_target, gl_name);
+        sCurrentBoundTextures[stage] = gl_name;
+}
+
+// static
+void LLImageGL::unbindTexture(S32 stage, LLGLenum bind_target)
+{
+        glActiveTextureARB(GL_TEXTURE0_ARB + stage);
+        glClientActiveTextureARB(GL_TEXTURE0_ARB + stage);
+        glBindTexture(bind_target, 0);
+        sCurrentBoundTextures[stage] = 0;
+}
+
+// static
+void LLImageGL::updateStats(F32 current_time)
+{
+        sLastFrameTime = current_time;
+        sBoundTextureMemory = sCurBoundTextureMemory;
+        sCurBoundTextureMemory = 0;
+}
+
+//static
+S32 LLImageGL::updateBoundTexMem(const S32 delta)
+{
+        LLImageGL::sCurBoundTextureMemory += delta;
+        return LLImageGL::sCurBoundTextureMemory;
+}
+
+//----------------------------------------------------------------------------
+
+//static 
+void LLImageGL::destroyGL(BOOL save_state)
+{
+        for (S32 stage = 0; stage < gGLManager.mNumTextureUnits; stage++)
+        {
+                LLImageGL::unbindTexture(stage, GL_TEXTURE_2D);
+        }
+        for (std::set<LLImageGL*>::iterator iter = sImageList.begin();
+                 iter != sImageList.end(); iter++)
+        {
+                LLImageGL* glimage = *iter;
+                if (glimage->mTexName && glimage->mComponents)
+                {
+                        if (save_state)
+                        {
+                                glimage->mSaveData = new LLImageRaw;
+                                glimage->readBackRaw(glimage->mCurrentDiscardLevel, glimage->mSaveData);
+                        }
+                        glimage->destroyGLTexture();
+                        stop_glerror();
+                }
+        }
+}
+
+//static 
+void LLImageGL::restoreGL()
+{
+        for (std::set<LLImageGL*>::iterator iter = sImageList.begin();
+                 iter != sImageList.end(); iter++)
+        {
+                LLImageGL* glimage = *iter;
+                if (glimage->mSaveData.notNull() && glimage->mSaveData->getComponents())
+                {
+                        if (glimage->getComponents())
+                        {
+                                glimage->createGLTexture(glimage->mCurrentDiscardLevel, glimage->mSaveData);
+                                stop_glerror();
+                        }
+                        glimage->mSaveData = NULL; // deletes data
+                }
+        }
+}
+
+//----------------------------------------------------------------------------
+
+//static 
+BOOL LLImageGL::create(LLPointer<LLImageGL>& dest, BOOL usemipmaps)
+{
+        dest = new LLImageGL(usemipmaps);
+        return TRUE;
+}
+
+BOOL LLImageGL::create(LLPointer<LLImageGL>& dest, U32 width, U32 height, U8 components, BOOL usemipmaps)
+{
+        dest = new LLImageGL(width, height, components, usemipmaps);
+        return TRUE;
+}
+
+BOOL LLImageGL::create(LLPointer<LLImageGL>& dest, const LLImageRaw* imageraw, BOOL usemipmaps)
+{
+        dest = new LLImageGL(imageraw, usemipmaps);
+        return TRUE;
+}
+
+//----------------------------------------------------------------------------
+
+LLImageGL::LLImageGL(BOOL usemipmaps)
+        : mSaveData(0)
+{
+        init(usemipmaps);
+        setSize(0, 0, 0);
+        sImageList.insert(this);
+        sCount++;
+}
+
+LLImageGL::LLImageGL(U32 width, U32 height, U8 components, BOOL usemipmaps)
+        : mSaveData(0)
+{
+        llassert( components <= 4 );
+        init(usemipmaps);
+        setSize(width, height, components);
+        sImageList.insert(this);
+        sCount++;
+}
+
+LLImageGL::LLImageGL(const LLImageRaw* imageraw, BOOL usemipmaps)
+        : mSaveData(0)
+{
+        init(usemipmaps);
+        setSize(0, 0, 0);
+        sImageList.insert(this);
+        sCount++;
+        createGLTexture(0, imageraw); 
+}
+
+LLImageGL::~LLImageGL()
+{
+        LLImageGL::cleanup();
+        sImageList.erase(this);
+        sCount--;
+}
+
+void LLImageGL::init(BOOL usemipmaps)
+{
+#ifdef DEBUG_MISS
+        mMissed                         = FALSE;
+#endif
+
+        mTextureMemory    = 0;
+        mLastBindTime     = 0.f;
+
+        mTarget                   = GL_TEXTURE_2D;
+        mBindTarget               = GL_TEXTURE_2D;
+        mUseMipMaps               = usemipmaps;
+        mHasMipMaps               = FALSE;
+        mAutoGenMips      = FALSE;
+        mTexName          = 0;
+        mIsResident       = 0;
+        mClampS                   = FALSE;
+        mClampT                   = FALSE;
+        mMipFilterNearest  = FALSE;
+        mWidth                          = 0;
+        mHeight                         = 0;
+        mComponents                     = 0;
+        
+        mMaxDiscardLevel = MAX_DISCARD_LEVEL;
+        mCurrentDiscardLevel = -1;
+        mDontDiscard = FALSE;
+        
+        mFormatInternal = -1;
+        mFormatPrimary = (LLGLenum) 0;
+        mFormatType = GL_UNSIGNED_BYTE;
+        mFormatSwapBytes = FALSE;
+        mHasExplicitFormat = FALSE;
+}
+
+void LLImageGL::cleanup()
+{
+        if (!gGLManager.mIsDisabled)
+        {
+                destroyGLTexture();
+        }
+        mSaveData = NULL; // deletes data
+}
+
+//----------------------------------------------------------------------------
+
+static bool check_power_of_two(S32 dim)
+{
+        while(dim > 1)
+        {
+                if (dim & 1)
+                {
+                        return false;
+                }
+                dim >>= 1;
+        }
+        return true;
+}
+
+//static
+bool LLImageGL::checkSize(S32 width, S32 height)
+{
+        return check_power_of_two(width) && check_power_of_two(height);
+}
+
+void LLImageGL::setSize(S32 width, S32 height, S32 ncomponents)
+{
+        if (width != mWidth || height != mHeight || ncomponents != mComponents)
+        {
+                // Check if dimensions are a power of two!
+                if (!checkSize(width,height))
+                {
+                        llerrs << llformat("Texture has non power of two dimention: %dx%d",width,height) << llendl;
+                }
+                
+                if (mTexName)
+                {
+//                      llwarns << "Setting Size of LLImageGL with existing mTexName = " << mTexName << llendl;
+                        destroyGLTexture();
+                }
+                
+                mWidth = width;
+                mHeight = height;
+                mComponents = ncomponents;
+                if (ncomponents > 0)
+                {
+                        mMaxDiscardLevel = 0;
+                        while (width > 1 && height > 1 && mMaxDiscardLevel < MAX_DISCARD_LEVEL)
+                        {
+                                mMaxDiscardLevel++;
+                                width >>= 1;
+                                height >>= 1;
+                        }
+                }
+                else
+                {
+                        mMaxDiscardLevel = MAX_DISCARD_LEVEL;
+                }
+        }
+}
+
+//----------------------------------------------------------------------------
+
+// virtual
+void LLImageGL::dump()
+{
+        llinfos << "mMaxDiscardLevel " << S32(mMaxDiscardLevel)
+                        << " mLastBindTime " << mLastBindTime
+                        << " mTarget " << S32(mTarget)
+                        << " mBindTarget " << S32(mBindTarget)
+                        << " mUseMipMaps " << S32(mUseMipMaps)
+                        << " mHasMipMaps " << S32(mHasMipMaps)
+                        << " mCurrentDiscardLevel " << S32(mCurrentDiscardLevel)
+                        << " mFormatInternal " << S32(mFormatInternal)
+                        << " mFormatPrimary " << S32(mFormatPrimary)
+                        << " mFormatType " << S32(mFormatType)
+                        << " mFormatSwapBytes " << S32(mFormatSwapBytes)
+                        << " mHasExplicitFormat " << S32(mHasExplicitFormat)
+#if DEBUG_MISS
+                        << " mMissed " << mMissed
+#endif
+                        << llendl;
+
+        llinfos << " mTextureMemory " << mTextureMemory
+                        << " mTexNames " << mTexName
+                        << " mIsResident " << S32(mIsResident)
+                        << llendl;
+}
+
+//----------------------------------------------------------------------------
+
+BOOL LLImageGL::bindTextureInternal(const S32 stage) const
+{
+        if (gGLManager.mIsDisabled)
+        {
+                llwarns << "Trying to bind a texture while GL is disabled!" << llendl;
+        }
+
+        stop_glerror();
+        
+        glActiveTextureARB(GL_TEXTURE0_ARB + stage);
+        //glClientActiveTextureARB(GL_TEXTURE0_ARB + stage);
+        
+        stop_glerror();
+
+        if (sCurrentBoundTextures[stage] && sCurrentBoundTextures[stage] == mTexName)
+        {
+                // already set!
+                return TRUE;
+        }
+
+        if (mTexName != 0)
+        {
+#ifdef DEBUG_MISS
+                mMissed = ! getIsResident(TRUE);
+#endif
+
+                glBindTexture(mBindTarget, mTexName);
+                sCurrentBoundTextures[stage] = mTexName;
+                stop_glerror();
+
+                if (mLastBindTime != sLastFrameTime)
+                {
+                        // we haven't accounted for this texture yet this frame
+                        updateBoundTexMem(mTextureMemory);
+                        mLastBindTime = sLastFrameTime;
+                }
+                
+                return TRUE;
+        }
+        else
+        {
+                glBindTexture(mBindTarget, 0);
+                sCurrentBoundTextures[stage] = 0;
+                return FALSE;
+        }
+}
+
+//virtual
+BOOL LLImageGL::bind(const S32 stage) const
+{
+        if (stage == -1)
+        {
+                return FALSE;
+        }
+        BOOL res = bindTextureInternal(stage);
+        //llassert(res);
+        return res;
+}
+
+void LLImageGL::setExplicitFormat( LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format, BOOL swap_bytes )
+{
+        // Note: must be called before createTexture()
+        // Note: it's up to the caller to ensure that the format matches the number of components.
+        mHasExplicitFormat = TRUE;
+        mFormatInternal = internal_format;
+        mFormatPrimary = primary_format;
+        if(type_format == 0)
+                mFormatType = GL_UNSIGNED_BYTE;
+        else
+                mFormatType = type_format;
+        mFormatSwapBytes = swap_bytes;
+}
+
+//----------------------------------------------------------------------------
+
+void LLImageGL::setImage(const LLImageRaw* imageraw)
+{
+        llassert((imageraw->getWidth() == getWidth(mCurrentDiscardLevel)) &&
+                         (imageraw->getHeight() == getHeight(mCurrentDiscardLevel)) &&
+                         (imageraw->getComponents() == getComponents()));
+        const U8* rawdata = imageraw->getData();
+        setImage(rawdata, FALSE);
+}
+
+void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
+{
+//      LLFastTimer t1(LLFastTimer::FTM_TEMP1);
+        
+        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(bindTextureInternal(0));
+        }
+        
+        if (mUseMipMaps)
+        {
+//              LLFastTimer t2(LLFastTimer::FTM_TEMP3);
+                if (data_hasmips)
+                {
+                        // NOTE: data_in points to largest image; smaller images
+                        // 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;
+                                if (d > mCurrentDiscardLevel)
+                                {
+                                        data_in -= dataFormatBytes(mFormatPrimary, w, h); // see above comment
+                                }
+                                if (is_compressed)
+                                {
+//                                      LLFastTimer t2(LLFastTimer::FTM_TEMP4);
+                                        S32 tex_size = dataFormatBytes(mFormatPrimary, w, h);
+                                        glCompressedTexImage2DARB(mTarget, gl_level, mFormatPrimary, w, h, 0, tex_size, (GLvoid *)data_in);
+                                        stop_glerror();
+                                }
+                                else
+                                {
+//                                      LLFastTimer t2(LLFastTimer::FTM_TEMP4);
+
+                                        if(mFormatSwapBytes)
+                                        {
+                                                glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
+                                                stop_glerror();
+                                        }
+                                                
+                                        glTexImage2D(mTarget, gl_level, mFormatInternal, w, h, 0, mFormatPrimary, GL_UNSIGNED_BYTE, (GLvoid*)data_in);
+                                        
+                                        if(mFormatSwapBytes)
+                                        {
+                                                glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
+                                                stop_glerror();
+                                        }
+                                                
+                                        stop_glerror();
+                                }
+                                stop_glerror();
+                        }                       
+                }
+                else if (!is_compressed)
+                {
+                        if (mAutoGenMips)
+                        {
+                                glTexParameteri(mBindTarget, GL_GENERATE_MIPMAP_SGIS, TRUE);
+                                stop_glerror();
+                                {
+//                                      LLFastTimer t2(LLFastTimer::FTM_TEMP4);
+
+                                        if(mFormatSwapBytes)
+                                        {
+                                                glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
+                                                stop_glerror();
+                                        }
+
+                                        glTexImage2D(mTarget, 0, mFormatInternal,
+                                                                 getWidth(mCurrentDiscardLevel), getHeight(mCurrentDiscardLevel), 0,
+                                                                 mFormatPrimary, mFormatType,
+                                                                 data_in);
+                                        stop_glerror();
+
+                                        if(mFormatSwapBytes)
+                                        {
+                                                glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
+                                                stop_glerror();
+                                        }
+                                }
+                        }
+                        else
+                        {
+                                // Create mips by hand
+                                // about 30% faster than autogen on ATI 9800, 50% slower on nVidia 4800
+                                // ~4x faster than gluBuild2DMipmaps
+                                S32 width = getWidth(mCurrentDiscardLevel);
+                                S32 height = getHeight(mCurrentDiscardLevel);
+                                S32 nummips = mMaxDiscardLevel - mCurrentDiscardLevel + 1;
+                                S32 w = width, h = height;
+                                const U8* prev_mip_data = 0;
+                                const U8* cur_mip_data = 0;
+                                for (int m=0; m<nummips; m++)
+                                {
+                                        if (m==0)
+                                        {
+                                                cur_mip_data = data_in;
+                                        }
+                                        else
+                                        {
+                                                S32 bytes = w * h * mComponents;
+                                                U8* new_data = new U8[bytes];
+                                                LLImageBase::generateMip(prev_mip_data, new_data, w, h, mComponents);
+                                                cur_mip_data = new_data;
+                                        }
+                                        llassert(w > 0 && h > 0 && cur_mip_data);
+                                        {
+//                                              LLFastTimer t1(LLFastTimer::FTM_TEMP4);
+                                                if(mFormatSwapBytes)
+                                                {
+                                                        glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
+                                                        stop_glerror();
+                                                }
+
+                                                glTexImage2D(mTarget, m, mFormatInternal, w, h, 0, mFormatPrimary, mFormatType, cur_mip_data);
+                                                stop_glerror();
+
+                                                if(mFormatSwapBytes)
+                                                {
+                                                        glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
+                                                        stop_glerror();
+                                                }
+                                        }
+                                        if (prev_mip_data && prev_mip_data != data_in)
+                                        {
+                                                delete[] prev_mip_data;
+                                        }
+                                        prev_mip_data = cur_mip_data;
+                                        w >>= 1;
+                                        h >>= 1;
+                                }
+                                if (prev_mip_data && prev_mip_data != data_in)
+                                {
+                                        delete[] prev_mip_data;
+                                }
+                        }
+                }
+                else
+                {
+                        llerrs << "Compressed Image has mipmaps but data does not (can not auto generate compressed mips)" << llendl;
+                }
+                mHasMipMaps = TRUE;
+        }
+        else
+        {
+//              LLFastTimer t2(LLFastTimer::FTM_TEMP5);
+                S32 w = getWidth();
+                S32 h = getHeight();
+                if (is_compressed)
+                {
+                        S32 tex_size = dataFormatBytes(mFormatPrimary, w, h);
+                        glCompressedTexImage2DARB(mTarget, 0, mFormatPrimary, w, h, 0, tex_size, (GLvoid *)data_in);
+                        stop_glerror();
+                }
+                else
+                {
+                        if(mFormatSwapBytes)
+                        {
+                                glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
+                                stop_glerror();
+                        }
+
+                        glTexImage2D(mTarget, 0, mFormatInternal, w, h, 0,
+                                                 mFormatPrimary, mFormatType, (GLvoid *)data_in);
+                        stop_glerror();
+
+                        if(mFormatSwapBytes)
+                        {
+                                glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
+                                stop_glerror();
+                        }
+
+                }
+                mHasMipMaps = FALSE;
+        }
+        stop_glerror();
+}
+
+BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height)
+{
+        if (!width || !height)
+        {
+                return TRUE;
+        }
+        if (mTexName == 0)
+        {
+                llwarns << "Setting subimage on image without GL texture" << llendl;
+                return FALSE;
+        }
+        
+        if (x_pos == 0 && y_pos == 0 && width == getWidth() && height == getHeight())
+        {
+                setImage(datap, FALSE);
+        }
+        else
+        {
+                if (mUseMipMaps)
+                {
+                        dump();
+                        llerrs << "setSubImage called with mipmapped image (not supported)" << llendl;
+                }
+                llassert(mCurrentDiscardLevel == 0);
+                if (((x_pos + width) > getWidth()) || 
+                        (y_pos + height) > getHeight())
+                {
+                        dump();
+                        llerrs << "Subimage not wholly in target image!" 
+                                   << " x_pos " << x_pos
+                                   << " y_pos " << y_pos
+                                   << " width " << width
+                                   << " height " << height
+                                   << " getWidth() " << getWidth()
+                                   << " getHeight() " << getHeight()
+                                   << llendl;
+                }
+
+                if ((x_pos + width) > data_width || 
+                        (y_pos + height) > data_height)
+                {
+                        dump();
+                        llerrs << "Subimage not wholly in source image!" 
+                                   << " x_pos " << x_pos
+                                   << " y_pos " << y_pos
+                                   << " width " << width
+                                   << " height " << height
+                                   << " source_width " << data_width
+                                   << " source_height " << data_height
+                                   << llendl;
+                }
+
+
+                glPixelStorei(GL_UNPACK_ROW_LENGTH, data_width);
+                stop_glerror();
+
+                if(mFormatSwapBytes)
+                {
+                        glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
+                        stop_glerror();
+                }
+
+                datap += (y_pos * data_width + x_pos) * getComponents();
+                // Update the GL texture
+                llverify(bindTextureInternal(0));
+                stop_glerror();
+
+                glTexSubImage2D(mTarget, 0, x_pos, y_pos, 
+                                                width, height, mFormatPrimary, mFormatType, datap);
+                stop_glerror();
+
+                if(mFormatSwapBytes)
+                {
+                        glPixelStorei(GL_UNPACK_SWAP_BYTES, 0);
+                        stop_glerror();
+                }
+
+                glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+                stop_glerror();
+        }
+        
+        return TRUE;
+}
+
+BOOL LLImageGL::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height)
+{
+        return setSubImage(imageraw->getData(), imageraw->getWidth(), imageraw->getHeight(), x_pos, y_pos, width, height);
+}
+
+// Copy sub image from frame buffer
+BOOL LLImageGL::setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height)
+{
+        if (bindTextureInternal(0))
+        {
+                glCopyTexSubImage2D(GL_TEXTURE_2D, 0, fb_x, fb_y, x_pos, y_pos, width, height);
+                stop_glerror();
+                return TRUE;
+        }
+        else
+        {
+                return FALSE;
+        }
+}
+
+BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename/*=0*/)
+{
+        if (gGLManager.mIsDisabled)
+        {
+                llwarns << "Trying to create a texture while GL is disabled!" << llendl;
+                return FALSE;
+        }
+        llassert(gGLManager.mInited || gNoRender);
+        stop_glerror();
+
+        if (discard_level < 0)
+        {
+                llassert(mCurrentDiscardLevel >= 0);
+                discard_level = mCurrentDiscardLevel;
+        }
+        discard_level = llclamp(discard_level, 0, (S32)mMaxDiscardLevel);
+
+        // Actual image width/height = raw image width/height * 2^discard_level
+        S32 w = imageraw->getWidth() << discard_level;
+        S32 h = imageraw->getHeight() << discard_level;
+
+        // setSize may call destroyGLTexture if the size does not match
+        setSize(w, h, imageraw->getComponents());
+
+        if( !mHasExplicitFormat )
+        {
+                switch (mComponents)
+                {
+                  case 1:
+                        // Use luminance alpha (for fonts)
+                        mFormatInternal = GL_LUMINANCE8;
+                        mFormatPrimary = GL_LUMINANCE;
+                        mFormatType = GL_UNSIGNED_BYTE;
+                        break;
+                  case 2:
+                        // Use luminance alpha (for fonts)
+                        mFormatInternal = GL_LUMINANCE8_ALPHA8;
+                        mFormatPrimary = GL_LUMINANCE_ALPHA;
+                        mFormatType = GL_UNSIGNED_BYTE;
+                        break;
+                  case 3:
+                        mFormatInternal = GL_RGB8;
+                        mFormatPrimary = GL_RGB;
+                        mFormatType = GL_UNSIGNED_BYTE;
+                        break;
+                  case 4:
+                        mFormatInternal = GL_RGBA8;
+                        mFormatPrimary = GL_RGBA;
+                        mFormatType = GL_UNSIGNED_BYTE;
+                        break;
+                  default:
+                        llerrs << "Bad number of components for texture: " << (U32)getComponents() << llendl;
+                }
+        }
+
+        const U8* rawdata = imageraw->getData();
+        return createGLTexture(discard_level, rawdata, FALSE, usename);
+}
+
+BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_hasmips, S32 usename)
+{
+        llassert(data_in);
+
+        if (discard_level < 0)
+        {
+                llassert(mCurrentDiscardLevel >= 0);
+                discard_level = mCurrentDiscardLevel;
+        }
+        discard_level = llclamp(discard_level, 0, (S32)mMaxDiscardLevel);
+
+        if (mTexName != 0 && discard_level == mCurrentDiscardLevel)
+        {
+                // This will only be true if the size has not changed
+                setImage(data_in, data_hasmips);
+                return TRUE;
+        }
+        
+        GLuint old_name = mTexName;
+//      S32 old_discard = mCurrentDiscardLevel;
+        
+        if (usename != 0)
+        {
+                mTexName = usename;
+        }
+        else
+        {
+                glGenTextures(1, (GLuint*)&mTexName);
+                stop_glerror();
+                {
+//                      LLFastTimer t1(LLFastTimer::FTM_TEMP6);
+                        llverify(bindTextureInternal(0));
+                        glTexParameteri(mBindTarget, GL_TEXTURE_BASE_LEVEL, 0);
+                        glTexParameteri(mBindTarget, GL_TEXTURE_MAX_LEVEL,  mMaxDiscardLevel-discard_level);
+                }
+        }
+        if (!mTexName)
+        {
+                llerrs << "LLImageGL::createGLTexture failed to make texture" << llendl;
+        }
+
+        if (mUseMipMaps)
+        {
+                mAutoGenMips = gGLManager.mHasMipMapGeneration;
+#if LL_DARWIN
+                // On the Mac GF2 and GF4MX drivers, auto mipmap generation doesn't work right with alpha-only textures.
+                if(gGLManager.mIsGF2or4MX && (mFormatInternal == GL_ALPHA8) && (mFormatPrimary == GL_ALPHA))
+                {
+                        mAutoGenMips = FALSE;
+                }
+#endif
+        }
+
+        mCurrentDiscardLevel = discard_level;
+
+        setImage(data_in, data_hasmips);
+
+        setClamp(mClampS, mClampT);
+        setMipFilterNearest(mMipFilterNearest);
+        
+        // things will break if we don't unbind after creation
+        unbindTexture(0, mBindTarget);
+        stop_glerror();
+
+        if (old_name != 0)
+        {
+                sGlobalTextureMemory -= mTextureMemory;
+                glDeleteTextures(1, &old_name);
+                stop_glerror();
+        }
+
+        mTextureMemory = getMipBytes(discard_level);
+        sGlobalTextureMemory += mTextureMemory;
+                
+        // mark this as bound at this point, so we don't throw it out immediately
+        mLastBindTime = sLastFrameTime;
+
+        return TRUE;
+}
+
+BOOL LLImageGL::setDiscardLevel(S32 discard_level)
+{
+        llassert(discard_level >= 0);
+        llassert(mCurrentDiscardLevel >= 0);
+
+        discard_level = llclamp(discard_level, 0, (S32)mMaxDiscardLevel);       
+
+        if (mDontDiscard)
+        {
+                // don't discard!
+                return FALSE;
+        }
+        else if (discard_level == mCurrentDiscardLevel)
+        {
+                // nothing to do
+                return FALSE;
+        }
+        else if (discard_level < mCurrentDiscardLevel)
+        {
+                // larger image
+                dump();
+                llerrs << "LLImageGL::setDiscardLevel() called with larger discard level; use createGLTexture()" << llendl;
+                return FALSE;
+        }
+        else if (mUseMipMaps)
+        {
+                LLPointer<LLImageRaw> imageraw = new LLImageRaw;
+                while(discard_level > mCurrentDiscardLevel)
+                {
+                        if (readBackRaw(discard_level, imageraw))
+                        {
+                                break;
+                        }
+                        discard_level--;
+                }
+                if (discard_level == mCurrentDiscardLevel)
+                {
+                        // unable to increase the discard level
+                        return FALSE;
+                }
+                return createGLTexture(discard_level, imageraw);
+        }
+        else
+        {
+#ifndef LL_LINUX // *FIX: This should not be skipped for the linux client.
+                llerrs << "LLImageGL::setDiscardLevel() called on image without mipmaps" << llendl;
+#endif
+                return FALSE;
+        }
+}
+
+BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw)
+{
+        if (discard_level < 0)
+        {
+                discard_level = mCurrentDiscardLevel;
+        }
+        
+        if (mTexName == 0 || discard_level < mCurrentDiscardLevel)
+        {
+                return FALSE;
+        }
+
+        S32 gl_discard = discard_level - mCurrentDiscardLevel;
+
+        llverify(bindTextureInternal(0));
+        
+        LLGLint glwidth = 0;
+        glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_WIDTH, (GLint*)&glwidth);
+        if (glwidth == 0)
+        {
+                // No mip data smaller than current discard level
+                return FALSE;
+        }
+
+        S32 width = getWidth(discard_level);
+        S32 height = getHeight(discard_level);
+        S32 ncomponents = getComponents();
+        if (ncomponents == 0)
+        {
+                return FALSE;
+        }
+
+        if (width <= 0 || width > 2048 || height <= 0 || height > 2048 || ncomponents < 1 || ncomponents > 4)
+        {
+                llerrs << llformat("LLImageGL::readBackRaw: bogus params: %d x %d x %d",width,height,ncomponents) << llendl;
+        }
+        
+        LLGLint is_compressed = 0;
+        glGetTexLevelParameteriv(mTarget, is_compressed, GL_TEXTURE_COMPRESSED, (GLint*)&is_compressed);
+        if (is_compressed)
+        {
+                LLGLint glbytes;
+                glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, (GLint*)&glbytes);
+                imageraw->allocateDataSize(width, height, ncomponents, glbytes);
+                glGetCompressedTexImageARB(mTarget, gl_discard, (GLvoid*)(imageraw->getData()));
+                stop_glerror();
+        }
+        else
+        {
+                imageraw->allocateDataSize(width, height, ncomponents);
+                glGetTexImage(GL_TEXTURE_2D, gl_discard, mFormatPrimary, mFormatType, (GLvoid*)(imageraw->getData()));
+                stop_glerror();
+        }
+                
+        return TRUE;
+}
+
+void LLImageGL::destroyGLTexture()
+{
+        stop_glerror();
+
+        if (mTexName != 0)
+        {
+                for (int i = 0; i < gGLManager.mNumTextureUnits; i++)
+                {
+                        if (sCurrentBoundTextures[i] == mTexName)
+                        {
+                                unbindTexture(i, GL_TEXTURE_2D);
+                                stop_glerror();
+                        }
+                }
+
+                sGlobalTextureMemory -= mTextureMemory;
+                mTextureMemory = 0;
+
+                glDeleteTextures(1, (GLuint*)&mTexName);
+                mTexName = 0;
+
+                stop_glerror();
+        }
+}
+
+//----------------------------------------------------------------------------
+
+void LLImageGL::setClamp(BOOL clamps, BOOL clampt)
+{
+        mClampS = clamps;
+        mClampT = clampt;
+        if (mTexName != 0)
+        {
+                glTexParameteri(mBindTarget, GL_TEXTURE_WRAP_S, clamps ? GL_CLAMP_TO_EDGE : GL_REPEAT);
+                glTexParameteri(mBindTarget, GL_TEXTURE_WRAP_T, clampt ? GL_CLAMP_TO_EDGE : GL_REPEAT);
+        }
+        stop_glerror();
+}
+
+void LLImageGL::setMipFilterNearest(BOOL nearest, BOOL min_nearest)
+{
+        mMipFilterNearest = nearest;
+
+        if (mTexName != 0)
+        {
+                if (min_nearest)
+                {
+                        glTexParameteri(mBindTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+                }
+                else if (mHasMipMaps)
+                {
+                        glTexParameteri(mBindTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+                }
+                else
+                {
+                        glTexParameteri(mBindTarget, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+                }
+                if (mMipFilterNearest)
+                {
+                        glTexParameteri(mBindTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+                }
+                else 
+                {
+                        glTexParameteri(mBindTarget, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+                }
+                if (gGLManager.mHasAnisotropic)
+                {
+                        if (sGlobalUseAnisotropic && !mMipFilterNearest)
+                        {
+                                F32 largest_anisotropy;
+                                glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &largest_anisotropy);
+                                glTexParameterf(mBindTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT, largest_anisotropy);
+                        }
+                        else
+                        {
+                                glTexParameterf(mBindTarget, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.f);
+                        }
+                }
+        }
+        
+        stop_glerror();
+}
+
+BOOL LLImageGL::getIsResident(BOOL test_now)
+{
+        if (test_now)
+        {
+                if (mTexName != 0)
+                {
+                        glAreTexturesResident(1, (GLuint*)&mTexName, &mIsResident);
+                }
+                else
+                {
+                        mIsResident = FALSE;
+                }
+        }
+
+        return mIsResident;
+}
+
+S32 LLImageGL::getHeight(S32 discard_level) const
+{
+        if (discard_level < 0)
+        {
+                discard_level = mCurrentDiscardLevel;
+        }
+        S32 height = mHeight >> discard_level;
+        if (height < 1) height = 1;
+        return height;
+}
+
+S32 LLImageGL::getWidth(S32 discard_level) const
+{
+        if (discard_level < 0)
+        {
+                discard_level = mCurrentDiscardLevel;
+        }
+        S32 width = mWidth >> discard_level;
+        if (width < 1) width = 1;
+        return width;
+}
+
+S32 LLImageGL::getBytes(S32 discard_level) const
+{
+        if (discard_level < 0)
+        {
+                discard_level = mCurrentDiscardLevel;
+        }
+        S32 w = mWidth>>discard_level;
+        S32 h = mHeight>>discard_level;
+        if (w == 0) w = 1;
+        if (h == 0) h = 1;
+        return dataFormatBytes(mFormatPrimary, w, h);
+}
+
+S32 LLImageGL::getMipBytes(S32 discard_level) const
+{
+        if (discard_level < 0)
+        {
+                discard_level = mCurrentDiscardLevel;
+        }
+        S32 w = mWidth>>discard_level;
+        S32 h = mHeight>>discard_level;
+        S32 res = dataFormatBytes(mFormatPrimary, w, h);
+        if (mUseMipMaps)
+        {
+                while (w > 1 && h > 1)
+                {
+                        w >>= 1; if (w == 0) w = 1;
+                        h >>= 1; if (h == 0) h = 1;
+                        res += dataFormatBytes(mFormatPrimary, w, h);
+                }
+        }
+        return res;
+}
+
+BOOL LLImageGL::getBoundRecently() const
+{
+        return (BOOL)(sLastFrameTime - mLastBindTime < MIN_TEXTURE_LIFETIME);
+}
+
+void LLImageGL::setTarget(const LLGLenum target, const LLGLenum bind_target)
+{
+        mTarget = target;
+        mBindTarget = bind_target;
+}
+
+//----------------------------------------------------------------------------
+
+// Manual Mip Generation
+/*
+                S32 width = getWidth(discard_level);
+                S32 height = getHeight(discard_level);
+                S32 w = width, h = height;
+                S32 nummips = 1;
+                while (w > 4 && h > 4)
+                {
+                        w >>= 1; h >>= 1;
+                        nummips++;
+                }
+                stop_glerror();
+                w = width, h = height;
+                const U8* prev_mip_data = 0;
+                const U8* cur_mip_data = 0;
+                for (int m=0; m<nummips; m++)
+                {
+                        if (m==0)
+                        {
+                                cur_mip_data = rawdata;
+                        }
+                        else
+                        {
+                                S32 bytes = w * h * mComponents;
+                                U8* new_data = new U8[bytes];
+                                LLImageBase::generateMip(prev_mip_data, new_data, w, h, mComponents);
+                                cur_mip_data = new_data;
+                        }
+                        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);
+                                stop_glerror();
+                        }
+                        if (prev_mip_data && prev_mip_data != rawdata)
+                        {
+                                delete prev_mip_data;
+                        }
+                        prev_mip_data = cur_mip_data;
+                        w >>= 1;
+                        h >>= 1;
+                }
+                if (prev_mip_data && prev_mip_data != rawdata)
+                {
+                        delete prev_mip_data;
+                }
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
+                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL,  nummips);
+*/  
diff --git a/linden/indra/llrender/llimagegl.h b/linden/indra/llrender/llimagegl.h
new file mode 100644
index 0000000..6356703
--- /dev/null
+++ b/linden/indra/llrender/llimagegl.h
@@ -0,0 +1,204 @@
+/** 
+ * @file llimagegl.h
+ * @brief Object for managing images and their textures
+ *
+ * Copyright (c) 2001-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+
+#ifndef LL_LLIMAGEGL_H
+#define LL_LLIMAGEGL_H
+
+#include "llimage.h"
+
+#include "llgltypes.h"
+#include "llmemory.h"
+
+//============================================================================
+
+class LLImageGL : public LLThreadSafeRefCount
+{
+public:
+        // Size calculation
+        static S32 dataFormatBits(S32 dataformat);
+        static S32 dataFormatBytes(S32 dataformat, S32 width, S32 height);
+        static S32 dataFormatComponents(S32 dataformat);
+
+        // Wrapper for glBindTexture that keeps LLImageGL in sync.
+        // Usually you want stage = 0 and bind_target = GL_TEXTURE_2D
+        static void bindExternalTexture( LLGLuint gl_name, S32 stage, LLGLenum bind_target);
+        static void unbindTexture(S32 stage, LLGLenum target);
+
+        // needs to be called every frame
+        static void updateStats(F32 current_time);
+
+        // Save off / restore GL textures
+        static void destroyGL(BOOL save_state = TRUE);
+        static void restoreGL();
+
+        // Sometimes called externally for textures not using LLImageGL (should go away...)
+        static S32 updateBoundTexMem(const S32 delta);
+
+        static bool checkSize(S32 width, S32 height);
+        
+        // Not currently necessary for LLImageGL, but required in some derived classes,
+        // so include for compatability
+        static BOOL create(LLPointer<LLImageGL>& dest, BOOL usemipmaps = TRUE);
+        static BOOL create(LLPointer<LLImageGL>& dest, U32 width, U32 height, U8 components, BOOL usemipmaps = TRUE);
+        static BOOL create(LLPointer<LLImageGL>& dest, const LLImageRaw* imageraw, BOOL usemipmaps = TRUE);
+        
+public:
+        LLImageGL(BOOL usemipmaps = TRUE);
+        LLImageGL(U32 width, U32 height, U8 components, BOOL usemipmaps = TRUE);
+        LLImageGL(const LLImageRaw* imageraw, BOOL usemipmaps = TRUE);
+        
+protected:
+        virtual ~LLImageGL();
+        BOOL bindTextureInternal(const S32 stage = 0) const;
+
+public:
+        virtual void dump();    // debugging info to llinfos
+        virtual BOOL bind(const S32 stage = 0) const;
+
+        void setSize(S32 width, S32 height, S32 ncomponents);
+
+        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);
+        void setImage(const LLImageRaw* imageraw);
+        void setImage(const U8* data_in, BOOL data_hasmips = FALSE);
+        BOOL setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height);
+        BOOL setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height);
+        BOOL setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height);
+        BOOL setDiscardLevel(S32 discard_level);
+        BOOL readBackRaw(S32 discard_level, LLImageRaw* imageraw); // Read back a raw image for this discard level, if it exists
+        void destroyGLTexture();
+        
+        void setClamp(BOOL clamps, BOOL clampt);
+        void setMipFilterNearest(BOOL 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; }
+
+        S32      getDiscardLevel() const                { return mCurrentDiscardLevel; }
+        S32      getMaxDiscardLevel() const             { return mMaxDiscardLevel; }
+
+        S32      getWidth(S32 discard_level = -1) const;
+        S32      getHeight(S32 discard_level = -1) const;
+        U8       getComponents() const { return mComponents; }
+        S32  getBytes(S32 discard_level = -1) const;
+        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 getMipFilterNearest() const { return mMipFilterNearest; }
+        
+        BOOL getHasGLTexture() const { return mTexName != 0; }
+        LLGLuint getTexName() const { return mTexName; }
+
+        BOOL getIsResident(BOOL test_now = FALSE); // not const
+
+        void setTarget(const LLGLenum target, const LLGLenum bind_target);
+
+        BOOL getUseMipMaps() const { return mUseMipMaps; }
+        void setUseMipMaps(BOOL usemips) { mUseMipMaps = usemips; }
+        BOOL getUseDiscard() const { return mUseMipMaps && !mDontDiscard; }
+        BOOL getDontDiscard() const { return mDontDiscard; }
+
+protected:
+        void init(BOOL usemipmaps);
+        virtual void cleanup(); // Clean up the LLImageGL so it can be reinitialized.  Be careful when using this in derived class destructors
+
+public:
+        // Various GL/Rendering options
+        S32 mTextureMemory;
+        mutable F32  mLastBindTime;     // last time this was bound, by discard level
+        mutable F32  mLastBindAttempt;  // last time bindTexture was called on this texture
+
+private:
+        LLPointer<LLImageRaw> mSaveData; // used for destroyGL/restoreGL
+        S8 mUseMipMaps;
+        S8 mHasMipMaps;
+        S8 mHasExplicitFormat; // If false (default), GL format is f(mComponents)
+        S8 mAutoGenMips;
+        
+protected:
+        LLGLenum mTarget;               // Normally GL_TEXTURE2D, sometimes something else (ex. cube maps)
+        LLGLenum mBindTarget;   // NOrmally GL_TEXTURE2D, sometimes something else (ex. cube maps)
+
+        LLGLuint mTexName;
+
+        LLGLboolean mIsResident;
+
+        U16 mWidth;
+        U16 mHeight;
+        
+        S8 mComponents;
+        S8 mMaxDiscardLevel;
+        S8 mCurrentDiscardLevel;
+        S8 mDontDiscard;                        // Keep full res version of this image (for UI, etc)
+
+        S8 mClampS;                                     // Need to save clamp state
+        S8 mClampT;
+        S8 mMipFilterNearest;           // if TRUE, set magfilter to GL_NEAREST
+        
+        LLGLint  mFormatInternal; // = GL internalformat
+        LLGLenum mFormatPrimary;  // = GL format (pixel data format)
+        LLGLenum mFormatType;
+        BOOL     mFormatSwapBytes;// if true, use glPixelStorei(GL_UNPACK_SWAP_BYTES, 1)
+
+        // STATICS
+public: 
+        static std::set<LLImageGL*> sImageList;
+        static S32 sCount;
+        
+        static F32 sLastFrameTime;
+
+        static LLGLuint sCurrentBoundTextures[MAX_GL_TEXTURE_UNITS]; // Currently bound texture ID
+
+        // Global memory statistics
+        static S32 sGlobalTextureMemory;                // Tracks main memory texmem
+        static S32 sBoundTextureMemory;                 // Tracks bound texmem for last completed frame
+        static S32 sCurBoundTextureMemory;              // Tracks bound texmem for current frame
+
+        static BOOL sGlobalUseAnisotropic;
+
+#if DEBUG_MISS
+        BOOL mMissed; // Missed on last bind?
+        BOOL getMissed() const { return mMissed; };
+#else
+        BOOL getMissed() const { return FALSE; };
+#endif
+};
+
+//RN: maybe this needs to moved elsewhere?
+class LLImageProviderInterface
+{
+public:
+        LLImageProviderInterface() {};
+        virtual ~LLImageProviderInterface() {};
+
+        virtual LLImageGL* getUIImageByID(const LLUUID& id, BOOL clamped = TRUE) = 0;
+};
+
+#endif // LL_LLIMAGEGL_H
diff --git a/linden/indra/llrender/llrender.vcproj b/linden/indra/llrender/llrender.vcproj
new file mode 100644
index 0000000..9ca9b03
--- /dev/null
+++ b/linden/indra/llrender/llrender.vcproj
@@ -0,0 +1,230 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+        ProjectType="Visual C++"
+        Version="7.10"
+        Name="llrender"
+        ProjectGUID="{2ADE3C14-94C4-40BF-B033-70F3C954EE90}"
+        Keyword="Win32Proj">
+        <Platforms>
+                <Platform
+                        Name="Win32"/>
+        </Platforms>
+        <Configurations>
+                <Configuration
+                        Name="Debug|Win32"
+                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
+                        IntermediateDirectory="Debug"
+                        ConfigurationType="4"
+                        CharacterSet="1">
+                        <Tool
+                                Name="VCCLCompilerTool"
+                                Optimization="0"
+                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\llimage;..\llwindow;..\..\libraries\i686-win32\include;..\..\libraries\include\"
+                                PreprocessorDefinitions="WIN32;_DEBUG;_LIB;LL_WINDOWS;LL_DEBUG"
+                                MinimalRebuild="TRUE"
+                                BasicRuntimeChecks="3"
+                                RuntimeLibrary="1"
+                                StructMemberAlignment="4"
+                                ForceConformanceInForLoopScope="TRUE"
+                                UsePrecompiledHeader="0"
+                                WarningLevel="3"
+                                WarnAsError="TRUE"
+                                Detect64BitPortabilityProblems="FALSE"
+                                DebugInformationFormat="4"/>
+                        <Tool
+                                Name="VCCustomBuildTool"/>
+                        <Tool
+                                Name="VCLibrarianTool"
+                                OutputFile="$(OutDir)/llrender.lib"/>
+                        <Tool
+                                Name="VCMIDLTool"/>
+                        <Tool
+                                Name="VCPostBuildEventTool"/>
+                        <Tool
+                                Name="VCPreBuildEventTool"/>
+                        <Tool
+                                Name="VCPreLinkEventTool"/>
+                        <Tool
+                                Name="VCResourceCompilerTool"/>
+                        <Tool
+                                Name="VCWebServiceProxyGeneratorTool"/>
+                        <Tool
+                                Name="VCXMLDataGeneratorTool"/>
+                        <Tool
+                                Name="VCManagedWrapperGeneratorTool"/>
+                        <Tool
+                                Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+                </Configuration>
+                <Configuration
+                        Name="Release|Win32"
+                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
+                        IntermediateDirectory="Release"
+                        ConfigurationType="4"
+                        CharacterSet="1">
+                        <Tool
+                                Name="VCCLCompilerTool"
+                                GlobalOptimizations="TRUE"
+                                InlineFunctionExpansion="2"
+                                EnableIntrinsicFunctions="TRUE"
+                                OptimizeForProcessor="3"
+                                OptimizeForWindowsApplication="TRUE"
+                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\llimage;..\llwindow;..\..\libraries\i686-win32\include;..\..\libraries\include\"
+                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;LL_WINDOWS;LL_RELEASE"
+                                RuntimeLibrary="0"
+                                StructMemberAlignment="0"
+                                ForceConformanceInForLoopScope="TRUE"
+                                UsePrecompiledHeader="0"
+                                WarningLevel="3"
+                                WarnAsError="TRUE"
+                                Detect64BitPortabilityProblems="FALSE"
+                                DebugInformationFormat="3"/>
+                        <Tool
+                                Name="VCCustomBuildTool"/>
+                        <Tool
+                                Name="VCLibrarianTool"
+                                OutputFile="$(OutDir)/llrender.lib"/>
+                        <Tool
+                                Name="VCMIDLTool"/>
+                        <Tool
+                                Name="VCPostBuildEventTool"/>
+                        <Tool
+                                Name="VCPreBuildEventTool"/>
+                        <Tool
+                                Name="VCPreLinkEventTool"/>
+                        <Tool
+                                Name="VCResourceCompilerTool"/>
+                        <Tool
+                                Name="VCWebServiceProxyGeneratorTool"/>
+                        <Tool
+                                Name="VCXMLDataGeneratorTool"/>
+                        <Tool
+                                Name="VCManagedWrapperGeneratorTool"/>
+                        <Tool
+                                Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+                </Configuration>
+                <Configuration
+                        Name="ReleaseNoOpt|Win32"
+                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
+                        IntermediateDirectory="$(ConfigurationName)"
+                        ConfigurationType="4"
+                        CharacterSet="1">
+                        <Tool
+                                Name="VCCLCompilerTool"
+                                Optimization="0"
+                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\llimage;..\llwindow;..\..\libraries\i686-win32\include;..\..\libraries\include\"
+                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;LL_WINDOWS;LL_RELEASE"
+                                RuntimeLibrary="0"
+                                StructMemberAlignment="0"
+                                ForceConformanceInForLoopScope="TRUE"
+                                UsePrecompiledHeader="0"
+                                WarningLevel="3"
+                                WarnAsError="TRUE"
+                                Detect64BitPortabilityProblems="FALSE"
+                                DebugInformationFormat="3"/>
+                        <Tool
+                                Name="VCCustomBuildTool"/>
+                        <Tool
+                                Name="VCLibrarianTool"
+                                OutputFile="$(OutDir)/llrender.lib"/>
+                        <Tool
+                                Name="VCMIDLTool"/>
+                        <Tool
+                                Name="VCPostBuildEventTool"/>
+                        <Tool
+                                Name="VCPreBuildEventTool"/>
+                        <Tool
+                                Name="VCPreLinkEventTool"/>
+                        <Tool
+                                Name="VCResourceCompilerTool"/>
+                        <Tool
+                                Name="VCWebServiceProxyGeneratorTool"/>
+                        <Tool
+                                Name="VCXMLDataGeneratorTool"/>
+                        <Tool
+                                Name="VCManagedWrapperGeneratorTool"/>
+                        <Tool
+                                Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+                </Configuration>
+        </Configurations>
+        <References>
+        </References>
+        <Files>
+                <Filter
+                        Name="Source Files"
+                        Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+                        UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+                        <File
+                                RelativePath=".\llagpmempool.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\llagpmempoolarb.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\llagpmempoolati.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\llagpmempoolnv.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\llfont.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\llfontgl.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\llgldbg.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\llimagegl.cpp">
+                        </File>
+                        <File
+                                RelativePath=".\text_out.cpp">
+                        </File>
+                </Filter>
+                <Filter
+                        Name="Header Files"
+                        Filter="h;hpp;hxx;hm;inl;inc;xsd"
+                        UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+                        <File
+                                RelativePath=".\glext.h">
+                        </File>
+                        <File
+                                RelativePath=".\llagpmempool.h">
+                        </File>
+                        <File
+                                RelativePath=".\llagpmempoolarb.h">
+                        </File>
+                        <File
+                                RelativePath=".\llagpmempoolati.h">
+                        </File>
+                        <File
+                                RelativePath=".\llagpmempoolnv.h">
+                        </File>
+                        <File
+                                RelativePath=".\llfont.h">
+                        </File>
+                        <File
+                                RelativePath=".\llfontgl.h">
+                        </File>
+                        <File
+                                RelativePath=".\llgldbg.h">
+                        </File>
+                        <File
+                                RelativePath=".\llimagegl.h">
+                        </File>
+                        <File
+                                RelativePath=".\llvertexprogramgl.h">
+                        </File>
+                        <File
+                                RelativePath=".\text_out.h">
+                        </File>
+                </Filter>
+                <Filter
+                        Name="Resource Files"
+                        Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
+                        UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}">
+                </Filter>
+        </Files>
+        <Globals>
+        </Globals>
+</VisualStudioProject>
diff --git a/linden/indra/llrender/llvertexprogramgl.cpp b/linden/indra/llrender/llvertexprogramgl.cpp
new file mode 100644
index 0000000..bc00a64
--- /dev/null
+++ b/linden/indra/llrender/llvertexprogramgl.cpp
@@ -0,0 +1,121 @@
+/** 
+ * @file llvertexprogramgl.cpp
+ * @brief LLVertexProgramGL base class
+ *
+ * Copyright (c) 2003-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+// This file contains the definition of LLVertexProgramGL, 
+// for purposes of running vertex programs on GL hardware.
+
+#include "linden_common.h"
+
+#include "llvertexprogramgl.h"
+
+#include "llglheaders.h"
+
+LLVertexProgramGL::LLVertexProgramGL()
+{
+        mVertexProgramID = 0;
+}
+
+LLVertexProgramGL::~LLVertexProgramGL()
+{
+        glDeleteProgramsARB(1, (GLuint*) &mVertexProgramID);
+}
+
+BOOL LLVertexProgramGL::load(const char * filename)
+{
+        FILE *fp = fopen(filename, "r");
+        if (!fp)
+        {
+                llwarns << "Unable to open vertex program " << filename << llendl;
+                return FALSE;
+        }
+
+        fseek(fp,0,SEEK_END);
+        S32 file_size = ftell(fp);
+        fseek(fp,0,SEEK_SET);
+
+        char *text_buffer = new char[file_size + 1];
+
+        S32 num_read = (S32)fread(text_buffer, sizeof(char), file_size, fp);
+
+        if (ferror(fp) || num_read == 0)
+        {
+                llwarns << "Unable to read vertex program " << filename << llendl;
+                fclose(fp);
+                delete[] text_buffer;
+                return FALSE;
+        }
+        text_buffer[num_read] = '\0';
+        fclose(fp);
+
+        //Send program string to OpenGL
+        glGenProgramsARB(1, (GLuint*) &mVertexProgramID);
+        glBindProgramARB(GL_VERTEX_PROGRAM_ARB, mVertexProgramID);
+        glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, num_read, text_buffer);
+
+        const GLubyte * program_error_string = glGetString(GL_PROGRAM_ERROR_STRING_ARB);
+
+        GLint error_pos;
+        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_pos);
+
+        if(error_pos!=-1)
+        {
+                glGetError();
+                S32 line_num = 1;
+                char *next_token = strchr(text_buffer, '\n');
+                while(NULL != next_token && next_token < (text_buffer + error_pos))
+                {
+                        next_token++;
+                        line_num++;
+                        next_token = strchr(next_token, '\n');
+                } 
+                char output[1024];
+                char bad_code[11];
+                strncpy(bad_code, text_buffer + error_pos, 10);
+                bad_code[10] = '\0';
+
+                sprintf(output, "%s(%d): Vertex Program Error: %s at (%s)\n", filename, line_num, program_error_string, bad_code);
+                gErrorStream << output << std::endl;
+                // clean up buffer
+                delete[] text_buffer;
+                return FALSE;
+        }
+
+        // clean up buffer
+        delete[] text_buffer;
+        return TRUE;
+}
+
+void LLVertexProgramGL::bind()
+{
+        glEnable(GL_VERTEX_PROGRAM_ARB);
+        glBindProgramARB(GL_VERTEX_PROGRAM_ARB, mVertexProgramID);
+}
+
+void LLVertexProgramGL::unbind()
+{
+        glDisable(GL_VERTEX_PROGRAM_ARB);
+}
diff --git a/linden/indra/llrender/llvertexprogramgl.h b/linden/indra/llrender/llvertexprogramgl.h
new file mode 100644
index 0000000..78cb1c9
--- /dev/null
+++ b/linden/indra/llrender/llvertexprogramgl.h
@@ -0,0 +1,51 @@
+/** 
+ * @file llvertexprogramgl.h
+ * @brief LLVertexProgramGL base class
+ *
+ * Copyright (c) 2003-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_LLVERTEXPROGRAMGL_H
+#define LL_LLVERTEXPROGRAMGL_H
+
+// This file contains the definition of LLVertexProgramGL, 
+// for purposes of running vertex programs on GL hardware.
+
+#include "llgl.h"
+
+class LLVertexProgramGL
+{
+public:
+        LLVertexProgramGL();
+        ~LLVertexProgramGL();
+
+        void bind();
+        void unbind();
+
+        BOOL load(const char * filename);
+
+private:
+        LLGLuint mVertexProgramID;
+};
+
+#endif // LL_LLVERTEXPROGRAMGL_H
diff --git a/linden/indra/llrender/text_out.cpp b/linden/indra/llrender/text_out.cpp
new file mode 100644
index 0000000..f4892b2
--- /dev/null
+++ b/linden/indra/llrender/text_out.cpp
@@ -0,0 +1,115 @@
+/** 
+ * @file text_out.cpp
+ * @brief Text rendering implementation
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+/* DEPRECATED - Use LLFontGL for raw rendering, or make an LLTextBox to hold the text */
+
+#include "linden_common.h"
+
+#include "text_out.h"
+#include "llfontgl.h"
+//#include "vmath.h"
+#include "v4color.h"
+
+#define MAX_TEXT_LINE_LENGTH    (256)
+#define MAX_TEXT_LINES                  (128)
+
+extern S32 gWindowWidth;
+extern S32 gWindowHeight;
+
+S32 gNumTextLines = 0;
+
+LLColor4 gCurrentColor;
+//U8    gCurrentBGColor[] = { 32, 32, 32 };
+
+//F32 gCurrentScale = 10.f;
+
+typedef struct s_text_line
+{
+//      const LLFontGL  *font;
+//      U8              color[3];
+//      U8              bg_color[3];
+        char    line[MAX_TEXT_LINE_LENGTH];
+        S32             x, y;
+//      ETextModifiers  tm;
+//      ETextColorModifiers fcm;
+//      ETextColorModifiers bcm;
+} TEXT_LINE;
+
+TEXT_LINE       gTextLine[MAX_TEXT_LINES];
+
+void set_text_color( const LLColor4& color )
+{
+        gCurrentColor = color;
+}
+/*
+void set_text_bg_color(S32 red, S32 green, S32 blue)
+{
+        gCurrentBGColor[0] = red;
+        gCurrentBGColor[1] = green;
+        gCurrentBGColor[2] = blue;
+}
+*/
+void reset_num_text_lines(void)
+{
+        gNumTextLines = 0;
+}
+
+void add_text(S32 x, S32 y, char *text) // , ETextModifiers tm, ETextColorModifiers fcm, ETextColorModifiers bcm)
+{
+        if (gNumTextLines > MAX_TEXT_LINES) return;
+
+        TEXT_LINE *linep = &gTextLine[gNumTextLines++]; 
+
+        strcpy(linep->line, text);
+        linep->x = x;
+        linep->y = y;
+}
+
+
+// Writes text on the screen.  Deprecated, don't write new code using this.
+void show_text_gl(void)
+{
+        S32 i;
+
+        TEXT_LINE *linep;
+
+        if (gNumTextLines > MAX_TEXT_LINES)
+        {
+                gNumTextLines = MAX_TEXT_LINES;
+        }
+
+        for (i = 0; i < gNumTextLines; i++)
+        {
+                linep = &gTextLine[i];
+
+                LLFontGL::sMonospace->renderUTF8(linep->line, 0, (F32)linep->x, (F32)linep->y, gCurrentColor,
+                                                                                 LLFontGL::LEFT, LLFontGL::TOP,
+                                                                                 LLFontGL::NORMAL, S32_MAX, S32_MAX, NULL, FALSE);
+        }
+        gNumTextLines = 0;
+}
+
diff --git a/linden/indra/llrender/text_out.h b/linden/indra/llrender/text_out.h
new file mode 100644
index 0000000..5080bd5
--- /dev/null
+++ b/linden/indra/llrender/text_out.h
@@ -0,0 +1,40 @@
+/** 
+ * @file text_out.h
+ * @brief Text rendering implementation
+ *
+ * Copyright (c) 2000-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_TEXT_OUT_H
+#define LL_TEXT_OUT_H
+
+// DEPRECATED - Use LLFontGL for raw rendering, or make an LLTextBox to hold the text
+
+class LLColor4;
+
+void set_text_color(const LLColor4& color);
+void add_text(S32 x, S32 y, char *text);
+void show_text_gl(void);
+void reset_num_text_lines(void);
+
+#endif