1 files changed, 116 insertions, 29 deletions

diff --git a/linden/indra/llrender/llrender.cpp b/linden/indra/llrender/llrender.cpp
index ff0a2db..ba95a19 100644
--- a/linden/indra/llrender/llrender.cpp
+++ b/linden/indra/llrender/llrender.cpp
@@ -17,7 +17,8 @@
  * There are special exceptions to the terms and conditions of the GPL as
  * it is applied to this Source Code. View the full text of the exception
  * in the file doc/FLOSS-exception.txt in this software distribution, or
- * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * online at
+ * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  * 
  * By copying, modifying or distributing this software, you acknowledge
  * that you have read and understood your obligations described above,
@@ -74,7 +75,7 @@ static GLenum sGLCompareFunc[] =
         GL_GREATER
 };
 
-const U32 immediate_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXCOORD;
+const U32 immediate_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXCOORD0;
 
 static GLenum sGLBlendFactor[] =
 {
@@ -95,7 +96,8 @@ LLTexUnit::LLTexUnit(S32 index)
 mCurrColorOp(TBO_MULT), mCurrAlphaOp(TBO_MULT),
 mCurrColorSrc1(TBS_TEX_COLOR), mCurrColorSrc2(TBS_PREV_COLOR),
 mCurrAlphaSrc1(TBS_TEX_ALPHA), mCurrAlphaSrc2(TBS_PREV_ALPHA),
-mCurrColorScale(1), mCurrAlphaScale(1), mCurrTexture(0)
+mCurrColorScale(1), mCurrAlphaScale(1), mCurrTexture(0),
+mHasMipMaps(false)
 {
         llassert_always(index < LL_NUM_TEXTURE_LAYERS);
         mIndex = index;
@@ -175,8 +177,9 @@ void LLTexUnit::disable(void)
         }
 }
 
-bool LLTexUnit::bind(const LLImageGL* texture, bool forceBind)
+bool LLTexUnit::bind(LLImageGL* texture, bool forceBind)
 {
+        stop_glerror();
         if (mIndex < 0) return false;
 
         gGL.flush();
@@ -189,14 +192,28 @@ bool LLTexUnit::bind(const LLImageGL* texture, bool forceBind)
         
         if (!texture->getTexName()) //if texture does not exist
         {
+                //if deleted, will re-generate it immediately
+                texture->forceImmediateUpdate() ;
+
                 return texture->bindDefaultImage(mIndex);
         }
-        // Disabled caching of binding state.
-        activate();
-        enable(texture->getTarget());
-        mCurrTexture = texture->getTexName();
-        glBindTexture(sGLTextureType[texture->getTarget()], mCurrTexture);
-        texture->updateBindStats();
+
+        if ((mCurrTexture != texture->getTexName()) || forceBind)
+        {
+                activate();
+                enable(texture->getTarget());
+                mCurrTexture = texture->getTexName();
+                glBindTexture(sGLTextureType[texture->getTarget()], mCurrTexture);
+                texture->updateBindStats();
+                texture->setActive() ;
+                mHasMipMaps = texture->mHasMipMaps;
+                if (texture->mTexOptionsDirty)
+                {
+                        texture->mTexOptionsDirty = false;
+                        setTextureAddressMode(texture->mAddressMode);
+                        setTextureFilteringOption(texture->mFilterOption);
+                }
+        }
         return true;
 }
 
@@ -206,8 +223,13 @@ bool LLTexUnit::bind(LLCubeMap* cubeMap)
 
         gGL.flush();
 
-        // Disabled caching of binding state.
-        if (cubeMap != NULL)
+        if (cubeMap == NULL)
+        {
+                llwarns << "NULL LLTexUnit::bind cubemap" << llendl;
+                return false;
+        }
+
+        if (mCurrTexture != cubeMap->mImages[0]->getTexName())
         {
                 if (gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps)
                 {
@@ -215,18 +237,27 @@ bool LLTexUnit::bind(LLCubeMap* cubeMap)
                         enable(LLTexUnit::TT_CUBE_MAP);
                         mCurrTexture = cubeMap->mImages[0]->getTexName();
                         glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, mCurrTexture);
+                        mHasMipMaps = cubeMap->mImages[0]->mHasMipMaps;
                         cubeMap->mImages[0]->updateBindStats();
-                        cubeMap->mImages[0]->setMipFilterNearest (FALSE, FALSE);
+                        if (cubeMap->mImages[0]->mTexOptionsDirty)
+                        {
+                                cubeMap->mImages[0]->mTexOptionsDirty = false;
+                                setTextureAddressMode(cubeMap->mImages[0]->mAddressMode);
+                                setTextureFilteringOption(cubeMap->mImages[0]->mFilterOption);
+                        }
                         return true;
                 }
                 else
                 {
-                        llwarns << "Using cube map without extension!" << llendl
+                        llwarns << "Using cube map without extension!" << llendl;
+                        return false;
                 }
         }
-        return false;
+        return true;
 }
 
+// LLRenderTarget is unavailible on the mapserver since it uses FBOs.
+#if !LL_MESA_HEADLESS
 bool LLTexUnit::bind(LLRenderTarget* renderTarget, bool bindDepth)
 {
         if (mIndex < 0) return false;
@@ -244,23 +275,26 @@ bool LLTexUnit::bind(LLRenderTarget* renderTarget, bool bindDepth)
 
         return true;
 }
+#endif // LL_MESA_HEADLESS
 
