Geoff McLane:

add a bunch of debugging code to find a persistant bug for Atlas/Map and fix them one by one.

simgear/screen/RenderTexture.cpp

@@ -29,6 +29,8 @@
 // OS X: Alexander Powell (someone please help)
 // Various Bug Fixes: Daniel (Redge) Sperl 
 //                    Bill Baxter
+// Ubuntu 8.04 64bit: Geoff McLane - 2009-07-01
+// to work even when version 1.2 is returned.
 //
 // --------------------------------------------------------------------------
 /**
@@ -69,6 +71,24 @@
 
 using namespace std;
 
+// DEBUG - add a lot of noise
+//#ifndef _DEBUG
+//#define _DEBUG
+//#endif
+
+#ifdef _DEBUG
+#define dbg_printf printf
+const char * get_attr_name( int val, int * pdef );
+#else
+#define dbg_printf
+#endif
+
+// CHOP/NOT CHOP SOME CODE TO GET SOMETHING WORKING!
+#define ADD_QUERY_BUFFER    
+#define ADD_GET_DRAWABLE
+// =======================================
+
+
 #ifdef _WIN32
 static bool fctPtrInited = false;
 /* WGL_ARB_pixel_format */
@@ -152,10 +172,12 @@ RenderTexture::RenderTexture(const char *strMode)
     _iDepthTextureID(0),
     _pPoorDepthTexture(0) // [Redge]
 {
+    dbg_printf("RenderTexture::RenderTexture(%s) BGN instantiation.\n", strMode );
     _iNumColorBits[0] = _iNumColorBits[1] = 
         _iNumColorBits[2] = _iNumColorBits[3] = 0;
 
 #ifdef _WIN32
+    dbg_printf("RenderTexture::RenderTexture in _WIN32.\n" );
     _pixelFormatAttribs.push_back(WGL_DRAW_TO_PBUFFER_ARB);
     _pixelFormatAttribs.push_back(true);
     _pixelFormatAttribs.push_back(WGL_SUPPORT_OPENGL_ARB);
@@ -164,11 +186,13 @@ RenderTexture::RenderTexture(const char *strMode)
     _pbufferAttribs.push_back(WGL_PBUFFER_LARGEST_ARB);
     _pbufferAttribs.push_back(true);
 #elif defined( __MACH__ )
+    dbg_printf("RenderTexture::RenderTexture in __MACH__.\n" );
     //_pixelFormatAttribs.push_back(kCGLPFANoRecovery);
     _pixelFormatAttribs.push_back(kCGLPFAAccelerated);
     _pixelFormatAttribs.push_back(kCGLPFAWindow);
     _pixelFormatAttribs.push_back(kCGLPFAPBuffer);
 #else
+    dbg_printf("RenderTexture::RenderTexture !_WIN32 and !__MACH__.\n" );
     _pbufferAttribs.push_back(GLX_RENDER_TYPE_SGIX);
     _pbufferAttribs.push_back(GLX_RGBA_BIT_SGIX);
     _pbufferAttribs.push_back(GLX_DRAWABLE_TYPE_SGIX);
@@ -186,6 +210,10 @@ RenderTexture::RenderTexture(const char *strMode)
 #else
     _pixelFormatAttribs.push_back(None);
 #endif
+
+    dbg_printf("RenderTexture::RenderTexture(%s) END instantiation. pf=%d pb=%d\n",
+      strMode, _pixelFormatAttribs.size(), _pbufferAttribs.size() );
+
 }
 
 
@@ -199,6 +227,7 @@ RenderTexture::RenderTexture(const char *strMode)
 */ 
 RenderTexture::~RenderTexture()
 {
+    dbg_printf("RenderTexture::~RenderTexture: destructor.\n" );
     _Invalidate();
 }
 
@@ -312,9 +341,9 @@ void PrintExtensionError( const char* strMsg, ... )
     va_end(args);
     
     SG_LOG(SG_GL, SG_ALERT, strMsg);
+    dbg_printf("Error: RenderTexture requires the following unsupported OpenGL extensions: \n[%s]\n", strMsg);
 }
 
-
 //---------------------------------------------------------------------------
 // Function     	: RenderTexture::Initialize
 // Description	    : 
