Ported many texture engine changes from Snowglobe.

6 files changed, 315 insertions, 70 deletions

diff --git a/linden/indra/llrender/llcubemap.cpp b/linden/indra/llrender/llcubemap.cpp
index 754d90c..a5c677d 100644
--- a/linden/indra/llrender/llcubemap.cpp
+++ b/linden/indra/llrender/llcubemap.cpp
@@ -94,7 +94,7 @@ void LLCubeMap::initGL()
                                 mImages[i] = new LLImageGL(64, 64, 4, (use_cube_mipmaps? TRUE : FALSE));
                                 mImages[i]->setTarget(mTargets[i], LLTexUnit::TT_CUBE_MAP);
                                 mRawImages[i] = new LLImageRaw(64, 64, 4);
-                                mImages[i]->createGLTexture(0, mRawImages[i], texname);
+                                mImages[i]->createGLTexture(0, mRawImages[i], texname, TRUE);
                                 
                                 gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_CUBE_MAP, texname); 
                                 mImages[i]->setAddressMode(LLTexUnit::TAM_CLAMP);
@@ -106,7 +106,7 @@ void LLCubeMap::initGL()
         }
         else
         {
-                llwarns << "Using cube map without extension!" << llendl
+                llwarns << "Using cube map without extension!" << llendl;
         }
 }
 
diff --git a/linden/indra/llrender/llimagegl.cpp b/linden/indra/llrender/llimagegl.cpp
index d1efb11..27b1d55 100644
--- a/linden/indra/llrender/llimagegl.cpp
+++ b/linden/indra/llrender/llimagegl.cpp
@@ -43,8 +43,6 @@
 #include "llmath.h"
 #include "llgl.h"
 #include "llrender.h"
-
-
 //----------------------------------------------------------------------------
 
 const F32 MIN_TEXTURE_LIFETIME = 10.f;
@@ -61,8 +59,33 @@ S32 LLImageGL::sCount					= 0;
 
 BOOL LLImageGL::sGlobalUseAnisotropic   = FALSE;
 F32 LLImageGL::sLastFrameTime                   = 0.f;
+BOOL LLImageGL::sAllowReadBackRaw       = FALSE ;
 
 std::set<LLImageGL*> LLImageGL::sImageList;
+
+//****************************************************************************************************
+//The below for texture auditing use only
+//****************************************************************************************************
+//-----------------------
+//debug use
+BOOL gAuditTexture = FALSE ;
+#define MAX_TEXTURE_LOG_SIZE 22 //2048 * 2048
+std::vector<S32> LLImageGL::sTextureLoadedCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
+std::vector<S32> LLImageGL::sTextureBoundCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
+std::vector<S32> LLImageGL::sTextureCurBoundCounter(MAX_TEXTURE_LOG_SIZE + 1) ;
+S32 LLImageGL::sCurTexSizeBar = -1 ;
+S32 LLImageGL::sCurTexPickSize = -1 ;
+LLPointer<LLImageGL> LLImageGL::sDefaultTexturep = NULL;
+S32 LLImageGL::sMaxCatagories = 1 ;
+
+std::vector<S32> LLImageGL::sTextureMemByCategory;
+std::vector<S32> LLImageGL::sTextureMemByCategoryBound ;
+std::vector<S32> LLImageGL::sTextureCurMemByCategoryBound ;
+//------------------------
+//****************************************************************************************************
+//End for texture auditing use only
+//****************************************************************************************************
+
 //**************************************************************************************
 //below are functions for debug use
 //do not delete them even though they are not currently being used.
@@ -110,6 +133,20 @@ void LLImageGL::checkTexSize() const
 //**************************************************************************************
 
 //----------------------------------------------------------------------------
+//static 
+void LLImageGL::initClass(S32 num_catagories) 
+{
+        sMaxCatagories = num_catagories ;
+
+        sTextureMemByCategory.resize(sMaxCatagories);
+        sTextureMemByCategoryBound.resize(sMaxCatagories) ;
+        sTextureCurMemByCategoryBound.resize(sMaxCatagories) ;
+}
+
+//static 
+void LLImageGL::cleanupClass() 
+{       
+}
 
 //static
 S32 LLImageGL::dataFormatBits(S32 dataformat)