-bool LLTexUnit::bindManual(eTextureType type, U32 texture)
+bool LLTexUnit::bindManual(eTextureType type, U32 texture, bool hasMips)
 {
-        if (mIndex < 0) return false;
+        if (mIndex < 0 || mCurrTexture == texture) return false;
 
-        // Disabled caching of binding state.
         gGL.flush();
         
         activate();
         enable(type);
         mCurrTexture = texture;
         glBindTexture(sGLTextureType[type], texture);
+        mHasMipMaps = hasMips;
         return true;
 }
 
 void LLTexUnit::unbind(eTextureType type)
 {
+        stop_glerror();
+
         if (mIndex < 0) return;
 
         // Disabled caching of binding state.
@@ -276,17 +310,57 @@ void LLTexUnit::unbind(eTextureType type)
 
 void LLTexUnit::setTextureAddressMode(eTextureAddressMode mode)
 {
-        if (mIndex < 0) return;
+        if (mIndex < 0 || mCurrTexture == 0) return;
 
-        if (true)
+        activate();
+
+        glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_S, sGLAddressMode[mode]);
+        glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_T, sGLAddressMode[mode]);
+        if (mCurrTexType == TT_CUBE_MAP)
         {
-                activate();
+                glTexParameteri (GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, sGLAddressMode[mode]);
+        }
+}
+
+void LLTexUnit::setTextureFilteringOption(LLTexUnit::eTextureFilterOptions option)
+{
+        if (mIndex < 0 || mCurrTexture == 0) return;
 
-                glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_S, sGLAddressMode[mode]);
-                glTexParameteri (sGLTextureType[mCurrTexType], GL_TEXTURE_WRAP_T, sGLAddressMode[mode]);
-                if (mCurrTexType == TT_CUBE_MAP)
+        if (option == TFO_POINT)
+        {
+                glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        }
+        else
+        {
+                glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        }
+
+        if (option >= TFO_TRILINEAR && mHasMipMaps)
+        {
+                glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+        } 
+        else if (option >= TFO_BILINEAR)
+        {
+                glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        }
+        else
+        {
+                glTexParameteri(sGLTextureType[mCurrTexType], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        }
+
+        if (gGLManager.mHasAnisotropic)
+        {
+                if (LLImageGL::sGlobalUseAnisotropic && option == TFO_ANISOTROPIC)
                 {
-                        glTexParameteri (GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, sGLAddressMode[mode]);
+                        if (gGL.mMaxAnisotropy < 1.f)
+                        {
+                                glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gGL.mMaxAnisotropy);
+                        }
+                        glTexParameterf(sGLTextureType[mCurrTexType], GL_TEXTURE_MAX_ANISOTROPY_EXT, gGL.mMaxAnisotropy);
+                }
+                else
+                {
+                        glTexParameterf(sGLTextureType[mCurrTexType], GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.f);
                 }
         }
 }
@@ -589,12 +663,13 @@ void LLTexUnit::debugTextureUnit(void)
 
 
 LLRender::LLRender()
-: mDirty(false), mCount(0), mMode(LLRender::TRIANGLES)
+: mDirty(false), mCount(0), mMode(LLRender::TRIANGLES),
+        mMaxAnisotropy(0.f) 
 {
         mBuffer = new LLVertexBuffer(immediate_mask, 0);
         mBuffer->allocateBuffer(4096, 0, TRUE);
         mBuffer->getVertexStrider(mVerticesp);
-        mBuffer->getTexCoordStrider(mTexcoordsp);
+        mBuffer->getTexCoord0Strider(mTexcoordsp);
         mBuffer->getColorStrider(mColorsp);
         
         mTexUnits.reserve(LL_NUM_TEXTURE_LAYERS);
@@ -687,7 +762,10 @@ void LLRender::setColorMask(bool writeColorR, bool writeColorG, bool writeColorB
         mCurrColorMask[2] = writeColorB;
         mCurrColorMask[3] = writeAlpha;
 
-        glColorMask(writeColorR, writeColorG, writeColorB, writeAlpha);
+        glColorMask(writeColorR ? GL_TRUE : GL_FALSE, 
+                                writeColorG ? GL_TRUE : GL_FALSE,
+                                writeColorB ? GL_TRUE : GL_FALSE,
+                                writeAlpha ? GL_TRUE : GL_FALSE);
 }
 
 void LLRender::setSceneBlendType(eBlendType type)
@@ -767,6 +845,14 @@ bool LLRender::verifyTexUnitActive(U32 unitToVerify)
         }
 }
 
+void LLRender::clearErrors()
+{
+        while (glGetError())
+        {
+                //loop until no more error flags left
+        }
+}
+
 void LLRender::begin(const GLuint& mode)
 {
         if (mode != mMode)
@@ -852,13 +938,14 @@ void LLRender::flush()
                                 
                 mBuffer->setBuffer(immediate_mask);
                 mBuffer->drawArrays(mMode, 0, mCount);
-
+                
                 mVerticesp[0] = mVerticesp[mCount];
                 mTexcoordsp[0] = mTexcoordsp[mCount];
                 mColorsp[0] = mColorsp[mCount];
                 mCount = 0;
         }
 }
+
 void LLRender::vertex3f(const GLfloat& x, const GLfloat& y, const GLfloat& z)
 { 
         //the range of mVerticesp, mColorsp and mTexcoordsp is [0, 4095]