@@ -332,6 +361,8 @@ bool RenderTexture::Initialize(int width, int height,
 {
     assert(width > 0 && height > 0);
 
+    dbg_printf("RenderTexture::Initialize w=%d h=%d\n", width, height );
+    
     _iWidth = width; _iHeight = height;
     _bPowerOf2 = IsPowerOfTwo(width) && IsPowerOfTwo(height);
 
@@ -339,8 +370,10 @@ bool RenderTexture::Initialize(int width, int height,
     _bCopyContext  = copyContext;
 
     // Check if this is an NVXX GPU and verify necessary extensions.
-    if (!_VerifyExtensions())
+    if (!_VerifyExtensions()) {
-        return false;
+       dbg_printf("RenderTexture::Initialize: _VerifyExtensions() FAILED - returning false.\n" );
+       return false;
+    }
     
     if (_bInitialized)
         _Invalidate();
@@ -617,33 +650,71 @@ bool RenderTexture::Initialize(int width, int height,
 #endif
 
 #else // !_WIN32, !__MACH_
+
     _pDisplay = glXGetCurrentDisplay();
+    if ( !_pDisplay ) {
+        dbg_printf("RenderTexture::Initialize: ERROR: glXGetCurrentDisplay() returned NULL! return false\n");
+        return false;
+    }
+    dbg_printf("RenderTexture::Initialize: got glXGetCurrentDisplay() _pDisplay=[%p]\n", _pDisplay);
+    // glXGetCurrentContext returns the current context, as specified by glXMakeCurrent.
+    // If there is no current context, NULL is returned.
     GLXContext context = glXGetCurrentContext();
+    if ( !context ) {
+        dbg_printf("RenderTexture::Initialize: ERROR: glXGetCurrentContext() returned NULL! return false\n");
+        return false;
+    }
+    dbg_printf("RenderTexture::Initialize: got glXGetCurrentContext() context=[%p]\n", context);
     int screen = DefaultScreen(_pDisplay);
+    dbg_printf("RenderTexture::Initialize: DefaultScreen(_pDisplay) screen=%d\n", screen);
+    
     XVisualInfo *visInfo = NULL;
     
     GLXFBConfig *fbConfigs;
     int nConfigs;
-    
+#ifdef _DEBUG
+    dbg_printf("Using %d pixelFormatAttribs array\n", _pixelFormatAttribs.size());
+    size_t max = _pixelFormatAttribs.size() / 2;
+    int dat = 0;
+    size_t n;
+    for (n = 0; n < max; n++) {
+      const char * cp = get_attr_name(_pixelFormatAttribs[n*2], &dat);
+      printf( "%s(%d) = %d (def=%d)\n",
+       cp, _pixelFormatAttribs[n*2], _pixelFormatAttribs[(n*2)+1], dat );
+    }
+    n *= 2;
+    if ( n < _pixelFormatAttribs.size() )
+      printf( "Array ends with %d\n", _pixelFormatAttribs[n] );
+    else
+      printf( "WARNING: Array does not appear ODD! which is ODD\n" );
+      
+#endif
     fbConfigs = glXChooseFBConfigPtr(_pDisplay, screen, 
                                       &_pixelFormatAttribs[0], &nConfigs);
+    // NOTE: ref: http://www.opengl.org/sdk/docs/man/xhtml/glXChooseFBConfig.xml says
+    // Next, call glXGetFBConfigAttrib to retrieve additional attributes for the frame buffer configurations and then select between them.
     
-    if (nConfigs == 0 || !fbConfigs) 
+    if (nConfigs <= 0 || !fbConfigs) 
     {
         SG_LOG(SG_GL, SG_ALERT,
             "RenderTexture Error: Couldn't find a suitable pixel format.");
+        dbg_printf("RenderTexture Error: Couldn't find a suitable pixel format. return false\n");
         return false;
     }
     
+    dbg_printf("RenderTexture::Initialize: glXChooseFBConfigPtr() nConfigs = %d, fbConfigs=[%p]\n", nConfigs, fbConfigs);
+    
+    int pbufAttrib[] = {
+      GLX_PBUFFER_WIDTH,   _iWidth,
+      GLX_PBUFFER_HEIGHT,  _iHeight,
+      GLX_LARGEST_PBUFFER, False,
+      None
+    };
     // Pick the first returned format that will return a pbuffer
-    if (glXVersion1_3Present)
+    // if (glXVersion1_3Present)
+    if (glXCreatePbufferPtr && glXGetVisualFromFBConfigPtr && glXCreateContextPtr) 
     {
-        int pbufAttrib[] = {
+        dbg_printf("RenderTexture::Initialize: glXVersion1_3Present = TRUE\n");
-            GLX_PBUFFER_WIDTH,   _iWidth,
-            GLX_PBUFFER_HEIGHT,  _iHeight,
-            GLX_LARGEST_PBUFFER, False,
-            None
-        };
         for (int i=0;i<nConfigs;i++)
         {
             _hPBuffer = glXCreatePbufferPtr(_pDisplay, fbConfigs[i], pbufAttrib);
@@ -656,6 +727,7 @@ bool RenderTexture::Initialize(int width, int height,
                                                True);
                 if (!_hGLContext)
                 {
+                    dbg_printf("RenderTexture Error: glXCreateContextPtr(_pDisplay, visInfo,..) FAILED! return false\n");
                     return false;
                 }
                 XFree( visInfo );
@@ -670,27 +742,37 @@ bool RenderTexture::Initialize(int width, int height,
         int iNumFormats;
         int attrib = 0;
 #endif
-        for (int i=0;i<nConfigs;i++)
+        dbg_printf("RenderTexture::Initialize: glXVersion1_3Present = FALSE w=%d h=%d\n", _iWidth, _iHeight);
+        for (int i=0; i < nConfigs; i++)
         {
+             dbg_printf("RenderTexture::Initialize: %d: glXCreateGLXPbufferPtr() get buffer ptr\n", (i + 1));
             _hPBuffer = glXCreateGLXPbufferPtr(_pDisplay, fbConfigs[i], 
-                                               _iWidth, _iHeight, NULL);
+                                               _iWidth, _iHeight,
+                                               &pbufAttrib[0] ); //NULL);
             if (_hPBuffer) 
             {
+                dbg_printf("RenderTexture::Initialize: %d: glXCreateGLXPbufferPtr() got buffer [%p]\n", (i + 1), _hPBuffer);
                 _hGLContext = glXCreateContextWithConfigPtr(_pDisplay, 
                                                              fbConfigs[i], 
                                                              GLX_RGBA_TYPE, 
                                                              _bShareObjects ? context : NULL, 
                                                              True);
+                dbg_printf("RenderTexture::Initialize: %d: glXCreateContextWithConfigPtr() _hGLContext=[%p]\n", (i + 1), _hGLContext);
                 break;
+            } else {
+                dbg_printf("RenderTexture::Initialize: %d: glXCreateGLXPbufferPtr() NO buffer\n", (i + 1));
             }
         }
     }
+    
+    dbg_printf("RenderTexture::Initialize: doing XFree( fbConfigs=[%p].\n", fbConfigs);
     XFree( fbConfigs );
     
     if (!_hPBuffer)
     {
         SG_LOG(SG_GL, SG_ALERT, 
                 "RenderTexture Error: glXCreateGLXPbufferPtr() failed.");
+        dbg_printf("RenderTexture Error: glXCreateGLXPbufferPtr() failed.\n");
         return false;
     }
     
@@ -703,20 +785,29 @@ bool RenderTexture::Initialize(int width, int height,
         {
             SG_LOG(SG_GL, SG_ALERT, 
                     "RenderTexture Error: glXCreateContext() failed.");
+            dbg_printf("RenderTexture Error: glXCreateContext() failed. return false\n");
             return false;
         }
     }
     
-    if (!glXVersion1_3Present)
+    // if (!glXVersion1_3Present)
+    if ((!glXCreatePbufferPtr || !glXGetVisualFromFBConfigPtr || !glXCreateContextPtr) &&
+        (!glXVersion1_3Present))
     {
+#ifdef ADD_QUERY_BUFFER    
+        dbg_printf("RenderTexture::Initialize: Doing glXQueryGLXPbufferSGIXPtr with GLX_WIDTH_SGIX\n");
         glXQueryGLXPbufferSGIXPtr(_pDisplay, _hPBuffer, GLX_WIDTH_SGIX, 
                                   (GLuint*)&_iWidth);
+        dbg_printf("RenderTexture::Initialize: Doing glXQueryGLXPbufferSGIXPtr with GLX_HEIGHT_SGIX\n");
         glXQueryGLXPbufferSGIXPtr(_pDisplay, _hPBuffer, GLX_HEIGHT_SGIX, 
                                   (GLuint*)&_iHeight);
+#else
+        dbg_printf("RenderTexture::Initialize: SKIPPED doing glXQueryGLXPbufferSGIXPtr with GLX_WIDTH_SGIX and GLX_HEIGHT_SGIX\n");
+#endif // #ifdef ADD_QUERY_BUFFER    
     }
     
     _bInitialized = true;
-    
+    dbg_printf( "RenderTexture::Initialize: _bIniialized set TRUE\n" );
     // XXX Query the color format
     
 #endif
@@ -740,13 +831,26 @@ bool RenderTexture::Initialize(int width, int height,
         return false;
     }
 #else
+
+#ifdef ADD_GET_DRAWABLE
+     dbg_printf( "RenderTexture::Initialize: doing glXGetCurrentContext()\n" );
     _hPreviousContext = glXGetCurrentContext();
+     dbg_printf( "RenderTexture::Initialize: doing glXGetCurrentDrawable()\n" );
     _hPreviousDrawable = glXGetCurrentDrawable();
+#else
+    _hPreviousContext = context;
+    _hPreviousDrawable = 0;
+     dbg_printf( "RenderTexture::Initialize: SKIPPED doing glXGetCurrentContext(2nd) AND glXGetCurrentDrawable()\n" );
+#endif // #ifdef ADD_GET_DRAWABLE
     
+    dbg_printf( "RenderTexture::Initialize: doing glXMakeCurrent(_pDisplay(%p), _hPBuffer(%p), _hGLContext(%p))\n",
+       _pDisplay, _hPBuffer, _hGLContext );
     if (False == glXMakeCurrent(_pDisplay, _hPBuffer, _hGLContext)) 
     {
+        dbg_printf( "glXMakeCurrent(_pDisplay, _hPBuffer, _hGLContext) FAILED. return false\n" );
         return false;
     }
+    
 #endif
     
     bool result = _InitializeTextures();   
@@ -773,16 +877,23 @@ bool RenderTexture::Initialize(int width, int height,
     if (False == glXMakeCurrent(_pDisplay, 
                                 _hPreviousDrawable, _hPreviousContext))
     {
+        dbg_printf("glXMakeCurrent(_pDisplay, _hPreviousDrawable, _hPreviousContext)) FAILED! return false\n" );
         return false;
     }
+    
     if (glXVersion1_3Present)
+    //if ((glXVersion1_3Present) ||
+    //    (glXCreatePbufferPtr && glXGetVisualFromFBConfigPtr && glXCreateContextPtr && glXQueryDrawablePtr)) 
     {
+        dbg_printf( "RenderTexture::Initialize: doing glXGetCurrentDrawable()\n" );
         GLXDrawable draw = glXGetCurrentDrawable();
+        dbg_printf( "RenderTexture::Initialize: doing glXQueryDrawablePtr for GLX_WIDTH and GLX_HEIGHT\n" );
         glXQueryDrawablePtr(_pDisplay, draw, GLX_WIDTH, (unsigned int*)&_iWidth);
         glXQueryDrawablePtr(_pDisplay, draw, GLX_HEIGHT, (unsigned int*)&_iHeight);
     }
 #endif
 
+    dbg_printf( "RenderTexture::Initialize(w=%d,h=%d): returning %s\n", _iWidth, _iHeight, (result ? "TRUE" : "FALSE") );
     return result;
 }
 
@@ -798,6 +909,8 @@ bool RenderTexture::Initialize(int width, int height,
 */ 
 bool RenderTexture::_Invalidate()
 {
+    dbg_printf( "RenderTexture::_Invalidate() called...\n" );
+    
     _iNumColorBits[0] = _iNumColorBits[1] = 
         _iNumColorBits[2] = _iNumColorBits[3] = 0;
     _iNumDepthBits = 0;
@@ -845,10 +958,12 @@ bool RenderTexture::_Invalidate()
             glXMakeCurrent(_pDisplay, _hPBuffer, 0);
         glXDestroyPbufferPtr(_pDisplay, _hPBuffer);
         _hPBuffer = 0;
+       dbg_printf( "RenderTexture::_Invalidate: glXDestroyPbufferPtr(_pDisplay, _hPBuffer); return true\n" );
         return true;
     }
 #endif
 
+    dbg_printf( "RenderTexture::_Invalidate: return false\n" );
     // [WVB] do we need to call _ReleaseBoundBuffers() too?
     return false;
 }
@@ -867,6 +982,8 @@ bool RenderTexture::_Invalidate()
 */ 
 bool RenderTexture::Reset(const char *strMode, ...)
 {
+   dbg_printf("RenderTexure:Reset(): with %s\n", strMode);
+   
     _iWidth = 0; _iHeight = 0; 
     _bIsTexture = false; _bIsDepthTexture = false,
     _bHasARBDepthTexture = true;
@@ -889,11 +1006,21 @@ bool RenderTexture::Reset(const char *strMode, ...)
     _pPoorDepthTexture = 0;
     _pixelFormatAttribs.clear();
     _pbufferAttribs.clear();
-
+    if (IsInitialized())
-    if (IsInitialized() && !_Invalidate())
     {
-        SG_LOG(SG_GL, SG_ALERT, "RenderTexture::Reset(): failed to invalidate.");
+      if (!_Invalidate())
+      {
+        dbg_printf( "RenderTexture::Reset(): failed to invalidate. return false\n");
         return false;
+      }
+      else
+      {
+        dbg_printf( "RenderTexture::Reset(): was Initialized, and now _Invalidate() ok.");
+      }
+    }
+    else
+    {
+      dbg_printf("RenderTexure:Reset(): previous NOT initialised!\n");
     }
     
     _iNumColorBits[0] = _iNumColorBits[1] = 
@@ -939,6 +1066,7 @@ bool RenderTexture::Reset(const char *strMode, ...)
 #else
     _pixelFormatAttribs.push_back(None);
 #endif
+    dbg_printf("RenderTexure:Reset(): returning true.\n");
     return true;
 }
 
@@ -1307,6 +1435,7 @@ void RenderTexture::_ParseModeString(const char *modeString,
                                      vector<int> &pfAttribs, 
                                      vector<int> &pbAttribs)
 {
+    dbg_printf("RenderTexture::_ParseModeString(%s). BGN vf=%d vp=%d\n", modeString, pfAttribs.size(), pbAttribs.size() );
     if (!modeString || strcmp(modeString, "") == 0)
         return;
 
@@ -1384,10 +1513,14 @@ void RenderTexture::_ParseModeString(const char *modeString,
 	    _iNumComponents += 3;
             continue;
         }
-		else if (kv.first == "rgb") 
+		else if (kv.first == "rgb")
+       {
             SG_LOG(SG_GL, SG_ALERT, 
                     "RenderTexture Warning: mistake in components definition "
                     "(rgb + " << _iNumComponents << ").");
+            dbg_printf("RenderTexture Warning 1: mistake in components definition "
+                    "(rgb + %d).\n", _iNumComponents );
+       }
         
         if (kv.first == "rgba" && (_iNumComponents == 0))
         {
@@ -1444,9 +1577,13 @@ void RenderTexture::_ParseModeString(const char *modeString,
             continue;
         }
 		else if (kv.first == "rgba") 
+      {
             SG_LOG(SG_GL, SG_ALERT, 
                     "RenderTexture Warning: mistake in components definition "
                     "(rgba + " << _iNumComponents << ").");
+            dbg_printf("RenderTexture Warning 2: mistake in components definition "
+                    "(rgb + %d).\n", _iNumComponents );
+      }
         
         if (kv.first == "r" && (_iNumComponents <= 1))
         {
@@ -1474,10 +1611,13 @@ void RenderTexture::_ParseModeString(const char *modeString,
             continue;
         }
 	else if (kv.first == "r") 
+   {
             SG_LOG(SG_GL, SG_ALERT, 
                     "RenderTexture Warning: mistake in components definition "
                     "(r + " << _iNumComponents << ").");
-
+            dbg_printf("RenderTexture Warning 3: mistake in components definition "
+                    "(rgb + %d).\n", _iNumComponents );
+   }
         if (kv.first == "rg" && (_iNumComponents <= 1))
         {
             if (kv.second.find("f") != kv.second.npos)
@@ -1515,9 +1655,13 @@ void RenderTexture::_ParseModeString(const char *modeString,
             continue;
         }
 		else if (kv.first == "rg") 
+      {
             SG_LOG(SG_GL, SG_ALERT, 
                     "RenderTexture Warning: mistake in components definition "
                     "(rg + " << _iNumComponents << ").");
+            dbg_printf("RenderTexture Warning 4: mistake in components definition "
+                    "(rgb + %d).\n", _iNumComponents );
+      }
 
         if (kv.first == "depth")
         {
@@ -1680,6 +1824,8 @@ void RenderTexture::_ParseModeString(const char *modeString,
         SG_LOG(SG_GL, SG_ALERT, 
                 "RenderTexture Error: Unknown pbuffer attribute: " <<
                 token.c_str());
+        dbg_printf("RenderTexture Error: Uknown pbuffer attribute: %s\n",
+            token.c_str() );
     }
 
     // Processing of some options must be last because of interactions.
@@ -1690,6 +1836,7 @@ void RenderTexture::_ParseModeString(const char *modeString,
         SG_LOG(SG_GL, SG_ALERT,
                 "RenderTexture Warning: Depth and Color texture targets "
                 "should match.");
+        dbg_printf( "RenderTexture Warning: Depth and Color texture targets should match.\n");
     }
 
     // Apply default bit format if none specified
@@ -1760,6 +1907,7 @@ void RenderTexture::_ParseModeString(const char *modeString,
         SG_LOG(SG_GL, SG_ALERT, "RenderTexture Warning: No support found for "
                 "render to depth texture.");
 #endif
+        dbg_printf("RenderTexture Warning: No support found for render to depth texture.\n");
         _bIsDepthTexture = false;
     }
 #endif
@@ -1878,6 +2026,8 @@ void RenderTexture::_ParseModeString(const char *modeString,
                             "RenderTexture Warning: Bad number of components "
                             "(r=1,rg=2,rgb=3,rgba=4): " <<
                             _iNumComponents);
+                    dbg_printf("RenderTexture Warning 1: Bad number of components (r=1,rg=2,rgb=3,rgba=4): %d\n",
+                            _iNumComponents);
                     break;
                 }
             }
@@ -1925,6 +2075,8 @@ void RenderTexture::_ParseModeString(const char *modeString,
                 SG_LOG(SG_GL, SG_ALERT, 
                         "RenderTexture Warning: Bad number of components "
                         "(r=1,rg=2,rgb=3,rgba=4): " << _iNumComponents);
+                dbg_printf("RenderTexture Warning 2: Bad number of components (r=1,rg=2,rgb=3,rgba=4): %d\n",
+                            _iNumComponents);
                 break;
             }
         }
@@ -2023,9 +2175,9 @@ void RenderTexture::_ParseModeString(const char *modeString,
         }
 #elif defined(DEBUG) || defined(_DEBUG)
         SG_LOG(SG_GL, SG_ALERT, 
-                "RenderTexture Error: Render to Texture not supported in "
+                "RenderTexture Error: Render to Texture not supported in Linux or MacOS");
-                "Linux or MacOS\ n");
 #endif  
+      dbg_printf( "RenderTexture Error 1: Render to Texture not supported in Linux or MacOS\n");
     }
         
     if (_bIsDepthTexture && (RT_RENDER_TO_TEXTURE == _eUpdateMode))
@@ -2052,7 +2204,10 @@ void RenderTexture::_ParseModeString(const char *modeString,
         SG_LOG(SG_GL, SG_INFO, "RenderTexture Error: Render to Texture not supported in "
                "Linux or MacOS");
 #endif 
+      dbg_printf( "RenderTexture Error 2: Render to Texture not supported in Linux or MacOS\n");
     }
+    dbg_printf("RenderTexture::_ParseModeString(%s). END vf=%d vp=%d\n", modeString, pfAttribs.size(), pbAttribs.size() );
+
 }
 
 //---------------------------------------------------------------------------
@@ -2122,6 +2277,7 @@ vector<int> RenderTexture::_ParseBitVector(string bitVector)
 */ 
 bool RenderTexture::_VerifyExtensions()
 {
+   dbg_printf("RenderTexture::_VerifyExtensions() called...\n");
 #ifdef _WIN32
 	// a second call to _VerifyExtensions will allways return true, causing a crash
 	// if the extension is not supported
@@ -2205,15 +2361,42 @@ bool RenderTexture::_VerifyExtensions()
 #else
     Display* dpy = glXGetCurrentDisplay();
     int minor = 0, major = 0;
-    if (!glXQueryVersion(dpy, &major, &minor))
+    if (!dpy) {
+        dbg_printf("_VerifyExtensions: glXGetCurrentDisplay() returned NULL! returning false\n");
         return false;
+    }
+    if (!glXQueryVersion(dpy, &major, &minor)) 
+    {
+        dbg_printf("_VerifyExtensions: glXQueryVersion(dpy, &major, &minor) FAILED! returning false\n");
+        return false;
+    }
+    else
+    {
+        dbg_printf("_VerifyExtensions: glXQueryVersion(dpy, major=%d, minor=%d)\n", major, minor);
+    }
 
     int screen = DefaultScreen(dpy);
     const char* extString = glXQueryExtensionsString(dpy, screen);
+    dbg_printf("_VerifyExtensions: glXQueryExtensionsString(dpy, screen) returned -\n[%s]\n",
+      (extString ? extString : "<NULL>") );
     if (!SGSearchExtensionsString(extString, "GLX_SGIX_fbconfig") ||
         !SGSearchExtensionsString(extString, "GLX_SGIX_pbuffer"))
-        return false;
+    {
-
+        dbg_printf("_VerifyExtensions: glXQueryExtensionsString(dpy,screen) does NOT contain GLX_SGIX_fbconfig or GLX_SGIX_pbuffer!\n" );
+        const char * extClient = glXGetClientString( dpy, GLX_EXTENSIONS );
+        if (!extClient ||
+            !SGSearchExtensionsString(extClient, "GLX_SGIX_fbconfig") ||
+            !SGSearchExtensionsString(extClient, "GLX_SGIX_pbuffer"))
+        {
+            dbg_printf("_VerifyExtensions: AND glXGetClientString(dpy,GLX_EXTENSIONS) also! returning false\n" );
+            return false;
+        }
+        else
+        {
+            dbg_printf("_VerifyExtensions: BUT glXGetClientString(dpy,GLX_EXTENSIONS) returned \n[%s]\n", extClient );
+            dbg_printf("Since this DOES contain fbconfig and pbuffer, continuing...\n");
+        }
+    }
     // First try the glX version 1.3 functions.
     glXChooseFBConfigPtr = (glXChooseFBConfigProc)SGLookupFunction("glXChooseFBConfig");
     glXCreatePbufferPtr = (glXCreatePbufferProc)SGLookupFunction("glXCreatePbuffer");
@@ -2228,10 +2411,22 @@ bool RenderTexture::_VerifyExtensions()
         glXGetVisualFromFBConfigPtr &&
         glXCreateContextPtr &&
         glXDestroyPbufferPtr &&
-        glXQueryDrawablePtr)
+        glXQueryDrawablePtr) {
+        dbg_printf("_VerifyExtensions: setting glXVersion1_3Present TRUE\n" );
         glXVersion1_3Present = true;
+    }
     else
     {
+        dbg_printf("_VerifyExtensions: setting glXVersion1_3Present FALSE\n Reason: " );
+        if ( !((1 <= major && 3 <= minor) || 2 <= major) ) { dbg_printf( "Version wrong %d.%d ", major, minor ); }
+        if ( !glXChooseFBConfigPtr ) { dbg_printf( "missing glXChooseFBConfigPtr " ); }
+        if ( !glXCreatePbufferPtr ) { dbg_printf( "missing glXCreatePbufferPtr " ); }
+        if ( !glXGetVisualFromFBConfigPtr ) { dbg_printf( "missing glXGetVisualFromFBConfigPtr " ); }
+        if ( !glXCreateContextPtr ) { dbg_printf( "missing glXCreateContextPtr " ); }
+        if ( !glXDestroyPbufferPtr ) { dbg_printf( "missing glXDestroyPbufferPtr " ); }
+        if ( !glXQueryDrawablePtr ) { dbg_printf( "missing glXQueryDrawablePtr " ); }
+        dbg_printf("\n");
+        
         glXChooseFBConfigPtr = (glXChooseFBConfigProc)SGLookupFunction("glXChooseFBConfigSGIX");
         glXCreateGLXPbufferPtr = (glXCreateGLXPbufferProc)SGLookupFunction("glXCreateGLXPbufferSGIX");
         glXGetVisualFromFBConfigPtr =  (glXGetVisualFromFBConfigProc)SGLookupFunction("glXGetVisualFromFBConfigSGIX");
@@ -2239,14 +2434,25 @@ bool RenderTexture::_VerifyExtensions()
         glXDestroyPbufferPtr = (glXDestroyPbufferProc)SGLookupFunction("glXDestroyGLXPbufferSGIX");
         glXQueryGLXPbufferSGIXPtr = (glXQueryGLXPbufferSGIXProc)SGLookupFunction("glXQueryGLXPbufferSGIX");
 
-
         if (!glXChooseFBConfigPtr ||
             !glXCreateGLXPbufferPtr ||
             !glXGetVisualFromFBConfigPtr ||
             !glXCreateContextWithConfigPtr ||
             !glXDestroyPbufferPtr ||
             !glXQueryGLXPbufferSGIXPtr)
-            return false;
+            {
+               dbg_printf("_VerifyExtensions: some pointer is NULL! return false\n" );
+               if ( !glXCreateGLXPbufferPtr ) {
+                  dbg_printf("RenderTexture::Initialize: ERROR glXCreateGLXPbufferPtr = NULL!\n");
+               } else if ( !glXCreateContextWithConfigPtr ) {
+                  dbg_printf("RenderTexture::Initialize: ERROR glXCreateContextWithConfigPtr = NULL!\n");
+               } else if ( !glXVersion1_3Present && !glXQueryGLXPbufferSGIXPtr ) {
+                  dbg_printf("RenderTexture::Initialize: ERROR glXQueryGLXPbufferSGIXPtr = NULL!\n");
+               }
+               return false;
+            } else {
+               dbg_printf("_VerifyExtensions: appear to have all 'procs' glXCreateGLXPbufferPtr=[%p]\n", glXCreateGLXPbufferPtr );
+            }
     }
 
     if (_bIsDepthTexture && !GL_ARB_depth_texture)
@@ -2266,6 +2472,7 @@ bool RenderTexture::_VerifyExtensions()
     }
 #endif
   
+    dbg_printf("RenderTexture::_VerifyExtensions: return true.\n");
     return true;
 }
 
@@ -2279,7 +2486,9 @@ bool RenderTexture::_VerifyExtensions()
 */ 
 bool RenderTexture::_InitializeTextures()
 {
+   dbg_printf( "RenderTexture::_InitializeTextures() called\n" );
     // Determine the appropriate texture formats and filtering modes.
+    
     if (_bIsTexture || _bIsDepthTexture)
     {
         if (_bRectangle && GL_NV_texture_rectangle)
@@ -2315,6 +2524,7 @@ bool RenderTexture::_InitializeTextures()
                     SG_LOG(SG_GL, SG_ALERT, 
                         "RenderTexture Error: mipmapped float textures not "
                         "supported.");
+                    dbg_printf( "RenderTexture Error: mipmapped float textures not supported. return false\n");
                     return false;
                 }
             
@@ -2378,6 +2588,8 @@ bool RenderTexture::_InitializeTextures()
                     SG_LOG(SG_GL, SG_INFO, "RenderTexture Error: "
                            "Invalid number of components: " <<
                            _iNumComponents);
+                    dbg_printf( "RenderTexture Error: Invalid number of components: %d - return false\n",
+                        _iNumComponents);
                     return false;
                 }
             }