@@ -176,12 +213,44 @@ void LLImageGL::updateStats(F32 current_time)
         sLastFrameTime = current_time;
         sBoundTextureMemoryInBytes = sCurBoundTextureMemory;
         sCurBoundTextureMemory = 0;
+
+        if(gAuditTexture)
+        {
+                for(U32 i = 0 ; i < sTextureCurBoundCounter.size() ; i++)
+                {
+                        sTextureBoundCounter[i] = sTextureCurBoundCounter[i] ;
+                        sTextureCurBoundCounter[i] = 0 ;
+                }
+                for(U32 i = 0 ; i < sTextureCurMemByCategoryBound.size() ; i++)
+                {
+                        sTextureMemByCategoryBound[i] = sTextureCurMemByCategoryBound[i] ;
+                        sTextureCurMemByCategoryBound[i] = 0 ;
+                }
+        }
 }
 
 //static
-S32 LLImageGL::updateBoundTexMem(const S32 delta)
+S32 LLImageGL::updateBoundTexMemStatic(const S32 delta, const S32 size, S32 category)
+{
+        if(gAuditTexture)
+        {
+                sTextureCurBoundCounter[getTextureCounterIndex(size)]++ ;
+                sTextureCurMemByCategoryBound[category] += delta ;
+        }
+        
+        LLImageGL::sCurBoundTextureMemory += delta ;
+        return LLImageGL::sCurBoundTextureMemory;
+}
+
+S32 LLImageGL::updateBoundTexMem()const
 {
-        LLImageGL::sCurBoundTextureMemory += delta;
+        if(gAuditTexture)
+        {
+                sTextureCurBoundCounter[getTextureCounterIndex(mTextureMemory / mComponents)]++ ;
+                sTextureCurMemByCategoryBound[mCategory] += mTextureMemory ;
+        }
+
+        LLImageGL::sCurBoundTextureMemory += mTextureMemory ;
         return LLImageGL::sCurBoundTextureMemory;
 }
 
@@ -195,6 +264,7 @@ void LLImageGL::destroyGL(BOOL save_state)
                 gGL.getTexUnit(stage)->unbind(LLTexUnit::TT_TEXTURE);
         }
         
+        sAllowReadBackRaw = true ;
         for (std::set<LLImageGL*>::iterator iter = sImageList.begin();
                  iter != sImageList.end(); iter++)
         {
@@ -204,7 +274,7 @@ void LLImageGL::destroyGL(BOOL save_state)
                         if (save_state && glimage->isGLTextureCreated() && glimage->mComponents)
                         {
                                 glimage->mSaveData = new LLImageRaw;
-                                if(!glimage->readBackRaw(glimage->mCurrentDiscardLevel, glimage->mSaveData, false))
+                                if(!glimage->readBackRaw(glimage->mCurrentDiscardLevel, glimage->mSaveData, false)) //necessary, keep it.
                                 {
                                         glimage->mSaveData = NULL ;
                                 }
@@ -214,6 +284,7 @@ void LLImageGL::destroyGL(BOOL save_state)
                         stop_glerror();
                 }
         }
+        sAllowReadBackRaw = false ;
 }
 
 //static 
@@ -231,7 +302,7 @@ void LLImageGL::restoreGL()
                 {
                         if (glimage->getComponents() && glimage->mSaveData->getComponents())
                         {
-                                glimage->createGLTexture(glimage->mCurrentDiscardLevel, glimage->mSaveData);
+                                glimage->createGLTexture(glimage->mCurrentDiscardLevel, glimage->mSaveData, 0, TRUE, glimage->getCategory());
                                 stop_glerror();
                         }
                         glimage->mSaveData = NULL; // deletes data
@@ -311,7 +382,7 @@ void LLImageGL::init(BOOL usemipmaps)
         mTextureState       = NO_DELETE ;
         mTextureMemory    = 0;
         mLastBindTime     = 0.f;
-
+        
         mTarget                   = GL_TEXTURE_2D;
         mBindTarget               = LLTexUnit::TT_TEXTURE;
         mUseMipMaps               = usemipmaps;
@@ -338,7 +409,9 @@ void LLImageGL::init(BOOL usemipmaps)
         mHasExplicitFormat = FALSE;
 
         mGLTextureCreated = FALSE ;
+
         mIsMask = FALSE;
+        mCategory = -1 ;
 }
 
 void LLImageGL::cleanup()
