Second Life viewer sources 1.21.0-RC

1 files changed, 88 insertions, 59 deletions

diff --git a/linden/indra/llwindow/llgl.cpp b/linden/indra/llrender/llgl.cpp
index debf2e3..843bc79 100644
--- a/linden/indra/llwindow/llgl.cpp
+++ b/linden/indra/llrender/llgl.cpp
@@ -60,6 +60,8 @@ 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
@@ -284,6 +286,7 @@ LLGLManager::LLGLManager() :
         mIsGF3(FALSE),
         mIsGFFX(FALSE),
         mATIOffsetVerticalLines(FALSE),
+        mATIOldDriver(FALSE),
 
         mHasRequirements(TRUE),
 
@@ -350,11 +353,11 @@ bool LLGLManager::initGL()
 
         // Extract video card strings and convert to upper case to
         // work around driver-to-driver variation in capitalization.
-        mGLVendor = LLString((const char *)glGetString(GL_VENDOR));
-        LLString::toUpper(mGLVendor);
+        mGLVendor = std::string((const char *)glGetString(GL_VENDOR));
+        LLStringUtil::toUpper(mGLVendor);
 
-        mGLRenderer = LLString((const char *)glGetString(GL_RENDERER));
-        LLString::toUpper(mGLRenderer);
+        mGLRenderer = std::string((const char *)glGetString(GL_RENDERER));
+        LLStringUtil::toUpper(mGLRenderer);
 
         parse_gl_version( &mDriverVersionMajor, 
                 &mDriverVersionMinor, 
@@ -369,7 +372,7 @@ bool LLGLManager::initGL()
         {
                 mGLVendorShort = "ATI";
                 BOOL mobile = FALSE;
-                if (mGLRenderer.find("MOBILITY") != LLString::npos)
+                if (mGLRenderer.find("MOBILITY") != std::string::npos)
                 {
                         mobile = TRUE;
                 }
@@ -381,37 +384,48 @@ bool LLGLManager::initGL()
                         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 ") != LLString::npos)
+        else if (mGLVendor.find("NVIDIA ") != std::string::npos)
         {
                 mGLVendorShort = "NVIDIA";
                 mIsNVIDIA = TRUE;
-                if (   mGLRenderer.find("GEFORCE4 MX") != LLString::npos
-                        || mGLRenderer.find("GEFORCE2") != LLString::npos
-                        || mGLRenderer.find("GEFORCE 2") != LLString::npos
-                        || mGLRenderer.find("GEFORCE4 460 GO") != LLString::npos
-                        || mGLRenderer.find("GEFORCE4 440 GO") != LLString::npos
-                        || mGLRenderer.find("GEFORCE4 420 GO") != LLString::npos)
+                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") != LLString::npos
-                                 || mGLRenderer.find("QUADRO FX") != LLString::npos
-                                 || mGLRenderer.find("NV34") != LLString::npos)
+                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") != LLString::npos)
+                else if(mGLRenderer.find("GEFORCE3") != std::string::npos)
                 {
                         mIsGF3 = TRUE;
                 }
 
         }
-        else if (mGLVendor.find("INTEL") != LLString::npos
+        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") != LLString::npos
+                 || mGLRenderer.find("INTEL") != std::string::npos
 #endif //LL_LINUX
                  )
         {
@@ -452,12 +466,12 @@ bool LLGLManager::initGL()
 
 void LLGLManager::getGLInfo(LLSD& info)
 {
-        info["GLInfo"]["GLVendor"] = LLString((const char *)glGetString(GL_VENDOR));
-        info["GLInfo"]["GLRenderer"] = LLString((const char *)glGetString(GL_RENDERER));
-        info["GLInfo"]["GLVersion"] = LLString((const char *)glGetString(GL_VERSION));
+        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
-        LLString all_exts = (const char *)gGLHExts.mSysExts;
+        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)
@@ -467,19 +481,19 @@ void LLGLManager::getGLInfo(LLSD& info)
 #endif
 }
 
-LLString LLGLManager::getGLInfoString()
+std::string LLGLManager::getGLInfoString()
 {
-        LLString info_str;
-        LLString all_exts, line;
+        std::string info_str;
+        std::string all_exts, line;
 
-        info_str += LLString("GL_VENDOR      ") + LLString((const char *)glGetString(GL_VENDOR)) + LLString("\n");
-        info_str += LLString("GL_RENDERER    ") + LLString((const char *)glGetString(GL_RENDERER)) + LLString("\n");
-        info_str += LLString("GL_VERSION     ") + LLString((const char *)glGetString(GL_VERSION)) + LLString("\n");
+        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;
-        LLString::replaceChar(all_exts, ' ', '\n');
-        info_str += LLString("GL_EXTENSIONS:\n") + all_exts + LLString("\n");
+        LLStringUtil::replaceChar(all_exts, ' ', '\n');
+        info_str += std::string("GL_EXTENSIONS:\n") + all_exts + std::string("\n");
 #endif
         
         return info_str;
@@ -487,26 +501,24 @@ LLString LLGLManager::getGLInfoString()
 
 void LLGLManager::printGLInfoString()
 {
-        LLString info_str;
-        LLString all_exts, line;
+        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 = (const char *)gGLHExts.mSysExts;
-        LLString::replaceChar(all_exts, ' ', '\n');
+        all_exts = std::string(gGLHExts.mSysExts);
+        LLStringUtil::replaceChar(all_exts, ' ', '\n');
         LL_DEBUGS("RenderInit") << "GL_EXTENSIONS:\n" << all_exts << LL_ENDL;
 #endif
 }
 
-LLString LLGLManager::getRawGLString()
+std::string LLGLManager::getRawGLString()
 {
-        LLString gl_string;
-        gl_string.assign((char*)glGetString(GL_VENDOR));
-        gl_string.append(" ");
-        gl_string.append((char*)glGetString(GL_RENDERER));
+        std::string gl_string;
+        gl_string = ll_safe_string((char*)glGetString(GL_VENDOR)) + " " + ll_safe_string((char*)glGetString(GL_RENDERER));
         return gl_string;
 }
 
@@ -991,11 +1003,12 @@ void LLGLState::initClass()
         sStateMap[GL_DITHER] = GL_TRUE;
         sStateMap[GL_TEXTURE_2D] = GL_TRUE;
 
-        //make sure vertex arrays are enabled
-        glEnableClientState(GL_VERTEX_ARRAY);
-
-        //make sure multi sampling is disabled by default
+        //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
@@ -1031,7 +1044,7 @@ void LLGLState::dumpStates()
         }
 }
 