@@ -2436,6 +2648,7 @@ bool RenderTexture::_InitializeTextures()
         }
     }
 
+    dbg_printf( "RenderTexture::_InitializeTextures() returning true\n" );
     return true;
 }
 
@@ -2567,7 +2780,7 @@ bool RenderTexture::_ReleaseBoundBuffers()
 * @fn RenderTexture::_MakeCurrent()
 * @brief Makes the RenderTexture's context current
 */ 
-
+static GLXContext last_hGLContext = 0;
 bool RenderTexture::_MakeCurrent() 
 {
 #ifdef _WIN32
@@ -2588,10 +2801,15 @@ bool RenderTexture::_MakeCurrent()
 #else
     if (false == glXMakeCurrent(_pDisplay, _hPBuffer, _hGLContext)) 
     {
+        dbg_printf( "_MakeCurrent: glXMakeCurrent FAILED! returning false\n");
         return false;
     }
 #endif
 
+    if ( last_hGLContext != _hGLContext ) {
+      last_hGLContext = _hGLContext;
+      dbg_printf( "_MakeCurrent: glXMakeCurrent set to [%p] SUCCESS! returning true\n", _hGLContext );
+    }
     return true;
 }
 
@@ -2657,6 +2875,7 @@ RenderTexture::RenderTexture(int width, int height,
     SG_LOG(SG_GL, SG_ALERT, 
             "RenderTexture Warning: Deprecated Contructor interface used.");
 #endif
+    dbg_printf("RenderTexture Warning: Deprecated Contructor interface used.\n");
     
     _iNumColorBits[0] = _iNumColorBits[1] = 
         _iNumColorBits[2] = _iNumColorBits[3] = 0;
@@ -2694,6 +2913,7 @@ bool RenderTexture::Initialize(bool         bShare       /* = true */,
     SG_LOG(SG_GL, SG_ALERT, 
             "RenderTexture Warning: Deprecated Initialize() interface used.");
 #endif   
+    dbg_printf("RenderTexture Warning: Deprecated Initialize() interface used.\n");
 
     // create a mode string.
     string mode = "";
@@ -2800,14 +3020,195 @@ bool RenderTexture::Reset(int iWidth, int iHeight)
 {
     SG_LOG(SG_GL, SG_ALERT, 
             "RenderTexture Warning: Deprecated Reset() interface used.");
+            
+    dbg_printf("RenderTexture Warning: Deprecated Reset(x,y) interface used.\n");
 
     if (!_Invalidate())
     {
         SG_LOG(SG_GL, SG_ALERT, "RenderTexture::Reset(): failed to invalidate.");
+        dbg_printf( "RenderTexture::Reset(x,y): failed to invalidate. returning false\n");
         return false;
     }
     _iWidth     = iWidth;
     _iHeight    = iHeight;
     
+    dbg_printf( "RenderTexture::Reset(x,y): succeeded. returning true\n");
     return true;
 }
+
+#ifdef _DEBUG
+/* just some DEBUG ONLY code, to show the 'attributes' */
+
+typedef struct tagPXATTS {
+   int attr;
+   const char * name;
+   const char * desc;
+   int def;
+}PXATTS, * PPXATTS;
+
+static PXATTS pxAtts[] = {
+   { GLX_FBCONFIG_ID, "GLX_FBCONFIG_ID",
+     "followed by a valid XID that indicates the desired GLX frame buffer configuration. "
+     "When a GLX_FBCONFIG_ID is specified, all attributes are ignored. The default value is GLX_DONT_CARE.",
+     GLX_DONT_CARE },
+   { GLX_BUFFER_SIZE, "GLX_BUFFER_SIZE",
+   "Must be followed by a nonnegative integer that indicates the desired color index buffer size."
+   "The smallest index buffer of at least the specified size is preferred. This attribute is ignored if GLX_COLOR_INDEX_BIT is not set "
+   "in GLX_RENDER_TYPE. The default value is 0.",
+    0 },
+   { GLX_LEVEL, "GLX_LEVEL",
+   "Must be followed by an integer buffer-level specification. This specification is honored exactly."
+   "Buffer level 0 corresponds to the default frame buffer of the display. "
+   "Buffer level 1 is the first overlay frame buffer, level two the second overlay frame buffer, and so on."
+   "Negative buffer levels correspond to underlay frame buffers. The default value is 0.",
+    0 },
+   { GLX_DOUBLEBUFFER, "GLX_DOUBLEBUFFER",
+   "Must be followed by True or False. If True is specified, then only double-buffered frame buffer configurations are considered;"
+   "if False is specified, then only single-buffered frame buffer configurations are considered. The default value is GLX_DONT_CARE.",
+    GLX_DONT_CARE },
+   { GLX_STEREO, "GLX_STEREO",
+   "Must be followed by True or False. If True is specified, then only stereo frame buffer configurations are considered;"
+   " if False is specified, then only monoscopic frame buffer configurations are considered. The default value is False.",
+   False },
+   { GLX_AUX_BUFFERS, "GLX_AUX_BUFFERS",
+   "Must be followed by a nonnegative integer that indicates the desired number of auxiliary buffers."
+   " Configurations with the  smallest number of auxiliary buffers that meet or exceed the specified number are preferred."
+   " The default value is 0.",
+   0 },
+   { GLX_RED_SIZE, "GLX_RED_SIZE",
+   "must be followed by a nonnegative minimum size",
+   0 },
+   { GLX_GREEN_SIZE, "GLX_GREEN_SIZE",
+   "must be followed by a nonnegative minimum size",
+   0 },
+   { GLX_BLUE_SIZE, "GLX_BLUE_SIZE",
+   "must be followed by a nonnegative minimum size",
+   0 },
+   { GLX_ALPHA_SIZE, "GLX_ALPHA_SIZE",
+   "Each attribute, if present, must be followed by a nonnegative minimum size specification or GLX_DONT_CARE."
+   " The largest available total RGBA color buffer size (sum of GLX_RED_SIZE, GLX_GREEN_SIZE, GLX_BLUE_SIZE, and GLX_ALPHA_SIZE) "
+   " of at least the minimum size specified for each color component is preferred. If the requested number of bits for a color "
+   " component is 0 or GLX_DONT_CARE, it is not considered. The default value for each color component is 0.",
+   0 },
+   { GLX_DEPTH_SIZE, "GLX_DEPTH_SIZE",
+   "Must be followed by a nonnegative minimum size specification. If this value is zero, "
+   "frame buffer configurations with no depth buffer are preferred."
+   "Otherwise, the largest available depth buffer of at least the minimum size is preferred. The default value is 0.",
+   0 },
+   { GLX_STENCIL_SIZE, "GLX_STENCIL_SIZE",
+   "Must be followed by a nonnegative integer that indicates the desired number of stencil bitplanes."
+   "The smallest stencil buffer of at least the specified size is preferred. If the desired value is zero,"
+   " frame buffer configurations with no stencil buffer are preferred. The default value is 0.",
+   0 },
+   { GLX_ACCUM_RED_SIZE, "GLX_ACCUM_RED_SIZE",
+   "Must be followed by a nonnegative minimum size specification. If this value is zero, "
+   " frame buffer configurations with no red accumulation buffer are preferred."
+   " Otherwise, the largest possible red accumulation buffer of at least the minimum size is preferred. The default value is 0.",
+   0 },
+   { GLX_ACCUM_GREEN_SIZE, "GLX_ACCUM_GREEN_SIZE",
+   "Must be followed by a nonnegative minimum size specification. If this value is zero, "
+   "frame buffer configurations with no green accumulation buffer are preferred. "
+   "Otherwise, the largest possible green accumulation buffer of at least the minimum size is preferred. The default value is 0.",
+   0 },
+   { GLX_ACCUM_BLUE_SIZE, "GLX_ACCUM_BLUE_SIZE",
+   "Must be followed by a nonnegative minimum size specification. If this value is zero, "
+   "frame buffer configurations with no blue accumulation buffer are preferred. "
+   "Otherwise, the largest possible blue accumulation buffer of at least the minimum size is preferred. The default value is 0.",
+   0 },
+   { GLX_ACCUM_ALPHA_SIZE, "GLX_ACCUM_ALPHA_SIZE",
+   "Must be followed by a nonnegative minimum size specification. If this value is zero, "
+   "frame buffer configurations with no alpha accumulation buffer are preferred. "
+   "Otherwise, the largest possible alpha accumulation buffer of at least the minimum size is preferred. The default value is 0.",
+   0 },
+   { GLX_RENDER_TYPE, "GLX_RENDER_TYPE",
+   "Must be followed by a mask indicating which OpenGL rendering modes the frame buffer configuration must support. "
+   "Valid bits are GLX_RGBA_BIT and GLX_COLOR_INDEX_BIT. If the mask is set to GLX_RGBA_BIT | GLX_COLOR_INDEX_BIT, "
+   "then only frame buffer configurations that can be bound to both RGBA contexts and color index contexts will be considered. "
+   "The default value is GLX_RGBA_BIT.",
+    GLX_RGBA_BIT },
+   { GLX_DRAWABLE_TYPE, "GLX_DRAWABLE_TYPE",
+   "Must be followed by a mask indicating which GLX drawable types the frame buffer configuration must support. "
+   "Valid bits are GLX_WINDOW_BIT, GLX_PIXMAP_BIT, and GLX_PBUFFER_BIT. For example, if mask is set to "
+   "GLX_WINDOW_BIT | GLX_PIXMAP_BIT,  only frame buffer configurations that support both windows and GLX pixmaps "
+   "will be considered. The default value is GLX_WINDOW_BIT.", 
+   GLX_WINDOW_BIT },
+   { GLX_X_RENDERABLE, "GLX_X_RENDERABLE",
+   "Must be followed by True or False. If True is specified, then only frame buffer configurations that "
+   "have associated X visuals (and can be used to render to Windows and/or GLX pixmaps) will be considered. "
+   "The default value is GLX_DONT_CARE. ",
+   GLX_DONT_CARE },
+   { GLX_X_VISUAL_TYPE, "GLX_X_VISUAL_TYPE",
+   "Must be followed by one of GLX_TRUE_COLOR, GLX_DIRECT_COLOR, GLX_PSEUDO_COLOR, GLX_STATIC_COLOR, "
+   "GLX_GRAY_SCALE, or GLX_STATIC_GRAY, indicating the desired X visual type. "
+   "Not all frame buffer configurations have an associated X visual. If GLX_DRAWABLE_TYPE is specified in attrib_list and the "
+   "mask that follows does not have GLX_WINDOW_BIT set, then this value is ignored. It is also ignored if "
+   "GLX_X_RENDERABLE is specified as False. RGBA rendering may be supported for visuals of type "
+   "GLX_TRUE_COLOR, GLX_DIRECT_COLOR, GLX_PSEUDO_COLOR, or GLX_STATIC_COLOR, "
+   "but color index rendering is only supported for visuals of type GLX_PSEUDO_COLOR or GLX_STATIC_COLOR "
+   "(i.e., single-channel visuals). The tokens GLX_GRAY_SCALE and GLX_STATIC_GRAY will "
+   "not match current OpenGL enabled visuals, but are included for future use."
+   "The default value for GLX_X_VISUAL_TYPE is GLX_DONT_CARE.",
+   GLX_DONT_CARE },
+   { GLX_CONFIG_CAVEAT, "GLX_CONFIG_CAVEAT",
+   "Must be followed by one of GLX_NONE, GLX_SLOW_CONFIG, GLX_NON_CONFORMANT_CONFIG. "
+   "If GLX_NONE is specified, then only frame buffer configurations with "
+   "no caveats will be considered; if GLX_SLOW_CONFIG is specified, then only slow frame buffer configurations will be considered; if "
+   "GLX_NON_CONFORMANT_CONFIG is specified, then only nonconformant frame buffer configurations will be considered."
+   "The default value is GLX_DONT_CARE.",
+   GLX_DONT_CARE },
+   { GLX_TRANSPARENT_TYPE, "GLX_TRANSPARENT_TYPE",
+   "Must be followed by one of GLX_NONE, GLX_TRANSPARENT_RGB, GLX_TRANSPARENT_INDEX. "
+   "If GLX_NONE is specified, then only opaque frame buffer configurations will be considered; "
+   "if GLX_TRANSPARENT_RGB is specified, then only transparent frame buffer configurations that support RGBA rendering will be considered; "
+   "if GLX_TRANSPARENT_INDEX is specified, then only transparent frame buffer configurations that support color index rendering will be considered."
+   "The default value is GLX_NONE.",
+    GLX_NONE },
+   { GLX_TRANSPARENT_INDEX_VALUE, "GLX_TRANSPARENT_INDEX_VALUE",
+   "Must be followed by an integer value indicating the transparent index value; the value must be between 0 and the maximum "
+   "frame buffer value for indices. Only frame buffer configurations that use the "
+   "specified transparent index value will be considered. The default value is GLX_DONT_CARE. "
+   "This attribute is ignored unless GLX_TRANSPARENT_TYPE is included in attrib_list and specified as GLX_TRANSPARENT_INDEX.",
+   GLX_DONT_CARE },
+   { GLX_TRANSPARENT_RED_VALUE, "GLX_TRANSPARENT_RED_VALUE",
+   "Must be followed by an integer value indicating the transparent red value; the value must be between 0 and the maximum "
+   "frame buffer value for red. Only frame buffer configurations that use the specified transparent red value will be considered. "
+   "The default value is GLX_DONT_CARE. This attribute is ignored unless GLX_TRANSPARENT_TYPE is included in "
+   "attrib_list and specified as GLX_TRANSPARENT_RGB.",
+   GLX_DONT_CARE },
+   { GLX_TRANSPARENT_GREEN_VALUE, "GLX_TRANSPARENT_GREEN_VALUE",
+   "Must be followed by an integer value indicating the transparent green value; the value must be between 0 and the maximum "
+   "frame buffer value for green. Only frame buffer configurations that use the specified transparent green value will be considered."
+   "The default value is GLX_DONT_CARE. This attribute is "
+   "ignored unless GLX_TRANSPARENT_TYPE is included in attrib_list and specified as GLX_TRANSPARENT_RGB.",
+   GLX_DONT_CARE },
+   { GLX_TRANSPARENT_BLUE_VALUE, "GLX_TRANSPARENT_BLUE_VALUE",
+   "Must be followed by an integer value indicating the transparent blue value; the value must be between 0 and the maximum "
+   "frame buffer value for blue. Only frame buffer configurations that use the specified transparent blue value will be considered."
+   "The default value is GLX_DONT_CARE. This attribute is ignored unless GLX_TRANSPARENT_TYPE is included in "
+   "attrib_list and specified as GLX_TRANSPARENT_RGB. ",
+   GLX_DONT_CARE },
+   { GLX_TRANSPARENT_ALPHA_VALUE, "GLX_TRANSPARENT_ALPHA_VALUE",
+   "Must be followed by an integer value indicating the transparent alpha value; the value must be between 0 and the maximum "
+   "frame buffer value for alpha. Only frame buffer configurations that use the "
+   "specified transparent alpha value will be considered. The default value is GLX_DONT_CARE.",
+   GLX_DONT_CARE },
+   { 0, NULL, NULL, -1 }
+};
+
+const char * get_attr_name( int val, int * pdef )
+{
+   PPXATTS pat = &pxAtts[0];
+   while( pat->name )
+   {
+      if ( pat->attr == val ) {
+         *pdef = pat->def;
+         return pat->name;
+      }
+      pat++;
+   }
+   *pdef = -1;
+   return "VALUE NOT IN LIST";
+}
+
+#endif
+// eof - RenderTexture.cpp

simgear/screen/TestRenderTexture.cpp

@@ -17,6 +17,7 @@
 #  include <GL/glut.h>
 #endif
 
+#include <simgear/debug/logstream.hxx>
 #include <simgear/screen/extensions.hxx>
 #include <simgear/screen/RenderTexture.h>
 
@@ -24,6 +25,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#define dbg_printf
+//#define dbg_printf printf
+
 void Reshape(int w, int h);
 
 GLuint      iTextureProgram     = 0;
@@ -92,6 +96,10 @@ RenderTexture* CreateRenderTexture(const char *initstr)
     {
         fprintf(stderr, "RenderTexture Initialization failed!\n");
     }
+    else
+    {
+        printf("RenderTexture Initialization done.\n");
+    }
 
     // for shadow mapping we still have to bind it and set the correct 
     // texture parameters using the SGI_shadow or ARB_shadow extension
@@ -203,7 +211,8 @@ void Keyboard(unsigned char key, int x, int y)
         bShowDepthTexture = !bShowDepthTexture;
         break;
     case 13:
-        ++g_currentString%=g_numModeTestStrings;
+        ++g_currentString %= g_numModeTestStrings;
+        dbg_printf("Changed to #%d = [%s]\n", g_currentString, g_modeTestStrings[g_currentString]);
         DestroyRenderTexture(rt);
         rt = CreateRenderTexture(g_modeTestStrings[g_currentString]);
         break;
@@ -338,11 +347,18 @@ int main(int argc, char *argv[])
 
     rt = CreateRenderTexture(g_modeTestStrings[g_currentString]);
 
+    if (rt->IsInitialized() && rt->BeginCapture()) {
+      rt->EndCapture();
+      dbg_printf("Torus should also be shown.\n");
+    } else {
+      dbg_printf("No Torus init = %s\n", (rt->IsInitialized() ? "ok" : "NOT INITIALISED"));
+    }
+    
     printf("Press Enter to change RenderTexture parameters.\n"
            "Press 'r' to toggle the rectangle's motion.\n"
            "Press 't' to toggle the torus' motion.\n");
-    
 
+    
     glutMainLoop();
     return 0;
 }