@@ -438,6 +511,10 @@ void LLImageGL::dump()
 }
 
 //----------------------------------------------------------------------------
+void LLImageGL::forceUpdateBindStats(void) const
+{
+        mLastBindTime = sLastFrameTime;
+}
 
 void LLImageGL::updateBindStats(void) const
 {       
@@ -451,7 +528,8 @@ void LLImageGL::updateBindStats(void) const
                 {
                         // we haven't accounted for this texture yet this frame
                         sUniqueCount++;
-                        updateBoundTexMem(mTextureMemory);
+        
+                        updateBoundTexMem();
                         mLastBindTime = sLastFrameTime;
                 }
         }
@@ -464,7 +542,7 @@ bool LLImageGL::bindError(const S32 stage) const
 }
 
 //virtual
-bool LLImageGL::bindDefaultImage(const S32 stage) const
+bool LLImageGL::bindDefaultImage(const S32 stage) 
 {
         return false;
 }
@@ -503,7 +581,6 @@ void LLImageGL::setImage(const LLImageRaw* imageraw)
 void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
 {
 //      LLFastTimer t1(LLFastTimer::FTM_TEMP1);
-        llpushcallstacks ;
         bool is_compressed = false;
         if (mFormatPrimary >= GL_COMPRESSED_RGBA_S3TC_DXT1_EXT && mFormatPrimary <= GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
         {
@@ -716,12 +793,10 @@ void LLImageGL::setImage(const U8* data_in, BOOL data_hasmips)
         }
         stop_glerror();
         mGLTextureCreated = true;
-        llpushcallstacks ;
 }
 
-BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height)
+BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update)
 {
-        llpushcallstacks ;
         if (!width || !height)
         {
                 return TRUE;
@@ -737,7 +812,8 @@ BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S3
                 return FALSE;
         }
         
-        if (x_pos == 0 && y_pos == 0 && width == getWidth() && height == getHeight() && data_width == width && data_height == height)
+        // HACK: allow the caller to explicitly force the fast path (i.e. using glTexSubImage2D here instead of calling setImage) even when updating the full texture.
+        if (!force_fast_update && x_pos == 0 && y_pos == 0 && width == getWidth() && height == getHeight() && data_width == width && data_height == height)
         {
                 setImage(datap, FALSE);
         }
@@ -810,20 +886,20 @@ BOOL LLImageGL::setSubImage(const U8* datap, S32 data_width, S32 data_height, S3
                 stop_glerror();
                 mGLTextureCreated = true;
         }
-        llpushcallstacks ;
         return TRUE;
 }
 
