Second Life viewer sources 1.21.0-RC

33 files changed, 6873 insertions, 984 deletions

diff --git a/linden/indra/llrender/CMakeLists.txt b/linden/indra/llrender/CMakeLists.txt
new file mode 100644
index 0000000..76858d9
--- /dev/null
+++ b/linden/indra/llrender/CMakeLists.txt
@@ -0,0 +1,83 @@
+# -*- cmake -*-
+
+project(llrender)
+
+include(00-Common)
+include(FreeType)
+include(LLCommon)
+include(LLImage)
+include(LLMath)
+include(LLRender)
+include(LLWindow)
+
+include_directories(
+    ${FREETYPE_INCLUDE_DIRS}
+    ${LLCOMMON_INCLUDE_DIRS}
+    ${LLIMAGE_INCLUDE_DIRS}
+    ${LLMATH_INCLUDE_DIRS}
+    ${LLRENDER_INCLUDE_DIRS}
+    ${LLWINDOW_INCLUDE_DIRS}
+    )
+
+set(llrender_SOURCE_FILES
+    llcubemap.cpp
+    llfont.cpp
+    llfontgl.cpp
+    llgldbg.cpp
+    llglslshader.cpp
+    llimagegl.cpp
+    llpostprocess.cpp
+    llrender.cpp
+    llrendersphere.cpp
+    llrendertarget.cpp
+    llshadermgr.cpp
+    llvertexbuffer.cpp
+    )
+    
+set(llrender_HEADER_FILES
+    CMakeLists.txt
+
+    llcubemap.h
+    llfontgl.h
+    llfont.h
+    llgl.h
+    llgldbg.h
+    llglheaders.h
+    llglslshader.h
+    llglstates.h
+    llgltypes.h
+    llimagegl.h
+    llpostprocess.h
+    llrender.h
+    llrendersphere.h
+    llrendertarget.h
+    llshadermgr.h
+    llvertexbuffer.h
+    )
+
+set_source_files_properties(${llrender_HEADER_FILES}
+                            PROPERTIES HEADER_FILE_ONLY TRUE)
+
+list(APPEND llrender_SOURCE_FILES ${llrender_HEADER_FILES})
+
+if (SERVER AND NOT WINDOWS AND NOT DARWIN)
+  copy_server_sources(
+      llgl
+      )
+
+
+  set_source_files_properties(
+    ${server_SOURCE_FILES}
+    PROPERTIES
+    COMPILE_FLAGS "-DLL_MESA=1 -DLL_MESA_HEADLESS=1"
+    )
+  add_library (llrenderheadless
+    ${llrender_SOURCE_FILES}
+    ${server_SOURCE_FILES}
+    )
+else (SERVER AND NOT WINDOWS AND NOT DARWIN)
+  list(APPEND llrender_SOURCE_FILES
+      llgl.cpp
+      )
+endif (SERVER AND NOT WINDOWS AND NOT DARWIN)
+add_library (llrender ${llrender_SOURCE_FILES})
diff --git a/linden/indra/llrender/files.darwin.lst b/linden/indra/llrender/files.darwin.lst
deleted file mode 100644
index 2d27570..0000000
--- a/linden/indra/llrender/files.darwin.lst
+++ /dev/null
@@ -1 +0,0 @@
-llrender/llagpmempoolapple.cpp
diff --git a/linden/indra/llrender/files.lst b/linden/indra/llrender/files.lst
deleted file mode 100644
index 5dc9579..0000000
--- a/linden/indra/llrender/files.lst
+++ /dev/null
@@ -1,7 +0,0 @@
-llrender/llfont.cpp
-llrender/llfontgl.cpp
-llrender/llgldbg.cpp
-llrender/llrender.cpp
-llrender/llimagegl.cpp
-llrender/llrendertarget.cpp
-llrender/llvertexbuffer.cpp
diff --git a/linden/indra/llrender/llcubemap.cpp b/linden/indra/llrender/llcubemap.cpp
new file mode 100644
index 0000000..563d616
--- /dev/null
+++ b/linden/indra/llrender/llcubemap.cpp
@@ -0,0 +1,532 @@
+/** 
+ * @file llcubemap.cpp
+ * @brief LLCubeMap class implementation
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+#include "linden_common.h"
+
+#include "llworkerthread.h"
+
+#include "llcubemap.h"
+
+#include "v4coloru.h"
+#include "v3math.h"
+#include "v3dmath.h"
+#include "m3math.h"
+#include "m4math.h"
+#include "llcamera.h"
+
+#include "llrender.h"
+
+#include "llglheaders.h"
+
+const F32 epsilon = 1e-7f;
+const U16 RESOLUTION = 64;
+
+#if LL_DARWIN
+// mipmap generation on cubemap textures seems to be broken on the Mac for at least some cards.
+// Since the cubemap is small (64x64 per face) and doesn't have any fine detail, turning off mipmaps is a usable workaround.
+const BOOL use_cube_mipmaps = FALSE;
+#else
+const BOOL use_cube_mipmaps = FALSE;  //current build works best without cube mipmaps
+#endif
+
+bool LLCubeMap::sUseCubeMaps = true;
+
+LLCubeMap::LLCubeMap()
+        : mTextureStage(0),
+          mTextureCoordStage(0),
+          mMatrixStage(0)
+{
+}
+
+LLCubeMap::~LLCubeMap()
+{
+}
+
+void LLCubeMap::initGL()
+{
+        llassert(gGLManager.mInited);
+
+        if (gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps)
+        {
+                mTargets[0] = GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB;
+                mTargets[1] = GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB;
+                mTargets[2] = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB;
+                mTargets[3] = GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB;
+                mTargets[4] = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB;
+                mTargets[5] = GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB;
+                
+                // Not initialized, do stuff.
+                if (mImages[0].isNull())
+                {
+                        GLuint texname = 0;
+                        
+                        glGenTextures(1, &texname);
+
+                        for (int i = 0; i < 6; i++)
+                        {
+                                mImages[i] = new LLImageGL(64, 64, 4, (use_cube_mipmaps? TRUE : FALSE));
+                                mImages[i]->setTarget(mTargets[i], GL_TEXTURE_CUBE_MAP_ARB);
+                                mRawImages[i] = new LLImageRaw(64, 64, 4);
+                                mImages[i]->createGLTexture(0, mRawImages[i], texname);
+                                
+                                glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, texname);
+                                mImages[i]->setClampCubemap (TRUE, TRUE, TRUE);
+                                stop_glerror();
+                        }
+                }
+                disable();
+        }
+        else
+        {
+                llwarns << "Using cube map without extension!" << llendl
+        }
+}
+
+void LLCubeMap::initRawData(const std::vector<LLPointer<LLImageRaw> >& rawimages)
+{
+        bool flip_x[6] =        { false, true,  false, false, true,  false };
+        bool flip_y[6] =        { true,  true,  true,  false, true,  true  };
+        bool transpose[6] = { false, false, false, false, true,  true  };
+        
+        // Yes, I know that this is inefficient! - djs 08/08/02
+        for (int i = 0; i < 6; i++)
+        {
+                const U8 *sd = rawimages[i]->getData();
+                U8 *td = mRawImages[i]->getData();
+
+                S32 offset = 0;
+                S32 sx, sy, so;
+                for (int y = 0; y < 64; y++)
+                {
+                        for (int x = 0; x < 64; x++)
+                        {
+                                sx = x;
+                                sy = y;
+                                if (flip_y[i])
+                                {
+                                        sy = 63 - y;
+                                }
+                                if (flip_x[i])
+                                {
+                                        sx = 63 - x;
+                                }
+                                if (transpose[i])
+                                {
+                                        S32 temp = sx;
+                                        sx = sy;
+                                        sy = temp;
+                                }
+
+                                so = 64*sy + sx;
+                                so *= 4;
+                                *(td + offset++) = *(sd + so++);
+                                *(td + offset++) = *(sd + so++);
+                                *(td + offset++) = *(sd + so++);
+                                *(td + offset++) = *(sd + so++);
+                        }
+                }
+        }
+}
+
+void LLCubeMap::initGLData()
+{
+        for (int i = 0; i < 6; i++)
+        {
+                mImages[i]->setSubImage(mRawImages[i], 0, 0, 64, 64);
+        }
+}
+
+void LLCubeMap::init(const std::vector<LLPointer<LLImageRaw> >& rawimages)
+{
+        if (!gGLManager.mIsDisabled)
+        {
+                initGL();
+                initRawData(rawimages);
+                initGLData();
+        }
+}
+
+GLuint LLCubeMap::getGLName()
+{
+        return mImages[0]->getTexName();
+}
+
+void LLCubeMap::bind()
+{
+        if (gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps)
+        {
+                // We assume that if they have cube mapping, they have multitexturing.
+                if (mTextureStage > 0)
+                {
+                        gGL.getTexUnit(mTextureStage)->activate();
+                }
+                glEnable(GL_TEXTURE_CUBE_MAP_ARB);
+                glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, mImages[0]->getTexName());
+
+                mImages[0]->setMipFilterNearest (FALSE, FALSE);
+                if (mTextureStage > 0)
+                {
+                        gGL.getTexUnit(0)->activate();
+                }
+        }
+        else
+        {
+                llwarns << "Using cube map without extension!" << llendl
+        }
+}
+
+void LLCubeMap::enable(S32 stage)
+{
+        enableTexture(stage);
+        enableTextureCoords(stage);
+}
+
+void LLCubeMap::enableTexture(S32 stage)
+{
+        mTextureStage = stage;
+        if (gGLManager.mHasCubeMap && stage >= 0 && LLCubeMap::sUseCubeMaps)
+        {
+                if (stage > 0)
+                {
+                        gGL.getTexUnit(stage)->activate();
+                }
+                
+                glEnable(GL_TEXTURE_CUBE_MAP_ARB);
+                
+                if (stage > 0)
+                {
+                        gGL.getTexUnit(0)->activate();
+                }
+        }
+}
+
+void LLCubeMap::enableTextureCoords(S32 stage)
+{
+        mTextureCoordStage = stage;
+        if (gGLManager.mHasCubeMap && stage >= 0 && LLCubeMap::sUseCubeMaps)
+        {
+                if (stage > 0)
+                {
+                        gGL.getTexUnit(stage)->activate();
+                }
+                
+                glEnable(GL_TEXTURE_GEN_R);
+                glEnable(GL_TEXTURE_GEN_S);
+                glEnable(GL_TEXTURE_GEN_T);
+
+                glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
+                glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
+                glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
+                
+                if (stage > 0)
+                {
+                        gGL.getTexUnit(0)->activate();
+                }
+        }
+}
+
+void LLCubeMap::disable(void)
+{
+        disableTexture();
+        disableTextureCoords();
+}
+
+void LLCubeMap::disableTexture(void)
+{
+        if (gGLManager.mHasCubeMap && mTextureStage >= 0 && LLCubeMap::sUseCubeMaps)
+        {
+                if (mTextureStage > 0)
+                {
+                        gGL.getTexUnit(mTextureStage)->activate();
+                }
+                glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, 0);
+                glDisable(GL_TEXTURE_CUBE_MAP_ARB);
+                if (mTextureStage > 0)
+                {
+                        gGL.getTexUnit(0)->activate();
+                }
+        }
+}
+
+void LLCubeMap::disableTextureCoords(void)
+{
+        if (gGLManager.mHasCubeMap && mTextureCoordStage >= 0 && LLCubeMap::sUseCubeMaps)
+        {
+                if (mTextureCoordStage > 0)
+                {
+                        gGL.getTexUnit(mTextureCoordStage)->activate();
+                }
+                glDisable(GL_TEXTURE_GEN_S);
+                glDisable(GL_TEXTURE_GEN_T);
+                glDisable(GL_TEXTURE_GEN_R);
+                if (mTextureCoordStage > 0)
+                {
+                        gGL.getTexUnit(0)->activate();
+                }
+        }
+}
+
+void LLCubeMap::setMatrix(S32 stage)
+{
+        mMatrixStage = stage;
+        
+        if (stage > 0)
+        {
+                gGL.getTexUnit(stage)->activate();
+        }
+
+        LLVector3 x(LLVector3d(gGLModelView+0));
+        LLVector3 y(LLVector3d(gGLModelView+4));
+        LLVector3 z(LLVector3d(gGLModelView+8));
+
+        LLMatrix3 mat3;
+        mat3.setRows(x,y,z);
+        LLMatrix4 trans(mat3);
+        trans.transpose();
+
+        glMatrixMode(GL_TEXTURE);
+        glPushMatrix();
+        glLoadMatrixf((F32 *)trans.mMatrix);
+        glMatrixMode(GL_MODELVIEW);
+        
+        if (stage > 0)
+        {
+                gGL.getTexUnit(0)->activate();
+        }
+}
+
+void LLCubeMap::restoreMatrix()
+{
+        if (mMatrixStage > 0)
+        {
+                gGL.getTexUnit(mMatrixStage)->activate();
+        }
+        glMatrixMode(GL_TEXTURE);
+        glPopMatrix();
+        glMatrixMode(GL_MODELVIEW);
+        
+        if (mMatrixStage > 0)
+        {
+                gGL.getTexUnit(0)->activate();
+        }
+}
+
+void LLCubeMap::setReflection (void)
+{
+        glBindTexture (GL_TEXTURE_CUBE_MAP_ARB, getGLName());
+        mImages[0]->setMipFilterNearest (FALSE, FALSE);
+        mImages[0]->setClampCubemap (TRUE, TRUE);
+}
+
+LLVector3 LLCubeMap::map(U8 side, U16 v_val, U16 h_val) const
+{
+        LLVector3 dir;
+
+        const U8 curr_coef = side >> 1; // 0/1 = X axis, 2/3 = Y, 4/5 = Z
+        const S8 side_dir = (((side & 1) << 1) - 1);  // even = -1, odd = 1
+        const U8 i_coef = (curr_coef + 1) % 3;
+        const U8 j_coef = (i_coef + 1) % 3;
+
+        dir.mV[curr_coef] = side_dir;
+
+        switch (side)
+        {
+        case 0: // negative X
+                dir.mV[i_coef] = -F32((v_val<<1) + 1) / RESOLUTION + 1;
+                dir.mV[j_coef] = F32((h_val<<1) + 1) / RESOLUTION - 1;
+                break;
+        case 1: // positive X
+                dir.mV[i_coef] = -F32((v_val<<1) + 1) / RESOLUTION + 1;
+                dir.mV[j_coef] = -F32((h_val<<1) + 1) / RESOLUTION + 1;
+                break;
+        case 2: // negative Y
+                dir.mV[i_coef] = -F32((v_val<<1) + 1) / RESOLUTION + 1;
+                dir.mV[j_coef] = F32((h_val<<1) + 1) / RESOLUTION - 1;
+                break;
+        case 3: // positive Y
+                dir.mV[i_coef] = F32((v_val<<1) + 1) / RESOLUTION - 1;
+                dir.mV[j_coef] = F32((h_val<<1) + 1) / RESOLUTION - 1;
+                break;
+        case 4: // negative Z
+                dir.mV[i_coef] = -F32((h_val<<1) + 1) / RESOLUTION + 1;
+                dir.mV[j_coef] = -F32((v_val<<1) + 1) / RESOLUTION + 1;
+                break;
+        case 5: // positive Z
+                dir.mV[i_coef] = -F32((h_val<<1) + 1) / RESOLUTION + 1;
+                dir.mV[j_coef] = F32((v_val<<1) + 1) / RESOLUTION - 1;
+                break;
+        default:
+                dir.mV[i_coef] = F32((v_val<<1) + 1) / RESOLUTION - 1;
+                dir.mV[j_coef] = F32((h_val<<1) + 1) / RESOLUTION - 1;
+        }
+
+        dir.normVec();
+        return dir;
+}
+
+
+BOOL LLCubeMap::project(F32& v_val, F32& h_val, BOOL& outside,
+                                                U8 side, const LLVector3& dir) const
+{
+        const U8 curr_coef = side >> 1; // 0/1 = X axis, 2/3 = Y, 4/5 = Z
+        const S8 side_dir = (((side & 1) << 1) - 1);  // even = -1, odd = 1
+        const U8 i_coef = (curr_coef + 1) % 3;
+        const U8 j_coef = (i_coef + 1) % 3;
+
+        outside = TRUE;
+        if (side_dir * dir.mV[curr_coef] < 0)
+                return FALSE;
+
+        LLVector3 ray;
+
+        F32 norm_val = fabs(dir.mV[curr_coef]);
+
+        if (norm_val < epsilon)
+                norm_val = 1e-5f;
+
+        ray.mV[curr_coef] = side_dir;
+        ray.mV[i_coef] = dir.mV[i_coef] / norm_val;
+        ray.mV[j_coef] = dir.mV[j_coef] / norm_val;
+
+
+        const F32 i_val = (ray.mV[i_coef] + 1) * 0.5f * RESOLUTION;
+        const F32 j_val = (ray.mV[j_coef] + 1) * 0.5f * RESOLUTION;
+
+        switch (side)
+        {
+        case 0: // negative X
+                v_val = RESOLUTION - i_val;
+                h_val = j_val;
+                break;
+        case 1: // positive X
+                v_val = RESOLUTION - i_val;
+                h_val = RESOLUTION - j_val;
+                break;
+        case 2: // negative Y
+                v_val = RESOLUTION - i_val;
+                h_val = j_val;
+                break;
+        case 3: // positive Y
+                v_val = i_val;
+                h_val = j_val;
+                break;
+        case 4: // negative Z
+                v_val = RESOLUTION - j_val;
+                h_val = RESOLUTION - i_val;
+                break;
+        case 5: // positive Z
+                v_val = RESOLUTION - j_val;
+                h_val = i_val;
+                break;
+        default:
+                v_val = i_val;
+                h_val = j_val;
+        }
+
+        outside =  ((v_val < 0) || (v_val > RESOLUTION) ||
+                (h_val < 0) || (h_val > RESOLUTION));
+
+        return TRUE;
+}
+
+BOOL LLCubeMap::project(F32& v_min, F32& v_max, F32& h_min, F32& h_max, 
+                                                U8 side, LLVector3 dir[4]) const
+{
+        v_min = h_min = RESOLUTION;
+        v_max = h_max = 0;
+
+        BOOL fully_outside = TRUE;
+        for (U8 vtx = 0; vtx < 4; ++vtx)
+        {
+                F32 v_val, h_val;
+                BOOL outside;
+                BOOL consider = project(v_val, h_val, outside, side, dir[vtx]);
+                if (!outside)
+                        fully_outside = FALSE;
+                if (consider)
+                {
+                        if (v_val < v_min) v_min = v_val;
+                        if (v_val > v_max) v_max = v_val;
+                        if (h_val < h_min) h_min = h_val;
+                        if (h_val > h_max) h_max = h_val;
+                }
+        }
+
+        v_min = llmax(0.0f, v_min);
+        v_max = llmin(RESOLUTION - epsilon, v_max);
+        h_min = llmax(0.0f, h_min);
+        h_max = llmin(RESOLUTION - epsilon, h_max);
+
+        return !fully_outside;
+}
+
+
+void LLCubeMap::paintIn(LLVector3 dir[4], const LLColor4U& col)
+{
+        F32 v_min, v_max, h_min, h_max;
+        LLVector3 center = dir[0] + dir[1] + dir[2] + dir[3];
+        center.normVec();
+
+        for (U8 side = 0; side < 6; ++side)
+        {
+                if (!project(v_min, v_max, h_min, h_max, side, dir))
+                        continue;
+
+                U8 *td = mRawImages[side]->getData();
+                
+                U16 v_minu = (U16) v_min;
+                U16 v_maxu = (U16) (ceil(v_max) + 0.5);
+                U16 h_minu = (U16) h_min;
+                U16 h_maxu = (U16) (ceil(h_max) + 0.5);
+
+                for (U16 v = v_minu; v < v_maxu; ++v)
+                        for (U16 h = h_minu; h < h_maxu; ++h)
+                //for (U16 v = 0; v < RESOLUTION; ++v)
+                //      for (U16 h = 0; h < RESOLUTION; ++h)
+                        {
+                                const LLVector3 ray = map(side, v, h);
+                                if (ray * center > 0.999)
+                                {
+                                        const U32 offset = (RESOLUTION * v + h) * 4;
+                                        for (U8 cc = 0; cc < 3; ++cc)
+                                                td[offset + cc] = U8((td[offset + cc] + col.mV[cc]) * 0.5);
+                                }
+                        }
+                mImages[side]->setSubImage(mRawImages[side], 0, 0, 64, 64);
+        }
+}
+
+void LLCubeMap::destroyGL()
+{
+        for (S32 i = 0; i < 6; i++)
+        {
+                mImages[i] = NULL;
+        }
+}
diff --git a/linden/indra/llrender/llcubemap.h b/linden/indra/llrender/llcubemap.h
new file mode 100644
index 0000000..45bfa16
--- /dev/null
+++ b/linden/indra/llrender/llcubemap.h
@@ -0,0 +1,89 @@
+/** 
+ * @file llcubemap.h
+ * @brief LLCubeMap class definition
+ *
+ * $LicenseInfo:firstyear=2002&license=viewergpl$
+ * 
+ * Copyright (c) 2002-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLCUBEMAP_H
+#define LL_LLCUBEMAP_H
+
+#include "llgl.h"
+
+#include <vector>
+
+class LLVector3;
+
+// Environment map hack!
+class LLCubeMap : public LLRefCount
+{
+public:
+        LLCubeMap();
+        void init(const std::vector<LLPointer<LLImageRaw> >& rawimages);
+        void initGL();
+        void initRawData(const std::vector<LLPointer<LLImageRaw> >& rawimages);
+        void initGLData();
+
+        void bind();
+        void enable(S32 stage);
+        
+        void enableTexture(S32 stage);
+        void enableTextureCoords(S32 stage);
+        
+        void disable(void);
+        void disableTexture(void);
+        void disableTextureCoords(void);
+        void setMatrix(S32 stage);
+        void restoreMatrix();
+        void setReflection (void);
+
+        void finishPaint();
+
+        GLuint getGLName();
+
+        LLVector3 map(U8 side, U16 v_val, U16 h_val) const;
+        BOOL project(F32& v_val, F32& h_val, BOOL& outside,
+                                                U8 side, const LLVector3& dir) const;
+        BOOL project(F32& v_min, F32& v_max, F32& h_min, F32& h_max, 
+                                                U8 side, LLVector3 dir[4]) const;
+        void paintIn(LLVector3 dir[4], const LLColor4U& col);
+        void destroyGL();
+
+public:
+        static bool sUseCubeMaps;
+
+protected:
+        ~LLCubeMap();
+        LLGLenum mTargets[6];
+        LLPointer<LLImageGL> mImages[6];
+        LLPointer<LLImageRaw> mRawImages[6];
+        S32 mTextureStage;
+        S32 mTextureCoordStage;
+        S32 mMatrixStage;
+};
+
+#endif
diff --git a/linden/indra/llrender/llfont.h b/linden/indra/llrender/llfont.h
index 071e508..d937dfd 100644
--- a/linden/indra/llrender/llfont.h
+++ b/linden/indra/llrender/llfont.h
@@ -121,11 +121,11 @@ public:
 //                           ^     ^
 //                                               |     |
 //                              xxx x    |Ascender
-//                 x   x     |     |
+//                 x   x     v     |
 //      ---------   xxxx-------------- Baseline
-//      ^                      x         |     |
-//  | descender    x     |     |
-//      v                       xxxx     v     |LineHeight
+//      ^                      x               |
+//  | Descender    x           |
+//      v                       xxxx           |LineHeight
 //  -----------------------    |
 //                             v
 //      ------------------------------
diff --git a/linden/indra/llrender/llfontgl.cpp b/linden/indra/llrender/llfontgl.cpp
index 253bf50..a328196 100644
--- a/linden/indra/llrender/llfontgl.cpp
+++ b/linden/indra/llrender/llfontgl.cpp
@@ -48,7 +48,7 @@ F32 LLFontGL::sHorizDPI = 96.f;
 F32 LLFontGL::sScaleX = 1.f;
 F32 LLFontGL::sScaleY = 1.f;
 BOOL LLFontGL::sDisplayFont = TRUE ;
-LLString LLFontGL::sAppDir;
+std::string LLFontGL::sAppDir;
 
 LLFontGL* LLFontGL::sMonospace = NULL;
 LLFontGL* LLFontGL::sSansSerifSmall = NULL;
@@ -93,7 +93,7 @@ F32 llfont_round_y(F32 y)
 }
 
 // static
-U8 LLFontGL::getStyleFromString(const LLString &style)
+U8 LLFontGL::getStyleFromString(const std::string &style)
 {
         S32 ret = 0;
         if (style.find("NORMAL") != style.npos)
@@ -166,9 +166,9 @@ void LLFontGL::reset()
 }
 
 // static 
-LLString LLFontGL::getFontPathSystem()
+std::string LLFontGL::getFontPathSystem()
 {
-        LLString system_path;
+        std::string system_path;
 
         // Try to figure out where the system's font files are stored.
         char *system_root = NULL;
@@ -199,9 +199,9 @@ LLString LLFontGL::getFontPathSystem()
 
 
 // static 
-LLString LLFontGL::getFontPathLocal()
+std::string LLFontGL::getFontPathLocal()
 {
-        LLString local_path;
+        std::string 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
@@ -220,10 +220,10 @@ LLString LLFontGL::getFontPathLocal()
 }
 
 //static
-bool LLFontGL::loadFaceFallback(LLFontList *fontlistp, const LLString& fontname, const F32 point_size)
+bool LLFontGL::loadFaceFallback(LLFontList *fontlistp, const std::string& fontname, const F32 point_size)
 {
-        LLString local_path = getFontPathLocal();
-        LLString sys_path = getFontPathSystem();
+        std::string local_path = getFontPathLocal();
+        std::string sys_path = getFontPathSystem();
         
         // The fontname string may contain multiple font file names separated by semicolons.
         // Break it apart and try loading each one, in order.
@@ -235,7 +235,7 @@ bool LLFontGL::loadFaceFallback(LLFontList *fontlistp, const LLString& fontname,
         for(token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
         {
                 LLFont *fontp = new LLFont();
-                LLString font_path = local_path + *token_iter;
+                std::string font_path = local_path + *token_iter;
                 if (!fontp->loadFace(font_path, point_size, sVertDPI, sHorizDPI, 2, TRUE))
                 {
                         font_path = sys_path + *token_iter;
@@ -258,13 +258,13 @@ bool LLFontGL::loadFaceFallback(LLFontList *fontlistp, const LLString& fontname,
 }
 
 //static
-bool LLFontGL::loadFace(LLFontGL *fontp, const LLString& fontname, const F32 point_size, LLFontList *fallback_fontp)
+bool LLFontGL::loadFace(LLFontGL *fontp, const std::string& fontname, const F32 point_size, LLFontList *fallback_fontp)
 {
-        LLString local_path = getFontPathLocal();
-        LLString font_path = local_path + fontname;
+        std::string local_path = getFontPathLocal();
+        std::string font_path = local_path + fontname;
         if (!fontp->loadFace(font_path, point_size, sVertDPI, sHorizDPI, 2, FALSE))
         {
-                LLString sys_path = getFontPathSystem();
+                std::string sys_path = getFontPathSystem();
                 font_path = sys_path + fontname;
                 if (!fontp->loadFace(font_path, point_size, sVertDPI, sHorizDPI, 2, FALSE))
                 {
@@ -280,12 +280,12 @@ bool LLFontGL::loadFace(LLFontGL *fontp, const LLString& fontname, const F32 poi
 
 // 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,
+                                const std::string& monospace_file, F32 monospace_size,
+                                const std::string& sansserif_file,
+                                const std::string& sanserif_fallback_file, F32 ss_fallback_scale,
                                 F32 small_size, F32 medium_size, F32 big_size, F32 huge_size,
-                                const LLString& sansserif_bold_file, F32 bold_size,
-                                const LLString& app_dir)
+                                const std::string& sansserif_bold_file, F32 bold_size,
+                                const std::string& app_dir)
 {
         BOOL failed = FALSE;
         sVertDPI = (F32)llfloor(screen_dpi * y_scale);
@@ -554,7 +554,7 @@ BOOL LLFontGL::addChar(const llwchar wch)
 }
 
 
-S32 LLFontGL::renderUTF8(const LLString &text, const S32 offset, 
+S32 LLFontGL::renderUTF8(const std::string &text, const S32 offset, 
                                          const F32 x, const F32 y,
                                          const LLColor4 &color,
                                          const HAlign halign, const VAlign valign,
@@ -726,7 +726,7 @@ S32 LLFontGL::render(const LLWString &wstr,
                 if (getWidthF32(wstr.c_str(), 0, max_chars) * sScaleX > scaled_max_pixels)
                 {
                         // use four dots for ellipsis width to generate padding
-                        const LLWString dots(utf8str_to_wstring(LLString("....")));
+                        const LLWString dots(utf8str_to_wstring(std::string("....")));
                         scaled_max_pixels = llmax(0, scaled_max_pixels - llround(getWidthF32(dots.c_str())));
                         draw_ellipses = TRUE;
                 }
@@ -879,7 +879,7 @@ S32 LLFontGL::render(const LLWString &wstr,
                 //glLoadIdentity();
                 //gGL.translatef(sCurOrigin.mX, sCurOrigin.mY, 0.0f);
                 //glScalef(sScaleX, sScaleY, 1.f);
-                renderUTF8("...", 
+                renderUTF8(std::string("..."), 
                                 0,
                                 cur_x / sScaleX, (F32)y,
                                 color,
@@ -902,7 +902,7 @@ LLImageGL *LLFontGL::getImageGL() const
         return mImageGLp;
 }
 
-S32 LLFontGL::getWidth(const LLString& utf8text) const
+S32 LLFontGL::getWidth(const std::string& utf8text) const
 {
         LLWString wtext = utf8str_to_wstring(utf8text);
         return getWidth(wtext.c_str(), 0, S32_MAX);
@@ -913,7 +913,7 @@ 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
+S32 LLFontGL::getWidth(const std::string& 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);
@@ -925,7 +925,7 @@ S32 LLFontGL::getWidth(const llwchar* wchars, const S32 begin_offset, const S32
         return llround(width);
 }
 
-F32 LLFontGL::getWidthF32(const LLString& utf8text) const
+F32 LLFontGL::getWidthF32(const std::string& utf8text) const
 {
         LLWString wtext = utf8str_to_wstring(utf8text);
         return getWidthF32(wtext.c_str(), 0, S32_MAX);
@@ -936,7 +936,7 @@ 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
+F32 LLFontGL::getWidthF32(const std::string& 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);
@@ -1312,7 +1312,7 @@ void LLFontGL::clearEmbeddedChars()
         mEmbeddedChars.clear();
 }
 
-void LLFontGL::addEmbeddedChar( llwchar wc, LLImageGL* image, const LLString& label )
+void LLFontGL::addEmbeddedChar( llwchar wc, LLImageGL* image, const std::string& label )
 {
         LLWString wlabel = utf8str_to_wstring(label);
         addEmbeddedChar(wc, image, wlabel);
@@ -1429,40 +1429,40 @@ void LLFontGL::drawGlyph(const LLRectf& screen_rect, const LLRectf& uv_rect, con
 }
 
 // static
-LLString LLFontGL::nameFromFont(const LLFontGL* fontp)
+std::string LLFontGL::nameFromFont(const LLFontGL* fontp)
 {
         if (fontp == sSansSerifHuge)
         {
-                return LLString("SansSerifHuge");
+                return std::string("SansSerifHuge");
         }
         else if (fontp == sSansSerifSmall)
         {
-                return LLString("SansSerifSmall");
+                return std::string("SansSerifSmall");
         }
         else if (fontp == sSansSerif)
         {
-                return LLString("SansSerif");
+                return std::string("SansSerif");
         }
         else if (fontp == sSansSerifBig)
         {
-                return LLString("SansSerifBig");
+                return std::string("SansSerifBig");
         }
         else if (fontp == sSansSerifBold)
         {
-                return LLString("SansSerifBold");
+                return std::string("SansSerifBold");
         }
         else if (fontp == sMonospace)
         {
-                return LLString("Monospace");
+                return std::string("Monospace");
         }
         else
         {
-                return LLString();
+                return std::string();
         }
 }
 
 // static
-LLFontGL* LLFontGL::fontFromName(const LLString& font_name)
+LLFontGL* LLFontGL::fontFromName(const std::string& font_name)
 {
         LLFontGL* gl_font = NULL;
         if (font_name == "SansSerifHuge")
@@ -1493,16 +1493,16 @@ LLFontGL* LLFontGL::fontFromName(const LLString& font_name)
 }
 
 // static
-LLString LLFontGL::nameFromHAlign(LLFontGL::HAlign align)
+std::string 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();
+        if (align == LEFT)                      return std::string("left");
+        else if (align == RIGHT)        return std::string("right");
+        else if (align == HCENTER)      return std::string("center");
+        else return std::string();
 }
 
 // static
-LLFontGL::HAlign LLFontGL::hAlignFromName(const LLString& name)
+LLFontGL::HAlign LLFontGL::hAlignFromName(const std::string& name)
 {
         LLFontGL::HAlign gl_hfont_align = LLFontGL::LEFT;
         if (name == "left")
@@ -1522,17 +1522,17 @@ LLFontGL::HAlign LLFontGL::hAlignFromName(const LLString& name)
 }
 
 // static
-LLString LLFontGL::nameFromVAlign(LLFontGL::VAlign align)
+std::string 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();
+        if (align == TOP)                       return std::string("top");
+        else if (align == VCENTER)      return std::string("center");
+        else if (align == BASELINE)     return std::string("baseline");
+        else if (align == BOTTOM)       return std::string("bottom");
+        else return std::string();
 }
 
 // static
-LLFontGL::VAlign LLFontGL::vAlignFromName(const LLString& name)
+LLFontGL::VAlign LLFontGL::vAlignFromName(const std::string& name)
 {
         LLFontGL::VAlign gl_vfont_align = LLFontGL::BASELINE;
         if (name == "top")
diff --git a/linden/indra/llrender/llfontgl.h b/linden/indra/llrender/llfontgl.h
index 01046af..3f88e62 100644
--- a/linden/indra/llrender/llfontgl.h
+++ b/linden/indra/llrender/llfontgl.h
@@ -73,7 +73,7 @@ public:
         };
         
         // Takes a string with potentially several flags, i.e. "NORMAL|BOLD|ITALIC"
-        static U8 getStyleFromString(const LLString &style);
+        static U8 getStyleFromString(const std::string &style);
 
         LLFontGL();
         LLFontGL(const LLFontGL &source);
@@ -85,24 +85,24 @@ public:
         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,
+                                                                 const std::string& monospace_file, F32 monospace_size,
+                                                                 const std::string& sansserif_file,
+                                                                 const std::string& sansserif_fallback_file, F32 ss_fallback_scale,
                                                                  F32 small_size, F32 medium_size, F32 large_size, F32 huge_size,
-                                                                 const LLString& sansserif_bold_file, F32 bold_size,
-                                                                 const LLString& app_dir = LLString::null);
+                                                                 const std::string& sansserif_bold_file, F32 bold_size,
+                                                                 const std::string& app_dir = LLStringUtil::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);
+        static bool loadFaceFallback(LLFontList *fontp, const std::string& fontname, const F32 point_size);
+        static bool loadFace(LLFontGL *fontp, const std::string& fontname, const F32 point_size, LLFontList *fallback_fontp);
         /* virtual*/ BOOL loadFace(const std::string& filename,
                                                             const F32 point_size, const F32 vert_dpi, const F32 horz_dpi,
                                                             const S32 components, BOOL is_fallback);
 
 
