From: ehofman Date: Thu, 2 Jul 2009 14:01:38 +0000 (+0000) Subject: Geoff McLane: X-Git-Url: https://git.mxchange.org/?a=commitdiff_plain;h=eb06a90109f9a69a7cf0d2af87714b8147acc024;p=simgear.git Geoff McLane: add a bunch of debugging code to find a persistant bug for Atlas/Map and fix them one by one. --- diff --git a/simgear/screen/RenderTexture.cpp b/simgear/screen/RenderTexture.cpp index 0e5ba9ef..aaee155a 100644 --- a/simgear/screen/RenderTexture.cpp +++ b/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()) - return false; + if (!_VerifyExtensions()) { + 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[] = { - GLX_PBUFFER_WIDTH, _iWidth, - GLX_PBUFFER_HEIGHT, _iHeight, - GLX_LARGEST_PBUFFER, False, - None - }; + dbg_printf("RenderTexture::Initialize: glXVersion1_3Present = TRUE\n"); for (int i=0;i &pfAttribs, vector &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 " - "Linux or MacOS\ n"); + "RenderTexture Error: Render to Texture not supported in Linux or MacOS"); #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 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 : "") ); 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 diff --git a/simgear/screen/TestRenderTexture.cpp b/simgear/screen/TestRenderTexture.cpp index 2aa2e09f..1b7e748c 100644 --- a/simgear/screen/TestRenderTexture.cpp +++ b/simgear/screen/TestRenderTexture.cpp @@ -17,6 +17,7 @@ # include #endif +#include #include #include @@ -24,6 +25,9 @@ #include #include +#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; }