-BOOL LLImageGL::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height)
+BOOL LLImageGL::setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update)
 {
-        return setSubImage(imageraw->getData(), imageraw->getWidth(), imageraw->getHeight(), x_pos, y_pos, width, height);
+        return setSubImage(imageraw->getData(), imageraw->getWidth(), imageraw->getHeight(), x_pos, y_pos, width, height, force_fast_update);
 }
 
 // Copy sub image from frame buffer
 BOOL LLImageGL::setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height)
 {
-        if (gGL.getTexUnit(0)->bind(this, true))
+        if (gGL.getTexUnit(0)->bind(this, false, true))
         {
+                //checkTexSize() ;
                 glCopyTexSubImage2D(GL_TEXTURE_2D, 0, fb_x, fb_y, x_pos, y_pos, width, height);
                 mGLTextureCreated = true;
                 stop_glerror();
@@ -883,14 +959,14 @@ BOOL LLImageGL::createGLTexture()
         return TRUE ;
 }
 
-BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename/*=0*/)
+BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename/*=0*/, BOOL to_create, S32 category)
 {
-        llpushcallstacks ;
         if (gGLManager.mIsDisabled)
         {
                 llwarns << "Trying to create a texture while GL is disabled!" << llendl;
                 return FALSE;
         }
+
         mGLTextureCreated = false ;
         llassert(gGLManager.mInited);
         stop_glerror();
@@ -903,8 +979,10 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
         discard_level = llclamp(discard_level, 0, (S32)mMaxDiscardLevel);
 
         // Actual image width/height = raw image width/height * 2^discard_level
-        S32 w = imageraw->getWidth() << discard_level;
-        S32 h = imageraw->getHeight() << discard_level;
+        S32 raw_w = imageraw->getWidth() ;
+        S32 raw_h = imageraw->getHeight() ;
+        S32 w = raw_w << discard_level;
+        S32 h = raw_h << discard_level;
 
         // setSize may call destroyGLTexture if the size does not match
         setSize(w, h, imageraw->getComponents());
@@ -940,13 +1018,21 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S
                 }
         }
 
+        if(!to_create) //not create a gl texture
+        {
+                destroyGLTexture();
+                mCurrentDiscardLevel = discard_level;   
+                mLastBindTime = sLastFrameTime;
+                return TRUE ;
+        }
+
+        mCategory = category ;
         const U8* rawdata = imageraw->getData();
         return createGLTexture(discard_level, rawdata, FALSE, usename);
 }
 
 BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_hasmips, S32 usename)
 {
-        llpushcallstacks ;
         llassert(data_in);
 
         if (discard_level < 0)
@@ -1014,7 +1100,14 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_
         if (old_name != 0)
         {
                 sGlobalTextureMemoryInBytes -= mTextureMemory;
+
+                if(gAuditTexture)
+                {
+                        decTextureCounter() ;
+                }
+
                 LLImageGL::deleteTextures(1, &old_name);
+
                 stop_glerror();
         }
 
@@ -1022,13 +1115,15 @@ BOOL LLImageGL::createGLTexture(S32 discard_level, const U8* data_in, BOOL data_
         sGlobalTextureMemoryInBytes += mTextureMemory;
         setActive() ;
 
+        if(gAuditTexture)
+        {
+                incTextureCounter() ;
+        }
         // mark this as bound at this point, so we don't throw it out immediately
         mLastBindTime = sLastFrameTime;
-
-        llpushcallstacks ;
         return TRUE;
 }
-
+#if 0
 BOOL LLImageGL::setDiscardLevel(S32 discard_level)
 {
         llassert(discard_level >= 0);
@@ -1080,25 +1175,14 @@ BOOL LLImageGL::setDiscardLevel(S32 discard_level)
                 return FALSE;
         }
 }
-
-BOOL LLImageGL::isValidForSculpt(S32 discard_level, S32 image_width, S32 image_height, S32 ncomponents)
-{
-        assert_glerror();
-        S32 gl_discard = discard_level - mCurrentDiscardLevel;
-        LLGLint glwidth = 0;
-        glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_WIDTH, (GLint*)&glwidth);
-        LLGLint glheight = 0;
-        glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_HEIGHT, (GLint*)&glheight);
-        LLGLint glcomponents = 0 ;
-        glGetTexLevelParameteriv(mTarget, gl_discard, GL_TEXTURE_INTERNAL_FORMAT, (GLint*)&glcomponents);
-        assert_glerror();
-
-        return glwidth >= image_width && glheight >= image_height && (GL_RGB8 == glcomponents || GL_RGBA8 == glcomponents) ;
-}
+#endif
 
 BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok)
 {
-        llpushcallstacks ;
+        // VWR-13505 : Merov : Allow gl texture read back so save texture works again (temporary)
+        //llassert_always(sAllowReadBackRaw) ;
+        //llerrs << "should not call this function!" << llendl ;
+        
         if (discard_level < 0)
         {
                 discard_level = mCurrentDiscardLevel;
@@ -1201,7 +1285,7 @@ BOOL LLImageGL::readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compre
                 return FALSE ;
         }
         //-----------------------------------------------------------------------------------------------
-        llpushcallstacks ;
+
         return TRUE ;
 }
 