-void LLGLState::checkStates()  
+void LLGLState::checkStates(const std::string& msg)  
 {
         if (!gDebugGL)
         {
@@ -1055,7 +1068,7 @@ void LLGLState::checkStates()
         
         if (src != GL_SRC_ALPHA || dst != GL_ONE_MINUS_SRC_ALPHA)
         {
-                LL_GL_ERRS << "Blend function corrupted: " << std::hex << src << " " << std::hex << dst << LL_ENDL;
+                LL_GL_ERRS << "Blend function corrupted: " << std::hex << src << " " << std::hex << dst << "  " << msg << LL_ENDL;
         }
         
         for (std::map<LLGLenum, LLGLboolean>::iterator iter = sStateMap.begin();
@@ -1074,7 +1087,7 @@ void LLGLState::checkStates()
         stop_glerror();
 }
 
-void LLGLState::checkTextureChannels()
+void LLGLState::checkTextureChannels(const std::string& msg)
 {
         if (!gDebugGL)
         {
@@ -1175,11 +1188,11 @@ void LLGLState::checkTextureChannels()
 
         if (error)
         {
-                LL_GL_ERRS << "GL texture state corruption detected." << LL_ENDL;
+                LL_GL_ERRS << "GL texture state corruption detected.  " << msg << LL_ENDL;
         }
 }
 
-void LLGLState::checkClientArrays(U32 data_mask)
+void LLGLState::checkClientArrays(const std::string& msg, U32 data_mask)
 {
         if (!gDebugGL)
         {
@@ -1291,7 +1304,7 @@ void LLGLState::checkClientArrays(U32 data_mask)
 
         if (error)
         {
-                LL_GL_ERRS << "GL client array corruption detected." << LL_ENDL;
+                LL_GL_ERRS << "GL client array corruption detected.  " << msg << LL_ENDL;
         }
 }
 
@@ -1456,7 +1469,7 @@ void set_palette(U8 *palette_data)
 }
 
 
-void parse_gl_version( S32* major, S32* minor, S32* release, LLString* vendor_specific )
+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>]
@@ -1472,7 +1485,7 @@ void parse_gl_version( S32* major, S32* minor, S32* release, LLString* vendor_sp
                 return;
         }
 
-        LLString ver_copy( version );
+        std::string ver_copy( version );
         S32 len = (S32)strlen( version );       /* Flawfinder: ignore */
         S32 i = 0;
         S32 start;
@@ -1485,8 +1498,8 @@ void parse_gl_version( S32* major, S32* minor, S32* release, LLString* vendor_sp
                         break;
                 }
         }
-        LLString major_str = ver_copy.substr(start,i-start);
-        LLString::convertToS32(major_str, *major);
+        std::string major_str = ver_copy.substr(start,i-start);
+        LLStringUtil::convertToS32(major_str, *major);
 
         if( '.' == version[i] )
         {
@@ -1502,8 +1515,8 @@ void parse_gl_version( S32* major, S32* minor, S32* release, LLString* vendor_sp
                         break;
                 }
         }
-        LLString minor_str = ver_copy.substr(start,i-start);
-        LLString::convertToS32(minor_str, *minor);
+        std::string minor_str = ver_copy.substr(start,i-start);
+        LLStringUtil::convertToS32(minor_str, *minor);
 
         // Find the release number (optional)
         if( '.' == version[i] )
@@ -1519,8 +1532,8 @@ void parse_gl_version( S32* major, S32* minor, S32* release, LLString* vendor_sp
                         }
                 }
 
-                LLString release_str = ver_copy.substr(start,i-start);
-                LLString::convertToS32(release_str, *release);
+                std::string release_str = ver_copy.substr(start,i-start);
+                LLStringUtil::convertToS32(release_str, *release);
         }
 
         // Skip over any white space
@@ -1616,6 +1629,7 @@ void LLGLNamePool::cleanup()
 
 GLuint LLGLNamePool::allocate()
 {
+#if LL_GL_NAME_POOLING
         for (name_list_t::iterator iter = mNameList.begin(); iter != mNameList.end(); ++iter)
         {
                 if (!iter->used)
@@ -1631,18 +1645,33 @@ GLuint LLGLNamePool::allocate()
         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)
                 {
-                        iter->used = FALSE;
-                        return;
+                        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