-        S32 renderUTF8(const LLString &text, const S32 begin_offset,
+        S32 renderUTF8(const std::string &text, const S32 begin_offset,
                                    S32 x, S32 y,
                                    const LLColor4 &color) const
         {
@@ -111,7 +111,7 @@ public:
                                                   S32_MAX, S32_MAX, NULL, FALSE);
         }
         
-        S32 renderUTF8(const LLString &text, const S32 begin_offset,
+        S32 renderUTF8(const std::string &text, const S32 begin_offset,
                                    S32 x, S32 y,
                                    const LLColor4 &color,
                                    HAlign halign, VAlign valign, U8 style = NORMAL) const
@@ -122,7 +122,7 @@ public:
         }
         
         // renderUTF8 does a conversion, so is slower!
-        S32 renderUTF8(const LLString &text,
+        S32 renderUTF8(const std::string &text,
                 S32 begin_offset,
                 F32 x, F32 y,
                 const LLColor4 &color,
@@ -162,14 +162,14 @@ public:
         /*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 std::string& 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 std::string& 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 std::string& 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 std::string& 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
@@ -191,18 +191,18 @@ public:
 
         LLImageGL *getImageGL() const;
 
-        void       addEmbeddedChar( llwchar wc, LLImageGL* image, const LLString& label);
+        void       addEmbeddedChar( llwchar wc, LLImageGL* image, const std::string& 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 std::string nameFromFont(const LLFontGL* fontp);
+        static LLFontGL* fontFromName(const std::string& name);
 
-        static LLString nameFromHAlign(LLFontGL::HAlign align);
-        static LLFontGL::HAlign hAlignFromName(const LLString& name);
+        static std::string nameFromHAlign(LLFontGL::HAlign align);
+        static LLFontGL::HAlign hAlignFromName(const std::string& name);
 
-        static LLString nameFromVAlign(LLFontGL::VAlign align);
-        static LLFontGL::VAlign vAlignFromName(const LLString& name);
+        static std::string nameFromVAlign(LLFontGL::VAlign align);
+        static LLFontGL::VAlign vAlignFromName(const std::string& name);
 
         static void setFontDisplay(BOOL flag) { sDisplayFont = flag ; }
 
@@ -225,7 +225,7 @@ public:
         static F32 sScaleX;
         static F32 sScaleY;
         static BOOL     sDisplayFont ;
-        static LLString sAppDir;                        // For loading fonts
+        static std::string sAppDir;                     // For loading fonts
                 
         static LLFontGL*        sMonospace;             // medium
         static LLFontList*      sMonospaceFallback;
@@ -249,8 +249,8 @@ public:
 
 protected:
         /*virtual*/ BOOL addChar(const llwchar wch);
-        static LLString getFontPathLocal();
-        static LLString getFontPathSystem();    
+        static std::string getFontPathLocal();
+        static std::string getFontPathSystem();
 
 protected:
         LLPointer<LLImageRaw>   mRawImageGLp;
diff --git a/linden/indra/llrender/llgl.cpp b/linden/indra/llrender/llgl.cpp
new file mode 100644
index 0000000..843bc79
--- /dev/null
+++ b/linden/indra/llrender/llgl.cpp
@@ -0,0 +1,1763 @@
+/** 
+ * @file llgl.cpp
+ * @brief LLGL implementation
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+// This file sets some global GL parameters, and implements some 
+// useful functions for GL operations.
+
+#define GLH_EXT_SINGLE_FILE
+
+#include "linden_common.h"
+
+#include "boost/tokenizer.hpp"
+
+#include "llsys.h"
+
+#include "llgl.h"
+#include "llrender.h"
+
+#include "llerror.h"
+#include "llquaternion.h"
+#include "llmath.h"
+#include "m4math.h"
+#include "llstring.h"
+
+#include "llglheaders.h"
+
+#ifdef _DEBUG
+//#define GL_STATE_VERIFY
+#endif
+
+BOOL gDebugGL = FALSE;
+BOOL gClothRipple = FALSE;
+BOOL gNoRender = FALSE;
+LLMatrix4 gGLObliqueProjectionInverse;
+
+#define LL_GL_NAME_POOLING 0
+
+LLGLNamePool::pool_list_t LLGLNamePool::sInstances;
+
+#if (LL_WINDOWS || LL_LINUX) && !LL_MESA_HEADLESS
+// ATI prototypes
+// vertex blending prototypes
+PFNGLWEIGHTPOINTERARBPROC                       glWeightPointerARB = NULL;
+PFNGLVERTEXBLENDARBPROC                         glVertexBlendARB = NULL;
+PFNGLWEIGHTFVARBPROC                            glWeightfvARB = NULL;
+
+// Vertex buffer object prototypes
+PFNGLBINDBUFFERARBPROC                          glBindBufferARB = NULL;
+PFNGLDELETEBUFFERSARBPROC                       glDeleteBuffersARB = NULL;
+PFNGLGENBUFFERSARBPROC                          glGenBuffersARB = NULL;
+PFNGLISBUFFERARBPROC                            glIsBufferARB = NULL;
+PFNGLBUFFERDATAARBPROC                          glBufferDataARB = NULL;
+PFNGLBUFFERSUBDATAARBPROC                       glBufferSubDataARB = NULL;
+PFNGLGETBUFFERSUBDATAARBPROC            glGetBufferSubDataARB = NULL;
+PFNGLMAPBUFFERARBPROC                           glMapBufferARB = NULL;
+PFNGLUNMAPBUFFERARBPROC                         glUnmapBufferARB = NULL;
+PFNGLGETBUFFERPARAMETERIVARBPROC        glGetBufferParameterivARB = NULL;
+PFNGLGETBUFFERPOINTERVARBPROC           glGetBufferPointervARB = NULL;
+
+// vertex object prototypes
+PFNGLNEWOBJECTBUFFERATIPROC                     glNewObjectBufferATI = NULL;
+PFNGLISOBJECTBUFFERATIPROC                      glIsObjectBufferATI = NULL;
+PFNGLUPDATEOBJECTBUFFERATIPROC          glUpdateObjectBufferATI = NULL;
+PFNGLGETOBJECTBUFFERFVATIPROC           glGetObjectBufferfvATI = NULL;
+PFNGLGETOBJECTBUFFERIVATIPROC           glGetObjectBufferivATI = NULL;
+PFNGLFREEOBJECTBUFFERATIPROC            glFreeObjectBufferATI = NULL;
+PFNGLARRAYOBJECTATIPROC                         glArrayObjectATI = NULL;
+PFNGLVERTEXATTRIBARRAYOBJECTATIPROC     glVertexAttribArrayObjectATI = NULL;
+PFNGLGETARRAYOBJECTFVATIPROC            glGetArrayObjectfvATI = NULL;
+PFNGLGETARRAYOBJECTIVATIPROC            glGetArrayObjectivATI = NULL;
+PFNGLVARIANTARRAYOBJECTATIPROC          glVariantObjectArrayATI = NULL;
+PFNGLGETVARIANTARRAYOBJECTFVATIPROC     glGetVariantArrayObjectfvATI = NULL;
+PFNGLGETVARIANTARRAYOBJECTIVATIPROC     glGetVariantArrayObjectivATI = NULL;
+
+// GL_ARB_occlusion_query
+PFNGLGENQUERIESARBPROC glGenQueriesARB = NULL;
+PFNGLDELETEQUERIESARBPROC glDeleteQueriesARB = NULL;
+PFNGLISQUERYARBPROC glIsQueryARB = NULL;
+PFNGLBEGINQUERYARBPROC glBeginQueryARB = NULL;
+PFNGLENDQUERYARBPROC glEndQueryARB = NULL;
+PFNGLGETQUERYIVARBPROC glGetQueryivARB = NULL;
+PFNGLGETQUERYOBJECTIVARBPROC glGetQueryObjectivARB = NULL;
+PFNGLGETQUERYOBJECTUIVARBPROC glGetQueryObjectuivARB = NULL;
+
+// GL_ARB_point_parameters
+PFNGLPOINTPARAMETERFARBPROC glPointParameterfARB = NULL;
+PFNGLPOINTPARAMETERFVARBPROC glPointParameterfvARB = NULL;
+
+// GL_EXT_framebuffer_object
+PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT = NULL;
+PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT = NULL;
+PFNGLDELETERENDERBUFFERSEXTPROC glDeleteRenderbuffersEXT = NULL;
+PFNGLGENRENDERBUFFERSEXTPROC glGenRenderbuffersEXT = NULL;
+PFNGLRENDERBUFFERSTORAGEEXTPROC glRenderbufferStorageEXT = NULL;
+PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glGetRenderbufferParameterivEXT = NULL;
+PFNGLISFRAMEBUFFEREXTPROC glIsFramebufferEXT = NULL;
+PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT = NULL;
+PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT = NULL;
+PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT = NULL;
+PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT = NULL;
+PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glFramebufferTexture1DEXT = NULL;
+PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT = NULL;
+PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glFramebufferTexture3DEXT = NULL;
+PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT = NULL;
+PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT = NULL;
+PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT = NULL;
+
+//shader object prototypes
+PFNGLDELETEOBJECTARBPROC glDeleteObjectARB = NULL;
+PFNGLGETHANDLEARBPROC glGetHandleARB = NULL;
+PFNGLDETACHOBJECTARBPROC glDetachObjectARB = NULL;
+PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB = NULL;
+PFNGLSHADERSOURCEARBPROC glShaderSourceARB = NULL;
+PFNGLCOMPILESHADERARBPROC glCompileShaderARB = NULL;
+PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB = NULL;
+PFNGLATTACHOBJECTARBPROC glAttachObjectARB = NULL;
+PFNGLLINKPROGRAMARBPROC glLinkProgramARB = NULL;
+PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB = NULL;
+PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB = NULL;
+PFNGLUNIFORM1FARBPROC glUniform1fARB = NULL;
+PFNGLUNIFORM2FARBPROC glUniform2fARB = NULL;
+PFNGLUNIFORM3FARBPROC glUniform3fARB = NULL;
+PFNGLUNIFORM4FARBPROC glUniform4fARB = NULL;
+PFNGLUNIFORM1IARBPROC glUniform1iARB = NULL;
+PFNGLUNIFORM2IARBPROC glUniform2iARB = NULL;
+PFNGLUNIFORM3IARBPROC glUniform3iARB = NULL;
+PFNGLUNIFORM4IARBPROC glUniform4iARB = NULL;
+PFNGLUNIFORM1FVARBPROC glUniform1fvARB = NULL;
+PFNGLUNIFORM2FVARBPROC glUniform2fvARB = NULL;
+PFNGLUNIFORM3FVARBPROC glUniform3fvARB = NULL;
+PFNGLUNIFORM4FVARBPROC glUniform4fvARB = NULL;
+PFNGLUNIFORM1IVARBPROC glUniform1ivARB = NULL;
+PFNGLUNIFORM2IVARBPROC glUniform2ivARB = NULL;
+PFNGLUNIFORM3IVARBPROC glUniform3ivARB = NULL;
+PFNGLUNIFORM4IVARBPROC glUniform4ivARB = NULL;
+PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB = NULL;
+PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB = NULL;
+PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB = NULL;
+PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB = NULL;
+PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB = NULL;
+PFNGLGETINFOLOGARBPROC glGetInfoLogARB = NULL;
+PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB = NULL;
+PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB = NULL;
+PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB = NULL;
+PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB = NULL;
+PFNGLGETUNIFORMIVARBPROC glGetUniformivARB = NULL;
+PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB = NULL;
+
+// vertex shader prototypes
+#if LL_LINUX
+PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB = NULL;
+PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB = NULL;
+PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB = NULL;
+PFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB = NULL;
+PFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB = NULL;
+PFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB = NULL;
+PFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB = NULL;
+PFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB = NULL;
+PFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB = NULL;
+PFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB = NULL;
+PFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB = NULL;
+PFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB = NULL;
+PFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB = NULL;
+PFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB = NULL;
+PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB = NULL;
+PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB = NULL;
+PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB = NULL;
+PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB = NULL;
+#endif // LL_LINUX
+PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4nbvARB = NULL;
+PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4nivARB = NULL;
+PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4nsvARB = NULL;
+PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4nubARB = NULL;
+PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4nubvARB = NULL;
+PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4nuivARB = NULL;
+PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4nusvARB = NULL;
+#if LL_LINUX
+PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB = NULL;
+PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB = NULL;
+PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB = NULL;
+PFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB = NULL;
+PFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB = NULL;
+PFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB = NULL;
+PFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB = NULL;
+PFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB = NULL;
+PFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB = NULL;
+PFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB = NULL;
+PFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB = NULL;
+PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB = NULL;
+PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB = NULL;
+PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB = NULL;
+PFNGLPROGRAMSTRINGARBPROC glProgramStringARB = NULL;
+PFNGLBINDPROGRAMARBPROC glBindProgramARB = NULL;
+PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB = NULL;
+PFNGLGENPROGRAMSARBPROC glGenProgramsARB = NULL;
+PFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB = NULL;
+PFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB = NULL;
+PFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB = NULL;
+PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB = NULL;
+PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB = NULL;
+PFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB = NULL;
+PFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB = NULL;
+PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB = NULL;
+PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB = NULL;
+PFNGLGETPROGRAMIVARBPROC glGetProgramivARB = NULL;
+PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB = NULL;
+PFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB = NULL;
+PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB = NULL;
+PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB = NULL;
+PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB = NULL;
+PFNGLISPROGRAMARBPROC glIsProgramARB = NULL;
+#endif // LL_LINUX
+PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB = NULL;
+PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB = NULL;
+PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB = NULL;
+
+#if LL_WINDOWS
+PFNWGLSWAPINTERVALEXTPROC                       wglSwapIntervalEXT = NULL;
+#endif
+
+#if LL_LINUX
+PFNGLCOLORTABLEEXTPROC glColorTableEXT = NULL;
+#endif // LL_LINUX
+
+#endif
+
+LLGLManager gGLManager;
+
+LLGLManager::LLGLManager() :
+        mInited(FALSE),
+        mIsDisabled(FALSE),
+
+        mHasMultitexture(FALSE),
+        mNumTextureUnits(1),
+        mHasMipMapGeneration(FALSE),
+        mHasPalettedTextures(FALSE),
+        mHasCompressedTextures(FALSE),
+        mHasFramebufferObject(FALSE),
+
+        mHasVertexBufferObject(FALSE),
+        mHasPBuffer(FALSE),
+        mHasShaderObjects(FALSE),
+        mHasVertexShader(FALSE),
+        mHasFragmentShader(FALSE),
+        mHasOcclusionQuery(FALSE),
+        mHasPointParameters(FALSE),
+
+        mHasAnisotropic(FALSE),
+        mHasARBEnvCombine(FALSE),
+        mHasCubeMap(FALSE),
+
+        mIsATI(FALSE),
+        mIsNVIDIA(FALSE),
+        mIsIntel(FALSE),
+        mIsGF2or4MX(FALSE),
+        mIsGF3(FALSE),
+        mIsGFFX(FALSE),
+        mATIOffsetVerticalLines(FALSE),
+        mATIOldDriver(FALSE),
+
+        mHasRequirements(TRUE),
+
+        mHasSeparateSpecularColor(FALSE),
+
+        mDriverVersionMajor(1),
+        mDriverVersionMinor(0),
+        mDriverVersionRelease(0),
+        mGLVersion(1.0f),
+                
+        mVRAM(0),
+        mGLMaxVertexRange(0),
+        mGLMaxIndexRange(0)
+{
+}
+
+//---------------------------------------------------------------------
+// Global initialization for GL
+//---------------------------------------------------------------------
+void LLGLManager::initWGL()
+{
+        mHasPBuffer = FALSE;
+#if LL_WINDOWS && !LL_MESA_HEADLESS
+        if (!glh_init_extensions("WGL_ARB_pixel_format"))
+        {
+                LL_WARNS("RenderInit") << "No ARB pixel format extensions" << LL_ENDL;
+        }
+
+        if (ExtensionExists("WGL_EXT_swap_control", gGLHExts.mSysExts))
+        {
+        GLH_EXT_NAME(wglSwapIntervalEXT) = (PFNWGLSWAPINTERVALEXTPROC)GLH_EXT_GET_PROC_ADDRESS("wglSwapIntervalEXT");
+        }
+
+        if( !glh_init_extensions("WGL_ARB_pbuffer") )
+        {
+                LL_WARNS("RenderInit") << "No ARB WGL PBuffer extensions" << LL_ENDL;
+        }
+
+        if( !glh_init_extensions("WGL_ARB_render_texture") )
+        {
+                LL_WARNS("RenderInit") << "No ARB WGL render texture extensions" << LL_ENDL;
+        }
+
+        mHasPBuffer = ExtensionExists("WGL_ARB_pbuffer", gGLHExts.mSysExts) &&
+                                        ExtensionExists("WGL_ARB_render_texture", gGLHExts.mSysExts) &&
+                                        ExtensionExists("WGL_ARB_pixel_format", gGLHExts.mSysExts);
+#endif
+}
+
+// return false if unable (or unwilling due to old drivers) to init GL
+bool LLGLManager::initGL()
+{
+        if (mInited)
+        {
+                LL_ERRS("RenderInit") << "Calling init on LLGLManager after already initialized!" << LL_ENDL;
+        }
+
+        GLint alpha_bits;
+        glGetIntegerv( GL_ALPHA_BITS, &alpha_bits );
+        if( 8 != alpha_bits )
+        {
+                LL_WARNS("RenderInit") << "Frame buffer has less than 8 bits of alpha.  Avatar texture compositing will fail." << LL_ENDL;
+        }
+
+        // Extract video card strings and convert to upper case to
+        // work around driver-to-driver variation in capitalization.
+        mGLVendor = std::string((const char *)glGetString(GL_VENDOR));
+        LLStringUtil::toUpper(mGLVendor);
+
+        mGLRenderer = std::string((const char *)glGetString(GL_RENDERER));
+        LLStringUtil::toUpper(mGLRenderer);
+
+        parse_gl_version( &mDriverVersionMajor, 
+                &mDriverVersionMinor, 
+                &mDriverVersionRelease, 
+                &mDriverVersionVendorString );
+
+        mGLVersion = mDriverVersionMajor + mDriverVersionMinor * .1f;
+        
+        // Trailing space necessary to keep "nVidia Corpor_ati_on" cards
+        // from being recognized as ATI.
+        if (mGLVendor.substr(0,4) == "ATI ")
+        {
+                mGLVendorShort = "ATI";
+                BOOL mobile = FALSE;
+                if (mGLRenderer.find("MOBILITY") != std::string::npos)
+                {
+                        mobile = TRUE;
+                }
+                mIsATI = TRUE;
+
+#if LL_WINDOWS && !LL_MESA_HEADLESS
+                if (mDriverVersionRelease < 3842)
+                {
+                        mATIOffsetVerticalLines = TRUE;
+                }
+#endif // LL_WINDOWS
+
+#if (LL_WINDOWS || LL_LINUX) && !LL_MESA_HEADLESS
+                // release 7277 is a point at which we verify that ATI OpenGL
+                // drivers get pretty stable with SL, ~Catalyst 8.2,
+                // for both Win32 and Linux.
+                if (mDriverVersionRelease < 7277 &&
+                    mDriverVersionRelease != 0) // 0 == Undetectable driver version - these get to pretend to be new ATI drivers, though that decision may be revisited.
+                {
+                        mATIOldDriver = TRUE;
+                }
+#endif // (LL_WINDOWS || LL_LINUX) && !LL_MESA_HEADLESS
+        }
+        else if (mGLVendor.find("NVIDIA ") != std::string::npos)
+        {
+                mGLVendorShort = "NVIDIA";
+                mIsNVIDIA = TRUE;
+                if (   mGLRenderer.find("GEFORCE4 MX") != std::string::npos
+                        || mGLRenderer.find("GEFORCE2") != std::string::npos
+                        || mGLRenderer.find("GEFORCE 2") != std::string::npos
+                        || mGLRenderer.find("GEFORCE4 460 GO") != std::string::npos
+                        || mGLRenderer.find("GEFORCE4 440 GO") != std::string::npos
+                        || mGLRenderer.find("GEFORCE4 420 GO") != std::string::npos)
+                {
+                        mIsGF2or4MX = TRUE;
+                }
+                else if (mGLRenderer.find("GEFORCE FX") != std::string::npos
+                                 || mGLRenderer.find("QUADRO FX") != std::string::npos
+                                 || mGLRenderer.find("NV34") != std::string::npos)
+                {
+                        mIsGFFX = TRUE;
+                }
+                else if(mGLRenderer.find("GEFORCE3") != std::string::npos)
+                {
+                        mIsGF3 = TRUE;
+                }
+
+        }
+        else if (mGLVendor.find("INTEL") != std::string::npos
+#if LL_LINUX
+                 // The Mesa-based drivers put this in the Renderer string,
+                 // not the Vendor string.
+                 || mGLRenderer.find("INTEL") != std::string::npos
+#endif //LL_LINUX
+                 )
+        {
+                mGLVendorShort = "INTEL";
+                mIsIntel = TRUE;
+        }
+        else
+        {
+                mGLVendorShort = "MISC";
+        }
+        
+        // This is called here because it depends on the setting of mIsGF2or4MX, and sets up mHasMultitexture.
+        initExtensions();
+
+        if (mHasMultitexture)
+        {
+                GLint num_tex_units;            
+                glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &num_tex_units);
+                mNumTextureUnits = llmin(num_tex_units, (GLint)MAX_GL_TEXTURE_UNITS);
+                if (mIsIntel)
+                {
+                        mNumTextureUnits = llmin(mNumTextureUnits, 2);
+                }
+        }
+        else
+        {
+                mHasRequirements = FALSE;
+
+                // We don't support cards that don't support the GL_ARB_multitexture extension
+                LL_WARNS("RenderInit") << "GL Drivers do not support GL_ARB_multitexture" << LL_ENDL;
+                return false;
+        }
+        
+
+        initGLStates();
+        return true;
+}
+
+void LLGLManager::getGLInfo(LLSD& info)
+{
+        info["GLInfo"]["GLVendor"] = std::string((const char *)glGetString(GL_VENDOR));
+        info["GLInfo"]["GLRenderer"] = std::string((const char *)glGetString(GL_RENDERER));
+        info["GLInfo"]["GLVersion"] = std::string((const char *)glGetString(GL_VERSION));
+
+#if !LL_MESA_HEADLESS
+        std::string all_exts = ll_safe_string((const char *)gGLHExts.mSysExts);
+        boost::char_separator<char> sep(" ");
+        boost::tokenizer<boost::char_separator<char> > tok(all_exts, sep);
+        for(boost::tokenizer<boost::char_separator<char> >::iterator i = tok.begin(); i != tok.end(); ++i)
+        {
+                info["GLInfo"]["GLExtensions"].append(*i);
+        }
+#endif
+}
+
+std::string LLGLManager::getGLInfoString()
+{
+        std::string info_str;
+        std::string all_exts, line;
+
+        info_str += std::string("GL_VENDOR      ") + ll_safe_string((const char *)glGetString(GL_VENDOR)) + std::string("\n");
+        info_str += std::string("GL_RENDERER    ") + ll_safe_string((const char *)glGetString(GL_RENDERER)) + std::string("\n");
+        info_str += std::string("GL_VERSION     ") + ll_safe_string((const char *)glGetString(GL_VERSION)) + std::string("\n");
+
+#if !LL_MESA_HEADLESS
+        all_exts = (const char *)gGLHExts.mSysExts;
+        LLStringUtil::replaceChar(all_exts, ' ', '\n');
+        info_str += std::string("GL_EXTENSIONS:\n") + all_exts + std::string("\n");
+#endif
+        
+        return info_str;
+}
+
+void LLGLManager::printGLInfoString()
+{
+        std::string info_str;
+        std::string all_exts, line;
+        
+        LL_INFOS("RenderInit") << "GL_VENDOR:     " << ((const char *)glGetString(GL_VENDOR)) << LL_ENDL;
+        LL_INFOS("RenderInit") << "GL_RENDERER:   " << ((const char *)glGetString(GL_RENDERER)) << LL_ENDL;
+        LL_INFOS("RenderInit") << "GL_VERSION:    " << ((const char *)glGetString(GL_VERSION)) << LL_ENDL;
+
+#if !LL_MESA_HEADLESS
+        all_exts = std::string(gGLHExts.mSysExts);
+        LLStringUtil::replaceChar(all_exts, ' ', '\n');
+        LL_DEBUGS("RenderInit") << "GL_EXTENSIONS:\n" << all_exts << LL_ENDL;
+#endif
+}
+
+std::string LLGLManager::getRawGLString()
+{
+        std::string gl_string;
+        gl_string = ll_safe_string((char*)glGetString(GL_VENDOR)) + " " + ll_safe_string((char*)glGetString(GL_RENDERER));
+        return gl_string;
+}
+
+void LLGLManager::shutdownGL()
+{
+        if (mInited)
+        {
+                glFinish();
+                stop_glerror();
+                mInited = FALSE;
+        }
+}
+
+// these are used to turn software blending on. They appear in the Debug/Avatar menu
+// presence of vertex skinning/blending or vertex programs will set these to FALSE by default.
+
+extern LLCPUInfo gSysCPU;
+
+void LLGLManager::initExtensions()
+{
+#if LL_MESA_HEADLESS
+# if GL_ARB_multitexture
+        mHasMultitexture = TRUE;
+# else
+        mHasMultitexture = FALSE;
+# endif
+# if GL_ARB_texture_env_combine
+        mHasARBEnvCombine = TRUE;       
+# else
+        mHasARBEnvCombine = FALSE;
+# endif
+# if GL_ARB_texture_compression
+        mHasCompressedTextures = TRUE;
+# else
+        mHasCompressedTextures = FALSE;
+# endif
+# if GL_ARB_vertex_buffer_object
+        mHasVertexBufferObject = TRUE;
+# else
+        mHasVertexBufferObject = FALSE;
+# endif
+# if GL_EXT_framebuffer_object
+        mHasFramebufferObject = TRUE;
+# else
+        mHasFramebufferObject = FALSE;
+# endif
+        mHasMipMapGeneration = FALSE;
+        mHasPalettedTextures = FALSE;
+        mHasSeparateSpecularColor = FALSE;
+        mHasAnisotropic = FALSE;
+        mHasCubeMap = FALSE;
+        mHasOcclusionQuery = FALSE;
+        mHasPointParameters = FALSE;
+        mHasShaderObjects = FALSE;
+        mHasVertexShader = FALSE;
+        mHasFragmentShader = FALSE;
+#else // LL_MESA_HEADLESS
+        mHasMultitexture = glh_init_extensions("GL_ARB_multitexture");
+        mHasMipMapGeneration = glh_init_extensions("GL_SGIS_generate_mipmap");
+        mHasPalettedTextures = glh_init_extension("GL_EXT_paletted_texture");
+        mHasSeparateSpecularColor = glh_init_extensions("GL_EXT_separate_specular_color");
+        mHasAnisotropic = glh_init_extensions("GL_EXT_texture_filter_anisotropic");
+        glh_init_extensions("GL_ARB_texture_cube_map");
+        mHasCubeMap = ExtensionExists("GL_ARB_texture_cube_map", gGLHExts.mSysExts);
+        mHasARBEnvCombine = ExtensionExists("GL_ARB_texture_env_combine", gGLHExts.mSysExts);
+        mHasCompressedTextures = glh_init_extensions("GL_ARB_texture_compression");
+        mHasOcclusionQuery = ExtensionExists("GL_ARB_occlusion_query", gGLHExts.mSysExts);
+        mHasVertexBufferObject = ExtensionExists("GL_ARB_vertex_buffer_object", gGLHExts.mSysExts);
+        // mask out FBO support when packed_depth_stencil isn't there 'cause we need it for LLRenderTarget -Brad
+        mHasFramebufferObject = ExtensionExists("GL_EXT_framebuffer_object", gGLHExts.mSysExts)
+                && ExtensionExists("GL_EXT_packed_depth_stencil", gGLHExts.mSysExts);
+#if !LL_DARWIN
+        mHasPointParameters = !mIsATI && ExtensionExists("GL_ARB_point_parameters", gGLHExts.mSysExts);
+#endif
+        mHasShaderObjects = ExtensionExists("GL_ARB_shader_objects", gGLHExts.mSysExts) && ExtensionExists("GL_ARB_shading_language_100", gGLHExts.mSysExts);
+        mHasVertexShader = ExtensionExists("GL_ARB_vertex_program", gGLHExts.mSysExts) && ExtensionExists("GL_ARB_vertex_shader", gGLHExts.mSysExts)
+                                                && ExtensionExists("GL_ARB_shading_language_100", gGLHExts.mSysExts);
+        mHasFragmentShader = ExtensionExists("GL_ARB_fragment_shader", gGLHExts.mSysExts) && ExtensionExists("GL_ARB_shading_language_100", gGLHExts.mSysExts);
+#endif
+
+#if LL_LINUX
+        // Our extension support for the Linux Client is very young with some
+        // potential driver gotchas, so offer a semi-secret way to turn it off.
+        if (getenv("LL_GL_NOEXT"))      /* Flawfinder: ignore */
+        {
+                //mHasMultitexture = FALSE; // NEEDED!
+                mHasARBEnvCombine = FALSE;
+                mHasCompressedTextures = FALSE;
+                mHasVertexBufferObject = FALSE;
+                mHasFramebufferObject = FALSE;
+                mHasMipMapGeneration = FALSE;
+                mHasPalettedTextures = FALSE;
+                mHasSeparateSpecularColor = FALSE;
+                mHasAnisotropic = FALSE;
+                mHasCubeMap = FALSE;
+                mHasOcclusionQuery = FALSE;
+                mHasPointParameters = FALSE;
+                mHasShaderObjects = FALSE;
+                mHasVertexShader = FALSE;
+                mHasFragmentShader = FALSE;
+                LL_WARNS("RenderInit") << "GL extension support DISABLED via LL_GL_NOEXT" << LL_ENDL;
+        }
+        else if (getenv("LL_GL_BASICEXT"))      /* Flawfinder: ignore */
+        {
+                // This switch attempts to turn off all support for exotic
+                // extensions which I believe correspond to fatal driver
+                // bug reports.  This should be the default until we get a
+                // proper blacklist/whitelist on Linux.
+                mHasMipMapGeneration = FALSE;
+                mHasPalettedTextures = FALSE;
+                mHasAnisotropic = FALSE;
+                //mHasCubeMap = FALSE; // apparently fatal on Intel 915 & similar
+                //mHasOcclusionQuery = FALSE; // source of many ATI system hangs
+                mHasShaderObjects = FALSE;
+                mHasVertexShader = FALSE;
+                mHasFragmentShader = FALSE;
+                LL_WARNS("RenderInit") << "GL extension support forced to SIMPLE level via LL_GL_BASICEXT" << LL_ENDL;
+        }
+        if (getenv("LL_GL_BLACKLIST"))  /* Flawfinder: ignore */
+        {
+                // This lets advanced troubleshooters disable specific
+                // GL extensions to isolate problems with their hardware.
+                // SL-28126
+                const char *const blacklist = getenv("LL_GL_BLACKLIST");        /* Flawfinder: ignore */
+                LL_WARNS("RenderInit") << "GL extension support partially disabled via LL_GL_BLACKLIST: " << blacklist << LL_ENDL;
+                if (strchr(blacklist,'a')) mHasARBEnvCombine = FALSE;
+                if (strchr(blacklist,'b')) mHasCompressedTextures = FALSE;
+                if (strchr(blacklist,'c')) mHasVertexBufferObject = FALSE;
+                if (strchr(blacklist,'d')) mHasMipMapGeneration = FALSE;//S
+                if (strchr(blacklist,'e')) mHasPalettedTextures = FALSE;//S
+//              if (strchr(blacklist,'f')) mHasNVVertexArrayRange = FALSE;//S
+//              if (strchr(blacklist,'g')) mHasNVFence = FALSE;//S
+                if (strchr(blacklist,'h')) mHasSeparateSpecularColor = FALSE;
+                if (strchr(blacklist,'i')) mHasAnisotropic = FALSE;//S
+                if (strchr(blacklist,'j')) mHasCubeMap = FALSE;//S
+//              if (strchr(blacklist,'k')) mHasATIVAO = FALSE;//S
+                if (strchr(blacklist,'l')) mHasOcclusionQuery = FALSE;
+                if (strchr(blacklist,'m')) mHasShaderObjects = FALSE;//S
+                if (strchr(blacklist,'n')) mHasVertexShader = FALSE;//S
+                if (strchr(blacklist,'o')) mHasFragmentShader = FALSE;//S
+                if (strchr(blacklist,'p')) mHasPointParameters = FALSE;//S
+                if (strchr(blacklist,'q')) mHasFramebufferObject = FALSE;//S
+        }
+#endif // LL_LINUX
+
+#if LL_DARWIN || LL_LINUX
+        // MBW -- 12/4/2003 -- Using paletted textures causes a bunch of avatar rendering problems on the Mac.
+        // Not sure if this is due to driver problems or incorrect use of the extension, but I'm disabling it for now.
+        // Tofu - 2006-10-03 -- Same problem on Linux.
+        mHasPalettedTextures = false;
+#endif
+        
+        if (!mHasMultitexture)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize multitexturing" << LL_ENDL;
+        }
+        if (!mHasMipMapGeneration)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize mipmap generation" << LL_ENDL;
+        }
+        if (!mHasARBEnvCombine)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_texture_env_combine" << LL_ENDL;
+        }
+        if (!mHasPalettedTextures)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_EXT_paletted_texture" << LL_ENDL;
+        }
+        if (!mHasSeparateSpecularColor)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize separate specular color" << LL_ENDL;
+        }
+        if (!mHasAnisotropic)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize anisotropic filtering" << LL_ENDL;
+        }
+        if (!mHasCompressedTextures)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_texture_compression" << LL_ENDL;
+        }
+        if (!mHasOcclusionQuery)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_occlusion_query" << LL_ENDL;
+        }
+        if (!mHasPointParameters)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_point_parameters" << LL_ENDL;
+        }
+        if (!mHasShaderObjects)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_shader_objects" << LL_ENDL;
+        }
+        if (!mHasVertexShader)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_vertex_shader" << LL_ENDL;
+        }
+        if (!mHasFragmentShader)
+        {
+                LL_INFOS("RenderInit") << "Couldn't initialize GL_ARB_fragment_shader" << LL_ENDL;
+        }
+
+        // Disable certain things due to known bugs
+        if (mIsIntel && mHasMipMapGeneration)
+        {
+                LL_INFOS("RenderInit") << "Disabling mip-map generation for Intel GPUs" << LL_ENDL;
+                mHasMipMapGeneration = FALSE;
+        }
+        if (mIsATI && mHasMipMapGeneration)
+        {
+                LL_INFOS("RenderInit") << "Disabling mip-map generation for ATI GPUs (performance opt)" << LL_ENDL;
+                mHasMipMapGeneration = FALSE;
+        }
+        
+        // Misc
+        glGetIntegerv(GL_MAX_ELEMENTS_VERTICES, (GLint*) &mGLMaxVertexRange);
+        glGetIntegerv(GL_MAX_ELEMENTS_INDICES, (GLint*) &mGLMaxIndexRange);
+        
+#if (LL_WINDOWS || LL_LINUX) && !LL_MESA_HEADLESS
+        LL_DEBUGS("RenderInit") << "GL Probe: Getting symbols" << LL_ENDL;
+        if (mHasVertexBufferObject)
+        {
+                glBindBufferARB = (PFNGLBINDBUFFERARBPROC)GLH_EXT_GET_PROC_ADDRESS("glBindBufferARB");
+                if (glBindBufferARB)
+                {
+                        glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)GLH_EXT_GET_PROC_ADDRESS("glDeleteBuffersARB");
+                        glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGenBuffersARB");
+                        glIsBufferARB = (PFNGLISBUFFERARBPROC)GLH_EXT_GET_PROC_ADDRESS("glIsBufferARB");
+                        glBufferDataARB = (PFNGLBUFFERDATAARBPROC)GLH_EXT_GET_PROC_ADDRESS("glBufferDataARB");
+                        glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)GLH_EXT_GET_PROC_ADDRESS("glBufferSubDataARB");
+                        glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetBufferSubDataARB");
+                        glMapBufferARB = (PFNGLMAPBUFFERARBPROC)GLH_EXT_GET_PROC_ADDRESS("glMapBufferARB");
+                        glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)GLH_EXT_GET_PROC_ADDRESS("glUnmapBufferARB");
+                        glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetBufferParameterivARB");
+                        glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetBufferPointervARB");
+                }
+                else
+                {
+                        mHasVertexBufferObject = FALSE;
+                }
+        }
+        if (mHasFramebufferObject)
+        {
+                glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glIsRenderbufferEXT");
+                glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glBindRenderbufferEXT");
+                glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glDeleteRenderbuffersEXT");
+                glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGenRenderbuffersEXT");
+                glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glRenderbufferStorageEXT");
+                glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGetRenderbufferParameterivEXT");
+                glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glIsFramebufferEXT");
+                glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glBindFramebufferEXT");
+                glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glDeleteFramebuffersEXT");
+                glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGenFramebuffersEXT");
+                glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glCheckFramebufferStatusEXT");
+                glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glFramebufferTexture1DEXT");
+                glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glFramebufferTexture2DEXT");
+                glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glFramebufferTexture3DEXT");
+                glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) GLH_EXT_GET_PROC_ADDRESS("glFramebufferRenderbufferEXT");
+                glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGetFramebufferAttachmentParameterivEXT");
+                glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC) GLH_EXT_GET_PROC_ADDRESS("glGenerateMipmapEXT");
+        }
+#if !LL_LINUX
+        // This is expected to be a static symbol on Linux GL implementations
+        glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)GLH_EXT_GET_PROC_ADDRESS("glDrawRangeElements");
+        if (!glDrawRangeElements)
+        {
+                mGLMaxVertexRange = 0;
+                mGLMaxIndexRange = 0;
+        }
+#endif // !LL_LINUX
+#if LL_LINUX
+        // On Linux we need to get glColorTableEXT dynamically.
+        if (mHasPalettedTextures)
+        {
+                glColorTableEXT = (PFNGLCOLORTABLEEXTPROC)GLH_EXT_GET_PROC_ADDRESS("glColorTableEXT");
+        }
+#endif // LL_LINUX
+        if (mHasOcclusionQuery)
+        {
+                glGenQueriesARB = (PFNGLGENQUERIESARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGenQueriesARB");
+                glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)GLH_EXT_GET_PROC_ADDRESS("glDeleteQueriesARB");
+                glIsQueryARB = (PFNGLISQUERYARBPROC)GLH_EXT_GET_PROC_ADDRESS("glIsQueryARB");
+                glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)GLH_EXT_GET_PROC_ADDRESS("glBeginQueryARB");
+                glEndQueryARB = (PFNGLENDQUERYARBPROC)GLH_EXT_GET_PROC_ADDRESS("glEndQueryARB");
+                glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetQueryivARB");
+                glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetQueryObjectivARB");
+                glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glGetQueryObjectuivARB");
+        }
+        if (mHasPointParameters)
+        {
+                glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)GLH_EXT_GET_PROC_ADDRESS("glPointParameterfARB");
+                glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)GLH_EXT_GET_PROC_ADDRESS("glPointParameterfvARB");
+        }
+        if (mHasShaderObjects)
+        {
+                glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glDeleteObjectARB");
+                glGetHandleARB = (PFNGLGETHANDLEARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetHandleARB");
+                glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glDetachObjectARB");
+                glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glCreateShaderObjectARB");
+                glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) GLH_EXT_GET_PROC_ADDRESS("glShaderSourceARB");
+                glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) GLH_EXT_GET_PROC_ADDRESS("glCompileShaderARB");
+                glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glCreateProgramObjectARB");
+                glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glAttachObjectARB");
+                glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) GLH_EXT_GET_PROC_ADDRESS("glLinkProgramARB");
+                glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUseProgramObjectARB");
+                glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC) GLH_EXT_GET_PROC_ADDRESS("glValidateProgramARB");
+                glUniform1fARB = (PFNGLUNIFORM1FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform1fARB");
+                glUniform2fARB = (PFNGLUNIFORM2FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform2fARB");
+                glUniform3fARB = (PFNGLUNIFORM3FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform3fARB");
+                glUniform4fARB = (PFNGLUNIFORM4FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform4fARB");
+                glUniform1iARB = (PFNGLUNIFORM1IARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform1iARB");
+                glUniform2iARB = (PFNGLUNIFORM2IARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform2iARB");
+                glUniform3iARB = (PFNGLUNIFORM3IARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform3iARB");
+                glUniform4iARB = (PFNGLUNIFORM4IARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform4iARB");
+                glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform1fvARB");
+                glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform2fvARB");
+                glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform3fvARB");
+                glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform4fvARB");
+                glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform1ivARB");
+                glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform2ivARB");
+                glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform3ivARB");
+                glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniform4ivARB");
+                glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniformMatrix2fvARB");
+                glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniformMatrix3fvARB");
+                glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glUniformMatrix4fvARB");
+                glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetObjectParameterfvARB");
+                glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetObjectParameterivARB");
+                glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetInfoLogARB");
+                glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetAttachedObjectsARB");
+                glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetUniformLocationARB");
+                glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetActiveUniformARB");
+                glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetUniformfvARB");
+                glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetUniformivARB");
+                glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetShaderSourceARB");
+        }
+        if (mHasVertexShader)
+        {
+                glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetAttribLocationARB");
+                glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC) GLH_EXT_GET_PROC_ADDRESS("glBindAttribLocationARB");
+                glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetActiveAttribARB");
+                glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1dARB");
+                glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1dvARB");
+                glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1fARB");
+                glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1fvARB");
+                glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1sARB");
+                glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib1svARB");
+                glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2dARB");
+                glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2dvARB");
+                glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2fARB");
+                glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2fvARB");
+                glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2sARB");
+                glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib2svARB");
+                glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3dARB");
+                glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3dvARB");
+                glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3fARB");
+                glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3fvARB");
+                glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3sARB");
+                glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib3svARB");
+                glVertexAttrib4nbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nbvARB");
+                glVertexAttrib4nivARB = (PFNGLVERTEXATTRIB4NIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nivARB");
+                glVertexAttrib4nsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nsvARB");
+                glVertexAttrib4nubARB = (PFNGLVERTEXATTRIB4NUBARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nubARB");
+                glVertexAttrib4nubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nubvARB");
+                glVertexAttrib4nuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nuivARB");
+                glVertexAttrib4nusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4nusvARB");
+                glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4bvARB");
+                glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4dARB");
+                glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4dvARB");
+                glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4fARB");
+                glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4fvARB");
+                glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4ivARB");
+                glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4sARB");
+                glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4svARB");
+                glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4ubvARB");
+                glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4uivARB");
+                glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttrib4usvARB");
+                glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC) GLH_EXT_GET_PROC_ADDRESS("glVertexAttribPointerARB");
+                glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC) GLH_EXT_GET_PROC_ADDRESS("glEnableVertexAttribArrayARB");
+                glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) GLH_EXT_GET_PROC_ADDRESS("glDisableVertexAttribArrayARB");
+                glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramStringARB");
+                glBindProgramARB = (PFNGLBINDPROGRAMARBPROC) GLH_EXT_GET_PROC_ADDRESS("glBindProgramARB");
+                glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC) GLH_EXT_GET_PROC_ADDRESS("glDeleteProgramsARB");
+                glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGenProgramsARB");
+                glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramEnvParameter4dARB");
+                glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramEnvParameter4dvARB");
+                glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramEnvParameter4fARB");
+                glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramEnvParameter4fvARB");
+                glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramLocalParameter4dARB");
+                glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramLocalParameter4dvARB");
+                glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramLocalParameter4fARB");
+                glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glProgramLocalParameter4fvARB");
+                glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramEnvParameterdvARB");
+                glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramEnvParameterfvARB");
+                glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramLocalParameterdvARB");
+                glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramLocalParameterfvARB");
+                glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramivARB");
+                glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetProgramStringARB");
+                glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetVertexAttribdvARB");
+                glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetVertexAttribfvARB");
+                glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glGetVertexAttribivARB");
+                glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC) GLH_EXT_GET_PROC_ADDRESS("glgetVertexAttribPointervARB");
+                glIsProgramARB = (PFNGLISPROGRAMARBPROC) GLH_EXT_GET_PROC_ADDRESS("glIsProgramARB");
+        }
+        LL_DEBUGS("RenderInit") << "GL Probe: Got symbols" << LL_ENDL;
+#endif
+
+        mInited = TRUE;
+}
+
+void rotate_quat(LLQuaternion& rotation)
+{
+        F32 angle_radians, x, y, z;
+        rotation.getAngleAxis(&angle_radians, &x, &y, &z);
+        glRotatef(angle_radians * RAD_TO_DEG, x, y, z);
+}
+
+void flush_glerror()
+{
+        glGetError();
+}
+
+void assert_glerror()
+{
+        if (gNoRender || !gDebugGL) 
+        {
+                return;
+        }
+        if (!gGLManager.mInited)
+        {
+                LL_ERRS("RenderInit") << "GL not initialized" << LL_ENDL;
+        }
+        //  Create or update texture to be used with this data 
+        GLenum error;
+        error = glGetError();
+        BOOL quit = FALSE;
+        while (error)
+        {
+                quit = TRUE;
+#ifndef LL_LINUX // *FIX: !  This should be an error for linux as well.
+                GLubyte const * gl_error_msg = gluErrorString(error);
+                if (NULL != gl_error_msg)
+                {
+                        LL_WARNS("RenderState") << "GL Error:" << gl_error_msg << LL_ENDL;
+                }
+                else
+                {
+                        // gluErrorString returns NULL for some extensions' error codes.
+                        // you'll probably have to grep for the number in glext.h.
+                        LL_WARNS("RenderState") << "GL Error: UNKNOWN 0x" << std::hex << error << LL_ENDL;
+                }
+                error = glGetError();
+#endif
+        }
+
+        if (quit)
+        {
+                llerrs << "One or more unhandled GL errors." << llendl;
+        }
+}
+
+void clear_glerror()
+{
+        //  Create or update texture to be used with this data 
+        GLenum error;
+        error = glGetError();
+}
+
+///////////////////////////////////////////////////////////////
+//
+// LLGLState
+//
+
+// Static members
+std::map<LLGLenum, LLGLboolean> LLGLState::sStateMap;
+
+GLboolean LLGLDepthTest::sDepthEnabled = GL_FALSE; // OpenGL default
+GLenum LLGLDepthTest::sDepthFunc = GL_LESS; // OpenGL default
+GLboolean LLGLDepthTest::sWriteEnabled = GL_TRUE; // OpenGL default
+
+//static
+void LLGLState::initClass() 
+{
+        sStateMap[GL_DITHER] = GL_TRUE;
+        sStateMap[GL_TEXTURE_2D] = GL_TRUE;
+
+        //make sure multisample defaults to disabled
+        sStateMap[GL_MULTISAMPLE_ARB] = GL_FALSE;
+        glDisable(GL_MULTISAMPLE_ARB);
+
+        //default vertex arrays to enabled.
+        glEnableClientState(GL_VERTEX_ARRAY);
+}
+
+//static
+void LLGLState::restoreGL()
+{
+        sStateMap.clear();
+        initClass();
+}
+
+//static
+// Really shouldn't be needed, but seems we sometimes do.
+void LLGLState::resetTextureStates()
+{
+        gGL.flush();
+        GLint maxTextureUnits;
+        
+        glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextureUnits);
+        for (S32 j = maxTextureUnits-1; j >=0; j--)
+        {
+                gGL.getTexUnit(j)->activate();
+                glClientActiveTextureARB(GL_TEXTURE0_ARB+j);
+                j == 0 ? glEnable(GL_TEXTURE_2D) : glDisable(GL_TEXTURE_2D);
+        }
+}
+
+void LLGLState::dumpStates() 
+{
+        LL_INFOS("RenderState") << "GL States:" << LL_ENDL;
+        for (std::map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
+                 iter != sStateMap.end(); ++iter)
+        {
+                LL_INFOS("RenderState") << llformat(" 0x%04x : %s",(S32)iter->first,iter->second?"TRUE":"FALSE") << LL_ENDL;
+        }
+}
+
+void LLGLState::checkStates(const std::string& msg)  
+{
+        if (!gDebugGL)
+        {
+                return;
+        }
+
+        stop_glerror();
+
+        GLint activeTexture;
+        glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &activeTexture);
+        
+        if (activeTexture != GL_TEXTURE0_ARB)
+        {
+                LL_GL_ERRS << "Texture channel corrupted. " << LL_ENDL;
+        }
+        
+        GLint src;
+        GLint dst;
+        glGetIntegerv(GL_BLEND_SRC, &src);
+        glGetIntegerv(GL_BLEND_DST, &dst);
+        
+        if (src != GL_SRC_ALPHA || dst != GL_ONE_MINUS_SRC_ALPHA)
+        {
+                LL_GL_ERRS << "Blend function corrupted: " << std::hex << src << " " << std::hex << dst << "  " << msg << LL_ENDL;
+        }
+        
+        for (std::map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
+                 iter != sStateMap.end(); ++iter)
+        {
+                LLGLenum state = iter->first;
+                LLGLboolean cur_state = iter->second;
+                LLGLboolean gl_state = glIsEnabled(state);
+                if(cur_state != gl_state)
+                {
+                        dumpStates();
+                        LL_GL_ERRS << llformat("LLGLState error. State: 0x%04x",state) << LL_ENDL;
+                }
+        }
+        
+        stop_glerror();
+}
+
+void LLGLState::checkTextureChannels(const std::string& msg)
+{
+        if (!gDebugGL)
+        {
+                return;
+        }
+
+        GLint activeTexture;
+        glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &activeTexture);
+        
+        BOOL error = FALSE;
+
+        if (activeTexture != GL_TEXTURE0_ARB)
+        {
+                error = TRUE;
+                LL_WARNS("RenderState") << "Active texture channel corrupted. " << LL_ENDL;
+        }
+        else if (!glIsEnabled(GL_TEXTURE_2D))
+        {
+                error = TRUE;
+                LL_WARNS("RenderState") << "GL_TEXTURE_2D not enabled on texture channel 0." << LL_ENDL;
+        }
+        else 
+        {
+                GLint tex_env_mode = 0;
+
+                glGetTexEnviv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, &tex_env_mode);
+                if (tex_env_mode != GL_MODULATE)
+                {
+                        error = TRUE;
+                        LL_WARNS("RenderState") << "GL_TEXTURE_ENV_MODE invalid: " << std::hex << tex_env_mode << LL_ENDL;
+                }
+        }
+
+        GLint maxTextureUnits;
+        glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextureUnits);
+
+        static const char* label[] =
+        {
+                "GL_TEXTURE_2D",
+                "GL_TEXTURE_COORD_ARRAY",
+                "GL_TEXTURE_1D",
+                "GL_TEXTURE_CUBE_MAP_ARB",
+                "GL_TEXTURE_GEN_S",
+                "GL_TEXTURE_GEN_T",
+                "GL_TEXTURE_GEN_Q",
+                "GL_TEXTURE_GEN_R"
+        };
+
+        static GLint value[] =
+        {
+                GL_TEXTURE_2D,
+                GL_TEXTURE_COORD_ARRAY,
+                GL_TEXTURE_1D,
+                GL_TEXTURE_CUBE_MAP_ARB,
+                GL_TEXTURE_GEN_S,
+                GL_TEXTURE_GEN_T,
+                GL_TEXTURE_GEN_Q,
+                GL_TEXTURE_GEN_R
+        };
+
+        GLint stackDepth = 0;
+        LLMatrix4 identity;
+        LLMatrix4 matrix;
+
+        for (GLint i = 0; i < maxTextureUnits; i++)
+        {
+                gGL.getTexUnit(i)->activate();
+                glClientActiveTextureARB(GL_TEXTURE0_ARB+i);
+
+                glGetIntegerv(GL_TEXTURE_STACK_DEPTH, &stackDepth);
+
+                if (stackDepth != 1)
+                {
+                        error = TRUE;
+                        LL_WARNS("RenderState") << "Texture matrix stack corrupted." << LL_ENDL;
+                }
+
+                glGetFloatv(GL_TEXTURE_MATRIX, (GLfloat*) matrix.mMatrix);
+
+                if (matrix != identity)
+                {
+                        error = TRUE;
+                        LL_WARNS("RenderState") << "Texture matrix in channel " << i << " corrupt." << LL_ENDL;
+                }
+
+                for (S32 j = (i == 0 ? 1 : 0); j < 8; j++)
+                {
+                        if (glIsEnabled(value[j]))
+                        {
+                                error = TRUE;
+                                LL_WARNS("RenderState") << "Texture channel " << i << " still has " << label[j] << " enabled." << LL_ENDL;
+                        }
+                }
+        }
+
+        gGL.getTexUnit(0)->activate();
+        glClientActiveTextureARB(GL_TEXTURE0_ARB);
+
+        if (error)
+        {
+                LL_GL_ERRS << "GL texture state corruption detected.  " << msg << LL_ENDL;
+        }
+}
+
+void LLGLState::checkClientArrays(const std::string& msg, U32 data_mask)
+{
+        if (!gDebugGL)
+        {
+                return;
+        }
+
+        stop_glerror();
+        BOOL error = FALSE;
+
+        GLint active_texture;
+        glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE_ARB, &active_texture);
+
+        if (active_texture != GL_TEXTURE0_ARB)
+        {
+                llwarns << "Client active texture corrupted: " << active_texture << llendl;
+                error = TRUE;
+        }
+
+        glGetIntegerv(GL_ACTIVE_TEXTURE_ARB, &active_texture);
+        if (active_texture != GL_TEXTURE0_ARB)
+        {
+                llwarns << "Active texture corrupted: " << active_texture << llendl;
+                error = TRUE;
+        }
+
+        static const char* label[] =
+        {
+                "GL_VERTEX_ARRAY",
+                "GL_NORMAL_ARRAY",
+                "GL_COLOR_ARRAY",
+                "GL_TEXTURE_COORD_ARRAY"
+        };
+
+        static GLint value[] =
+        {
+                GL_VERTEX_ARRAY,
+                GL_NORMAL_ARRAY,
+                GL_COLOR_ARRAY,
+                GL_TEXTURE_COORD_ARRAY
+        };
+
+         U32 mask[] = 
+        { //copied from llvertexbuffer.h
+                0x0001, //MAP_VERTEX,
+                0x0002, //MAP_NORMAL,
+                0x0010, //MAP_COLOR,
+                0x0004, //MAP_TEXCOORD
+        };
+
+
+        for (S32 j = 0; j < 4; j++)
+        {
+                if (glIsEnabled(value[j]))
+                {
+                        if (!(mask[j] & data_mask))
+                        {
+                                error = TRUE;
+                                LL_WARNS("RenderState") << "GL still has " << label[j] << " enabled." << LL_ENDL;
+                        }
+                }
+                else
+                {
+                        if (mask[j] & data_mask)
+                        {
+                                error = TRUE;
+                                LL_WARNS("RenderState") << "GL does not have " << label[j] << " enabled." << LL_ENDL;
+                        }
+                }
+        }
+
+        glClientActiveTextureARB(GL_TEXTURE1_ARB);
+        gGL.getTexUnit(1)->activate();
+        if (glIsEnabled(GL_TEXTURE_COORD_ARRAY))
+        {
+                if (!(data_mask & 0x0008))
+                {
+                        error = TRUE;
+                        LL_WARNS("RenderState") << "GL still has GL_TEXTURE_COORD_ARRAY enabled on channel 1." << LL_ENDL;
+                }
+        }
+        else
+        {
+                if (data_mask & 0x0008)
+                {
+                        error = TRUE;
+                        LL_WARNS("RenderState") << "GL does not have GL_TEXTURE_COORD_ARRAY enabled on channel 1." << LL_ENDL;
+                }
+        }
+
+        if (glIsEnabled(GL_TEXTURE_2D))
+        {
+                if (!(data_mask & 0x0008))
+                {
+                        error = TRUE;
+                        LL_WARNS("RenderState") << "GL still has GL_TEXTURE_2D enabled on channel 1." << LL_ENDL;
+                }
+        }
+        else
+        {
+                if (data_mask & 0x0008)
+                {
+                        error = TRUE;
+                        LL_WARNS("RenderState") << "GL does not have GL_TEXTURE_2D enabled on channel 1." << LL_ENDL;
+                }
+        }
+
+        glClientActiveTextureARB(GL_TEXTURE0_ARB);
+        gGL.getTexUnit(0)->activate();
+
+        if (error)
+        {
+                LL_GL_ERRS << "GL client array corruption detected.  " << msg << LL_ENDL;
+        }
+}
+
+///////////////////////////////////////////////////////////////////////
+
+LLGLState::LLGLState(LLGLenum state, S32 enabled) :
+        mState(state), mWasEnabled(FALSE), mIsEnabled(FALSE)
+{
+        stop_glerror();
+        if (state)
+        {
+                mWasEnabled = sStateMap[state];
+                llassert(mWasEnabled == glIsEnabled(state));
+                setEnabled(enabled);
+                stop_glerror();
+        }
+}
+
+void LLGLState::setEnabled(S32 enabled)
+{
+        if (!mState)
+        {
+                return;
+        }
+        if (enabled == CURRENT_STATE)
+        {
+                enabled = sStateMap[mState] == GL_TRUE ? TRUE : FALSE;
+        }
+        else if (enabled == TRUE && sStateMap[mState] != GL_TRUE)
+        {
+                gGL.flush();
+                glEnable(mState);
+                sStateMap[mState] = GL_TRUE;
+        }
+        else if (enabled == FALSE && sStateMap[mState] != GL_FALSE)
+        {
+                gGL.flush();
+                glDisable(mState);
+                sStateMap[mState] = GL_FALSE;
+        }
+        mIsEnabled = enabled;
+}
+
+LLGLState::~LLGLState() 
+{
+        stop_glerror();
+        if (mState)
+        {
+                if (gDebugGL)
+                {
+                        llassert_always(sStateMap[mState] == glIsEnabled(mState));
+                }
+
+                if (mIsEnabled != mWasEnabled)
+                {
+                        gGL.flush();
+                        if (mWasEnabled)
+                        {
+                                glEnable(mState);
+                                sStateMap[mState] = GL_TRUE;
+                        }
+                        else
+                        {
+                                glDisable(mState);
+                                sStateMap[mState] = GL_FALSE;
+                        }
+                }
+        }
+        stop_glerror();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void LLGLManager::initGLStates()
+{
+        //gl states moved to classes in llglstates.h
+        LLGLState::initClass();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void enable_vertex_weighting(const S32 index)
+{
+#if GL_ARB_vertex_program
+        if (index > 0) glEnableVertexAttribArrayARB(index);     // vertex weights
+#endif
+}
+
+void disable_vertex_weighting(const S32 index)
+{
+#if GL_ARB_vertex_program
+        if (index > 0) glDisableVertexAttribArrayARB(index);    // vertex weights
+#endif
+}
+
+void enable_binormals(const S32 index)
+{
+#if GL_ARB_vertex_program
+        if (index > 0)
+        {
+                glEnableVertexAttribArrayARB(index);    // binormals
+        }
+#endif
+}
+
+void disable_binormals(const S32 index)
+{
+#if GL_ARB_vertex_program
+        if (index > 0)
+        {
+                glDisableVertexAttribArrayARB(index);   // binormals
+        }
+#endif
+}
+
+
+void enable_cloth_weights(const S32 index)
+{
+#if GL_ARB_vertex_program
+        if (index > 0)  glEnableVertexAttribArrayARB(index);
+#endif
+}
+
+void disable_cloth_weights(const S32 index)
+{
+#if GL_ARB_vertex_program
+        if (index > 0) glDisableVertexAttribArrayARB(index);
+#endif
+}
+
+void set_vertex_weights(const S32 index, const U32 stride, const F32 *weights)
+{
+#if GL_ARB_vertex_program
+        if (index > 0) glVertexAttribPointerARB(index, 1, GL_FLOAT, FALSE, stride, weights);
+        stop_glerror();
+#endif
+}
+
+void set_vertex_clothing_weights(const S32 index, const U32 stride, const LLVector4 *weights)
+{
+#if GL_ARB_vertex_program
+        if (index > 0) glVertexAttribPointerARB(index, 4, GL_FLOAT, TRUE, stride, weights);
+        stop_glerror();
+#endif
+}
+
+void set_binormals(const S32 index, const U32 stride,const LLVector3 *binormals)
+{
+#if GL_ARB_vertex_program
+        if (index > 0) glVertexAttribPointerARB(index, 3, GL_FLOAT, FALSE, stride, binormals);
+        stop_glerror();
+#endif
+}
+
+
+void set_palette(U8 *palette_data)
+{
+        if (gGLManager.mHasPalettedTextures)
+        {
+                glColorTableEXT(GL_TEXTURE_2D, GL_RGBA8, 256, GL_RGBA, GL_UNSIGNED_BYTE, palette_data);
+        }
+}
+
+
+void parse_gl_version( S32* major, S32* minor, S32* release, std::string* vendor_specific )
+{
+        // GL_VERSION returns a null-terminated string with the format: 
+        // <major>.<minor>[.<release>] [<vendor specific>]
+
+        const char* version = (const char*) glGetString(GL_VERSION);
+        *major = 0;
+        *minor = 0;
+        *release = 0;
+        vendor_specific->assign("");
+
+        if( !version )
+        {
+                return;
+        }
+
+        std::string ver_copy( version );
+        S32 len = (S32)strlen( version );       /* Flawfinder: ignore */
+        S32 i = 0;
+        S32 start;
+        // Find the major version
+        start = i;
+        for( ; i < len; i++ )
+        {
+                if( '.' == version[i] )
+                {
+                        break;
+                }
+        }
+        std::string major_str = ver_copy.substr(start,i-start);
+        LLStringUtil::convertToS32(major_str, *major);
+
+        if( '.' == version[i] )
+        {
+                i++;
+        }
+
+        // Find the minor version
+        start = i;
+        for( ; i < len; i++ )
+        {
+                if( ('.' == version[i]) || isspace(version[i]) )
+                {
+                        break;
+                }
+        }
+        std::string minor_str = ver_copy.substr(start,i-start);
+        LLStringUtil::convertToS32(minor_str, *minor);
+
+        // Find the release number (optional)
+        if( '.' == version[i] )
+        {
+                i++;
+
+                start = i;
+                for( ; i < len; i++ )
+                {
+                        if( isspace(version[i]) )
+                        {
+                                break;
+                        }
+                }
+
+                std::string release_str = ver_copy.substr(start,i-start);
+                LLStringUtil::convertToS32(release_str, *release);
+        }
+
+        // Skip over any white space
+        while( version[i] && isspace( version[i] ) )
+        {
+                i++;
+        }
+
+        // Copy the vendor-specific string (optional)
+        if( version[i] )
+        {
+                vendor_specific->assign( version + i );
+        }
+}
+
+LLGLUserClipPlane::LLGLUserClipPlane(const LLPlane& p, const glh::matrix4f& modelview, const glh::matrix4f& projection)
+{
+        mModelview = modelview;
+        mProjection = projection;
+
+        setPlane(p.mV[0], p.mV[1], p.mV[2], p.mV[3]);
+}
+
+void LLGLUserClipPlane::setPlane(F32 a, F32 b, F32 c, F32 d)
+{
+        glh::matrix4f& P = mProjection;
+        glh::matrix4f& M = mModelview;
+    
+        glh::matrix4f invtrans_MVP = (P * M).inverse().transpose();
+    glh::vec4f oplane(a,b,c,d);
+    glh::vec4f cplane;
+    invtrans_MVP.mult_matrix_vec(oplane, cplane);
+
+    cplane /= fabs(cplane[2]); // normalize such that depth is not scaled
+    cplane[3] -= 1;
+
+    if(cplane[2] < 0)
+        cplane *= -1;
+
+    glh::matrix4f suffix;
+    suffix.set_row(2, cplane);
+    glh::matrix4f newP = suffix * P;
+    glMatrixMode(GL_PROJECTION);
+        glPushMatrix();
+    glLoadMatrixf(newP.m);
+        gGLObliqueProjectionInverse = LLMatrix4(newP.inverse().transpose().m);
+    glMatrixMode(GL_MODELVIEW);
+}
+
+LLGLUserClipPlane::~LLGLUserClipPlane()
+{
+        glMatrixMode(GL_PROJECTION);
+        glPopMatrix();
+        glMatrixMode(GL_MODELVIEW);
+}
+
+LLGLNamePool::LLGLNamePool()
+{
+}
+
+void LLGLNamePool::registerPool(LLGLNamePool* pool)
+{
+        pool_list_t::iterator iter = std::find(sInstances.begin(), sInstances.end(), pool);
+        if (iter == sInstances.end())
+        {
+                sInstances.push_back(pool);
+        }
+}
+
+LLGLNamePool::~LLGLNamePool()
+{
+        pool_list_t::iterator iter = std::find(sInstances.begin(), sInstances.end(), this);
+        if (iter != sInstances.end())
+        {
+                sInstances.erase(iter);
+        }
+}
+
+void LLGLNamePool::upkeep()
+{
+        std::sort(mNameList.begin(), mNameList.end(), CompareUsed());
+}
+
+void LLGLNamePool::cleanup()
+{
+        for (name_list_t::iterator iter = mNameList.begin(); iter != mNameList.end(); ++iter)
+        {
+                releaseName(iter->name);
+        }
+
+        mNameList.clear();
+}
+
+GLuint LLGLNamePool::allocate()
+{
+#if LL_GL_NAME_POOLING
+        for (name_list_t::iterator iter = mNameList.begin(); iter != mNameList.end(); ++iter)
+        {
+                if (!iter->used)
+                {
+                        iter->used = TRUE;
+                        return iter->name;
+                }
+        }
+
+        NameEntry entry;
+        entry.name = allocateName();
+        entry.used = TRUE;
+        mNameList.push_back(entry);
+
+        return entry.name;
+#else
+        return allocateName();
+#endif
+}
+
+void LLGLNamePool::release(GLuint name)
+{
+#if LL_GL_NAME_POOLING
+        for (name_list_t::iterator iter = mNameList.begin(); iter != mNameList.end(); ++iter)
+        {
+                if (iter->name == name)
+                {
+                        if (iter->used)
+                        {
+                                iter->used = FALSE;
+                                return;
+                        }
+                        else
+                        {
+                                llerrs << "Attempted to release a pooled name that is not in use!" << llendl;
+                        }
+                }
+        }
+        llerrs << "Attempted to release a non pooled name!" << llendl;
+#else
+        releaseName(name);
+#endif
+}
+
+//static
+void LLGLNamePool::upkeepPools()
+{
+        for (pool_list_t::iterator iter = sInstances.begin(); iter != sInstances.end(); ++iter)
+        {
+                LLGLNamePool* pool = *iter;
+                pool->upkeep();
+        }
+}
+
+//static
+void LLGLNamePool::cleanupPools()
+{
+        for (pool_list_t::iterator iter = sInstances.begin(); iter != sInstances.end(); ++iter)
+        {
+                LLGLNamePool* pool = *iter;
+                pool->cleanup();
+        }
+}
+
+LLGLDepthTest::LLGLDepthTest(GLboolean depth_enabled, GLboolean write_enabled, GLenum depth_func)
+: mPrevDepthEnabled(sDepthEnabled), mPrevDepthFunc(sDepthFunc), mPrevWriteEnabled(sWriteEnabled)
+{
+        if (depth_enabled != sDepthEnabled)
+        {
+                gGL.flush();
+                if (depth_enabled) glEnable(GL_DEPTH_TEST);
+                else glDisable(GL_DEPTH_TEST);
+                sDepthEnabled = depth_enabled;
+        }
+        if (depth_func != sDepthFunc)
+        {
+                gGL.flush();
+                glDepthFunc(depth_func);
+                sDepthFunc = depth_func;
+        }
+        if (write_enabled != sWriteEnabled)
+        {
+                gGL.flush();
+                glDepthMask(write_enabled);
+                sWriteEnabled = write_enabled;
+        }
+}
+
+LLGLDepthTest::~LLGLDepthTest()
+{
+        if (sDepthEnabled != mPrevDepthEnabled )
+        {
+                gGL.flush();
+                if (mPrevDepthEnabled) glEnable(GL_DEPTH_TEST);
+                else glDisable(GL_DEPTH_TEST);
+                sDepthEnabled = mPrevDepthEnabled;
+        }
+        if (sDepthFunc != mPrevDepthFunc)
+        {
+                gGL.flush();
+                glDepthFunc(mPrevDepthFunc);
+                sDepthFunc = mPrevDepthFunc;
+        }
+        if (sWriteEnabled != mPrevWriteEnabled )
+        {
+                gGL.flush();
+                glDepthMask(mPrevWriteEnabled);
+                sWriteEnabled = mPrevWriteEnabled;
+        }
+}
+
+LLGLClampToFarClip::LLGLClampToFarClip(glh::matrix4f P)
+{
+        for (U32 i = 0; i < 4; i++)
+        {
+                P.element(2, i) = P.element(3, i) * 0.99999f;
+        }
+
+        glMatrixMode(GL_PROJECTION);
+        glPushMatrix();
+        glLoadMatrixf(P.m);
+        glMatrixMode(GL_MODELVIEW);
+}
+
+LLGLClampToFarClip::~LLGLClampToFarClip()
+{
+        glMatrixMode(GL_PROJECTION);
+        glPopMatrix();
+        glMatrixMode(GL_MODELVIEW);
+}
+
diff --git a/linden/indra/llrender/llgl.h b/linden/indra/llrender/llgl.h
new file mode 100644
index 0000000..cb368d7
--- /dev/null
+++ b/linden/indra/llrender/llgl.h
@@ -0,0 +1,378 @@
+/** 
+ * @file llgl.h
+ * @brief LLGL definition
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLGL_H
+#define LL_LLGL_H
+
+// This file contains various stuff for handling gl extensions and other gl related stuff.
+
+#include <string>
+#include <map>
+
+#include "llerror.h"
+#include "v4color.h"
+#include "llstring.h"
+#include "stdtypes.h"
+#include "v4math.h"
+#include "llplane.h"
+#include "llgltypes.h"
+
+#include "llglheaders.h"
+#include "glh/glh_linear.h"
+
+extern BOOL gDebugGL;
+
+#define LL_GL_ERRS LL_ERRS("RenderState")
+
+class LLSD;
+
+// Manage GL extensions...
+class LLGLManager
+{
+public:
+        LLGLManager();
+
+        bool initGL();
+        void shutdownGL();
+
+        void initWGL(); // Initializes stupid WGL extensions
+
+        std::string getRawGLString(); // For sending to simulator
+
+        BOOL mInited;
+        BOOL mIsDisabled;
+
+        // Extensions used by everyone
+        BOOL mHasMultitexture;
+        S32      mNumTextureUnits;
+        BOOL mHasMipMapGeneration;
+        BOOL mHasPalettedTextures;
+        BOOL mHasCompressedTextures;
+        BOOL mHasFramebufferObject;
+
+        // ARB Extensions
+        BOOL mHasVertexBufferObject;
+        BOOL mHasPBuffer;
+        BOOL mHasShaderObjects;
+        BOOL mHasVertexShader;
+        BOOL mHasFragmentShader;
+        BOOL mHasOcclusionQuery;
+        BOOL mHasPointParameters;
+
+        // Other extensions.
+        BOOL mHasAnisotropic;
+        BOOL mHasARBEnvCombine;
+        BOOL mHasCubeMap;
+
+        // Vendor-specific extensions
+        BOOL mIsATI;
+        BOOL mIsNVIDIA;
+        BOOL mIsIntel;
+        BOOL mIsGF2or4MX;
+        BOOL mIsGF3;
+        BOOL mIsGFFX;
+        BOOL mATIOffsetVerticalLines;
+        BOOL mATIOldDriver;
+
+        // Whether this version of GL is good enough for SL to use
+        BOOL mHasRequirements;
+
+        // Misc extensions
+        BOOL mHasSeparateSpecularColor;
+        
+        S32 mDriverVersionMajor;
+        S32 mDriverVersionMinor;
+        S32 mDriverVersionRelease;
+        F32 mGLVersion; // e.g = 1.4
+        std::string mDriverVersionVendorString;
+
+        S32 mVRAM; // VRAM in MB
+        S32 mGLMaxVertexRange;
+        S32 mGLMaxIndexRange;
+        
+        void getPixelFormat(); // Get the best pixel format
+
+        std::string getGLInfoString();
+        void printGLInfoString();
+        void getGLInfo(LLSD& info);
+
+        // In ALL CAPS
+        std::string mGLVendor;
+        std::string mGLVendorShort;
+
+        // In ALL CAPS
+        std::string mGLRenderer;
+
+private:
+        void initExtensions();
+        void initGLStates();
+        void initGLImages();
+};
+
+extern LLGLManager gGLManager;
+
+class LLQuaternion;
+class LLMatrix4;
+
+void rotate_quat(LLQuaternion& rotation);
+
+void flush_glerror(); // Flush GL errors when we know we're handling them correctly.
+
+void assert_glerror();
+
+void clear_glerror();
+
+//#if LL_DEBUG
+# define stop_glerror() assert_glerror()
+# define llglassertok() assert_glerror()
+//#else
+//# define stop_glerror()
+//# define llglassertok()
+//#endif
+
+#define llglassertok_always() assert_glerror()
+
+////////////////////////
+//
+// Note: U32's are GLEnum's...
+//
+
+// This is a class for GL state management
+
+/*
+        GL STATE MANAGEMENT DESCRIPTION
+
+        LLGLState and its two subclasses, LLGLEnable and LLGLDisable, manage the current 
+        enable/disable states of the GL to prevent redundant setting of state within a 
+        render path or the accidental corruption of what state the next path expects.
+
+        Essentially, wherever you would call glEnable set a state and then
+        subsequently reset it by calling glDisable (or vice versa), make an instance of 
+        LLGLEnable with the state you want to set, and assume it will be restored to its
+        original state when that instance of LLGLEnable is destroyed.  It is good practice
+        to exploit stack frame controls for optimal setting/unsetting and readability of 
+        code.  In llglstates.h, there are a collection of helper classes that define groups
+        of enables/disables that can cause multiple states to be set with the creation of
+        one instance.  
+
+        Sample usage:
+
+        //disable lighting for rendering hud objects
+        //INCORRECT USAGE
+        LLGLEnable lighting(GL_LIGHTING);
+        renderHUD();
+        LLGLDisable lighting(GL_LIGHTING);
+
+        //CORRECT USAGE
+        {
+                LLGLEnable lighting(GL_LIGHTING);
+                renderHUD();
+        }
+
+        If a state is to be set on a conditional, the following mechanism
+        is useful:
+
+        {
+                LLGLEnable lighting(light_hud ? GL_LIGHTING : 0);
+                renderHUD();
+        }
+
+        A LLGLState initialized with a parameter of 0 does nothing.
+
+        LLGLState works by maintaining a map of the current GL states, and ignoring redundant
+        enables/disables.  If a redundant call is attempted, it becomes a noop, otherwise,
+        it is set in the constructor and reset in the destructor.  
+
+        For debugging GL state corruption, running with debug enabled will trigger asserts
+        if the existing GL state does not match the expected GL state.
+
+*/
+class LLGLState
+{
+public:
+        static void initClass();
+        static void restoreGL();
+
+        static void resetTextureStates();
+        static void dumpStates();
+        static void checkStates(const std::string& msg = "");
+        static void checkTextureChannels(const std::string& msg = "");
+        static void checkClientArrays(const std::string& msg = "", U32 data_mask = 0x0001);
+        
+protected:
+        static std::map<LLGLenum, LLGLboolean> sStateMap;
+        
+public:
+        enum { CURRENT_STATE = -2 };
+        LLGLState(LLGLenum state, S32 enabled = CURRENT_STATE);
+        ~LLGLState();
+        void setEnabled(S32 enabled);
+        void enable() { setEnabled(TRUE); }
+        void disable() { setEnabled(FALSE); }
+protected:
+        LLGLenum mState;
+        BOOL mWasEnabled;
+        BOOL mIsEnabled;
+};
+
+// New LLGLState class wrappers that don't depend on actual GL flags.
+class LLGLEnableBlending : public LLGLState
+{
+public:
+        LLGLEnableBlending(bool enable);
+};
+
+class LLGLEnableAlphaReject : public LLGLState
+{
+public:
+        LLGLEnableAlphaReject(bool enable);
+};
+
+/// TODO: Being deprecated.
+class LLGLEnable : public LLGLState
+{
+public:
+        LLGLEnable(LLGLenum state) : LLGLState(state, TRUE) {}
+};
+
+/// TODO: Being deprecated.
+class LLGLDisable : public LLGLState
+{
+public:
+        LLGLDisable(LLGLenum state) : LLGLState(state, FALSE) {}
+};
+
+/*
+  Store and modify projection matrix to create an oblique
+  projection that clips to the specified plane.  Oblique
+  projections alter values in the depth buffer, so this
+  class should not be used mid-renderpass.  
+
+  Restores projection matrix on destruction.
+  GL_MODELVIEW_MATRIX is active whenever program execution
+  leaves this class.
+  Does not stack.
+  Caches inverse of projection matrix used in gGLObliqueProjectionInverse
+*/
+class LLGLUserClipPlane 
+{
+public:
+        
+        LLGLUserClipPlane(const LLPlane& plane, const glh::matrix4f& modelview, const glh::matrix4f& projection);
+        ~LLGLUserClipPlane();
+
+        void setPlane(F32 a, F32 b, F32 c, F32 d);
+
+private:
+        glh::matrix4f mProjection;
+        glh::matrix4f mModelview;
+};
+
+/*
+  Modify and load projection matrix to push depth values to far clip plane.
+
+  Restores projection matrix on destruction.
+  GL_MODELVIEW_MATRIX is active whenever program execution
+  leaves this class.
+  Does not stack.
+*/
+class LLGLClampToFarClip
+{
+public:
+        LLGLClampToFarClip(glh::matrix4f projection);
+        ~LLGLClampToFarClip();
+};
+
+/*
+        Generic pooling scheme for things which use GL names (used for occlusion queries and vertex buffer objects).
+        Prevents thrashing of GL name caches by avoiding calls to glGenFoo and glDeleteFoo.
+*/
+class LLGLNamePool
+{
+public:
+        typedef struct
+        {
+                GLuint name;
+                BOOL used;
+        } NameEntry;
+
+        struct CompareUsed
+        {
+                bool operator()(const NameEntry& lhs, const NameEntry& rhs)
+                {
+                        return lhs.used < rhs.used;  //FALSE entries first
+                }
+        };
+
+        typedef std::vector<NameEntry> name_list_t;
+        name_list_t mNameList;
+
+        LLGLNamePool();
+        virtual ~LLGLNamePool();
+        
+        void upkeep();
+        void cleanup();
+        
+        GLuint allocate();
+        void release(GLuint name);
+        
+        static void registerPool(LLGLNamePool* pool);
+        static void upkeepPools();
+        static void cleanupPools();
+
+protected:
+        typedef std::vector<LLGLNamePool*> pool_list_t;
+        static pool_list_t sInstances;
+        
+        virtual GLuint allocateName() = 0;
+        virtual void releaseName(GLuint name) = 0;
+};
+
+extern LLMatrix4 gGLObliqueProjectionInverse;
+
+#include "llglstates.h"
+
+void init_glstates();
+void enable_vertex_weighting(const S32 index);
+void disable_vertex_weighting(const S32 index);
+void enable_binormals(const S32 index);
+void disable_binormals(const S32 index);
+void enable_cloth_weights(const S32 index);
+void disable_cloth_weights(const S32 index);
+void set_vertex_weights(const S32 index, const U32 stride, const F32 *weights);
+void set_vertex_clothing_weights(const S32 index, const U32 stride, const LLVector4 *weights);
+void set_binormals(const S32 index, const U32 stride, const LLVector3 *binormals);
+void set_palette(U8* palette_data);
+void parse_gl_version( S32* major, S32* minor, S32* release, std::string* vendor_specific );
+
+extern BOOL gClothRipple;
+extern BOOL gNoRender;
+#endif // LL_LLGL_H
diff --git a/linden/indra/llrender/llgldbg.cpp b/linden/indra/llrender/llgldbg.cpp
index 953ba3a..526215b 100644
--- a/linden/indra/llrender/llgldbg.cpp
+++ b/linden/indra/llrender/llgldbg.cpp
@@ -43,7 +43,7 @@
 //------------------------------------------------------------------------
 // cmstr()
 //------------------------------------------------------------------------
-char *cmstr(int i)
+const char *cmstr(int i)
 {
         switch( i )
         {
@@ -59,7 +59,7 @@ char *cmstr(int i)
 //------------------------------------------------------------------------
 // facestr()
 //------------------------------------------------------------------------
-char *facestr(int i)
+const char *facestr(int i)
 {
         switch( i )
         {
@@ -81,7 +81,7 @@ const char *boolstr(int b)
 //------------------------------------------------------------------------
 // fv4()
 //------------------------------------------------------------------------
-char *fv4(F32 *f)
+const 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]);
@@ -91,7 +91,7 @@ char *fv4(F32 *f)
 //------------------------------------------------------------------------
 // fv3()
 //------------------------------------------------------------------------
-char *fv3(F32 *f)
+const char *fv3(F32 *f)
 {
         static char str[128];   /* Flawfinder: ignore */
         snprintf(str, sizeof(str), "%8.3f, %8.3f, %8.3f", f[0], f[1], f[2]);    /* Flawfinder: ignore */
@@ -101,7 +101,7 @@ char *fv3(F32 *f)
 //------------------------------------------------------------------------
 // fv1()
 //------------------------------------------------------------------------
-char *fv1(F32 *f)
+const char *fv1(F32 *f)
 {
         static char str[128];   /* Flawfinder: ignore */
         snprintf(str, sizeof(str), "%8.3f", f[0]);              /* Flawfinder: ignore */
diff --git a/linden/indra/llrender/llglheaders.h b/linden/indra/llrender/llglheaders.h
new file mode 100644
index 0000000..f047262
--- /dev/null
+++ b/linden/indra/llrender/llglheaders.h
@@ -0,0 +1,588 @@
+/** 
+ * @file llglheaders.h
+ * @brief LLGL definitions
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLGLHEADERS_H
+#define LL_LLGLHEADERS_H
+
+#if LL_MESA
+//----------------------------------------------------------------------------
+// MESA headers
+// quotes so we get libraries/.../GL/ version
+#define GL_GLEXT_PROTOTYPES
+#include "GL/gl.h"
+#include "GL/glext.h"
+#include "GL/glu.h"
+
+// The __APPLE__ kludge is to make glh_extensions.h not symbol-clash horribly
+# define __APPLE__
+# include "GL/glh_extensions.h"
+# undef __APPLE__
+
+#elif LL_LINUX
+//----------------------------------------------------------------------------
+// Linux, MESA headers, but not necessarily assuming MESA runtime.
+// quotes so we get libraries/.../GL/ version
+#include "GL/gl.h"
+#include "GL/glext.h"
+#include "GL/glu.h"
+
+
+#if LL_LINUX && !LL_MESA_HEADLESS
+// The __APPLE__ kludge is to make glh_extensions.h not symbol-clash horribly
+# define __APPLE__
+# include "GL/glh_extensions.h"
+# undef __APPLE__
+
+/* Although SDL very likely ends up calling glXGetProcAddress() itself,
+   if we use SDL_GL_GetProcAddress() then we get bogus addresses back on
+   some systems.  Weird. */
+/*# include "SDL/SDL.h"
+  # define GLH_EXT_GET_PROC_ADDRESS(p) SDL_GL_GetProcAddress(p) */
+#define GLX_GLXEXT_PROTOTYPES 1
+# include "GL/glx.h"
+# include "GL/glxext.h"
+// Use glXGetProcAddressARB instead of glXGetProcAddress - the ARB symbol
+// is considered 'legacy' but works on more machines.
+# define GLH_EXT_GET_PROC_ADDRESS(p) glXGetProcAddressARB((const GLubyte*)(p))
+// Whee, the X headers define 'Status'.  Undefine to avoid confusion.
+#undef Status
+#endif // LL_LINUX && !LL_MESA_HEADLESS
+
+
+// GL_ARB_vertex_buffer_object
+extern PFNGLBINDBUFFERARBPROC           glBindBufferARB;
+extern PFNGLDELETEBUFFERSARBPROC        glDeleteBuffersARB;
+extern PFNGLGENBUFFERSARBPROC           glGenBuffersARB;
+extern PFNGLISBUFFERARBPROC                     glIsBufferARB;
+extern PFNGLBUFFERDATAARBPROC           glBufferDataARB;
+extern PFNGLBUFFERSUBDATAARBPROC        glBufferSubDataARB;
+extern PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB;
+extern PFNGLMAPBUFFERARBPROC            glMapBufferARB;
+extern PFNGLUNMAPBUFFERARBPROC          glUnmapBufferARB;
+extern PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB;
+extern PFNGLGETBUFFERPOINTERVARBPROC    glGetBufferPointervARB;
+
+// GL_ATI_vertex_array_object
+extern PFNGLNEWOBJECTBUFFERATIPROC                      glNewObjectBufferATI;
+extern PFNGLISOBJECTBUFFERATIPROC                       glIsObjectBufferATI;
+extern PFNGLUPDATEOBJECTBUFFERATIPROC           glUpdateObjectBufferATI;
+extern PFNGLGETOBJECTBUFFERFVATIPROC            glGetObjectBufferfvATI;
+extern PFNGLGETOBJECTBUFFERIVATIPROC            glGetObjectBufferivATI;
+extern PFNGLFREEOBJECTBUFFERATIPROC                 glFreeObjectBufferATI;
+extern PFNGLARRAYOBJECTATIPROC                          glArrayObjectATI;
+extern PFNGLVERTEXATTRIBARRAYOBJECTATIPROC      glVertexAttribArrayObjectATI;
+extern PFNGLGETARRAYOBJECTFVATIPROC                     glGetArrayObjectfvATI;
+extern PFNGLGETARRAYOBJECTIVATIPROC                     glGetArrayObjectivATI;
+extern PFNGLVARIANTARRAYOBJECTATIPROC           glVariantObjectArrayATI;
+extern PFNGLGETVARIANTARRAYOBJECTFVATIPROC      glGetVariantArrayObjectfvATI;
+extern PFNGLGETVARIANTARRAYOBJECTIVATIPROC      glGetVariantArrayObjectivATI;
+
+// GL_ARB_occlusion_query
+extern PFNGLGENQUERIESARBPROC glGenQueriesARB;
+extern PFNGLDELETEQUERIESARBPROC glDeleteQueriesARB;
+extern PFNGLISQUERYARBPROC glIsQueryARB;
+extern PFNGLBEGINQUERYARBPROC glBeginQueryARB;
+extern PFNGLENDQUERYARBPROC glEndQueryARB;
+extern PFNGLGETQUERYIVARBPROC glGetQueryivARB;
+extern PFNGLGETQUERYOBJECTIVARBPROC glGetQueryObjectivARB;
+extern PFNGLGETQUERYOBJECTUIVARBPROC glGetQueryObjectuivARB;
+
+// GL_ARB_point_parameters
+extern PFNGLPOINTPARAMETERFARBPROC glPointParameterfARB;
+extern PFNGLPOINTPARAMETERFVARBPROC glPointParameterfvARB;
+
+// GL_ARB_shader_objects
+extern PFNGLDELETEOBJECTARBPROC glDeleteObjectARB;
+extern PFNGLGETHANDLEARBPROC glGetHandleARB;
+extern PFNGLDETACHOBJECTARBPROC glDetachObjectARB;
+extern PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB;
+extern PFNGLSHADERSOURCEARBPROC glShaderSourceARB;
+extern PFNGLCOMPILESHADERARBPROC glCompileShaderARB;
+extern PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB;
+extern PFNGLATTACHOBJECTARBPROC glAttachObjectARB;
+extern PFNGLLINKPROGRAMARBPROC glLinkProgramARB;
+extern PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB;
+extern PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB;
+extern PFNGLUNIFORM1FARBPROC glUniform1fARB;
+extern PFNGLUNIFORM2FARBPROC glUniform2fARB;
+extern PFNGLUNIFORM3FARBPROC glUniform3fARB;
+extern PFNGLUNIFORM4FARBPROC glUniform4fARB;
+extern PFNGLUNIFORM1IARBPROC glUniform1iARB;
+extern PFNGLUNIFORM2IARBPROC glUniform2iARB;
+extern PFNGLUNIFORM3IARBPROC glUniform3iARB;
+extern PFNGLUNIFORM4IARBPROC glUniform4iARB;
+extern PFNGLUNIFORM1FVARBPROC glUniform1fvARB;
+extern PFNGLUNIFORM2FVARBPROC glUniform2fvARB;
+extern PFNGLUNIFORM3FVARBPROC glUniform3fvARB;
+extern PFNGLUNIFORM4FVARBPROC glUniform4fvARB;
+extern PFNGLUNIFORM1IVARBPROC glUniform1ivARB;
+extern PFNGLUNIFORM2IVARBPROC glUniform2ivARB;
+extern PFNGLUNIFORM3IVARBPROC glUniform3ivARB;
+extern PFNGLUNIFORM4IVARBPROC glUniform4ivARB;
+extern PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB;
+extern PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB;
+extern PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB;
+extern PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB;
+extern PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB;
+extern PFNGLGETINFOLOGARBPROC glGetInfoLogARB;
+extern PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB;
+extern PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB;
+extern PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB;
+extern PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB;
+extern PFNGLGETUNIFORMIVARBPROC glGetUniformivARB;
+extern PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB;
+
+// GL_ARB_vertex_shader
+extern PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB;
+extern PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB;
+extern PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB;
+extern PFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB;
+extern PFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB;
+extern PFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB;
+extern PFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB;
+extern PFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB;
+extern PFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB;
+extern PFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB;
+extern PFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB;
+extern PFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB;
+extern PFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB;
+extern PFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB;
+extern PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB;
+extern PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB;
+extern PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB;
+extern PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB;
+extern PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4nbvARB;
+extern PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4nivARB;
+extern PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4nsvARB;
+extern PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4nubARB;
+extern PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4nubvARB;
+extern PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4nuivARB;
+extern PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4nusvARB;
+extern PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB;
+extern PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB;
+extern PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB;
+extern PFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB;
+extern PFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB;
+extern PFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB;
+extern PFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB;
+extern PFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB;
+extern PFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB;
+extern PFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB;
+extern PFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB;
+extern PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB;
+extern PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB;
+extern PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB;
+extern PFNGLPROGRAMSTRINGARBPROC glProgramStringARB;
+extern PFNGLBINDPROGRAMARBPROC glBindProgramARB;
+extern PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB;
+extern PFNGLGENPROGRAMSARBPROC glGenProgramsARB;
+extern PFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB;
+extern PFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB;
+extern PFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB;
+extern PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB;
+extern PFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB;
+extern PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB;
+extern PFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB;
+extern PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB;
+extern PFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB;
+extern PFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB;
+extern PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB;
+extern PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB;
+extern PFNGLGETPROGRAMIVARBPROC glGetProgramivARB;
+extern PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB;
+extern PFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB;
+extern PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB;
+extern PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB;
+extern PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB;
+extern PFNGLISPROGRAMARBPROC glIsProgramARB;
+extern PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB;
+extern PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB;
+extern PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB;
+
+extern PFNGLCOMPRESSEDTEXIMAGE2DARBPROC glCompressedTexImage2DARB;
+extern PFNGLGETCOMPRESSEDTEXIMAGEARBPROC glGetCompressedTexImageARB;
+
+extern PFNGLCOLORTABLEEXTPROC glColorTableEXT;
+
+//GL_EXT_framebuffer_object
+extern PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT;
+extern PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT;
+extern PFNGLDELETERENDERBUFFERSEXTPROC glDeleteRenderbuffersEXT;
+extern PFNGLGENRENDERBUFFERSEXTPROC glGenRenderbuffersEXT;
+extern PFNGLRENDERBUFFERSTORAGEEXTPROC glRenderbufferStorageEXT;
+extern PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glGetRenderbufferParameterivEXT;
+extern PFNGLISFRAMEBUFFEREXTPROC glIsFramebufferEXT;
+extern PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT;
+extern PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT;
+extern PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT;
+extern PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT;
+extern PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glFramebufferTexture1DEXT;
+extern PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT;
+extern PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glFramebufferTexture3DEXT;
+extern PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT;
+extern PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT;
+extern PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT;
+
+
+#elif LL_WINDOWS
+
+// windows gl headers depend on things like APIENTRY, so include windows.
+#define WIN32_LEAN_AND_MEAN
+#include <winsock2.h>
+#include <windows.h>
+
+//----------------------------------------------------------------------------
+#include <GL/gl.h>
+#include <GL/glu.h>
+
+// quotes so we get libraries/.../GL/ version
+#include "GL/glext.h"
+#include "GL/glh_extensions.h"
+
+
+// GL_ARB_vertex_buffer_object
+extern PFNGLBINDBUFFERARBPROC           glBindBufferARB;
+extern PFNGLDELETEBUFFERSARBPROC        glDeleteBuffersARB;
+extern PFNGLGENBUFFERSARBPROC           glGenBuffersARB;
+extern PFNGLISBUFFERARBPROC                     glIsBufferARB;
+extern PFNGLBUFFERDATAARBPROC           glBufferDataARB;
+extern PFNGLBUFFERSUBDATAARBPROC        glBufferSubDataARB;
+extern PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB;
+extern PFNGLMAPBUFFERARBPROC            glMapBufferARB;
+extern PFNGLUNMAPBUFFERARBPROC          glUnmapBufferARB;
+extern PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB;
+extern PFNGLGETBUFFERPOINTERVARBPROC    glGetBufferPointervARB;
+
+// GL_ATI_vertex_array_object
+extern PFNGLNEWOBJECTBUFFERATIPROC                      glNewObjectBufferATI;
+extern PFNGLISOBJECTBUFFERATIPROC                       glIsObjectBufferATI;
+extern PFNGLUPDATEOBJECTBUFFERATIPROC           glUpdateObjectBufferATI;
+extern PFNGLGETOBJECTBUFFERFVATIPROC            glGetObjectBufferfvATI;
+extern PFNGLGETOBJECTBUFFERIVATIPROC            glGetObjectBufferivATI;
+extern PFNGLFREEOBJECTBUFFERATIPROC                 glFreeObjectBufferATI;
+extern PFNGLARRAYOBJECTATIPROC                          glArrayObjectATI;
+extern PFNGLVERTEXATTRIBARRAYOBJECTATIPROC      glVertexAttribArrayObjectATI;
+extern PFNGLGETARRAYOBJECTFVATIPROC                     glGetArrayObjectfvATI;
+extern PFNGLGETARRAYOBJECTIVATIPROC                     glGetArrayObjectivATI;
+extern PFNGLVARIANTARRAYOBJECTATIPROC           glVariantObjectArrayATI;
+extern PFNGLGETVARIANTARRAYOBJECTFVATIPROC      glGetVariantArrayObjectfvATI;
+extern PFNGLGETVARIANTARRAYOBJECTIVATIPROC      glGetVariantArrayObjectivATI;
+
+extern PFNWGLSWAPINTERVALEXTPROC                        wglSwapIntervalEXT;
+
+// GL_ARB_occlusion_query
+extern PFNGLGENQUERIESARBPROC glGenQueriesARB;
+extern PFNGLDELETEQUERIESARBPROC glDeleteQueriesARB;
+extern PFNGLISQUERYARBPROC glIsQueryARB;
+extern PFNGLBEGINQUERYARBPROC glBeginQueryARB;
+extern PFNGLENDQUERYARBPROC glEndQueryARB;
+extern PFNGLGETQUERYIVARBPROC glGetQueryivARB;
+extern PFNGLGETQUERYOBJECTIVARBPROC glGetQueryObjectivARB;
+extern PFNGLGETQUERYOBJECTUIVARBPROC glGetQueryObjectuivARB;
+
+// GL_ARB_point_parameters
+extern PFNGLPOINTPARAMETERFARBPROC glPointParameterfARB;
+extern PFNGLPOINTPARAMETERFVARBPROC glPointParameterfvARB;
+
+// GL_ARB_shader_objects
+extern PFNGLDELETEOBJECTARBPROC glDeleteObjectARB;
+extern PFNGLGETHANDLEARBPROC glGetHandleARB;
+extern PFNGLDETACHOBJECTARBPROC glDetachObjectARB;
+extern PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB;
+extern PFNGLSHADERSOURCEARBPROC glShaderSourceARB;
+extern PFNGLCOMPILESHADERARBPROC glCompileShaderARB;
+extern PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB;
+extern PFNGLATTACHOBJECTARBPROC glAttachObjectARB;
+extern PFNGLLINKPROGRAMARBPROC glLinkProgramARB;
+extern PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB;
+extern PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB;
+extern PFNGLUNIFORM1FARBPROC glUniform1fARB;
+extern PFNGLUNIFORM2FARBPROC glUniform2fARB;
+extern PFNGLUNIFORM3FARBPROC glUniform3fARB;
+extern PFNGLUNIFORM4FARBPROC glUniform4fARB;
+extern PFNGLUNIFORM1IARBPROC glUniform1iARB;
+extern PFNGLUNIFORM2IARBPROC glUniform2iARB;
+extern PFNGLUNIFORM3IARBPROC glUniform3iARB;
+extern PFNGLUNIFORM4IARBPROC glUniform4iARB;
+extern PFNGLUNIFORM1FVARBPROC glUniform1fvARB;
+extern PFNGLUNIFORM2FVARBPROC glUniform2fvARB;
+extern PFNGLUNIFORM3FVARBPROC glUniform3fvARB;
+extern PFNGLUNIFORM4FVARBPROC glUniform4fvARB;
+extern PFNGLUNIFORM1IVARBPROC glUniform1ivARB;
+extern PFNGLUNIFORM2IVARBPROC glUniform2ivARB;
+extern PFNGLUNIFORM3IVARBPROC glUniform3ivARB;
+extern PFNGLUNIFORM4IVARBPROC glUniform4ivARB;
+extern PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB;
+extern PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB;
+extern PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB;
+extern PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB;
+extern PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB;
+extern PFNGLGETINFOLOGARBPROC glGetInfoLogARB;
+extern PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB;
+extern PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB;
+extern PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB;
+extern PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB;
+extern PFNGLGETUNIFORMIVARBPROC glGetUniformivARB;
+extern PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB;
+
+// GL_ARB_vertex_shader
+extern PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB;
+extern PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB;
+extern PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB;
+extern PFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB;
+extern PFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB;
+extern PFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB;
+extern PFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB;
+extern PFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB;
+extern PFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB;
+extern PFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB;
+extern PFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB;
+extern PFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB;
+extern PFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB;
+extern PFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB;
+extern PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB;
+extern PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB;
+extern PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB;
+extern PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB;
+extern PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4nbvARB;
+extern PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4nivARB;
+extern PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4nsvARB;
+extern PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4nubARB;
+extern PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4nubvARB;
+extern PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4nuivARB;
+extern PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4nusvARB;
+extern PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB;
+extern PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB;
+extern PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB;
+extern PFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB;
+extern PFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB;
+extern PFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB;
+extern PFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB;
+extern PFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB;
+extern PFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB;
+extern PFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB;
+extern PFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB;
+extern PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB;
+extern PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB;
+extern PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB;
+extern PFNGLPROGRAMSTRINGARBPROC glProgramStringARB;
+extern PFNGLBINDPROGRAMARBPROC glBindProgramARB;
+extern PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB;
+extern PFNGLGENPROGRAMSARBPROC glGenProgramsARB;
+extern PFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB;
+extern PFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB;
+extern PFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB;
+extern PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB;
+extern PFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB;
+extern PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB;
+extern PFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB;
+extern PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB;
+extern PFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB;
+extern PFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB;
+extern PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB;
+extern PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB;
+extern PFNGLGETPROGRAMIVARBPROC glGetProgramivARB;
+extern PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB;
+extern PFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB;
+extern PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB;
+extern PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB;
+extern PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB;
+extern PFNGLISPROGRAMARBPROC glIsProgramARB;
+extern PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB;
+extern PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB;
+extern PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB;
+
+//GL_EXT_framebuffer_object
+extern PFNGLISRENDERBUFFEREXTPROC glIsRenderbufferEXT;
+extern PFNGLBINDRENDERBUFFEREXTPROC glBindRenderbufferEXT;
+extern PFNGLDELETERENDERBUFFERSEXTPROC glDeleteRenderbuffersEXT;
+extern PFNGLGENRENDERBUFFERSEXTPROC glGenRenderbuffersEXT;
+extern PFNGLRENDERBUFFERSTORAGEEXTPROC glRenderbufferStorageEXT;
+extern PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC glGetRenderbufferParameterivEXT;
+extern PFNGLISFRAMEBUFFEREXTPROC glIsFramebufferEXT;
+extern PFNGLBINDFRAMEBUFFEREXTPROC glBindFramebufferEXT;
+extern PFNGLDELETEFRAMEBUFFERSEXTPROC glDeleteFramebuffersEXT;
+extern PFNGLGENFRAMEBUFFERSEXTPROC glGenFramebuffersEXT;
+extern PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC glCheckFramebufferStatusEXT;
+extern PFNGLFRAMEBUFFERTEXTURE1DEXTPROC glFramebufferTexture1DEXT;
+extern PFNGLFRAMEBUFFERTEXTURE2DEXTPROC glFramebufferTexture2DEXT;
+extern PFNGLFRAMEBUFFERTEXTURE3DEXTPROC glFramebufferTexture3DEXT;
+extern PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC glFramebufferRenderbufferEXT;
+extern PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmentParameterivEXT;
+extern PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT;
+
+
+#elif LL_DARWIN
+//----------------------------------------------------------------------------
+// LL_DARWIN
+
+#include <OpenGL/gl.h>
+#include <OpenGL/glu.h>
+
+#define GL_EXT_separate_specular_color 1
+#include <OpenGL/glext.h>
+
+#include "GL/glh_extensions.h"
+
+// These symbols don't exist on 10.3.9, so they have to be declared weak.  Redeclaring them here fixes the problem.
+// Note that they also must not be called on 10.3.9.  This should be taken care of by a runtime check for the existence of the GL extension.
+#include <AvailabilityMacros.h>
+
+// GL_EXT_framebuffer_object
+extern GLboolean glIsRenderbufferEXT(GLuint renderbuffer) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glDeleteRenderbuffersEXT(GLsizei n, const GLuint *renderbuffers) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glGenRenderbuffersEXT(GLsizei n, GLuint *renderbuffers) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint *params) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern GLboolean glIsFramebufferEXT(GLuint framebuffer) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glBindFramebufferEXT(GLenum target, GLuint framebuffer) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glDeleteFramebuffersEXT(GLsizei n, const GLuint *framebuffers) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glGenFramebuffersEXT(GLsizei n, GLuint *framebuffers) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern GLenum glCheckFramebufferStatusEXT(GLenum target) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint *params) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+extern void glGenerateMipmapEXT(GLenum target) AVAILABLE_MAC_OS_X_VERSION_10_4_AND_LATER;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+//
+// Define vertex buffer object headers on Mac
+//
+#ifndef GL_ARB_vertex_buffer_object
+#define GL_BUFFER_SIZE_ARB                0x8764
+#define GL_BUFFER_USAGE_ARB               0x8765
+#define GL_ARRAY_BUFFER_ARB               0x8892
+#define GL_ELEMENT_ARRAY_BUFFER_ARB       0x8893
+#define GL_ARRAY_BUFFER_BINDING_ARB       0x8894
+#define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB 0x8895
+#define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB 0x8896
+#define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB 0x8897
+#define GL_COLOR_ARRAY_BUFFER_BINDING_ARB 0x8898
+#define GL_INDEX_ARRAY_BUFFER_BINDING_ARB 0x8899
+#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB 0x889A
+#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB 0x889B
+#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB 0x889C
+#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB 0x889D
+#define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB 0x889E
+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB 0x889F
+#define GL_READ_ONLY_ARB                  0x88B8
+#define GL_WRITE_ONLY_ARB                 0x88B9
+#define GL_READ_WRITE_ARB                 0x88BA
+#define GL_BUFFER_ACCESS_ARB              0x88BB
+#define GL_BUFFER_MAPPED_ARB              0x88BC
+#define GL_BUFFER_MAP_POINTER_ARB         0x88BD
+#define GL_STREAM_DRAW_ARB                0x88E0
+#define GL_STREAM_READ_ARB                0x88E1
+#define GL_STREAM_COPY_ARB                0x88E2
+#define GL_STATIC_DRAW_ARB                0x88E4
+#define GL_STATIC_READ_ARB                0x88E5
+#define GL_STATIC_COPY_ARB                0x88E6
+#define GL_DYNAMIC_DRAW_ARB               0x88E8
+#define GL_DYNAMIC_READ_ARB               0x88E9
+#define GL_DYNAMIC_COPY_ARB               0x88EA
+#endif
+
+
+
+#ifndef GL_ARB_vertex_buffer_object
+/* GL types for handling large vertex buffer objects */
+typedef intptr_t GLintptrARB;
+typedef intptr_t GLsizeiptrARB;
+#endif
+
+
+#ifndef GL_ARB_vertex_buffer_object
+#define GL_ARB_vertex_buffer_object 1
+#ifdef GL_GLEXT_FUNCTION_POINTERS
+typedef void (* glBindBufferARBProcPtr) (GLenum target, GLuint buffer);
+typedef void (* glDeleteBufferARBProcPtr) (GLsizei n, const GLuint *buffers);
+typedef void (* glGenBuffersARBProcPtr) (GLsizei n, GLuint *buffers);
+typedef GLboolean (* glIsBufferARBProcPtr) (GLuint buffer);
+typedef void (* glBufferDataARBProcPtr) (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage);
+typedef void (* glBufferSubDataARBProcPtr) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data);
+typedef void (* glGetBufferSubDataARBProcPtr) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data);
+typedef GLvoid* (* glMapBufferARBProcPtr) (GLenum target, GLenum access);       /* Flawfinder: ignore */
+typedef GLboolean (* glUnmapBufferARBProcPtr) (GLenum target);
+typedef void (* glGetBufferParameterivARBProcPtr) (GLenum target, GLenum pname, GLint *params);
+typedef void (* glGetBufferPointervARBProcPtr) (GLenum target, GLenum pname, GLvoid* *params);
+#else
+extern void glBindBufferARB (GLenum, GLuint);
+extern void glDeleteBuffersARB (GLsizei, const GLuint *);
+extern void glGenBuffersARB (GLsizei, GLuint *);
+extern GLboolean glIsBufferARB (GLuint);
+extern void glBufferDataARB (GLenum, GLsizeiptrARB, const GLvoid *, GLenum);
+extern void glBufferSubDataARB (GLenum, GLintptrARB, GLsizeiptrARB, const GLvoid *);
+extern void glGetBufferSubDataARB (GLenum, GLintptrARB, GLsizeiptrARB, GLvoid *);
+extern GLvoid* glMapBufferARB (GLenum, GLenum);
+extern GLboolean glUnmapBufferARB (GLenum);
+extern void glGetBufferParameterivARB (GLenum, GLenum, GLint *);
+extern void glGetBufferPointervARB (GLenum, GLenum, GLvoid* *);
+#endif /* GL_GLEXT_FUNCTION_POINTERS */
+#endif
+
+// May be needed for DARWIN...
+// #ifndef GL_ARB_compressed_tex_image
+// #define GL_ARB_compressed_tex_image 1
+// #ifdef GL_GLEXT_FUNCTION_POINTERS
+// typedef void (* glCompressedTexImage1D) (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid*);
+// typedef void (* glCompressedTexImage2D) (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*);
+// typedef void (* glCompressedTexImage3D) (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*);
+// typedef void (* glCompressedTexSubImage1D) (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid*);
+// typedef void (* glCompressedTexSubImage2D) (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*);
+// typedef void (* glCompressedTexSubImage3D) (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*);
+// typedef void (* glGetCompressedTexImage) (GLenum, GLint, GLvoid*);
+// #else
+// extern void glCompressedTexImage1D (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid*);
+// extern void glCompressedTexImage2D (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*);
+// extern void glCompressedTexImage3D (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*);
+// extern void glCompressedTexSubImage1D (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid*);
+// extern void glCompressedTexSubImage2D (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*);
+// extern void glCompressedTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*);
+// extern void glGetCompressedTexImage (GLenum, GLint, GLvoid*);
+// #endif /* GL_GLEXT_FUNCTION_POINTERS */
+// #endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#include <AGL/gl.h>
+
+#endif // LL_MESA / LL_WINDOWS / LL_DARWIN
+
+
+#endif // LL_LLGLHEADERS_H
diff --git a/linden/indra/llrender/llglimmediate.cpp b/linden/indra/llrender/llglimmediate.cpp
index 17c2182..9b60e49 100644
--- a/linden/indra/llrender/llglimmediate.cpp
+++ b/linden/indra/llrender/llglimmediate.cpp
@@ -1 +1,265 @@
+<<<<<<< .working
 #error This file has been renamed llrender.cpp
+=======
+/** 
+ * @file llglimmediate.cpp
+ * @brief LLGLImmediate implementation
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llglimmediate.h"
+#include "llvertexbuffer.h"
+
+LLGLImmediate gGL;
+
+const U32 immediate_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXCOORD;
+
+LLGLImmediate::LLGLImmediate()
+{
+        mCount = 0;
+        mMode = LLVertexBuffer::TRIANGLES;
+        mBuffer = new LLVertexBuffer(immediate_mask, 0);
+        mBuffer->allocateBuffer(4096, 0, TRUE);
+        mBuffer->getVertexStrider(mVerticesp);
+        mBuffer->getTexCoordStrider(mTexcoordsp);
+        mBuffer->getColorStrider(mColorsp);
+}
+
+void LLGLImmediate::translatef(const GLfloat& x, const GLfloat& y, const GLfloat& z)
+{
+        flush();
+        glTranslatef(x,y,z);
+}
+
+void LLGLImmediate::scalef(const GLfloat& x, const GLfloat& y, const GLfloat& z)
+{
+        flush();
+        glScalef(x,y,z);
+}
+
+void LLGLImmediate::pushMatrix()
+{
+        flush();
+        glPushMatrix();
+}
+
+void LLGLImmediate::popMatrix()
+{
+        flush();
+        glPopMatrix();
+}
+
+void LLGLImmediate::blendFunc(GLenum sfactor, GLenum dfactor)
+{
+        flush();
+        glBlendFunc(sfactor, dfactor);
+}
+
+void LLGLImmediate::begin(const GLuint& mode)
+{
+        if (mode != mMode)
+        {
+                if (mMode == LLVertexBuffer::QUADS ||
+                        mMode == LLVertexBuffer::LINES ||
+                        mMode == LLVertexBuffer::TRIANGLES ||
+                        mMode == LLVertexBuffer::POINTS)
+                {
+                        flush();
+                }
+                else if (mCount != 0)
+                {
+                        llerrs << "gGL.begin() called redundantly." << llendl;
+                }
+                
+                mMode = mode;
+        }
+}
+
+void LLGLImmediate::end()
+{ 
+        if (mCount == 0)
+        {
+                return;
+                //IMM_ERRS << "GL begin and end called with no vertices specified." << llendl;
+        }
+
+        if ((mMode != LLVertexBuffer::QUADS && 
+                mMode != LLVertexBuffer::LINES &&
+                mMode != LLVertexBuffer::TRIANGLES &&
+                mMode != LLVertexBuffer::POINTS) ||
+                mCount > 2048)
+        {
+                flush();
+        }
+}
+
+void LLGLImmediate::flush()
+{
+        if (mCount > 0)
+        {
+#if 0
+                if (!glIsEnabled(GL_VERTEX_ARRAY))
+                {
+                        llerrs << "foo 1" << llendl;
+                }
+
+                if (!glIsEnabled(GL_COLOR_ARRAY))
+                {
+                        llerrs << "foo 2" << llendl;
+                }
+
+                if (!glIsEnabled(GL_TEXTURE_COORD_ARRAY))
+                {
+                        llerrs << "foo 3" << llendl;
+                }
+
+                if (glIsEnabled(GL_NORMAL_ARRAY))
+                {
+                        llerrs << "foo 7" << llendl;
+                }
+
+                GLvoid* pointer;
+
+                glGetPointerv(GL_VERTEX_ARRAY_POINTER, &pointer);
+                if (pointer != &(mBuffer[0].v))
+                {
+                        llerrs << "foo 4" << llendl;
+                }
+
+                glGetPointerv(GL_COLOR_ARRAY_POINTER, &pointer);
+                if (pointer != &(mBuffer[0].c))
+                {
+                        llerrs << "foo 5" << llendl;
+                }
+
+                glGetPointerv(GL_TEXTURE_COORD_ARRAY_POINTER, &pointer);
+                if (pointer != &(mBuffer[0].uv))
+                {
+                        llerrs << "foo 6" << llendl;
+                }
+#endif
+                                
+                mBuffer->setBuffer(immediate_mask);
+                mBuffer->drawArrays(mMode, 0, mCount);
+
+                mVerticesp[0] = mVerticesp[mCount];
+                mTexcoordsp[0] = mTexcoordsp[mCount];
+                mColorsp[0] = mColorsp[mCount];
+                mCount = 0;
+        }
+}
+
+void LLGLImmediate::vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z)
+{ 
+        if (mCount >= 4096)
+        {
+        //      llwarns << "GL immediate mode overflow.  Some geometry not drawn." << llendl;
+                return;
+        }
+
+        mVerticesp[mCount] = LLVector3(x,y,z);
+        mCount++;
+        if (mCount < 4096)
+        {
+                mVerticesp[mCount] = mVerticesp[mCount-1];
+                mColorsp[mCount] = mColorsp[mCount-1];
+                mTexcoordsp[mCount] = mTexcoordsp[mCount-1];
+        }
+}
+
+void LLGLImmediate::vertex2i(const GLint& x, const GLint& y)
+{
+        vertex3f((GLfloat) x, (GLfloat) y, 0);  
+}
+
+void LLGLImmediate::vertex2f(const GLfloat& x, const GLfloat& y)
+{ 
+        vertex3f(x,y,0);
+}
+
+void LLGLImmediate::vertex2fv(const GLfloat* v)
+{ 
+        vertex3f(v[0], v[1], 0);
+}
+
+void LLGLImmediate::vertex3fv(const GLfloat* v)
+{
+        vertex3f(v[0], v[1], v[2]);
+}
+
+void LLGLImmediate::texCoord2f(const GLfloat& x, const GLfloat& y)
+{ 
+        mTexcoordsp[mCount] = LLVector2(x,y);
+}
+
+void LLGLImmediate::texCoord2i(const GLint& x, const GLint& y)
+{ 
+        texCoord2f((GLfloat) x, (GLfloat) y);
+}
+
+void LLGLImmediate::texCoord2fv(const GLfloat* tc)
+{ 
+        texCoord2f(tc[0], tc[1]);
+}
+
+void LLGLImmediate::color4ub(const GLubyte& r, const GLubyte& g, const GLubyte& b, const GLubyte& a)
+{
+        mColorsp[mCount] = LLColor4U(r,g,b,a);
+}
+
+void LLGLImmediate::color4ubv(const GLubyte* c)
+{
+        color4ub(c[0], c[1], c[2], c[3]);
+}
+
+void LLGLImmediate::color4f(const GLfloat& r, const GLfloat& g, const GLfloat& b, const GLfloat& a)
+{
+        color4ub((GLubyte) (llclamp(r, 0.f, 1.f)*255),
+                (GLubyte) (llclamp(g, 0.f, 1.f)*255),
+                (GLubyte) (llclamp(b, 0.f, 1.f)*255),
+                (GLubyte) (llclamp(a, 0.f, 1.f)*255));
+}
+
+void LLGLImmediate::color4fv(const GLfloat* c)
+{ 
+        color4f(c[0],c[1],c[2],c[3]);
+}
+
+void LLGLImmediate::color3f(const GLfloat& r, const GLfloat& g, const GLfloat& b)
+{ 
+        color4f(r,g,b,1);
+}
+
+void LLGLImmediate::color3fv(const GLfloat* c)
+{ 
+        color4f(c[0],c[1],c[2],1);
+}
+
+>>>>>>> .merge-right.r88690
diff --git a/linden/indra/llrender/llglimmediate.h b/linden/indra/llrender/llglimmediate.h
index 4a7a0eb..2d7d768 100644
--- a/linden/indra/llrender/llglimmediate.h
+++ b/linden/indra/llrender/llglimmediate.h
@@ -1 +1,98 @@
+<<<<<<< .working
 #error This file has been renamed llrender.h
+=======
+/** 
+ * @file llglimmediate.h
+ * @brief LLGLImmediate definition
+ *
+ *      This class acts as a wrapper for OpenGL immediate calls concerning glBegin and glEnd.
+ *      The goal of this class is to minimize the number of api calls due to legacy rendering
+ *      code, and to define an interface for a multiple rendering API abstraction of the UI
+ *      rendering.
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLGLIMMEDIATE_H
+#define LL_LLGLIMMEDIATE_H
+
+#include "stdtypes.h"
+#include "llgltypes.h"
+#include "llglheaders.h"
+#include "llvertexbuffer.h"
+
+class LLGLImmediate
+{
+public:
+        LLGLImmediate();
+
+        void translatef(const GLfloat& x, const GLfloat& y, const GLfloat& z);
+        void scalef(const GLfloat& x, const GLfloat& y, const GLfloat& z);
+        void pushMatrix();
+        void popMatrix();
+        void blendFunc(GLenum sfactor, GLenum dfactor);
+        void flush();
+
+        void begin(const GLuint& mode);
+        void end();
+        void vertex2i(const GLint& x, const GLint& y);
+        void vertex2f(const GLfloat& x, const GLfloat& y);
+        void vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z);
+        void vertex2fv(const GLfloat* v);
+        void vertex3fv(const GLfloat* v);
+        
+        void texCoord2i(const GLint& x, const GLint& y);
+        void texCoord2f(const GLfloat& x, const GLfloat& y);
+        void texCoord2fv(const GLfloat* tc);
+
+        void color4ub(const GLubyte& r, const GLubyte& g, const GLubyte& b, const GLubyte& a);
+        void color4f(const GLfloat& r, const GLfloat& g, const GLfloat& b, const GLfloat& a);
+        void color4fv(const GLfloat* c);
+        void color3f(const GLfloat& r, const GLfloat& g, const GLfloat& b);
+        void color3fv(const GLfloat* c);
+        void color4ubv(const GLubyte* c);
+        
+        typedef struct Vertex
+        {
+                GLfloat v[3];
+                GLubyte c[4];
+                GLfloat uv[2];
+        };
+
+private:
+        U32 mCount;
+        U32 mMode;
+        LLPointer<LLVertexBuffer> mBuffer;
+        LLStrider<LLVector3> mVerticesp;
+        LLStrider<LLVector2> mTexcoordsp;
+        LLStrider<LLColor4U> mColorsp;
+};
+
+extern LLGLImmediate gGL;
+
+#endif
+>>>>>>> .merge-right.r88690
diff --git a/linden/indra/llrender/llglslshader.cpp b/linden/indra/llrender/llglslshader.cpp
new file mode 100644
index 0000000..26984e1
--- /dev/null
+++ b/linden/indra/llrender/llglslshader.cpp
@@ -0,0 +1,823 @@
+/** 
+ * @file llglslshader.cpp
+ * @brief GLSL helper functions and state.
+ *
+ * $LicenseInfo:firstyear=2005&license=viewergpl$
+ * 
+ * Copyright (c) 2005-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llglslshader.h"
+
+#include "llshadermgr.h"
+#include "llfile.h"
+#include "llrender.h"
+
+#if LL_DARWIN
+#include "OpenGL/OpenGL.h"
+#endif
+
+#ifdef LL_RELEASE_FOR_DOWNLOAD
+#define UNIFORM_ERRS LL_WARNS_ONCE("Shader")
+#else
+#define UNIFORM_ERRS LL_ERRS("Shader")
+#endif
+
+// Lots of STL stuff in here, using namespace std to keep things more readable
+using std::vector;
+using std::pair;
+using std::make_pair;
+using std::string;
+
+BOOL shouldChange(const LLVector4& v1, const LLVector4& v2)
+{
+        return v1 != v2;
+}
+
+LLShaderFeatures::LLShaderFeatures()
+: calculatesLighting(false), isShiny(false), isFullbright(false), hasWaterFog(false),
+hasTransport(false), hasSkinning(false), hasAtmospherics(false), isSpecular(false),
+hasGamma(false), hasLighting(false), calculatesAtmospherics(false)
+{
+}
+
+//===============================
+// LLGLSL Shader implementation
+//===============================
+LLGLSLShader::LLGLSLShader()
+: mProgramObject(0), mShaderLevel(0), mShaderGroup(SG_DEFAULT)
+{
+}
+
+void LLGLSLShader::unload()
+{
+        stop_glerror();
+        mAttribute.clear();
+        mTexture.clear();
+        mUniform.clear();
+        mShaderFiles.clear();
+
+        if (mProgramObject)
+        {
+                GLhandleARB obj[1024];
+                GLsizei count;
+
+                glGetAttachedObjectsARB(mProgramObject, 1024, &count, obj);
+                for (GLsizei i = 0; i < count; i++)
+                {
+                        glDeleteObjectARB(obj[i]);
+                }
+
+                glDeleteObjectARB(mProgramObject);
+
+                mProgramObject = 0;
+        }
+        
+        //hack to make apple not complain
+        glGetError();
+        
+        stop_glerror();
+}
+
+BOOL LLGLSLShader::createShader(vector<string> * attributes,
+                                                                vector<string> * uniforms)
+{
+        llassert_always(!mShaderFiles.empty());
+        BOOL success = TRUE;
+
+        // Create program
+        mProgramObject = glCreateProgramObjectARB();
+        
+        // Attach existing objects
+        if (!LLShaderMgr::instance()->attachShaderFeatures(this))
+        {
+                return FALSE;
+        }
+
+        vector< pair<string,GLenum> >::iterator fileIter = mShaderFiles.begin();
+        for ( ; fileIter != mShaderFiles.end(); fileIter++ )
+        {
+                GLhandleARB shaderhandle = LLShaderMgr::instance()->loadShaderFile((*fileIter).first, mShaderLevel, (*fileIter).second);
+                LL_DEBUGS("ShaderLoading") << "SHADER FILE: " << (*fileIter).first << " mShaderLevel=" << mShaderLevel << LL_ENDL;
+                if (mShaderLevel > 0)
+                {
+                        attachObject(shaderhandle);
+                }
+                else
+                {
+                        success = FALSE;
+                }
+        }
+
+        // Map attributes and uniforms
+        if (success)
+        {
+                success = mapAttributes(attributes);
+        }
+        if (success)
+        {
+                success = mapUniforms(uniforms);
+        }
+        if( !success )
+        {
+                LL_WARNS("ShaderLoading") << "Failed to link shader: " << mName << LL_ENDL;
+
+                // Try again using a lower shader level;
+                if (mShaderLevel > 0)
+                {
+                        LL_WARNS("ShaderLoading") << "Failed to link using shader level " << mShaderLevel << " trying again using shader level " << (mShaderLevel - 1) << LL_ENDL;
+                        mShaderLevel--;
+                        return createShader(attributes,uniforms);
+                }
+        }
+        return success;
+}
+
+BOOL LLGLSLShader::attachObject(std::string object)
+{
+        if (LLShaderMgr::instance()->mShaderObjects.count(object) > 0)
+        {
+                stop_glerror();
+                glAttachObjectARB(mProgramObject, LLShaderMgr::instance()->mShaderObjects[object]);
+                stop_glerror();
+                return TRUE;
+        }
+        else
+        {
+                LL_WARNS("ShaderLoading") << "Attempting to attach shader object that hasn't been compiled: " << object << LL_ENDL;
+                return FALSE;
+        }
+}
+
+void LLGLSLShader::attachObject(GLhandleARB object)
+{
+        if (object != 0)
+        {
+                stop_glerror();
+                glAttachObjectARB(mProgramObject, object);
+                stop_glerror();
+        }
+        else
+        {
+                LL_WARNS("ShaderLoading") << "Attempting to attach non existing shader object. " << LL_ENDL;
+        }
+}
+
+void LLGLSLShader::attachObjects(GLhandleARB* objects, S32 count)
+{
+        for (S32 i = 0; i < count; i++)
+        {
+                attachObject(objects[i]);
+        }
+}
+
+BOOL LLGLSLShader::mapAttributes(const vector<string> * attributes)
+{
+        //link the program
+        BOOL res = link();
+
+        mAttribute.clear();
+        U32 numAttributes = (attributes == NULL) ? 0 : attributes->size();
+        mAttribute.resize(LLShaderMgr::instance()->mReservedAttribs.size() + numAttributes, -1);
+        
+        if (res)
+        { //read back channel locations
+
+                //read back reserved channels first
+                for (U32 i = 0; i < (S32) LLShaderMgr::instance()->mReservedAttribs.size(); i++)
+                {
+                        const char* name = LLShaderMgr::instance()->mReservedAttribs[i].c_str();
+                        S32 index = glGetAttribLocationARB(mProgramObject, (const GLcharARB *)name);
+                        if (index != -1)
+                        {
+                                mAttribute[i] = index;
+                                LL_DEBUGS("ShaderLoading") << "Attribute " << name << " assigned to channel " << index << LL_ENDL;
+                        }
+                }
+                if (attributes != NULL)
+                {
+                        for (U32 i = 0; i < numAttributes; i++)
+                        {
+                                const char* name = (*attributes)[i].c_str();
+                                S32 index = glGetAttribLocationARB(mProgramObject, name);
+                                if (index != -1)
+                                {
+                                        mAttribute[LLShaderMgr::instance()->mReservedAttribs.size() + i] = index;
+                                        LL_DEBUGS("ShaderLoading") << "Attribute " << name << " assigned to channel " << index << LL_ENDL;
+                                }
+                        }
+                }
+
+                return TRUE;
+        }
+        
+        return FALSE;
+}
+
+void LLGLSLShader::mapUniform(GLint index, const vector<string> * uniforms)
+{
+        if (index == -1)
+        {
+                return;
+        }
+
+        GLenum type;
+        GLsizei length;
+        GLint size;
+        char name[1024];                /* Flawfinder: ignore */
+        name[0] = 0;
+
+        glGetActiveUniformARB(mProgramObject, index, 1024, &length, &size, &type, (GLcharARB *)name);
+        S32 location = glGetUniformLocationARB(mProgramObject, name);
+        if (location != -1)
+        {
+                mUniformMap[name] = location;
+                LL_DEBUGS("ShaderLoading") << "Uniform " << name << " is at location " << location << LL_ENDL;
+        
+                //find the index of this uniform
+                for (S32 i = 0; i < (S32) LLShaderMgr::instance()->mReservedUniforms.size(); i++)
+                {
+                        if ( (mUniform[i] == -1)
+                                && (LLShaderMgr::instance()->mReservedUniforms[i].compare(0, length, name, LLShaderMgr::instance()->mReservedUniforms[i].length()) == 0))
+                        {
+                                //found it
+                                mUniform[i] = location;
+                                mTexture[i] = mapUniformTextureChannel(location, type);
+                                return;
+                        }
+                }
+
+                if (uniforms != NULL)
+                {
+                        for (U32 i = 0; i < uniforms->size(); i++)
+                        {
+                                if ( (mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] == -1)
+                                        && ((*uniforms)[i].compare(0, length, name, (*uniforms)[i].length()) == 0))
+                                {
+                                        //found it
+                                        mUniform[i+LLShaderMgr::instance()->mReservedUniforms.size()] = location;
+                                        mTexture[i+LLShaderMgr::instance()->mReservedUniforms.size()] = mapUniformTextureChannel(location, type);
+                                        return;
+                                }
+                        }
+                }
+        }
+ }
+
+GLint LLGLSLShader::mapUniformTextureChannel(GLint location, GLenum type)
+{
+        if (type >= GL_SAMPLER_1D_ARB && type <= GL_SAMPLER_2D_RECT_SHADOW_ARB)
+        {       //this here is a texture
+                glUniform1iARB(location, mActiveTextureChannels);
+                LL_DEBUGS("ShaderLoading") << "Assigned to texture channel " << mActiveTextureChannels << LL_ENDL;
+                return mActiveTextureChannels++;
+        }
+        return -1;
+}
+
+BOOL LLGLSLShader::mapUniforms(const vector<string> * uniforms)
+{
+        BOOL res = TRUE;
+        
+        mActiveTextureChannels = 0;
+        mUniform.clear();
+        mUniformMap.clear();
+        mTexture.clear();
+        mValue.clear();
+        //initialize arrays
+        U32 numUniforms = (uniforms == NULL) ? 0 : uniforms->size();
+        mUniform.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
+        mTexture.resize(numUniforms + LLShaderMgr::instance()->mReservedUniforms.size(), -1);
+        
+        bind();
+
+        //get the number of active uniforms
+        GLint activeCount;
+        glGetObjectParameterivARB(mProgramObject, GL_OBJECT_ACTIVE_UNIFORMS_ARB, &activeCount);
+
+        for (S32 i = 0; i < activeCount; i++)
+        {
+                mapUniform(i, uniforms);
+        }
+
+        unbind();
+
+        return res;
+}
+
+BOOL LLGLSLShader::link(BOOL suppress_errors)
+{
+        return LLShaderMgr::instance()->linkProgramObject(mProgramObject, suppress_errors);
+}
+
+void LLGLSLShader::bind()
+{
+        if (gGLManager.mHasShaderObjects)
+        {
+                glUseProgramObjectARB(mProgramObject);
+
+                if (mUniformsDirty)
+                {
+                        LLShaderMgr::instance()->updateShaderUniforms(this);
+                        mUniformsDirty = FALSE;
+                }
+        }
+}
+
+void LLGLSLShader::unbind()
+{
+        if (gGLManager.mHasShaderObjects)
+        {
+                for (U32 i = 0; i < mAttribute.size(); ++i)
+                {
+                        vertexAttrib4f(i, 0,0,0,1);
+                }
+                glUseProgramObjectARB(0);
+        }
+}
+
+void LLGLSLShader::bindNoShader(void)
+{
+        glUseProgramObjectARB(0);
+}
+
+S32 LLGLSLShader::enableTexture(S32 uniform, S32 mode)
+{
+        if (uniform < 0 || uniform >= (S32)mTexture.size())
+        {
+                UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
+                return -1;
+        }
+        S32 index = mTexture[uniform];
+        if (index != -1)
+        {
+                gGL.getTexUnit(index)->activate();
+                glEnable(mode);
+        }
+        return index;
+}
+
+S32 LLGLSLShader::disableTexture(S32 uniform, S32 mode)
+{
+        if (uniform < 0 || uniform >= (S32)mTexture.size())
+        {
+                UNIFORM_ERRS << "Uniform out of range: " << uniform << LL_ENDL;
+                return -1;
+        }
+        S32 index = mTexture[uniform];
+        if (index != -1)
+        {
+                gGL.getTexUnit(index)->activate();
+                glDisable(mode);
+        }
+        return index;
+}
+
+void LLGLSLShader::uniform1f(U32 index, GLfloat x)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+                        if (iter == mValue.end() || iter->second.mV[0] != x)
+                        {
+                                glUniform1fARB(mUniform[index], x);
+                                mValue[mUniform[index]] = LLVector4(x,0.f,0.f,0.f);
+                        }
+                }
+        }
+}
+
+void LLGLSLShader::uniform2f(U32 index, GLfloat x, GLfloat y)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+                        LLVector4 vec(x,y,0.f,0.f);
+                        if (iter == mValue.end() || shouldChange(iter->second,vec))
+                        {
+                                glUniform2fARB(mUniform[index], x, y);
+                                mValue[mUniform[index]] = vec;
+                        }
+                }
+        }
+}
+
+void LLGLSLShader::uniform3f(U32 index, GLfloat x, GLfloat y, GLfloat z)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+                        LLVector4 vec(x,y,z,0.f);
+                        if (iter == mValue.end() || shouldChange(iter->second,vec))
+                        {
+                                glUniform3fARB(mUniform[index], x, y, z);
+                                mValue[mUniform[index]] = vec;
+                        }
+                }
+        }
+}
+
+void LLGLSLShader::uniform4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+                        LLVector4 vec(x,y,z,w);
+                        if (iter == mValue.end() || shouldChange(iter->second,vec))
+                        {
+                                glUniform4fARB(mUniform[index], x, y, z, w);
+                                mValue[mUniform[index]] = vec;
+                        }
+                }
+        }
+}
+
+void LLGLSLShader::uniform1fv(U32 index, U32 count, const GLfloat* v)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+                        LLVector4 vec(v[0],0.f,0.f,0.f);
+                        if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+                        {
+                                glUniform1fvARB(mUniform[index], count, v);
+                                mValue[mUniform[index]] = vec;
+                        }
+                }
+        }
+}
+
+void LLGLSLShader::uniform2fv(U32 index, U32 count, const GLfloat* v)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+                        LLVector4 vec(v[0],v[1],0.f,0.f);
+                        if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+                        {
+                                glUniform2fvARB(mUniform[index], count, v);
+                                mValue[mUniform[index]] = vec;
+                        }
+                }
+        }
+}
+
+void LLGLSLShader::uniform3fv(U32 index, U32 count, const GLfloat* v)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+                        LLVector4 vec(v[0],v[1],v[2],0.f);
+                        if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+                        {
+                                glUniform3fvARB(mUniform[index], count, v);
+                                mValue[mUniform[index]] = vec;
+                        }
+                }
+        }
+}
+
+void LLGLSLShader::uniform4fv(U32 index, U32 count, const GLfloat* v)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        std::map<GLint, LLVector4>::iterator iter = mValue.find(mUniform[index]);
+                        LLVector4 vec(v[0],v[1],v[2],v[3]);
+                        if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+                        {
+                                glUniform4fvARB(mUniform[index], count, v);
+                                mValue[mUniform[index]] = vec;
+                        }
+                }
+        }
+}
+
+void LLGLSLShader::uniformMatrix2fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        glUniformMatrix2fvARB(mUniform[index], count, transpose, v);
+                }
+        }
+}
+
+void LLGLSLShader::uniformMatrix3fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        glUniformMatrix3fvARB(mUniform[index], count, transpose, v);
+                }
+        }
+}
+
+void LLGLSLShader::uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v)
+{
+        if (mProgramObject > 0)
+        {       
+                if (mUniform.size() <= index)
+                {
+                        UNIFORM_ERRS << "Uniform index out of bounds." << LL_ENDL;
+                        return;
+                }
+
+                if (mUniform[index] >= 0)
+                {
+                        glUniformMatrix4fvARB(mUniform[index], count, transpose, v);
+                }
+        }
+}
+
+GLint LLGLSLShader::getUniformLocation(const string& uniform)
+{
+        if (mProgramObject > 0)
+        {
+                std::map<string, GLint>::iterator iter = mUniformMap.find(uniform);
+                if (iter != mUniformMap.end())
+                {
+                        llassert(iter->second == glGetUniformLocationARB(mProgramObject, uniform.c_str()));
+                        return iter->second;
+                }
+        }
+
+        return -1;
+}
+
+void LLGLSLShader::uniform1f(const string& uniform, GLfloat v)
+{
+        GLint location = getUniformLocation(uniform);
+                                
+        if (location >= 0)
+        {
+                std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+                LLVector4 vec(v,0.f,0.f,0.f);
+                if (iter == mValue.end() || shouldChange(iter->second,vec))
+                {
+                        glUniform1fARB(location, v);
+                        mValue[location] = vec;
+                }
+        }
+}
+
+void LLGLSLShader::uniform2f(const string& uniform, GLfloat x, GLfloat y)
+{
+        GLint location = getUniformLocation(uniform);
+                                
+        if (location >= 0)
+        {
+                std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+                LLVector4 vec(x,y,0.f,0.f);
+                if (iter == mValue.end() || shouldChange(iter->second,vec))
+                {
+                        glUniform2fARB(location, x,y);
+                        mValue[location] = vec;
+                }
+        }
+
+}
+
+void LLGLSLShader::uniform3f(const string& uniform, GLfloat x, GLfloat y, GLfloat z)
+{
+        GLint location = getUniformLocation(uniform);
+                                
+        if (location >= 0)
+        {
+                std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+                LLVector4 vec(x,y,z,0.f);
+                if (iter == mValue.end() || shouldChange(iter->second,vec))
+                {
+                        glUniform3fARB(location, x,y,z);
+                        mValue[location] = vec;
+                }
+        }
+}
+
+void LLGLSLShader::uniform4f(const string& uniform, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+        GLint location = getUniformLocation(uniform);
+
+        if (location >= 0)
+        {
+                std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+                LLVector4 vec(x,y,z,w);
+                if (iter == mValue.end() || shouldChange(iter->second,vec))
+                {
+                        glUniform4fARB(location, x,y,z,w);
+                        mValue[location] = vec;
+                }
+        }
+}
+
+void LLGLSLShader::uniform1fv(const string& uniform, U32 count, const GLfloat* v)
+{
+        GLint location = getUniformLocation(uniform);
+
+        if (location >= 0)
+        {
+                std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+                LLVector4 vec(v[0],0.f,0.f,0.f);
+                if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+                {
+                        glUniform1fvARB(location, count, v);
+                        mValue[location] = vec;
+                }
+        }
+}
+
+void LLGLSLShader::uniform2fv(const string& uniform, U32 count, const GLfloat* v)
+{
+        GLint location = getUniformLocation(uniform);
+                                
+        if (location >= 0)
+        {
+                std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+                LLVector4 vec(v[0],v[1],0.f,0.f);
+                if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+                {
+                        glUniform2fvARB(location, count, v);
+                        mValue[location] = vec;
+                }
+        }
+}
+
+void LLGLSLShader::uniform3fv(const string& uniform, U32 count, const GLfloat* v)
+{
+        GLint location = getUniformLocation(uniform);
+                                
+        if (location >= 0)
+        {
+                std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+                LLVector4 vec(v[0],v[1],v[2],0.f);
+                if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+                {
+                        glUniform3fvARB(location, count, v);
+                        mValue[location] = vec;
+                }
+        }
+}
+
+void LLGLSLShader::uniform4fv(const string& uniform, U32 count, const GLfloat* v)
+{
+        GLint location = getUniformLocation(uniform);
+
+        if (location >= 0)
+        {
+                LLVector4 vec(v);
+                std::map<GLint, LLVector4>::iterator iter = mValue.find(location);
+                if (iter == mValue.end() || shouldChange(iter->second,vec) || count != 1)
+                {
+                        glUniform4fvARB(location, count, v);
+                        mValue[location] = vec;
+                }
+        }
+}
+
+void LLGLSLShader::uniformMatrix2fv(const string& uniform, U32 count, GLboolean transpose, const GLfloat* v)
+{
+        GLint location = getUniformLocation(uniform);
+                                
+        if (location >= 0)
+        {
+                glUniformMatrix2fvARB(location, count, transpose, v);
+        }
+}
+
+void LLGLSLShader::uniformMatrix3fv(const string& uniform, U32 count, GLboolean transpose, const GLfloat* v)
+{
+        GLint location = getUniformLocation(uniform);
+                                
+        if (location >= 0)
+        {
+                glUniformMatrix3fvARB(location, count, transpose, v);
+        }
+}
+
+void LLGLSLShader::uniformMatrix4fv(const string& uniform, U32 count, GLboolean transpose, const GLfloat* v)
+{
+        GLint location = getUniformLocation(uniform);
+                                
+        if (location >= 0)
+        {
+                glUniformMatrix4fvARB(location, count, transpose, v);
+        }
+}
+
+
+void LLGLSLShader::vertexAttrib4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+{
+        if (mAttribute[index] > 0)
+        {
+                glVertexAttrib4fARB(mAttribute[index], x, y, z, w);
+        }
+}
+
+void LLGLSLShader::vertexAttrib4fv(U32 index, GLfloat* v)
+{
+        if (mAttribute[index] > 0)
+        {
+                glVertexAttrib4fvARB(mAttribute[index], v);
+        }
+}
diff --git a/linden/indra/llrender/llglslshader.h b/linden/indra/llrender/llglslshader.h
new file mode 100644
index 0000000..0fa8e41
--- /dev/null
+++ b/linden/indra/llrender/llglslshader.h
@@ -0,0 +1,139 @@
+/** 
+ * @file llglslshader.h
+ * @brief GLSL shader wrappers
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLGLSLSHADER_H
+#define LL_LLGLSLSHADER_H
+
+#include "llgl.h"
+
+class LLShaderFeatures
+{
+public:
+        bool calculatesLighting;
+        bool calculatesAtmospherics;
+        bool hasLighting; // implies no transport (it's possible to have neither though)
+        bool isShiny;
+        bool isFullbright; // implies no lighting
+        bool isSpecular;
+        bool hasWaterFog; // implies no gamma
+        bool hasTransport; // implies no lighting (it's possible to have neither though)
+        bool hasSkinning;       
+        bool hasAtmospherics;
+        bool hasGamma;
+
+        // char numLights;
+        
+        LLShaderFeatures();
+};
+
+class LLGLSLShader
+{
+public:
+
+        enum 
+        {
+                SG_DEFAULT = 0,
+                SG_SKY,
+                SG_WATER
+        };
+        
+        LLGLSLShader();
+
+        void unload();
+        BOOL createShader(std::vector<std::string> * attributes,
+                                                std::vector<std::string> * uniforms);
+        BOOL attachObject(std::string object);
+        void attachObject(GLhandleARB object);
+        void attachObjects(GLhandleARB* objects = NULL, S32 count = 0);
+        BOOL mapAttributes(const std::vector<std::string> * attributes);
+        BOOL mapUniforms(const std::vector<std::string> * uniforms);
+        void mapUniform(GLint index, const std::vector<std::string> * uniforms);
+        void uniform1f(U32 index, GLfloat v);
+        void uniform2f(U32 index, GLfloat x, GLfloat y);
+        void uniform3f(U32 index, GLfloat x, GLfloat y, GLfloat z);
+        void uniform4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+        void uniform1fv(U32 index, U32 count, const GLfloat* v);
+        void uniform2fv(U32 index, U32 count, const GLfloat* v);
+        void uniform3fv(U32 index, U32 count, const GLfloat* v);
+        void uniform4fv(U32 index, U32 count, const GLfloat* v);
+        void uniform1f(const std::string& uniform, GLfloat v);
+        void uniform2f(const std::string& uniform, GLfloat x, GLfloat y);
+        void uniform3f(const std::string& uniform, GLfloat x, GLfloat y, GLfloat z);
+        void uniform4f(const std::string& uniform, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+        void uniform1fv(const std::string& uniform, U32 count, const GLfloat* v);
+        void uniform2fv(const std::string& uniform, U32 count, const GLfloat* v);
+        void uniform3fv(const std::string& uniform, U32 count, const GLfloat* v);
+        void uniform4fv(const std::string& uniform, U32 count, const GLfloat* v);
+        void uniformMatrix2fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
+        void uniformMatrix3fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
+        void uniformMatrix4fv(U32 index, U32 count, GLboolean transpose, const GLfloat *v);
+        void uniformMatrix2fv(const std::string& uniform, U32 count, GLboolean transpose, const GLfloat *v);
+        void uniformMatrix3fv(const std::string& uniform, U32 count, GLboolean transpose, const GLfloat *v);
+        void uniformMatrix4fv(const std::string& uniform, U32 count, GLboolean transpose, const GLfloat *v);
+
+        void vertexAttrib4f(U32 index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
+        void vertexAttrib4fv(U32 index, GLfloat* v);
+        
+        GLint getUniformLocation(const std::string& uniform);
+        
+        GLint mapUniformTextureChannel(GLint location, GLenum type);
+        
+
+        //enable/disable texture channel for specified uniform
+        //if given texture uniform is active in the shader, 
+        //the corresponding channel will be active upon return
+        //returns channel texture is enabled in from [0-MAX)
+        S32 enableTexture(S32 uniform, S32 mode = GL_TEXTURE_2D);
+        S32 disableTexture(S32 uniform, S32 mode = GL_TEXTURE_2D); 
+        
+    BOOL link(BOOL suppress_errors = FALSE);
+        void bind();
+        void unbind();
+
+        // Unbinds any previously bound shader by explicitly binding no shader.
+        static void bindNoShader(void);
+
+        GLhandleARB mProgramObject;
+        std::vector<GLint> mAttribute; //lookup table of attribute enum to attribute channel
+        std::vector<GLint> mUniform;   //lookup table of uniform enum to uniform location
+        std::map<std::string, GLint> mUniformMap;  //lookup map of uniform name to uniform location
+        std::map<GLint, LLVector4> mValue; //lookup map of uniform location to last known value
+        std::vector<GLint> mTexture;
+        S32 mActiveTextureChannels;
+        S32 mShaderLevel;
+        S32 mShaderGroup;
+        BOOL mUniformsDirty;
+        LLShaderFeatures mFeatures;
+        std::vector< std::pair< std::string, GLenum > > mShaderFiles;
+        std::string mName;
+};
+
+#endif
diff --git a/linden/indra/llrender/llglstates.h b/linden/indra/llrender/llglstates.h
new file mode 100644
index 0000000..e53640c
--- /dev/null
+++ b/linden/indra/llrender/llglstates.h
@@ -0,0 +1,302 @@
+/** 
+ * @file llglstates.h
+ * @brief LLGL states definitions
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+//THIS HEADER SHOULD ONLY BE INCLUDED FROM llgl.h
+#ifndef LL_LLGLSTATES_H
+#define LL_LLGLSTATES_H
+
+#include "llimagegl.h"
+
+//----------------------------------------------------------------------------
+
+class LLGLDepthTest
+{
+        // Enabled by default
+public:
+        LLGLDepthTest(GLboolean depth_enabled, GLboolean write_enabled = GL_TRUE, GLenum depth_func = GL_LEQUAL);
+        
+        ~LLGLDepthTest();
+        
+        GLboolean mPrevDepthEnabled;
+        GLenum mPrevDepthFunc;
+        GLboolean mPrevWriteEnabled;
+private:
+        static GLboolean sDepthEnabled; // defaults to GL_FALSE
+        static GLenum sDepthFunc; // defaults to GL_LESS
+        static GLboolean sWriteEnabled; // defaults to GL_TRUE
+};
+
+//----------------------------------------------------------------------------
+
+class LLGLSDefault
+{
+protected:
+        LLGLEnable mColorMaterial;
+        LLGLDisable mAlphaTest, mBlend, mCullFace, mDither, mFog, 
+                mLineSmooth, mLineStipple, mNormalize, mPolygonSmooth,
+                mTextureGenQ, mTextureGenR, mTextureGenS, mTextureGenT,
+                mGLMultisample;
+public:
+        LLGLSDefault()
+                :
+                // Enable
+                mColorMaterial(GL_COLOR_MATERIAL),
+                // Disable
+                mAlphaTest(GL_ALPHA_TEST),
+                mBlend(GL_BLEND), 
+                mCullFace(GL_CULL_FACE),
+                mDither(GL_DITHER),
+                mFog(GL_FOG), 
+                mLineSmooth(GL_LINE_SMOOTH),
+                mLineStipple(GL_LINE_STIPPLE),
+                mNormalize(GL_NORMALIZE),
+                mPolygonSmooth(GL_POLYGON_SMOOTH),
+                mTextureGenQ(GL_TEXTURE_GEN_Q), 
+                mTextureGenR(GL_TEXTURE_GEN_R),
+                mTextureGenS(GL_TEXTURE_GEN_S), 
+                mTextureGenT(GL_TEXTURE_GEN_T),
+                mGLMultisample(GL_MULTISAMPLE_ARB)
+        { }
+};
+
+class LLGLSNoTexture 
+{
+public:
+        LLGLSNoTexture()
+        { LLImageGL::unbindTexture(0); }
+};
+
+class LLGLSObjectSelect
+{ 
+protected:
+        LLGLDisable mBlend, mFog, mAlphaTest;
+        LLGLEnable mCullFace;
+public:
+        LLGLSObjectSelect()
+                : mBlend(GL_BLEND), mFog(GL_FOG), 
+                  mAlphaTest(GL_ALPHA_TEST),
+                  mCullFace(GL_CULL_FACE)
+        { LLImageGL::unbindTexture(0); }
+};
+
+class LLGLSObjectSelectAlpha
+{
+protected:
+        LLGLEnable mAlphaTest;
+public:
+        LLGLSObjectSelectAlpha()
+                : mAlphaTest(GL_ALPHA_TEST)
+        {}
+};
+
+//----------------------------------------------------------------------------
+
+class LLGLSUIDefault
+{ 
+protected:
+        LLGLEnable mBlend, mAlphaTest;
+        LLGLDisable mCullFace;
+        LLGLDepthTest mDepthTest;
+public:
+        LLGLSUIDefault() 
+                : mBlend(GL_BLEND), mAlphaTest(GL_ALPHA_TEST),
+                  mCullFace(GL_CULL_FACE),
+                  mDepthTest(GL_FALSE, GL_TRUE, GL_LEQUAL)
+        {}
+};
+
+class LLGLSNoAlphaTest // : public LLGLSUIDefault
+{
+protected:
+        LLGLDisable mAlphaTest;
+public:
+        LLGLSNoAlphaTest()
+                : mAlphaTest(GL_ALPHA_TEST)
+        {}
+};
+
+class LLGLSNoTextureNoAlphaTest // : public LLGLSUIDefault
+{
+protected:
+        LLGLDisable mAlphaTest;
+public:
+        LLGLSNoTextureNoAlphaTest()
+                : mAlphaTest(GL_ALPHA_TEST)
+                  
+        { LLImageGL::unbindTexture(0); }
+};
+
+//----------------------------------------------------------------------------
+
+class LLGLSFog
+{
+protected:
+        LLGLEnable mFog;
+public:
+        LLGLSFog()
+                : mFog(GL_FOG)
+        {}
+};
+
+class LLGLSNoFog
+{
+protected:
+        LLGLDisable mFog;
+public:
+        LLGLSNoFog()
+                : mFog(GL_FOG)
+        {}
+};
+
+//----------------------------------------------------------------------------
+
+class LLGLSPipeline
+{ 
+protected:
+        LLGLEnable mCullFace;
+        LLGLDepthTest mDepthTest;
+public:
+        LLGLSPipeline()
+                : mCullFace(GL_CULL_FACE),
+                  mDepthTest(GL_TRUE, GL_TRUE, GL_LEQUAL)
+        { }             
+};
+
+class LLGLSPipelineAlpha // : public LLGLSPipeline
+{ 
+protected:
+        LLGLEnable mBlend, mAlphaTest;
+public:
+        LLGLSPipelineAlpha()
+                : mBlend(GL_BLEND),
+                  mAlphaTest(GL_ALPHA_TEST)
+        { }
+};
+
+class LLGLSPipelineEmbossBump
+{
+protected:
+        LLGLDisable mFog;
+public:
+        LLGLSPipelineEmbossBump()
+                : mFog(GL_FOG)
+        { }
+};
+
+class LLGLSPipelineSelection
+{ 
+protected:
+        LLGLDisable mCullFace;
+public:
+        LLGLSPipelineSelection()
+                : mCullFace(GL_CULL_FACE)
+        {}
+};
+
+class LLGLSPipelineAvatar
+{
+protected:
+        LLGLEnable mNormalize;
+public:
+        LLGLSPipelineAvatar()
+                : mNormalize(GL_NORMALIZE)
+        {}
+};
+
+class LLGLSPipelineSkyBox
+{ 
+protected:
+        LLGLDisable mAlphaTest, mCullFace, mFog;
+public:
+        LLGLSPipelineSkyBox()
+                : mAlphaTest(GL_ALPHA_TEST), mCullFace(GL_CULL_FACE), mFog(GL_FOG)
+        { }
+};
+
+class LLGLSTracker
+{
+protected:
+        LLGLEnable mCullFace, mBlend, mAlphaTest;
+public:
+        LLGLSTracker() :
+                mCullFace(GL_CULL_FACE),
+                mBlend(GL_BLEND),
+                mAlphaTest(GL_ALPHA_TEST)
+                
+        { LLImageGL::unbindTexture(0); }
+};
+
+//----------------------------------------------------------------------------
+
+class LLGLSSpecular
+{
+public:
+        LLGLSSpecular(const LLColor4& color, F32 shininess)
+        {
+                if (shininess > 0.0f)
+                {
+                        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, color.mV);
+                        S32 shiny = (S32)(shininess*128.f);
+                        shiny = llclamp(shiny,0,128);
+                        glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, shiny);
+                }
+        }
+        ~LLGLSSpecular()
+        {
+                glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, LLColor4(0.f,0.f,0.f,0.f).mV);
+                glMateriali(GL_FRONT_AND_BACK, GL_SHININESS, 0);
+        }
+};
+
+//----------------------------------------------------------------------------
+
+
+class LLGLSBlendFunc : public LLGLSPipeline {
+protected:
+        GLint mSavedSrc, mSavedDst;
+        LLGLEnable mBlend;
+
+public:
+        LLGLSBlendFunc(GLenum srcFunc, GLenum dstFunc) :
+                mBlend(GL_BLEND)
+        {
+                glGetIntegerv(GL_BLEND_SRC, &mSavedSrc);
+                glGetIntegerv(GL_BLEND_DST, &mSavedDst);
+                glBlendFunc(srcFunc, dstFunc);
+        }
+
+        ~LLGLSBlendFunc(void) {
+                glBlendFunc(mSavedSrc, mSavedDst);
+        }
+};
+
+
+#endif
diff --git a/linden/indra/llrender/llgltypes.h b/linden/indra/llrender/llgltypes.h
new file mode 100644
index 0000000..d22d5fa
--- /dev/null
+++ b/linden/indra/llrender/llgltypes.h
@@ -0,0 +1,44 @@
+/** 
+ * @file llgltypes.h
+ * @brief LLGL definition
+ *
+ * $LicenseInfo:firstyear=2006&license=viewergpl$
+ * 
+ * Copyright (c) 2006-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LLGLTYPES_H
+#define LLGLTYPES_H
+
+#define MAX_GL_TEXTURE_UNITS 16
+
+typedef U32 LLGLenum;
+typedef U32 LLGLuint;
+typedef S32 LLGLint;
+typedef F32 LLGLfloat;
+typedef F64 LLGLdouble;
+typedef U8 LLGLboolean;
+
+#endif
diff --git a/linden/indra/llrender/llimagegl.cpp b/linden/indra/llrender/llimagegl.cpp
index a402814..a871758 100644
--- a/linden/indra/llrender/llimagegl.cpp
+++ b/linden/indra/llrender/llimagegl.cpp
@@ -836,7 +836,7 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
                 llwarns << "Trying to create a texture while GL is disabled!" << llendl;
                 return FALSE;
         }
-        llassert(gGLManager.mInited || gNoRender);
+        llassert(gGLManager.mInited);
         stop_glerror();
 
         if (discard_level < 0)
diff --git a/linden/indra/llrender/llpostprocess.cpp b/linden/indra/llrender/llpostprocess.cpp
new file mode 100644
index 0000000..c884951
--- /dev/null
+++ b/linden/indra/llrender/llpostprocess.cpp
@@ -0,0 +1,574 @@
+/** 
+ * @file llpostprocess.cpp
+ * @brief LLPostProcess class implementation
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llpostprocess.h"
+#include "llglslshader.h"
+#include "llsdserialize.h"
+#include "llrender.h"
+
+
+LLPostProcess * gPostProcess = NULL;
+
+
+static const unsigned int NOISE_SIZE = 512;
+
+/// CALCULATING LUMINANCE (Using NTSC lum weights)
+/// http://en.wikipedia.org/wiki/Luma_%28video%29
+static const float LUMINANCE_R = 0.299f;
+static const float LUMINANCE_G = 0.587f;
+static const float LUMINANCE_B = 0.114f;
+
+static const char * const XML_FILENAME = "postprocesseffects.xml";
+
+LLPostProcess::LLPostProcess(void) : 
+                                        sceneRenderTexture(0), noiseTexture(0),
+                                        tempBloomTexture(0),
+                                        initialized(false),  
+                                        mAllEffects(LLSD::emptyMap()),
+                                        screenW(1), screenH(1)
+{
+        /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
+        std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight", XML_FILENAME));
+        LL_DEBUGS2("AppInit", "Shaders") << "Loading PostProcess Effects settings from " << pathName << LL_ENDL;
+
+        llifstream effectsXML(pathName);
+
+        if (effectsXML)
+        {
+                LLPointer<LLSDParser> parser = new LLSDXMLParser();
+
+                parser->parse(effectsXML, mAllEffects, LLSDSerialize::SIZE_UNLIMITED);
+        }
+
+        if (!mAllEffects.has("default"))
+        {
+                LLSD & defaultEffect = (mAllEffects["default"] = LLSD::emptyMap());
+
+                defaultEffect["enable_night_vision"] = LLSD::Boolean(false);
+                defaultEffect["enable_bloom"] = LLSD::Boolean(false);
+                defaultEffect["enable_color_filter"] = LLSD::Boolean(false);
+
+                /// NVG Defaults
+                defaultEffect["brightness_multiplier"] = 3.0;
+                defaultEffect["noise_size"] = 25.0;
+                defaultEffect["noise_strength"] = 0.4;
+
+                // TODO BTest potentially add this to tweaks?
+                noiseTextureScale = 1.0f;
+                
+                /// Bloom Defaults
+                defaultEffect["extract_low"] = 0.95;
+                defaultEffect["extract_high"] = 1.0;
+                defaultEffect["bloom_width"] = 2.25;
+                defaultEffect["bloom_strength"] = 1.5;
+
+                /// Color Filter Defaults
+                defaultEffect["brightness"] = 1.0;
+                defaultEffect["contrast"] = 1.0;
+                defaultEffect["saturation"] = 1.0;
+
+                LLSD& contrastBase = (defaultEffect["contrast_base"] = LLSD::emptyArray());
+                contrastBase.append(1.0);
+                contrastBase.append(1.0);
+                contrastBase.append(1.0);
+                contrastBase.append(0.5);
+        }
+
+        setSelectedEffect("default");
+        */
+}
+
+LLPostProcess::~LLPostProcess(void)
+{
+        glDeleteTextures(1, &sceneRenderTexture);
+        glDeleteTextures(1, &noiseTexture);
+        glDeleteTextures(1, &tempBloomTexture);
+}
+
+// static
+void LLPostProcess::initClass(void)
+{
+        //this will cause system to crash at second time login
+        //if first time login fails due to network connection --- bao
+        //***llassert_always(gPostProcess == NULL);
+        //replaced by the following line:
+        if(gPostProcess)
+                return ;
+        
+        
+        gPostProcess = new LLPostProcess();
+}
+
+// static
+void LLPostProcess::cleanupClass()
+{
+        delete gPostProcess;
+        gPostProcess = NULL;
+}
+
+void LLPostProcess::setSelectedEffect(std::string const & effectName)
+{
+        mSelectedEffectName = effectName;
+        static_cast<LLSD &>(tweaks) = mAllEffects[effectName];
+}
+
+void LLPostProcess::saveEffect(std::string const & effectName)
+{
+        /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
+        mAllEffects[effectName] = tweaks;
+
+        std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight", XML_FILENAME));
+        //llinfos << "Saving PostProcess Effects settings to " << pathName << llendl;
+
+        llofstream effectsXML(pathName);
+
+        LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
+
+        formatter->format(mAllEffects, effectsXML);
+        */
+}
+
+void LLPostProcess::apply(unsigned int width, unsigned int height)
+{
+        if (!initialized || width != screenW || height != screenH){
+                initialize(width, height);
+        }
+        if (shadersEnabled()){
+                doEffects();
+        }
+}
+
+void LLPostProcess::initialize(unsigned int width, unsigned int height)
+{
+        screenW = width;
+        screenH = height;
+        createTexture(sceneRenderTexture, screenW, screenH);
+        initialized = true;
+
+        checkError();
+        createNightVisionShader();
+        createBloomShader();
+        createColorFilterShader();
+        checkError();
+}
+
+inline bool LLPostProcess::shadersEnabled(void)
+{
+        return (tweaks.useColorFilter().asBoolean() ||
+                        tweaks.useNightVisionShader().asBoolean() ||
+                        tweaks.useBloomShader().asBoolean() );
+
+}
+
+void LLPostProcess::applyShaders(void)
+{
+        if (tweaks.useColorFilter()){
+                applyColorFilterShader();
+                checkError();
+        }       
+        if (tweaks.useNightVisionShader()){
+                /// If any of the above shaders have been called update the frame buffer;
+                if (tweaks.useColorFilter()){
+                        copyFrameBuffer(sceneRenderTexture, screenW, screenH);
+                }
+                applyNightVisionShader();
+                checkError();
+        }
+        if (tweaks.useBloomShader()){
+                /// If any of the above shaders have been called update the frame buffer;
+                if (tweaks.useColorFilter().asBoolean() || tweaks.useNightVisionShader().asBoolean()){
+                        copyFrameBuffer(sceneRenderTexture, screenW, screenH);
+                }
+                applyBloomShader();
+                checkError();
+        }
+}
+
+void LLPostProcess::applyColorFilterShader(void)
+{       
+        /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
+        gPostColorFilterProgram.bind();
+
+        gGL.getTexUnit(0)->activate();
+        glEnable(GL_TEXTURE_RECTANGLE_ARB);     
+
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, sceneRenderTexture);
+
+        getShaderUniforms(colorFilterUniforms, gPostColorFilterProgram.mProgramObject);
+        glUniform1iARB(colorFilterUniforms["RenderTexture"], 0);
+        glUniform1fARB(colorFilterUniforms["brightness"], tweaks.getBrightness());
+        glUniform1fARB(colorFilterUniforms["contrast"], tweaks.getContrast());
+        float baseI = (tweaks.getContrastBaseR() + tweaks.getContrastBaseG() + tweaks.getContrastBaseB()) / 3.0f;
+        baseI = tweaks.getContrastBaseIntensity() / ((baseI < 0.001f) ? 0.001f : baseI);
+        float baseR = tweaks.getContrastBaseR() * baseI;
+        float baseG = tweaks.getContrastBaseG() * baseI;
+        float baseB = tweaks.getContrastBaseB() * baseI;
+        glUniform3fARB(colorFilterUniforms["contrastBase"], baseR, baseG, baseB);
+        glUniform1fARB(colorFilterUniforms["saturation"], tweaks.getSaturation());
+        glUniform3fARB(colorFilterUniforms["lumWeights"], LUMINANCE_R, LUMINANCE_G, LUMINANCE_B);
+        
+        LLGLEnable blend(GL_BLEND);
+        gGL.setSceneBlendType(LLRender::BT_REPLACE);
+        LLGLDepthTest depth(GL_FALSE);
+                
+        /// Draw a screen space quad
+        drawOrthoQuad(screenW, screenH, QUAD_NORMAL);
+        gPostColorFilterProgram.unbind();
+        */
+}
+
+void LLPostProcess::createColorFilterShader(void)
+{
+        /// Define uniform names
+        colorFilterUniforms["RenderTexture"] = 0;
+        colorFilterUniforms["brightness"] = 0;
+        colorFilterUniforms["contrast"] = 0;
+        colorFilterUniforms["contrastBase"] = 0;
+        colorFilterUniforms["saturation"] = 0;
+        colorFilterUniforms["lumWeights"] = 0;
+}
+
+void LLPostProcess::applyNightVisionShader(void)
+{       
+        /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
+        gPostNightVisionProgram.bind();
+
+        gGL.getTexUnit(0)->activate();
+        glEnable(GL_TEXTURE_RECTANGLE_ARB);     
+
+        getShaderUniforms(nightVisionUniforms, gPostNightVisionProgram.mProgramObject);
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, sceneRenderTexture);
+        glUniform1iARB(nightVisionUniforms["RenderTexture"], 0);
+
+        gGL.getTexUnit(1)->activate();
+        glEnable(GL_TEXTURE_2D);        
+
+        glBindTexture(GL_TEXTURE_2D, noiseTexture);
+        glUniform1iARB(nightVisionUniforms["NoiseTexture"], 1);
+
+        
+        glUniform1fARB(nightVisionUniforms["brightMult"], tweaks.getBrightMult());
+        glUniform1fARB(nightVisionUniforms["noiseStrength"], tweaks.getNoiseStrength());
+        noiseTextureScale = 0.01f + ((101.f - tweaks.getNoiseSize()) / 100.f);
+        noiseTextureScale *= (screenH / NOISE_SIZE);
+
+
+        glUniform3fARB(nightVisionUniforms["lumWeights"], LUMINANCE_R, LUMINANCE_G, LUMINANCE_B);
+        
+        LLGLEnable blend(GL_BLEND);
+        gGL.setSceneBlendType(LLRender::BT_REPLACE);
+        LLGLDepthTest depth(GL_FALSE);
+                
+        /// Draw a screen space quad
+        drawOrthoQuad(screenW, screenH, QUAD_NOISE);
+        gPostNightVisionProgram.unbind();
+        gGL.getTexUnit(0)->activate();
+        */
+}
+
+void LLPostProcess::createNightVisionShader(void)
+{
+        /// Define uniform names
+        nightVisionUniforms["RenderTexture"] = 0;
+        nightVisionUniforms["NoiseTexture"] = 0;
+        nightVisionUniforms["brightMult"] = 0;  
+        nightVisionUniforms["noiseStrength"] = 0;
+        nightVisionUniforms["lumWeights"] = 0;  
+
+        createNoiseTexture(noiseTexture);
+}
+
+void LLPostProcess::applyBloomShader(void)
+{
+
+}
+
+void LLPostProcess::createBloomShader(void)
+{
+        createTexture(tempBloomTexture, unsigned(screenW * 0.5), unsigned(screenH * 0.5));
+
+        /// Create Bloom Extract Shader
+        bloomExtractUniforms["RenderTexture"] = 0;
+        bloomExtractUniforms["extractLow"] = 0;
+        bloomExtractUniforms["extractHigh"] = 0;        
+        bloomExtractUniforms["lumWeights"] = 0; 
+        
+        /// Create Bloom Blur Shader
+        bloomBlurUniforms["RenderTexture"] = 0;
+        bloomBlurUniforms["bloomStrength"] = 0; 
+        bloomBlurUniforms["texelSize"] = 0;
+        bloomBlurUniforms["blurDirection"] = 0;
+        bloomBlurUniforms["blurWidth"] = 0;
+}
+
+void LLPostProcess::getShaderUniforms(glslUniforms & uniforms, GLhandleARB & prog)
+{
+        /// Find uniform locations and insert into map  
+        std::map<const char *, GLuint>::iterator i;
+        for (i  = uniforms.begin(); i != uniforms.end(); ++i){
+                i->second = glGetUniformLocationARB(prog, i->first);
+        }
+}
+
+void LLPostProcess::doEffects(void)
+{
+        /// Save GL State
+        glPushAttrib(GL_ALL_ATTRIB_BITS);
+        glPushClientAttrib(GL_ALL_ATTRIB_BITS);
+
+        /// Copy the screen buffer to the render texture
+        copyFrameBuffer(sceneRenderTexture, screenW, screenH);
+
+        /// Clear the frame buffer.
+        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+        glClear(GL_COLOR_BUFFER_BIT);
+        
+        /// Change to an orthogonal view
+        viewOrthogonal(screenW, screenH);
+        
+        checkError();
+        applyShaders();
+        
+        LLGLSLShader::bindNoShader();
+        checkError();
+
+        /// Change to a perspective view
+        viewPerspective();      
+
+        /// Reset GL State
+        glPopClientAttrib();
+        glPopAttrib();
+        checkError();
+}
+
+void LLPostProcess::copyFrameBuffer(GLuint & texture, unsigned int width, unsigned int height)
+{
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture);
+        glCopyTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 0, 0, width, height, 0);
+}
+
+void LLPostProcess::drawOrthoQuad(unsigned int width, unsigned int height, QuadType type)
+{
+#if 0
+        float noiseX = 0.f;
+        float noiseY = 0.f;
+        float screenRatio = 1.0f;
+
+        if (type == QUAD_NOISE){
+                noiseX = ((float) rand() / (float) RAND_MAX);
+                noiseY = ((float) rand() / (float) RAND_MAX);
+                screenRatio = (float) width / (float) height;
+        }
+        
+
+        glBegin(GL_QUADS);
+                if (type != QUAD_BLOOM_EXTRACT){
+                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, (GLfloat) height);
+                } else {
+                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, (GLfloat) height * 2.0f);
+                }
+                if (type == QUAD_NOISE){
+                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
+                                                                        noiseX,
+                                                                        noiseTextureScale + noiseY);
+                } else if (type == QUAD_BLOOM_COMBINE){
+                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.f, (GLfloat) height * 0.5f);
+                }
+                glVertex2f(0.f, (GLfloat) screenH - height);
+
+                if (type != QUAD_BLOOM_EXTRACT){
+                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, 0.f);
+                } else {
+                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, 0.f);
+                }
+                if (type == QUAD_NOISE){
+                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
+                                                                        noiseX,
+                                                                        noiseY);
+                } else if (type == QUAD_BLOOM_COMBINE){
+                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.f, 0.f);
+                }
+                glVertex2f(0.f, (GLfloat) height + (screenH - height));
+
+                
+                if (type != QUAD_BLOOM_EXTRACT){
+                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width, 0.f);
+                } else {
+                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width * 2.0f, 0.f);
+                }
+                if (type == QUAD_NOISE){
+                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
+                                                                        screenRatio * noiseTextureScale + noiseX,
+                                                                        noiseY);
+                } else if (type == QUAD_BLOOM_COMBINE){
+                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB, (GLfloat) width * 0.5f, 0.f);
+                }
+                glVertex2f((GLfloat) width, (GLfloat) height + (screenH - height));
+
+                
+                if (type != QUAD_BLOOM_EXTRACT){
+                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width, (GLfloat) height);
+                } else {
+                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width * 2.0f, (GLfloat) height * 2.0f);
+                }
+                if (type == QUAD_NOISE){
+                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
+                                                                        screenRatio * noiseTextureScale + noiseX,
+                                                                        noiseTextureScale + noiseY);
+                } else if (type == QUAD_BLOOM_COMBINE){
+                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB, (GLfloat) width * 0.5f, (GLfloat) height * 0.5f);
+                }
+                glVertex2f((GLfloat) width, (GLfloat) screenH - height);
+        glEnd();
+#endif
+}
+
+void LLPostProcess::viewOrthogonal(unsigned int width, unsigned int height)
+{
+        glMatrixMode(GL_PROJECTION);
+        glPushMatrix();
+        glLoadIdentity();
+        glOrtho( 0.f, (GLdouble) width , (GLdouble) height , 0.f, -1.f, 1.f );
+        glMatrixMode(GL_MODELVIEW);
+        glPushMatrix();
+        glLoadIdentity();
+}
+
+void LLPostProcess::viewPerspective(void)
+{
+        glMatrixMode( GL_PROJECTION );
+        glPopMatrix();
+        glMatrixMode( GL_MODELVIEW );
+        glPopMatrix();
+}
+
+void LLPostProcess::changeOrthogonal(unsigned int width, unsigned int height)
+{
+        viewPerspective();
+        viewOrthogonal(width, height);
+}
+
+void LLPostProcess::createTexture(GLuint & texture, unsigned int width, unsigned int height)
+{
+        if (texture != 0){
+                glDeleteTextures(1, &texture);
+        }
+
+        std::vector<GLubyte> data(width * height * 4, 0);
+
+        glGenTextures(1, &texture);
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture);
+        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 4, width, height, 0,
+                GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
+        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+}
+
+void LLPostProcess::createNoiseTexture(GLuint & texture)
+{
+        if (texture != 0){
+                glDeleteTextures(1, &texture);
+        }
+        glGenTextures(1, &texture);
+
+        std::vector<GLubyte> buffer(NOISE_SIZE * NOISE_SIZE);
+        for (unsigned int i = 0; i < NOISE_SIZE; i++){
+                for (unsigned int k = 0; k < NOISE_SIZE; k++){
+                        buffer[(i * NOISE_SIZE) + k] = (GLubyte)((double) rand() / ((double) RAND_MAX + 1.f) * 255.f);
+                }
+        }
+        glBindTexture(GL_TEXTURE_2D, texture);
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, NOISE_SIZE, NOISE_SIZE, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, &buffer[0]);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+}
+
+bool LLPostProcess::checkError(void)
+{
+        GLenum glErr;
+    bool    retCode = false;
+
+    glErr = glGetError();
+    while (glErr != GL_NO_ERROR)
+    {
+                // shaderErrorLog << (const char *) gluErrorString(glErr) << std::endl;
+                char const * err_str_raw = (const char *) gluErrorString(glErr);
+
+                if(err_str_raw == NULL)
+                {
+                        std::ostringstream err_builder;
+                        err_builder << "unknown error number " << glErr;
+                        mShaderErrorString = err_builder.str();
+                }
+                else
+                {
+                        mShaderErrorString = err_str_raw;
+                }
+
+        retCode = true;
+        glErr = glGetError();
+    }
+    return retCode;
+}
+
+void LLPostProcess::checkShaderError(GLhandleARB shader)
+{
+    GLint infologLength = 0;
+    GLint charsWritten  = 0;
+    GLchar *infoLog;
+
+    checkError();  // Check for OpenGL errors
+
+    glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infologLength);
+
+    checkError();  // Check for OpenGL errors
+
+    if (infologLength > 0)
+    {
+        infoLog = (GLchar *)malloc(infologLength);
+        if (infoLog == NULL)
+        {
+            /// Could not allocate infolog buffer
+            return;
+        }
+        glGetInfoLogARB(shader, infologLength, &charsWritten, infoLog);
+                // shaderErrorLog << (char *) infoLog << std::endl;
+                mShaderErrorString = (char *) infoLog;
+        free(infoLog);
+    }
+    checkError();  // Check for OpenGL errors
+}
diff --git a/linden/indra/llrender/llpostprocess.h b/linden/indra/llrender/llpostprocess.h
new file mode 100644
index 0000000..cd9f477
--- /dev/null
+++ b/linden/indra/llrender/llpostprocess.h
@@ -0,0 +1,268 @@
+/** 
+ * @file llpostprocess.h
+ * @brief LLPostProcess class definition
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_POSTPROCESS_H
+#define LL_POSTPROCESS_H
+
+#include <map>
+#include <fstream>
+#include "llgl.h"
+#include "llglheaders.h"
+
+class LLPostProcess 
+{
+public:
+
+        typedef enum _QuadType {
+                QUAD_NORMAL,
+                QUAD_NOISE,
+                QUAD_BLOOM_EXTRACT,
+                QUAD_BLOOM_COMBINE
+        } QuadType;
+
+        /// GLSL Shader Encapsulation Struct
+        typedef std::map<const char *, GLuint> glslUniforms;
+
+        struct PostProcessTweaks : public LLSD {
+                inline PostProcessTweaks() : LLSD(LLSD::emptyMap())
+                {
+                }
+
+                inline LLSD & brightMult() {
+                        return (*this)["brightness_multiplier"];
+                }
+
+                inline LLSD & noiseStrength() {
+                        return (*this)["noise_strength"];
+                }
+
+                inline LLSD & noiseSize() {
+                        return (*this)["noise_size"];
+                }
+
+                inline LLSD & extractLow() {
+                        return (*this)["extract_low"];
+                }
+
+                inline LLSD & extractHigh() {
+                        return (*this)["extract_high"];
+                }
+
+                inline LLSD & bloomWidth() {
+                        return (*this)["bloom_width"];
+                }
+
+                inline LLSD & bloomStrength() {
+                        return (*this)["bloom_strength"];
+                }
+
+                inline LLSD & brightness() {
+                        return (*this)["brightness"];
+                }
+
+                inline LLSD & contrast() {
+                        return (*this)["contrast"];
+                }
+
+                inline LLSD & contrastBaseR() {
+                        return (*this)["contrast_base"][0];
+                }
+
+                inline LLSD & contrastBaseG() {
+                        return (*this)["contrast_base"][1];
+                }
+
+                inline LLSD & contrastBaseB() {
+                        return (*this)["contrast_base"][2];
+                }
+
+                inline LLSD & contrastBaseIntensity() {
+                        return (*this)["contrast_base"][3];
+                }
+
+                inline LLSD & saturation() {
+                        return (*this)["saturation"];
+                }
+
+                inline LLSD & useNightVisionShader() {
+                        return (*this)["enable_night_vision"];
+                }
+
+                inline LLSD & useBloomShader() {
+                        return (*this)["enable_bloom"];
+                }
+
+                inline LLSD & useColorFilter() {
+                        return (*this)["enable_color_filter"];
+                }
+
+
+                inline F32 getBrightMult() const {
+                        return F32((*this)["brightness_multiplier"].asReal());
+                }
+
+                inline F32 getNoiseStrength() const {
+                        return F32((*this)["noise_strength"].asReal());
+                }
+
+                inline F32 getNoiseSize() const {
+                        return F32((*this)["noise_size"].asReal());
+                }
+
+                inline F32 getExtractLow() const {
+                        return F32((*this)["extract_low"].asReal());
+                }
+
+                inline F32 getExtractHigh() const {
+                        return F32((*this)["extract_high"].asReal());
+                }
+
+                inline F32 getBloomWidth() const {
+                        return F32((*this)["bloom_width"].asReal());
+                }
+
+                inline F32 getBloomStrength() const {
+                        return F32((*this)["bloom_strength"].asReal());
+                }
+
+                inline F32 getBrightness() const {
+                        return F32((*this)["brightness"].asReal());
+                }
+
+                inline F32 getContrast() const {
+                        return F32((*this)["contrast"].asReal());
+                }
+
+                inline F32 getContrastBaseR() const {
+                        return F32((*this)["contrast_base"][0].asReal());
+                }
+
+                inline F32 getContrastBaseG() const {
+                        return F32((*this)["contrast_base"][1].asReal());
+                }
+
+                inline F32 getContrastBaseB() const {
+                        return F32((*this)["contrast_base"][2].asReal());
+                }
+
+                inline F32 getContrastBaseIntensity() const {
+                        return F32((*this)["contrast_base"][3].asReal());
+                }
+
+                inline F32 getSaturation() const {
+                        return F32((*this)["saturation"].asReal());
+                }
+
+        };
+        
+        GLuint sceneRenderTexture;
+        GLuint noiseTexture;
+        GLuint tempBloomTexture;
+        bool initialized;
+        PostProcessTweaks tweaks;
+
+        // the map of all availible effects
+        LLSD mAllEffects;
+
+public:
+        LLPostProcess(void);
+
+        ~LLPostProcess(void);
+
+        void apply(unsigned int width, unsigned int height);
+
+        /// Perform global initialization for this class.
+        static void initClass(void);
+
+        // Cleanup of global data that's only inited once per class.
+        static void cleanupClass();
+
+        void setSelectedEffect(std::string const & effectName);
+
+        inline std::string const & getSelectedEffect(void) const {
+                return mSelectedEffectName;
+        }
+
+        void saveEffect(std::string const & effectName);
+
+private:
+                /// read in from file
+        std::string mShaderErrorString;
+        unsigned int screenW;
+        unsigned int screenH;
+
+        float noiseTextureScale;
+        
+        /// Shader Uniforms
+        glslUniforms nightVisionUniforms;
+        glslUniforms bloomExtractUniforms;
+        glslUniforms bloomBlurUniforms;
+        glslUniforms colorFilterUniforms;
+
+        // the name of currently selected effect in mAllEffects
+        // invariant: tweaks == mAllEffects[mSelectedEffectName]
+        std::string mSelectedEffectName;
+
+        /// General functions
+        void initialize(unsigned int width, unsigned int height);
+        void doEffects(void);
+        void applyShaders(void);
+        bool shadersEnabled(void);
+
+        /// Night Vision Functions
+        void createNightVisionShader(void);
+        void applyNightVisionShader(void);
+
+        /// Bloom Functions
+        void createBloomShader(void);
+        void applyBloomShader(void);
+
+        /// Color Filter Functions
+        void createColorFilterShader(void);
+        void applyColorFilterShader(void);
+
+        /// OpenGL Helper Functions
+        void getShaderUniforms(glslUniforms & uniforms, GLhandleARB & prog);
+        void createTexture(GLuint & texture, unsigned int width, unsigned int height);
+        void copyFrameBuffer(GLuint & texture, unsigned int width, unsigned int height);
+        void createNoiseTexture(GLuint & texture);
+        bool checkError(void);
+        void checkShaderError(GLhandleARB shader);
+        void drawOrthoQuad(unsigned int width, unsigned int height, QuadType type);
+        void viewOrthogonal(unsigned int width, unsigned int height);
+        void changeOrthogonal(unsigned int width, unsigned int height);
+        void viewPerspective(void);
+};
+
+extern LLPostProcess * gPostProcess;
+
+
+#endif // LL_POSTPROCESS_H
diff --git a/linden/indra/llrender/llrender.cpp b/linden/indra/llrender/llrender.cpp
index e9c1227..13edf8a 100644
--- a/linden/indra/llrender/llrender.cpp
+++ b/linden/indra/llrender/llrender.cpp
@@ -36,6 +36,12 @@
 
 LLRender gGL;
 
+// Handy copies of last good GL matrices
+F64     gGLModelView[16];
+F64     gGLLastModelView[16];
+F64 gGLProjection[16];
+S32     gGLViewport[4];
+
 static const U32 LL_NUM_TEXTURE_LAYERS = 8; 
 
 static GLenum sGLCompareFunc[] =
@@ -445,6 +451,12 @@ void LLRender::translatef(const GLfloat& x, const GLfloat& y, const GLfloat& z)
         glTranslatef(x,y,z);
 }
 
+void LLRender::scalef(const GLfloat& x, const GLfloat& y, const GLfloat& z)
+{
+        flush();
+        glScalef(x,y,z);
+}
+
 void LLRender::pushMatrix()
 {
         flush();
diff --git a/linden/indra/llrender/llrender.h b/linden/indra/llrender/llrender.h
index 03280fe..edf46ff 100644
--- a/linden/indra/llrender/llrender.h
+++ b/linden/indra/llrender/llrender.h
@@ -178,6 +178,7 @@ public:
         ~LLRender();
 
         void translatef(const GLfloat& x, const GLfloat& y, const GLfloat& z);
+        void scalef(const GLfloat& x, const GLfloat& y, const GLfloat& z);
         void pushMatrix();
         void popMatrix();
 
@@ -232,7 +233,10 @@ private:
         std::vector<LLTexUnit*> mTexUnits;
 };
 
-
+extern F64 gGLModelView[16];
+extern F64 gGLLastModelView[16];
+extern F64 gGLProjection[16];
+extern S32 gGLViewport[4];
 
 extern LLRender gGL;
 
diff --git a/linden/indra/llrender/llrender.vcproj b/linden/indra/llrender/llrender.vcproj
deleted file mode 100644
index d9144cb..0000000
--- a/linden/indra/llrender/llrender.vcproj
+++ /dev/null
@@ -1,232 +0,0 @@
-<?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"
-                                AdditionalOptions="/Oy-"
-                                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"
-                                AdditionalOptions="/Oy-"
-                                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=".\llfont.cpp">
-                        </File>
-                        <File
-                                RelativePath=".\llfontgl.cpp">
-                        </File>
-                        <File
-                                RelativePath=".\llgldbg.cpp">
-                        </File>
-                        <File
-                                RelativePath=".\llrender.cpp">
-                        </File>
-                        <File
-                                RelativePath=".\llimagegl.cpp">
-                        </File>
-                        <File
-                                RelativePath=".\llrendertarget.cpp">
-                        </File>
-                        <File
-                                RelativePath=".\llvertexbuffer.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=".\llrender.h">
-                        </File>
-                        <File
-                                RelativePath=".\llimagegl.h">
-                        </File>
-                        <File
-                                RelativePath=".\llrendertarget.h">
-                        </File>
-                        <File
-                                RelativePath=".\llvertexbuffer.h">
-                        </File>
-                        <File
-                                RelativePath=".\llvertexprogramgl.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/llrender_vc8.vcproj b/linden/indra/llrender/llrender_vc8.vcproj
deleted file mode 100644
index 2147cec..0000000
--- a/linden/indra/llrender/llrender_vc8.vcproj
+++ /dev/null
@@ -1,329 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-        ProjectType="Visual C++"
-        Version="8.00"
-        Name="llrender"
-        ProjectGUID="{2ADE3C14-94C4-40BF-B033-70F3C954EE90}"
-        RootNamespace="llrender"
-        Keyword="Win32Proj"
-        >
-        <Platforms>
-                <Platform
-                        Name="Win32"
-                />
-        </Platforms>
-        <ToolFiles>
-        </ToolFiles>
-        <Configurations>
-                <Configuration
-                        Name="Debug|Win32"
-                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
-                        IntermediateDirectory="Debug"
-                        ConfigurationType="4"
-                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
-                        CharacterSet="1"
-                        >
-                        <Tool
-                                Name="VCPreBuildEventTool"
-                        />
-                        <Tool
-                                Name="VCCustomBuildTool"
-                        />
-                        <Tool
-                                Name="VCXMLDataGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCWebServiceProxyGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCMIDLTool"
-                        />
-                        <Tool
-                                Name="VCCLCompilerTool"
-                                Optimization="0"
-                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\llimage;..\llwindow;..\..\libraries\i686-win32\include;..\..\libraries\include\"
-                                PreprocessorDefinitions="WIN32;_DEBUG;_LIB;LL_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_USE_32BIT_TIME_T;LL_DEBUG"
-                                MinimalRebuild="true"
-                                BasicRuntimeChecks="3"
-                                RuntimeLibrary="1"
-                                StructMemberAlignment="4"
-                                TreatWChar_tAsBuiltInType="false"
-                                ForceConformanceInForLoopScope="true"
-                                UsePrecompiledHeader="0"
-                                WarningLevel="3"
-                                WarnAsError="true"
-                                Detect64BitPortabilityProblems="false"
-                                DebugInformationFormat="4"
-                        />
-                        <Tool
-                                Name="VCManagedResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCPreLinkEventTool"
-                        />
-                        <Tool
-                                Name="VCLibrarianTool"
-                                OutputFile="$(OutDir)/llrender.lib"
-                        />
-                        <Tool
-                                Name="VCALinkTool"
-                        />
-                        <Tool
-                                Name="VCXDCMakeTool"
-                        />
-                        <Tool
-                                Name="VCBscMakeTool"
-                        />
-                        <Tool
-                                Name="VCFxCopTool"
-                        />
-                        <Tool
-                                Name="VCPostBuildEventTool"
-                        />
-                </Configuration>
-                <Configuration
-                        Name="Release|Win32"
-                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
-                        IntermediateDirectory="Release"
-                        ConfigurationType="4"
-                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
-                        CharacterSet="1"
-                        >
-                        <Tool
-                                Name="VCPreBuildEventTool"
-                        />
-                        <Tool
-                                Name="VCCustomBuildTool"
-                        />
-                        <Tool
-                                Name="VCXMLDataGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCWebServiceProxyGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCMIDLTool"
-                        />
-                        <Tool
-                                Name="VCCLCompilerTool"
-                                AdditionalOptions="/Oy-"
-                                InlineFunctionExpansion="2"
-                                EnableIntrinsicFunctions="true"
-                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\llimage;..\llwindow;..\..\libraries\i686-win32\include;..\..\libraries\include\"
-                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;LL_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_USE_32BIT_TIME_T;LL_RELEASE"
-                                RuntimeLibrary="0"
-                                StructMemberAlignment="0"
-                                TreatWChar_tAsBuiltInType="false"
-                                ForceConformanceInForLoopScope="true"
-                                UsePrecompiledHeader="0"
-                                WarningLevel="3"
-                                WarnAsError="true"
-                                Detect64BitPortabilityProblems="false"
-                                DebugInformationFormat="3"
-                        />
-                        <Tool
-                                Name="VCManagedResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCPreLinkEventTool"
-                        />
-                        <Tool
-                                Name="VCLibrarianTool"
-                                OutputFile="$(OutDir)/llrender.lib"
-                        />
-                        <Tool
-                                Name="VCALinkTool"
-                        />
-                        <Tool
-                                Name="VCXDCMakeTool"
-                        />
-                        <Tool
-                                Name="VCBscMakeTool"
-                        />
-                        <Tool
-                                Name="VCFxCopTool"
-                        />
-                        <Tool
-                                Name="VCPostBuildEventTool"
-                        />
-                </Configuration>
-                <Configuration
-                        Name="ReleaseNoOpt|Win32"
-                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
-                        IntermediateDirectory="$(ConfigurationName)"
-                        ConfigurationType="4"
-                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
-                        CharacterSet="1"
-                        >
-                        <Tool
-                                Name="VCPreBuildEventTool"
-                        />
-                        <Tool
-                                Name="VCCustomBuildTool"
-                        />
-                        <Tool
-                                Name="VCXMLDataGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCWebServiceProxyGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCMIDLTool"
-                        />
-                        <Tool
-                                Name="VCCLCompilerTool"
-                                AdditionalOptions="/Oy-"
-                                Optimization="0"
-                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\llimage;..\llwindow;..\..\libraries\i686-win32\include;..\..\libraries\include\"
-                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;LL_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_USE_32BIT_TIME_T;LL_RELEASE"
-                                RuntimeLibrary="0"
-                                StructMemberAlignment="0"
-                                TreatWChar_tAsBuiltInType="false"
-                                ForceConformanceInForLoopScope="true"
-                                UsePrecompiledHeader="0"
-                                WarningLevel="3"
-                                WarnAsError="true"
-                                Detect64BitPortabilityProblems="false"
-                                DebugInformationFormat="3"
-                        />
-                        <Tool
-                                Name="VCManagedResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCPreLinkEventTool"
-                        />
-                        <Tool
-                                Name="VCLibrarianTool"
-                                OutputFile="$(OutDir)/llrender.lib"
-                        />
-                        <Tool
-                                Name="VCALinkTool"
-                        />
-                        <Tool
-                                Name="VCXDCMakeTool"
-                        />
-                        <Tool
-                                Name="VCBscMakeTool"
-                        />
-                        <Tool
-                                Name="VCFxCopTool"
-                        />
-                        <Tool
-                                Name="VCPostBuildEventTool"
-                        />
-                </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=".\llfont.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llfontgl.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llgldbg.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llimagegl.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llrender.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llrendertarget.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llvertexbuffer.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=".\llrender.h"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llrendertarget.h"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llvertexbuffer.h"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llvertexprogramgl.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/llrender_vc9.vcproj b/linden/indra/llrender/llrender_vc9.vcproj
deleted file mode 100644
index 67385e6..0000000
--- a/linden/indra/llrender/llrender_vc9.vcproj
+++ /dev/null
@@ -1,330 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-        ProjectType="Visual C++"
-        Version="9.00"
-        Name="llrender"
-        ProjectGUID="{2ADE3C14-94C4-40BF-B033-70F3C954EE90}"
-        RootNamespace="llrender"
-        Keyword="Win32Proj"
-        TargetFrameworkVersion="131072"
-        >
-        <Platforms>
-                <Platform
-                        Name="Win32"
-                />
-        </Platforms>
-        <ToolFiles>
-        </ToolFiles>
-        <Configurations>
-                <Configuration
-                        Name="Debug|Win32"
-                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
-                        IntermediateDirectory="Debug"
-                        ConfigurationType="4"
-                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
-                        CharacterSet="1"
-                        >
-                        <Tool
-                                Name="VCPreBuildEventTool"
-                        />
-                        <Tool
-                                Name="VCCustomBuildTool"
-                        />
-                        <Tool
-                                Name="VCXMLDataGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCWebServiceProxyGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCMIDLTool"
-                        />
-                        <Tool
-                                Name="VCCLCompilerTool"
-                                Optimization="0"
-                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\llimage;..\llwindow;..\..\libraries\i686-win32\include;..\..\libraries\include\"
-                                PreprocessorDefinitions="WIN32;_DEBUG;_LIB;LL_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_USE_32BIT_TIME_T;LL_DEBUG"
-                                MinimalRebuild="true"
-                                BasicRuntimeChecks="3"
-                                RuntimeLibrary="1"
-                                StructMemberAlignment="4"
-                                TreatWChar_tAsBuiltInType="false"
-                                ForceConformanceInForLoopScope="true"
-                                UsePrecompiledHeader="0"
-                                WarningLevel="3"
-                                WarnAsError="true"
-                                Detect64BitPortabilityProblems="false"
-                                DebugInformationFormat="4"
-                        />
-                        <Tool
-                                Name="VCManagedResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCPreLinkEventTool"
-                        />
-                        <Tool
-                                Name="VCLibrarianTool"
-                                OutputFile="$(OutDir)/llrender.lib"
-                        />
-                        <Tool
-                                Name="VCALinkTool"
-                        />
-                        <Tool
-                                Name="VCXDCMakeTool"
-                        />
-                        <Tool
-                                Name="VCBscMakeTool"
-                        />
-                        <Tool
-                                Name="VCFxCopTool"
-                        />
-                        <Tool
-                                Name="VCPostBuildEventTool"
-                        />
-                </Configuration>
-                <Configuration
-                        Name="Release|Win32"
-                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
-                        IntermediateDirectory="Release"
-                        ConfigurationType="4"
-                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
-                        CharacterSet="1"
-                        >
-                        <Tool
-                                Name="VCPreBuildEventTool"
-                        />
-                        <Tool
-                                Name="VCCustomBuildTool"
-                        />
-                        <Tool
-                                Name="VCXMLDataGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCWebServiceProxyGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCMIDLTool"
-                        />
-                        <Tool
-                                Name="VCCLCompilerTool"
-                                AdditionalOptions="/Oy-"
-                                InlineFunctionExpansion="2"
-                                EnableIntrinsicFunctions="true"
-                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\llimage;..\llwindow;..\..\libraries\i686-win32\include;..\..\libraries\include\"
-                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;LL_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_USE_32BIT_TIME_T;LL_RELEASE"
-                                RuntimeLibrary="0"
-                                StructMemberAlignment="0"
-                                TreatWChar_tAsBuiltInType="false"
-                                ForceConformanceInForLoopScope="true"
-                                UsePrecompiledHeader="0"
-                                WarningLevel="3"
-                                WarnAsError="true"
-                                Detect64BitPortabilityProblems="false"
-                                DebugInformationFormat="3"
-                        />
-                        <Tool
-                                Name="VCManagedResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCPreLinkEventTool"
-                        />
-                        <Tool
-                                Name="VCLibrarianTool"
-                                OutputFile="$(OutDir)/llrender.lib"
-                        />
-                        <Tool
-                                Name="VCALinkTool"
-                        />
-                        <Tool
-                                Name="VCXDCMakeTool"
-                        />
-                        <Tool
-                                Name="VCBscMakeTool"
-                        />
-                        <Tool
-                                Name="VCFxCopTool"
-                        />
-                        <Tool
-                                Name="VCPostBuildEventTool"
-                        />
-                </Configuration>
-                <Configuration
-                        Name="ReleaseNoOpt|Win32"
-                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"
-                        IntermediateDirectory="$(ConfigurationName)"
-                        ConfigurationType="4"
-                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
-                        CharacterSet="1"
-                        >
-                        <Tool
-                                Name="VCPreBuildEventTool"
-                        />
-                        <Tool
-                                Name="VCCustomBuildTool"
-                        />
-                        <Tool
-                                Name="VCXMLDataGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCWebServiceProxyGeneratorTool"
-                        />
-                        <Tool
-                                Name="VCMIDLTool"
-                        />
-                        <Tool
-                                Name="VCCLCompilerTool"
-                                AdditionalOptions="/Oy-"
-                                Optimization="0"
-                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\llmessage;..\llimage;..\llwindow;..\..\libraries\i686-win32\include;..\..\libraries\include\"
-                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;LL_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_USE_32BIT_TIME_T;LL_RELEASE"
-                                RuntimeLibrary="0"
-                                StructMemberAlignment="0"
-                                TreatWChar_tAsBuiltInType="false"
-                                ForceConformanceInForLoopScope="true"
-                                UsePrecompiledHeader="0"
-                                WarningLevel="3"
-                                WarnAsError="true"
-                                Detect64BitPortabilityProblems="false"
-                                DebugInformationFormat="3"
-                        />
-                        <Tool
-                                Name="VCManagedResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCResourceCompilerTool"
-                        />
-                        <Tool
-                                Name="VCPreLinkEventTool"
-                        />
-                        <Tool
-                                Name="VCLibrarianTool"
-                                OutputFile="$(OutDir)/llrender.lib"
-                        />
-                        <Tool
-                                Name="VCALinkTool"
-                        />
-                        <Tool
-                                Name="VCXDCMakeTool"
-                        />
-                        <Tool
-                                Name="VCBscMakeTool"
-                        />
-                        <Tool
-                                Name="VCFxCopTool"
-                        />
-                        <Tool
-                                Name="VCPostBuildEventTool"
-                        />
-                </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=".\llfont.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llfontgl.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llgldbg.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llrender.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llimagegl.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llrendertarget.cpp"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llvertexbuffer.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=".\llrender.h"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llimagegl.h"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llrendertarget.h"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llvertexbuffer.h"
-                                >
-                        </File>
-                        <File
-                                RelativePath=".\llvertexprogramgl.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/llrendersphere.cpp b/linden/indra/llrender/llrendersphere.cpp
new file mode 100644
index 0000000..0c3cd19
--- /dev/null
+++ b/linden/indra/llrender/llrendersphere.cpp
@@ -0,0 +1,182 @@
+/** 
+ * @file llrendersphere.cpp
+ * @brief implementation of the LLRenderSphere class.
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+//      Sphere creates a set of display lists that can then be called to create 
+//      a lit sphere at different LOD levels.  You only need one instance of sphere 
+//      per viewer - then call the appropriate list.  
+
+#include "linden_common.h"
+
+#include "llrendersphere.h"
+#include "llerror.h"
+
+#include "llglheaders.h"
+
+GLUquadricObj *gQuadObj2 = NULL;
+LLRenderSphere gSphere;
+
+void drawSolidSphere(GLdouble radius, GLint slices, GLint stacks);
+
+void drawSolidSphere(GLdouble radius, GLint slices, GLint stacks)
+{
+        if (!gQuadObj2)
+        {
+                gQuadObj2 = gluNewQuadric();
+                if (!gQuadObj2)
+                {
+                        llwarns << "drawSolidSphere couldn't allocate quadric" << llendl;
+                        return;
+                }
+        }
+
+        gluQuadricDrawStyle(gQuadObj2, GLU_FILL);
+        gluQuadricNormals(gQuadObj2, GLU_SMOOTH);
+        // If we ever changed/used the texture or orientation state
+        // of quadObj, we'd need to change it to the defaults here
+        // with gluQuadricTexture and/or gluQuadricOrientation.
+        gluQuadricTexture(gQuadObj2, GL_TRUE);
+        gluSphere(gQuadObj2, radius, slices, stacks);
+}
+
+
+// lat = 0 is Z-axis
+// lon = 0, lat = 90 at X-axis
+void lat2xyz(LLVector3 * result, F32 lat, F32 lon)
+{
+        // Convert a latitude and longitude to x,y,z on a normal sphere and return it in result
+        F32 r;
+        result->mV[VX] = (F32) (cos(lon * DEG_TO_RAD) * sin(lat * DEG_TO_RAD));
+        result->mV[VY] = (F32) (sin(lon * DEG_TO_RAD) * sin(lat * DEG_TO_RAD));
+        r = (F32) pow(result->mV[VX] * result->mV[VX] + result->mV[VY] * result->mV[VY], 0.5f);
+        if (r == 1.0f) 
+        {
+                result->mV[VZ] = 0.0f;
+        }
+        else
+        {
+                result->mV[VZ] = (F32) pow(1 - r*r, 0.5f);
+                if (lat > 90.01)
+                {
+                        result->mV[VZ] *= -1.0;
+                }
+        }
+}
+
+void lat2xyz_rad(LLVector3 * result, F32 lat, F32 lon)
+{
+        // Convert a latitude and longitude to x,y,z on a normal sphere and return it in result
+        F32 r;
+        result->mV[VX] = (F32) (cos(lon) * sin(lat));
+        result->mV[VY] = (F32) (sin(lon) * sin(lat));
+        r = (F32) pow(result->mV[VX] * result->mV[VX] + result->mV[VY] * result->mV[VY], 0.5f);
+        if (r == 1.0f) 
+                result->mV[VZ] = 0.0f;
+        else
+        {
+                result->mV[VZ] = (F32) pow(1 - r*r, 0.5f);
+                if (lat > F_PI_BY_TWO) result->mV[VZ] *= -1.0;
+        }
+}
+
+// A couple thoughts on sphere drawing:
+// 1) You need more slices than stacks, but little less than 2:1
+// 2) At low LOD, setting stacks to an odd number avoids a "band" around the equator, making things look smoother
+void LLRenderSphere::prerender()
+{
+        //  Create a series of display lists for different LODs
+        mDList[0] = glGenLists(1);
+        glNewList(mDList[0], GL_COMPILE);
+        drawSolidSphere(1.0, 30, 20);
+        glEndList();
+
+        mDList[1] = glGenLists(1);
+        glNewList(mDList[1], GL_COMPILE);
+        drawSolidSphere(1.0, 20, 15);
+        glEndList();
+
+        mDList[2] = glGenLists(1);
+        glNewList(mDList[2], GL_COMPILE);
+        drawSolidSphere(1.0, 12, 8);
+        glEndList();
+
+        mDList[3] = glGenLists(1);
+        glNewList(mDList[3], GL_COMPILE);
+        drawSolidSphere(1.0, 8, 5);
+        glEndList();
+}
+
+void LLRenderSphere::cleanupGL()
+{
+        for (S32 detail = 0; detail < 4; detail++)
+        {
+                glDeleteLists(mDList[detail], 1);
+                mDList[detail] = 0;
+        }
+        
+        if (gQuadObj2)
+        {
+                gluDeleteQuadric(gQuadObj2);
+                gQuadObj2 = NULL;
+        }
+}
+
+// Constants here are empirically derived from my eyeballs, JNC
+//
+// The toughest adjustment is the cutoff for the lowest LOD
+// Maybe we should have more LODs at the low end?
+void LLRenderSphere::render(F32 pixel_area)
+{
+        S32 level_of_detail;
+
+        if (pixel_area > 10000.f)
+        {
+                level_of_detail = 0;
+        }
+        else if (pixel_area > 800.f)
+        {
+                level_of_detail = 1;
+        }
+        else if (pixel_area > 100.f)
+        {
+                level_of_detail = 2;
+        }
+        else
+        {
+                level_of_detail = 3;
+        }
+        glCallList(mDList[level_of_detail]);
+}
+
+
+void LLRenderSphere::render()
+{
+        glCallList(mDList[0]);
+}
diff --git a/linden/indra/llrender/llrendersphere.h b/linden/indra/llrender/llrendersphere.h
new file mode 100644
index 0000000..ace57e4
--- /dev/null
+++ b/linden/indra/llrender/llrendersphere.h
@@ -0,0 +1,47 @@
+/** 
+ * @file llrendersphere.h
+ * @brief interface for the LLRenderSphere class.
+ *
+ * $LicenseInfo:firstyear=2001&license=internal$
+ * 
+ * Copyright (c) 2001-2008, Linden Research, Inc.
+ * 
+ * The following source code is PROPRIETARY AND CONFIDENTIAL. Use of
+ * this source code is governed by the Linden Lab Source Code Disclosure
+ * Agreement ("Agreement") previously entered between you and Linden
+ * Lab. By accessing, using, copying, modifying or distributing this
+ * software, you acknowledge that you have been informed of your
+ * obligations under the Agreement and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLRENDERSPHERE_H
+#define LL_LLRENDERSPHERE_H
+
+#include "llmath.h"
+#include "v3math.h"
+#include "v4math.h"
+#include "m3math.h"
+#include "m4math.h"
+#include "v4color.h"
+#include "llgl.h"
+
+void lat2xyz(LLVector3 * result, F32 lat, F32 lon);                     // utility routine
+
+class LLRenderSphere  
+{
+public:
+        LLGLuint        mDList[5];
+
+        void prerender();
+        void cleanupGL();
+        void render(F32 pixel_area);            // of a box of size 1.0 at that position
+        void render();                                          // render at highest LOD
+};
+
+extern LLRenderSphere gSphere;
+#endif
diff --git a/linden/indra/llrender/llrendertarget.cpp b/linden/indra/llrender/llrendertarget.cpp
index 708c582..e18ec56 100644
--- a/linden/indra/llrender/llrendertarget.cpp
+++ b/linden/indra/llrender/llrendertarget.cpp
@@ -99,11 +99,16 @@ void LLRenderTarget::allocate(U32 resx, U32 resy, U32 color_fmt, BOOL depth, U32
 
                 glGenFramebuffersEXT(1, (GLuint *) &mFBO);
 
+                stop_glerror();
+
                 glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, mFBO);
 
+                stop_glerror();
+
                 if (mDepth)
                 {
                         glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, mUsage, mDepth, 0);
+                        stop_glerror();
                         glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, mUsage, mDepth, 0);
                         stop_glerror();
                 }
diff --git a/linden/indra/llrender/llshadermgr.cpp b/linden/indra/llrender/llshadermgr.cpp
new file mode 100644
index 0000000..4416775
--- /dev/null
+++ b/linden/indra/llrender/llshadermgr.cpp
@@ -0,0 +1,513 @@
+/** 
+ * @file llshadermgr.cpp
+ * @brief Shader manager implementation.
+ *
+ * $LicenseInfo:firstyear=2005&license=viewergpl$
+ * 
+ * Copyright (c) 2005-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llshadermgr.h"
+
+#include "llfile.h"
+#include "llrender.h"
+
+#if LL_DARWIN
+#include "OpenGL/OpenGL.h"
+#endif
+
+#ifdef LL_RELEASE_FOR_DOWNLOAD
+#define UNIFORM_ERRS LL_WARNS_ONCE("Shader")
+#else
+#define UNIFORM_ERRS LL_ERRS("Shader")
+#endif
+
+// Lots of STL stuff in here, using namespace std to keep things more readable
+using std::vector;
+using std::pair;
+using std::make_pair;
+using std::string;
+
+LLShaderMgr * LLShaderMgr::sInstance = NULL;
+
+LLShaderMgr::LLShaderMgr()
+{
+}
+
+
+LLShaderMgr::~LLShaderMgr()
+{
+}
+
+// static
+LLShaderMgr * LLShaderMgr::instance()
+{
+        if(NULL == sInstance)
+        {
+                LL_ERRS("Shaders") << "LLShaderMgr should already have been instantiated by the application!" << LL_ENDL;
+        }
+
+        return sInstance;
+}
+
+BOOL LLShaderMgr::attachShaderFeatures(LLGLSLShader * shader)
+{
+        llassert_always(shader != NULL);
+        LLShaderFeatures *features = & shader->mFeatures;
+        
+        //////////////////////////////////////
+        // Attach Vertex Shader Features First
+        //////////////////////////////////////
+        
+        // NOTE order of shader object attaching is VERY IMPORTANT!!!
+        if (features->calculatesAtmospherics)
+        {
+                if (!shader->attachObject("windlight/atmosphericsVarsV.glsl"))
+                {
+                        return FALSE;
+                }
+        }
+
+        if (features->calculatesLighting)
+        {
+                if (!shader->attachObject("windlight/atmosphericsHelpersV.glsl"))
+                {
+                        return FALSE;
+                }
+                
+                if (features->isSpecular)
+                {
+                        if (!shader->attachObject("lighting/lightFuncSpecularV.glsl"))
+                        {
+                                return FALSE;
+                        }
+                        
+                        if (!shader->attachObject("lighting/sumLightsSpecularV.glsl"))
+                        {
+                                return FALSE;
+                        }
+                        
+                        if (!shader->attachObject("lighting/lightSpecularV.glsl"))
+                        {
+                                return FALSE;
+                        }
+                }
+                else 
+                {
+                        if (!shader->attachObject("lighting/lightFuncV.glsl"))
+                        {
+                                return FALSE;
+                        }
+                        
+                        if (!shader->attachObject("lighting/sumLightsV.glsl"))
+                        {
+                                return FALSE;
+                        }
+                        
+                        if (!shader->attachObject("lighting/lightV.glsl"))
+                        {
+                                return FALSE;
+                        }
+                }
+        }
+        
+        // NOTE order of shader object attaching is VERY IMPORTANT!!!
+        if (features->calculatesAtmospherics)
+        {
+                if (!shader->attachObject("windlight/atmosphericsV.glsl"))
+                {
+                        return FALSE;
+                }
+        }
+
+        if (features->hasSkinning)
+        {
+                if (!shader->attachObject("avatar/avatarSkinV.glsl"))
+                {
+                        return FALSE;
+                }
+        }
+        
+        ///////////////////////////////////////
+        // Attach Fragment Shader Features Next
+        ///////////////////////////////////////
+
+        if(features->calculatesAtmospherics)
+        {
+                if (!shader->attachObject("windlight/atmosphericsVarsF.glsl"))
+                {
+                        return FALSE;
+                }
+        }
+
+        // NOTE order of shader object attaching is VERY IMPORTANT!!!
+        if (features->hasGamma)
+        {
+                if (!shader->attachObject("windlight/gammaF.glsl"))
+                {
+                        return FALSE;
+                }
+        }
+        
+        if (features->hasAtmospherics)
+        {
+                if (!shader->attachObject("windlight/atmosphericsF.glsl"))
+                {
+                        return FALSE;
+                }
+        }
+        
+        if (features->hasTransport)
+        {
+                if (!shader->attachObject("windlight/transportF.glsl"))
+                {
+                        return FALSE;
+                }
+
+                // Test hasFullbright and hasShiny and attach fullbright and 
+                // fullbright shiny atmos transport if we split them out.
+        }
+
+        // NOTE order of shader object attaching is VERY IMPORTANT!!!
+        if (features->hasWaterFog)
+        {
+                if (!shader->attachObject("environment/waterFogF.glsl"))
+                {
+                        return FALSE;
+                }
+        }
+        
+        if (features->hasLighting)
+        {
+        
+                if (features->hasWaterFog)
+                {
+                        if (!shader->attachObject("lighting/lightWaterF.glsl"))
+                        {
+                                return FALSE;
+                        }
+                }
+                
+                else
+                {
+                        if (!shader->attachObject("lighting/lightF.glsl"))
+                        {
+                                return FALSE;
+                        }
+                }               
+        }
+        
+        // NOTE order of shader object attaching is VERY IMPORTANT!!!
+        else if (features->isFullbright)
+        {
+        
+                if (features->hasWaterFog)
+                {
+                        if (!shader->attachObject("lighting/lightFullbrightWaterF.glsl"))
+                        {
+                                return FALSE;
+                        }
+                }
+                
+                else if (features->isShiny)
+                {
+                        if (!shader->attachObject("lighting/lightFullbrightShinyF.glsl"))
+                        {
+                                return FALSE;
+                        }
+                }
+                
+                else
+                {
+                        if (!shader->attachObject("lighting/lightFullbrightF.glsl"))
+                        {
+                                return FALSE;
+                        }
+                }
+        }
+
+        // NOTE order of shader object attaching is VERY IMPORTANT!!!
+        else if (features->isShiny)
+        {
+        
+                if (features->hasWaterFog)
+                {
+                        if (!shader->attachObject("lighting/lightShinyWaterF.glsl"))
+                        {
+                                return FALSE;
+                        }
+                }
+                
+                else 
+                {
+                        if (!shader->attachObject("lighting/lightShinyF.glsl"))
+                        {
+                                return FALSE;
+                        }
+                }
+        }
+        return TRUE;
+}
+
+//============================================================================
+// Load Shader
+
+static std::string get_object_log(GLhandleARB ret)
+{
+        std::string res;
+        
+        //get log length 
+        GLint length;
+        glGetObjectParameterivARB(ret, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
+        if (length > 0)
+        {
+                //the log could be any size, so allocate appropriately
+                GLcharARB* log = new GLcharARB[length];
+                glGetInfoLogARB(ret, length, &length, log);
+                res = std::string((char *)log);
+                delete[] log;
+        }
+        return res;
+}
+
+void LLShaderMgr::dumpObjectLog(GLhandleARB ret, BOOL warns) 
+{
+        std::string log = get_object_log(ret);
+        if ( log.length() > 0 )
+        {
+                if (warns)
+                {
+                        LL_WARNS("ShaderLoading") << log << LL_ENDL;
+                }
+                else
+                {
+                        LL_DEBUGS("ShaderLoading") << log << LL_ENDL;
+                }
+}
+}
+
+GLhandleARB LLShaderMgr::loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type)
+{
+        GLenum error;
+        error = glGetError();
+        if (error != GL_NO_ERROR)
+        {
+                LL_WARNS("ShaderLoading") << "GL ERROR entering loadShaderFile(): " << error << LL_ENDL;
+        }
+        
+        LL_DEBUGS("ShaderLoading") << "Loading shader file: " << filename << " class " << shader_level << LL_ENDL;
+
+        if (filename.empty()) 
+        {
+                return 0;
+        }
+
+
+        //read in from file
+        LLFILE* file = NULL;
+
+        S32 try_gpu_class = shader_level;
+        S32 gpu_class;
+
+        //find the most relevant file
+        for (gpu_class = try_gpu_class; gpu_class > 0; gpu_class--)
+        {       //search from the current gpu class down to class 1 to find the most relevant shader
+                std::stringstream fname;
+                fname << getShaderDirPrefix();
+                fname << gpu_class << "/" << filename;
+                
+                LL_DEBUGS("ShaderLoading") << "Looking in " << fname.str() << LL_ENDL;
+                file = LLFile::fopen(fname.str(), "r");         /* Flawfinder: ignore */
+                if (file)
+                {
+                        LL_INFOS("ShaderLoading") << "Loading file: shaders/class" << gpu_class << "/" << filename << " (Want class " << gpu_class << ")" << LL_ENDL;
+                        break; // done
+                }
+        }
+        
+        if (file == NULL)
+        {
+                LL_WARNS("ShaderLoading") << "GLSL Shader file not found: " << filename << LL_ENDL;
+                return 0;
+        }
+
+        //we can't have any lines longer than 1024 characters 
+        //or any shaders longer than 1024 lines... deal - DaveP
+        GLcharARB buff[1024];
+        GLcharARB* text[1024];
+        GLuint count = 0;
+
+
+        //copy file into memory
+        while(fgets((char *)buff, 1024, file) != NULL && count < (sizeof(buff)/sizeof(buff[0]))) 
+        {
+                text[count++] = (GLcharARB *)strdup((char *)buff); 
+        }
+        fclose(file);
+
+        //create shader object
+        GLhandleARB ret = glCreateShaderObjectARB(type);
+        error = glGetError();
+        if (error != GL_NO_ERROR)
+        {
+                LL_WARNS("ShaderLoading") << "GL ERROR in glCreateShaderObjectARB: " << error << LL_ENDL;
+        }
+        else
+        {
+                //load source
+                glShaderSourceARB(ret, count, (const GLcharARB**) text, NULL);
+                error = glGetError();
+                if (error != GL_NO_ERROR)
+                {
+                        LL_WARNS("ShaderLoading") << "GL ERROR in glShaderSourceARB: " << error << LL_ENDL;
+                }
+                else
+                {
+                        //compile source
+                        glCompileShaderARB(ret);
+                        error = glGetError();
+                        if (error != GL_NO_ERROR)
+                        {
+                                LL_WARNS("ShaderLoading") << "GL ERROR in glCompileShaderARB: " << error << LL_ENDL;
+                        }
+                }
+        }
+        //free memory
+        for (GLuint i = 0; i < count; i++)
+        {
+                free(text[i]);
+        }
+        if (error == GL_NO_ERROR)
+        {
+                //check for errors
+                GLint success = GL_TRUE;
+                glGetObjectParameterivARB(ret, GL_OBJECT_COMPILE_STATUS_ARB, &success);
+                error = glGetError();
+                if (error != GL_NO_ERROR || success == GL_FALSE) 
+                {
+                        //an error occured, print log
+                        LL_WARNS("ShaderLoading") << "GLSL Compilation Error: (" << error << ") in " << filename << LL_ENDL;
+                        dumpObjectLog(ret);
+                        ret = 0;
+                }
+        }
+        else
+        {
+                ret = 0;
+        }
+        stop_glerror();
+
+        //successfully loaded, save results
+        if (ret)
+        {
+                // Add shader file to map
+                mShaderObjects[filename] = ret;
+                shader_level = try_gpu_class;
+        }
+        else
+        {
+                if (shader_level > 1)
+                {
+                        shader_level--;
+                        return loadShaderFile(filename,shader_level,type);
+                }
+                LL_WARNS("ShaderLoading") << "Failed to load " << filename << LL_ENDL;  
+        }
+        return ret;
+}
+
+BOOL LLShaderMgr::linkProgramObject(GLhandleARB obj, BOOL suppress_errors) 
+{
+        //check for errors
+        glLinkProgramARB(obj);
+        GLint success = GL_TRUE;
+        glGetObjectParameterivARB(obj, GL_OBJECT_LINK_STATUS_ARB, &success);
+        if (!suppress_errors && success == GL_FALSE) 
+        {
+                //an error occured, print log
+                LL_WARNS("ShaderLoading") << "GLSL Linker Error:" << LL_ENDL;
+        }
+
+// NOTE: Removing LL_DARWIN block as it doesn't seem to actually give the correct answer, 
+// but want it for reference once I move it.
+#if 0
+        // Force an evaluation of the gl state so the driver can tell if the shader will run in hardware or software
+        // per Apple's suggestion   
+        glBegin(gGL.mMode);
+        glEnd();
+
+        // Query whether the shader can or cannot run in hardware
+        // http://developer.apple.com/qa/qa2007/qa1502.html
+        long vertexGPUProcessing;
+        CGLContextObj ctx = CGLGetCurrentContext();
+        CGLGetParameter (ctx, kCGLCPGPUVertexProcessing, &vertexGPUProcessing); 
+        long fragmentGPUProcessing;
+        CGLGetParameter (ctx, kCGLCPGPUFragmentProcessing, &fragmentGPUProcessing);
+        if (!fragmentGPUProcessing || !vertexGPUProcessing)
+        {
+                LL_WARNS("ShaderLoading") << "GLSL Linker: Running in Software:" << LL_ENDL;
+                success = GL_FALSE;
+                suppress_errors = FALSE;                
+        }
+        
+#else
+        std::string log = get_object_log(obj);
+        LLStringUtil::toLower(log);
+        if (log.find("software") != std::string::npos)
+        {
+                LL_WARNS("ShaderLoading") << "GLSL Linker: Running in Software:" << LL_ENDL;
+                success = GL_FALSE;
+                suppress_errors = FALSE;
+        }
+#endif
+        if (!suppress_errors)
+        {
+        dumpObjectLog(obj, !success);
+        }
+
+        return success;
+}
+
+BOOL LLShaderMgr::validateProgramObject(GLhandleARB obj)
+{
+        //check program validity against current GL
+        glValidateProgramARB(obj);
+        GLint success = GL_TRUE;
+        glGetObjectParameterivARB(obj, GL_OBJECT_VALIDATE_STATUS_ARB, &success);
+        if (success == GL_FALSE)
+        {
+                LL_WARNS("ShaderLoading") << "GLSL program not valid: " << LL_ENDL;
+                dumpObjectLog(obj);
+        }
+        else
+        {
+                dumpObjectLog(obj, FALSE);
+        }
+
+        return success;
+}
+
diff --git a/linden/indra/llrender/llshadermgr.h b/linden/indra/llrender/llshadermgr.h
new file mode 100644
index 0000000..8918416
--- /dev/null
+++ b/linden/indra/llrender/llshadermgr.h
@@ -0,0 +1,75 @@
+/** 
+ * @file llshadermgr.h
+ * @brief Shader Manager
+ *
+ * $LicenseInfo:firstyear=2001&license=viewergpl$
+ * 
+ * Copyright (c) 2001-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_SHADERMGR_H
+#define LL_SHADERMGR_H
+
+#include "llgl.h"
+#include "llglslshader.h"
+
+class LLShaderMgr
+{
+public:
+        LLShaderMgr();
+        virtual ~LLShaderMgr();
+
+        // singleton pattern implementation
+        static LLShaderMgr * instance();
+
+        BOOL attachShaderFeatures(LLGLSLShader * shader);
+        void dumpObjectLog(GLhandleARB ret, BOOL warns = TRUE);
+        BOOL    linkProgramObject(GLhandleARB obj, BOOL suppress_errors = FALSE);
+        BOOL    validateProgramObject(GLhandleARB obj);
+        GLhandleARB loadShaderFile(const std::string& filename, S32 & shader_level, GLenum type);
+
+        // Implemented in the application to actually point to the shader directory.
+        virtual std::string getShaderDirPrefix(void) = 0; // Pure Virtual
+
+        // Implemented in the application to actually update out of date uniforms for a particular shader
+        virtual void updateShaderUniforms(LLGLSLShader * shader) = 0; // Pure Virtual
+
+public:
+        // Map of shader names to compiled
+        std::map<std::string, GLhandleARB> mShaderObjects;
+
+        //global (reserved slot) shader parameters
+        std::vector<std::string> mReservedAttribs;
+
+        std::vector<std::string> mReservedUniforms;
+
+protected:
+
+        // our parameter manager singleton instance
+        static LLShaderMgr * sInstance;
+
+}; //LLShaderMgr
+
+#endif
diff --git a/linden/indra/llrender/llvertexbuffer.cpp b/linden/indra/llrender/llvertexbuffer.cpp
index 9635ae3..547663b 100644
--- a/linden/indra/llrender/llvertexbuffer.cpp
+++ b/linden/indra/llrender/llvertexbuffer.cpp
@@ -190,10 +190,12 @@ void LLVertexBuffer::drawRange(U32 mode, U32 start, U32 end, U32 count, U32 indi
         if (mode > NUM_MODES)
         {
                 llerrs << "Invalid draw mode: " << mode << llendl;
+                return;
         }
 
         glDrawRangeElements(sGLMode[mode], start, end, count, GL_UNSIGNED_SHORT, 
                 ((U16*) getIndicesPointer()) + indices_offset);
+        stop_glerror();
 }
 
 void LLVertexBuffer::draw(U32 mode, U32 count, U32 indices_offset) const
@@ -217,6 +219,7 @@ void LLVertexBuffer::draw(U32 mode, U32 count, U32 indices_offset) const
         if (mode > NUM_MODES)
         {
                 llerrs << "Invalid draw mode: " << mode << llendl;
+                return;
         }
 
         glDrawElements(sGLMode[mode], count, GL_UNSIGNED_SHORT,
@@ -240,9 +243,11 @@ void LLVertexBuffer::drawArrays(U32 mode, U32 first, U32 count) const
         if (mode > NUM_MODES)
         {
                 llerrs << "Invalid draw mode: " << mode << llendl;
+                return;
         }
 
         glDrawArrays(sGLMode[mode], first, count);
+        stop_glerror();
 }
 
 //static
diff --git a/linden/indra/llrender/llvertexbuffer.h b/linden/indra/llrender/llvertexbuffer.h
index 64a6f60..8edcf69 100644
--- a/linden/indra/llrender/llvertexbuffer.h
+++ b/linden/indra/llrender/llvertexbuffer.h
@@ -41,6 +41,7 @@
 #include "llmemory.h"
 #include <set>
 #include <vector>
+#include <list>
 
 //============================================================================
 // NOTES