@@ -1219,12 +1303,19 @@ void LLImageGL::destroyGLTexture()
                                 stop_glerror();
                         }
                 }
-
-                sGlobalTextureMemoryInBytes -= mTextureMemory;
-                mTextureMemory = 0;
-
+                
+                if(mTextureMemory)
+                {
+                        if(gAuditTexture)
+                        {
+                                decTextureCounter() ;
+                        }
+                        sGlobalTextureMemoryInBytes -= mTextureMemory;
+                        mTextureMemory = 0;
+                }
+                
                 LLImageGL::deleteTextures(1, &mTexName);
-                mTextureState = DELETED ;               
+                mTextureState = DELETED ;
                 mTexName = 0;
                 mCurrentDiscardLevel = -1 ; //invalidate mCurrentDiscardLevel.
                 mGLTextureCreated = FALSE ;
@@ -1338,6 +1429,11 @@ S32 LLImageGL::getMipBytes(S32 discard_level) const
         return res;
 }
 
+BOOL LLImageGL::isJustBound() const
+{
+        return (BOOL)(sLastFrameTime - mLastBindTime < 0.5f);
+}
+
 BOOL LLImageGL::getBoundRecently() const
 {
         return (BOOL)(sLastFrameTime - mLastBindTime < MIN_TEXTURE_LIFETIME);
@@ -1539,6 +1635,87 @@ BOOL LLImageGL::getMask(const LLVector2 &tc)
         return res;
 }
 
+void LLImageGL::setCategory(S32 category) 
+{
+        if(!gAuditTexture)
+        {
+                return ;
+        }
+        if(mCategory != category)
+        {               
+                if(mCategory > -1)
+                {
+                        sTextureMemByCategory[mCategory] -= mTextureMemory ;
+                }
+                sTextureMemByCategory[category] += mTextureMemory ;
+                
+                mCategory = category;
+        }
+}
+
+//for debug use 
+//val is a "power of two" number
+S32 LLImageGL::getTextureCounterIndex(U32 val) 
+{
+        //index range is [0, MAX_TEXTURE_LOG_SIZE].
+        if(val < 2)
+        {
+                return 0 ;
+        }
+        else if(val >= (1 << MAX_TEXTURE_LOG_SIZE))
+        {
+                return MAX_TEXTURE_LOG_SIZE ;
+        }
+        else
+        {
+                S32 ret = 0 ;
+                while(val >>= 1)
+                {
+                        ++ret;
+                }
+                return ret ;
+        }
+}
+void LLImageGL::incTextureCounterStatic(U32 val, S32 ncomponents, S32 category) 
+{
+        sTextureLoadedCounter[getTextureCounterIndex(val)]++ ;
+        sTextureMemByCategory[category] += (S32)val * ncomponents ;
+}
+void LLImageGL::decTextureCounterStatic(U32 val, S32 ncomponents, S32 category) 
+{
+        sTextureLoadedCounter[getTextureCounterIndex(val)]-- ;
+        sTextureMemByCategory[category] += (S32)val * ncomponents ;
+}
+void LLImageGL::incTextureCounter() 
+{
+        sTextureLoadedCounter[getTextureCounterIndex(mTextureMemory / mComponents)]++ ;
+        sTextureMemByCategory[mCategory] += mTextureMemory ;
+}
+void LLImageGL::decTextureCounter() 
+{
+        sTextureLoadedCounter[getTextureCounterIndex(mTextureMemory / mComponents)]-- ;
+        sTextureMemByCategory[mCategory] -= mTextureMemory ;
+}
+void LLImageGL::setCurTexSizebar(S32 index, BOOL set_pick_size)
+{
+        sCurTexSizeBar = index ;
+
+        if(set_pick_size)
+        {
+                sCurTexPickSize = (1 << index) ;
+        }
+        else
+        {
+                sCurTexPickSize = -1 ;
+        }
+}
+void LLImageGL::resetCurTexSizebar()
+{
+        sCurTexSizeBar = -1 ;
+        sCurTexPickSize = -1 ;
+}
+//----------------------------------------------------------------------------
+
 //----------------------------------------------------------------------------
 
 
diff --git a/linden/indra/llrender/llimagegl.h b/linden/indra/llrender/llimagegl.h
index 2f08a5a..c8df101 100644
--- a/linden/indra/llrender/llimagegl.h
+++ b/linden/indra/llrender/llimagegl.h
@@ -46,7 +46,6 @@
 #define MEGA_BYTES_TO_BYTES(x) ((x) << 20)
 
 //============================================================================
-
 class LLImageGL : public LLRefCount
 {
         friend class LLTexUnit;
@@ -57,6 +56,7 @@ public:
         static S32 dataFormatComponents(S32 dataformat);
 
         void updateBindStats(void) const;
+        void forceUpdateBindStats(void) const;
 
         // needs to be called every frame
         static void updateStats(F32 current_time);
@@ -65,9 +65,10 @@ public:
         static void destroyGL(BOOL save_state = TRUE);
         static void restoreGL();
 
-        // Sometimes called externally for textures not using LLImageGL (should go away...)
-        static S32 updateBoundTexMem(const S32 delta);
-
+        // Sometimes called externally for textures not using LLImageGL (should go away...)     
+        static S32 updateBoundTexMemStatic(const S32 delta, const S32 size, S32 category) ;
+        S32 updateBoundTexMem()const;
+        
         static bool checkSize(S32 width, S32 height);
         
         // Not currently necessary for LLImageGL, but required in some derived classes,
@@ -89,7 +90,7 @@ protected:
 public:
         virtual void dump();    // debugging info to llinfos
         virtual bool bindError(const S32 stage = 0) const;
-        virtual bool bindDefaultImage(const S32 stage = 0) const;
+        virtual bool bindDefaultImage(const S32 stage = 0) ;
         virtual void forceImmediateUpdate() ;
 
         void setSize(S32 width, S32 height, S32 ncomponents);
@@ -101,20 +102,22 @@ public:
         static void setManualImage(U32 target, S32 miplevel, S32 intformat, S32 width, S32 height, U32 pixformat, U32 pixtype, const void *pixels);
 
         BOOL createGLTexture() ;
-        BOOL createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename = 0);
+        BOOL createGLTexture(S32 discard_level, const LLImageRaw* imageraw, S32 usename = 0, BOOL to_create = TRUE, 
+                S32 category = sMaxCatagories - 1);
         BOOL createGLTexture(S32 discard_level, const U8* data, BOOL data_hasmips = FALSE, S32 usename = 0);
         void setImage(const LLImageRaw* imageraw);
         void setImage(const U8* data_in, BOOL data_hasmips = FALSE);
-        BOOL setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height);
-        BOOL setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height);
+        BOOL setSubImage(const LLImageRaw* imageraw, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update = FALSE);
+        BOOL setSubImage(const U8* datap, S32 data_width, S32 data_height, S32 x_pos, S32 y_pos, S32 width, S32 height, BOOL force_fast_update = FALSE);
         BOOL setSubImageFromFrameBuffer(S32 fb_x, S32 fb_y, S32 x_pos, S32 y_pos, S32 width, S32 height);
-        BOOL setDiscardLevel(S32 discard_level);
+
         // Read back a raw image for this discard level, if it exists
         BOOL readBackRaw(S32 discard_level, LLImageRaw* imageraw, bool compressed_ok); 
         void destroyGLTexture();
 
         void setExplicitFormat(LLGLint internal_format, LLGLenum primary_format, LLGLenum type_format = 0, BOOL swap_bytes = FALSE);
         void dontDiscard() { mDontDiscard = 1; mTextureState = NO_DELETE; }
+        void setComponents(S8 ncomponents) { mComponents = ncomponents; }
 
         S32      getDiscardLevel() const                { return mCurrentDiscardLevel; }
         S32      getMaxDiscardLevel() const             { return mMaxDiscardLevel; }
@@ -127,6 +130,7 @@ public:
         S32  getBytes(S32 discard_level = -1) const;
         S32  getMipBytes(S32 discard_level = -1) const;
         BOOL getBoundRecently() const;
+        BOOL isJustBound() const;
         LLGLenum getPrimaryFormat() const { return mFormatPrimary; }
 
         BOOL getHasGLTexture() const { return mTexName != 0; }
@@ -147,8 +151,6 @@ public:
         BOOL getUseDiscard() const { return mUseMipMaps && !mDontDiscard; }
         BOOL getDontDiscard() const { return mDontDiscard; }
 
-        BOOL isValidForSculpt(S32 discard_level, S32 image_width, S32 image_height, S32 ncomponents) ;
-
         void updatePickMask(S32 width, S32 height, const U8* data_in);
         BOOL getMask(const LLVector2 &tc);
 
@@ -175,6 +177,7 @@ public:
         void forceActive() ;
         void setNoDelete() ;
 
+        void setTextureSize(S32 size) {mTextureMemory = size;}
 protected:
         void init(BOOL usemipmaps);
         virtual void cleanup(); // Clean up the LLImageGL so it can be reinitialized.  Be careful when using this in derived class destructors
@@ -183,7 +186,7 @@ public:
         // Various GL/Rendering options
         S32 mTextureMemory;
         mutable F32  mLastBindTime;     // last time this was bound, by discard level
-
+        
 private:
         LLPointer<LLImageRaw> mSaveData; // used for destroyGL/restoreGL
         U8* mPickMask;  //downsampled bitmap approximation of alpha channel.  NULL if no alpha channel
@@ -198,7 +201,7 @@ private:
         U16      mWidth;
         U16      mHeight;       
         S8       mCurrentDiscardLevel;
-
+        
 protected:
         LLGLenum mTarget;               // Normally GL_TEXTURE2D, sometimes something else (ex. cube maps)
         LLTexUnit::eTextureType mBindTarget;    // Normally TT_TEXTURE, sometimes something else (ex. cube maps)
@@ -237,7 +240,7 @@ public:
         static S32 sCount;
         
         static F32 sLastFrameTime;
-
+        
         static LLGLuint sCurrentBoundTextures[MAX_GL_TEXTURE_UNITS]; // Currently bound texture ID
 
         // Global memory statistics
@@ -253,6 +256,57 @@ public:
 #else
         BOOL getMissed() const { return FALSE; };
 #endif
+
+public:
+        static void initClass(S32 num_catagories) ;
+        static void cleanupClass() ;
+private:
+        static S32 sMaxCatagories ;
+
+        //the flag to allow to call readBackRaw(...).
+        //can be removed if we do not use that function at all.
+        static BOOL sAllowReadBackRaw ;
+//
+//****************************************************************************************************
+//The below for texture auditing use only
+//****************************************************************************************************
+private:
+        S32 mCategory ;
+public:         
+        void setCategory(S32 category) ;
+        S32  getCategory()const {return mCategory ;}
+
+        //for debug use: show texture size distribution 
+        //----------------------------------------
+        static LLPointer<LLImageGL> sDefaultTexturep; //default texture to replace normal textures
+        static std::vector<S32> sTextureLoadedCounter ;
+        static std::vector<S32> sTextureBoundCounter ;
+        static std::vector<S32> sTextureCurBoundCounter ;
+        static S32 sCurTexSizeBar ;
+        static S32 sCurTexPickSize ;
+
+        static S32 getTextureCounterIndex(U32 val) ;
+        static void incTextureCounterStatic(U32 val, S32 ncomponents, S32 category) ;
+        static void decTextureCounterStatic(U32 val, S32 ncomponents, S32 category) ;
+        static void setCurTexSizebar(S32 index, BOOL set_pick_size = TRUE) ;
+        static void resetCurTexSizebar();
+
+        void incTextureCounter() ;
+        void decTextureCounter() ;
+        //----------------------------------------
+
+        //for debug use: show texture category distribution 
+        //----------------------------------------              
+        
+        static std::vector<S32> sTextureMemByCategory;
+        static std::vector<S32> sTextureMemByCategoryBound ;
+        static std::vector<S32> sTextureCurMemByCategoryBound ;
+        //----------------------------------------      
+//****************************************************************************************************
+//End of definitions for texture auditing use only
+//****************************************************************************************************
+
 };
 
+extern BOOL gAuditTexture;
 #endif // LL_LLIMAGEGL_H
diff --git a/linden/indra/llrender/llrender.cpp b/linden/indra/llrender/llrender.cpp
index ba95a19..93ff822 100644
--- a/linden/indra/llrender/llrender.cpp
+++ b/linden/indra/llrender/llrender.cpp
@@ -177,7 +177,7 @@ void LLTexUnit::disable(void)
         }
 }
 
-bool LLTexUnit::bind(LLImageGL* texture, bool forceBind)
+bool LLTexUnit::bind(LLImageGL* texture, bool for_rendering, bool forceBind)
 {
         stop_glerror();
         if (mIndex < 0) return false;
@@ -192,12 +192,25 @@ bool LLTexUnit::bind(LLImageGL* texture, bool forceBind)
         
         if (!texture->getTexName()) //if texture does not exist
         {
-                //if deleted, will re-generate it immediately
-                texture->forceImmediateUpdate() ;
+                if (texture->isDeleted())
+                {
+                        // This will re-generate the texture immediately.
+                        texture->forceImmediateUpdate() ;
+                }
 
+                texture->forceUpdateBindStats() ;
                 return texture->bindDefaultImage(mIndex);
         }
 
+        if(gAuditTexture && for_rendering && LLImageGL::sCurTexPickSize > 0)
+        {
+                if(texture->getWidth() * texture->getHeight() == LLImageGL::sCurTexPickSize)
+                {
+                        texture->updateBindStats();
+                        return bind(LLImageGL::sDefaultTexturep.get());
+                }
+        }
+
         if ((mCurrTexture != texture->getTexName()) || forceBind)
         {
                 activate();
@@ -214,6 +227,7 @@ bool LLTexUnit::bind(LLImageGL* texture, bool forceBind)
                         setTextureFilteringOption(texture->mFilterOption);
                 }
         }
+
         return true;
 }
 
diff --git a/linden/indra/llrender/llrender.h b/linden/indra/llrender/llrender.h
index 437c715..ce84e74 100644
--- a/linden/indra/llrender/llrender.h
+++ b/linden/indra/llrender/llrender.h
@@ -148,7 +148,7 @@ public:
         
         // Binds the LLImageGL to this texture unit 
         // (automatically enables the unit for the LLImageGL's texture type)
-        bool bind(LLImageGL* texture, bool forceBind = false);
+        bool bind(LLImageGL* texture, bool for_rendering = false, bool forceBind = false);
 
         // Binds a cubemap to this texture unit 
         // (automatically enables the texture unit for cubemaps)
diff --git a/linden/indra/llrender/llrendertarget.cpp b/linden/indra/llrender/llrendertarget.cpp
index b7f3177..4cf8451 100644
--- a/linden/indra/llrender/llrendertarget.cpp
+++ b/linden/indra/llrender/llrendertarget.cpp
@@ -139,7 +139,7 @@ void LLRenderTarget::addColorAttachment(U32 color_fmt)
 
         U32 offset = mTex.size();
         if (offset >= 4 ||
-                offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers))
+                (offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers)))
         {
                 llerrs << "Too many color attachments!" << llendl;
         }
@@ -608,7 +608,7 @@ void LLMultisampleBuffer::addColorAttachment(U32 color_fmt)
 
         U32 offset = mTex.size();
         if (offset >= 4 ||
-                offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers))
+                (offset > 0 && (mFBO == 0 || !gGLManager.mHasDrawBuffers)))
         {
                 llerrs << "Too many color attachments!" << llendl;
         }