Hi Alexander,
I didn't see the crash (I work under Linux) but a code review of the
RenderSurface constructor did reveal that it was lacking a number of
member variable initializers. I have added these back including the
missing _realized = false; line. These changes are now checked in.
I've also attached the changed src/osgPlugins/cfgRenderSurface.cpp.
Could you test and let me know if it fixes things.
FYI, you don't need to svn access to check svn - you can do it all on
the website - just go to Browse Source link from the front page. Our
svn server also support https, there is a chance this might work for
you.
Robert.
On Tue, Jan 27, 2009 at 11:53 PM, Pecoraro, Alexander N
<[email protected]> wrote:
> I noticed a bug in the 2.6.0 version of the API with the viewer config file
> reader plugin. I can't access the latest developer source code right now so
> I can't verify that the bug still exists in the 2.7 version of the API, but
> I've attached the config file that I used to reproduce the problem. The
> problem is that the plugin causes a segfault when it reads that
> configuration file because the _realized member variable of the
> RenderSurface class defined in src/osgPlugins/cfg/RenderSurface.cpp is never
> given an initial value. Interestingly enough this problem does not occur on
> my Linux box, which is running Redhat Enterprise Client 5. However, on my
> Windows box with Visual Studio 2005 Professional the _realized variable is
> auto-initialized to true which ends up causing the segfault to occur. I'm
> guessing, but haven't verified, that the reason it works on my Linux box is
> because the GCC compiler auto-initializes the variable to false which
> prevents the bug from occurring.
>
>
>
> Here is how I ran the osgviewer to get it to crash:
>
>
>
> osgviewer -c oneWindow.cfg <name of osg file>
>
>
>
> I also found that once I went into the ReaderSurface's constructor and added
> "_realized = false;" to it then the bug went away.
>
>
>
> Alex
>
> _______________________________________________
> osg-users mailing list
> [email protected]
> http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org
>
>
/* -*-c++-*- Producer - Copyright (C) 2001-2004 Don Burns
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#include <stdlib.h>
#include <string.h>
#include "RenderSurface.h"
using namespace std;
using namespace osgProducer;
const std::string RenderSurface::defaultWindowName = std::string(" *** Producer::RenderSurface *** ");
const unsigned int RenderSurface::UnknownDimension = 0xFFFFFFFF;
const unsigned int RenderSurface::UnknownAmount = 0xFFFFFFFF;
unsigned int RenderSurface::_numScreens = RenderSurface::UnknownAmount;
bool RenderSurface::_shareAllGLContexts = false;
//GLContext RenderSurface::_globallySharedGLContext = 0L;
void RenderSurface::shareAllGLContexts(bool flag)
{
_shareAllGLContexts = flag;
}
bool RenderSurface::allGLContextsAreShared()
{
return _shareAllGLContexts;
}
const std::string &RenderSurface::getDefaultWindowName()
{
return defaultWindowName;
}
RenderSurface::RenderSurface( void )
{
_drawableType = DrawableType_Window;
_hostname = "";
_displayNum = 0;
// _screen = 0;
_mayFullScreen = true;
_isFullScreen = true;
// This used to be #ifdefed for the X11 implementation
// but the code is pure C++ and should compile anywhere
// The _dislayNum variable is used by CGL as well.
char *envptr = getenv( "DISPLAY" );
if( envptr != NULL && *envptr != 0 )
{
size_t p0 = 0;
size_t p1 = string(envptr).find(":", p0);
_hostname = string(envptr).substr(p0,p1);
p0 = p1+1;
p1 = string(envptr).find(".", p0);
if( p1 > 0 )
{
_displayNum = atoi((string(envptr).substr(p0,p1)).c_str());
p0 = p1+1;
p1 = string(envptr).length() - p0;
if( p1 > 0 )
_screen = atoi((string(envptr).substr(p0,p1)).c_str());
}
else if( p1 < string(envptr).length() )
{
p1 = string(envptr).length();
_displayNum = atoi((string(envptr).substr(p0,p1)).c_str());
_screen = 0;
}
}
_windowLeft = 0;
_windowRight = 1;
_windowBottom = 0;
_windowTop = 1;
_windowX = 0;
_windowY = 0;
_windowWidth = UnknownDimension;
_windowHeight = UnknownDimension;
_screenWidth = UnknownDimension;
_screenHeight = UnknownDimension;
_customFullScreenOriginX = 0;
_customFullScreenOriginY = 0;
_customFullScreenWidth = UnknownDimension;
_customFullScreenHeight = UnknownDimension;
_useCustomFullScreen = false;
_readDrawableRenderSurface = 0L;
_windowName = defaultWindowName;
_realized = false;
_useConfigEventThread = true;
_overrideRedirectFlag = false;
char *override_envptr = getenv( "PRODUCER_OVERRIDE_REDIRECT" );
if( override_envptr != NULL && *override_envptr != 0 )
{
if (strcmp(override_envptr,"true")==0 || strcmp(override_envptr,"True")==0 || strcmp(override_envptr,"TRUE")==0)
{
_overrideRedirectFlag = true;
}
else
{
_overrideRedirectFlag = false;
}
}
_decorations = true;
_useCursorFlag = true;
_useDefaultEsc = true;
_checkOwnEvents = true;
_inputRectangle.set( -1.0, 1.0, -1.0, 1.0 );
_bindInputRectangleToWindowSize = false;
_rtt_mode = RenderToTextureMode_None;
//_rtt_mode = RenderToRGBTexture;
_rtt_target = Texture2D;
_rtt_options = RenderToTextureOptions_Default;
_rtt_mipmap = 0;
_rtt_face = PositiveX;
_rtt_dirty_mipmap = true;
_rtt_dirty_face = true;
#ifdef _WIN32_IMPLEMENTATION
_ownWindow = true;
_ownVisualChooser = true;
_ownVisualInfo = true;
_hinstance = NULL;
_glcontext = NULL;
_mx = 0;
_my = 0;
_mbutton = 0;
#endif
}
RenderSurface::~RenderSurface( void )
{
#if 0
cancel();
_fini();
while (isRunning())
{
//std::cout << "waiting for RenderSurface to cancel"<<std::endl;
OpenThreads::Thread::YieldCurrentThread();
}
delete _threadReady;
#endif
}
void RenderSurface::setDrawableType( RenderSurface::DrawableType drawableType )
{
if( _realized )
{
std::cerr << "Warning: RenderSurface::setDrawableType() "
"has no effect after RenderSurface has been realized\n";
return;
}
_drawableType = drawableType;
}
RenderSurface::DrawableType RenderSurface::getDrawableType()
{
return _drawableType;
}
void RenderSurface::setReadDrawable( osgProducer::RenderSurface *rs )
{
_readDrawableRenderSurface = rs;
#if 0
if( _realized )
makeCurrent();
#endif
}
#if 0
void RenderSurface::setParentWindow( Window parent )
{
_parent = parent;
}
Producer::Window RenderSurface::getParentWindow( void ) const
{
return _parent;
}
#endif
void RenderSurface::setWindowName( const std::string &name )
{
// _setWindowName( name );
_windowName = name;
}
const std::string &RenderSurface::getWindowName( void ) const
{
return _windowName;
}
void RenderSurface::setHostName( const std::string &name )
{
_hostname = name;
}
const std::string &RenderSurface::getHostName( void ) const
{
return _hostname;
}
#if 0
void RenderSurface::setDisplay( Display *dpy )
{
_dpy = dpy;
}
Producer::Display *RenderSurface::getDisplay()
{
#ifdef WIN32
return &_hdc;
#else
return _dpy;
#endif
}
const Producer::Display *RenderSurface::getDisplay() const
{
#ifdef WIN32
return &_hdc;
#else
return _dpy;
#endif
}
#endif
void RenderSurface::setDisplayNum( int num )
{
_displayNum = num;
}
int RenderSurface::getDisplayNum( void ) const
{
return _displayNum;
}
void RenderSurface::setScreenNum( int num )
{
_screen = num;
}
int RenderSurface::getScreenNum( void ) const
{
return _screen;
}
void RenderSurface::setWindowRectangle( int x, int y, unsigned int width, unsigned int height, bool resize)
{
if( _useCustomFullScreen )
{
_windowX = x + _customFullScreenOriginX;
_windowY = y + _customFullScreenOriginY;
}
else
{
_windowX = x;
_windowY = y;
}
_windowWidth = width;
_windowHeight = height;
#ifdef _OSX_AGL_IMPLEMENTATION
fullScreen(false); // STH: this may break other implementations, but it is necessary for OSX
#else
_isFullScreen = false;
#endif
#if 0
if( _realized && resize )
_resizeWindow();
else
#endif
if( _bindInputRectangleToWindowSize == true )
_inputRectangle.set( 0.0, _windowWidth, 0.0, _windowHeight );
}
void RenderSurface::getWindowRectangle( int &x, int &y, unsigned int &width, unsigned int &height ) const
{
if( _isFullScreen )
{
x = 0;
y = 0;
if( _useCustomFullScreen == true )
{
width = _customFullScreenWidth;
height = _customFullScreenHeight;
}
else
{
width = _screenWidth;
height = _screenHeight;
}
}
else
{
x = _windowX;
y = _windowY;
width = _windowWidth;
height = _windowHeight;
}
}
void RenderSurface::useDefaultFullScreenRectangle()
{
_useCustomFullScreen = false;
}
void RenderSurface::setCustomFullScreenRectangle( int x, int y, unsigned int width, unsigned int height )
{
_customFullScreenOriginX = x;
_customFullScreenOriginY = y;
_customFullScreenWidth = width;
_customFullScreenHeight = height;
_useCustomFullScreen = true;
_windowX += _customFullScreenOriginX;
_windowY += _customFullScreenOriginY;
}
int RenderSurface::getWindowOriginX() const
{
if( _isFullScreen )
{
if( _useCustomFullScreen == true )
return _customFullScreenOriginX;
else
return 0;
}
return _windowX;
}
int RenderSurface::getWindowOriginY() const
{
if( _isFullScreen )
{
if( _useCustomFullScreen == true )
return _customFullScreenOriginY;
else
return 0;
}
return _windowY;
}
unsigned int RenderSurface::getWindowWidth() const
{
if( _isFullScreen )
{
if( _useCustomFullScreen == true )
return _customFullScreenWidth;
else
return _screenWidth;
}
return _windowWidth;
}
unsigned int RenderSurface::getWindowHeight() const
{
if( _isFullScreen )
{
if( _useCustomFullScreen == true )
return _customFullScreenHeight;
else
return _screenHeight;
}
return _windowHeight;
}
void RenderSurface::setInputRectangle( const InputRectangle &inputRectangle )
{
_inputRectangle = inputRectangle;
}
const RenderSurface::InputRectangle &RenderSurface::getInputRectangle() const
{
return _inputRectangle;
}
void RenderSurface::bindInputRectangleToWindowSize( bool flag)
{
_bindInputRectangleToWindowSize = flag;
if( _bindInputRectangleToWindowSize == true )
_inputRectangle.set( 0.0, float(_windowWidth), 0.0, float(_windowHeight) );
else
_inputRectangle.set( -1.0, 1.0, -1.0, 1.0 );
}
void RenderSurface::useBorder( bool flag )
{
_decorations = flag;
#if 0
if( _realized )
_setBorder(_decorations);
#endif
}
bool RenderSurface::usesBorder()
{
return _decorations;
}
#if 0
void RenderSurface::useCursor( bool flag )
{
_useCursor(flag);
}
void RenderSurface::setCursor( Cursor cursor )
{
_setCursor(cursor);
}
void RenderSurface::setCursorToDefault()
{
_setCursorToDefault();
}
void RenderSurface::setWindow( const Window win )
{
if( _realized )
{
std::cerr << "RenderSurface::setWindow() - cannot set window after RenderSurface has been realized\n";
return;
}
_win = win;
#ifdef WIN32
_ownWindow = false;
#endif
}
Producer::Window RenderSurface::getWindow( void ) const
{
return _win;
}
GLContext RenderSurface::getGLContext( void) const
{
return _glcontext;
}
void RenderSurface::setGLContext( GLContext glContext )
{
if( _realized )
{
std::cerr << "RenderSurface::setGLContext() - Warning: Must be set before realize()." << std::endl;
return;
}
_glcontext = glContext;
}
bool RenderSurface::isRealized() const
{
return _realized;
}
void RenderSurface::setVisualInfo( VisualInfo *vi )
{
if( _realized )
{
std::cerr << "RenderSurface::setVisualInfo():Warning - has no effect after RenderSurface has been realized\n";
return;
}
_visualInfo = vi;
#ifdef _WIN32_IMPLEMENTATION
_ownVisualInfo = false;
#endif
}
VisualInfo *RenderSurface::getVisualInfo( void )
{
return _visualInfo;
}
const VisualInfo *RenderSurface::getVisualInfo( void ) const
{
return _visualInfo;
}
#endif
void RenderSurface::setVisualChooser( VisualChooser *vc )
{
if( _realized )
{
std::cerr << "RenderSurface::setVisualChooser():Warning - has no effect after RenderSurface has been realized\n";
return;
}
_visualChooser = vc;
#ifdef _WIN32_IMPLEMENTATION
_ownVisualChooser = false;
#endif
}
VisualChooser *RenderSurface::getVisualChooser( void )
{
return _visualChooser.get();
}
const VisualChooser *RenderSurface::getVisualChooser( void ) const
{
return _visualChooser.get();
}
#if 0
void RenderSurface::getScreenSize( unsigned int &width, unsigned int &height ) const
{
if( _realized )
{
if( _useCustomFullScreen == true )
{
width = _customFullScreenWidth;
height = _customFullScreenHeight;
}
else
{
width = _screenWidth;
height = _screenHeight;
}
}
else
{
_computeScreenSize(width, height);
}
}
#endif
#if 0
void RenderSurface::useConfigEventThread( bool flag )
{
if( _realized )
{
// This message is annoying. Cameras that share a render surface will call this after the
// render surface has been realized, which is valid.
//std::cerr << "RenderSurface::useConfigEventThread():Warning - has no effect after RenderSurface has been realized\n";
return;
}
_useConfigEventThread = flag;
}
unsigned int RenderSurface::getRefreshRate() const
{
if( !_realized ) return 0;
return _refreshRate;
}
void RenderSurface::addRealizeCallback( Callback *realizeCB )
{
if( _realized )
{
std::cerr << "RenderSurface::addRealizeCallback() : Warning. RenderSurface is already realized. ignored.\n";
return;
}
_realizeCallbacks.push_back( realizeCB );
}
bool RenderSurface::waitForRealize()
{
if( _realized ) return true;
while( _realized == false )
_realizeBlock->block();
return true;
}
void RenderSurface::positionPointer( int x, int y )
{
_positionPointer(x,y);
}
void RenderSurface::initThreads()
{
_initThreads();
}
#endif
RenderSurface::RenderToTextureMode RenderSurface::getRenderToTextureMode() const
{
return _rtt_mode;
}
void RenderSurface::setRenderToTextureMode(RenderToTextureMode mode)
{
_rtt_mode = mode;
}
RenderSurface::RenderToTextureTarget RenderSurface::getRenderToTextureTarget() const
{
return _rtt_target;
}
void RenderSurface::setRenderToTextureTarget(RenderToTextureTarget target)
{
_rtt_target = target;
}
RenderSurface::RenderToTextureOptions RenderSurface::getRenderToTextureOptions() const
{
return _rtt_options;
}
void RenderSurface::setRenderToTextureOptions(RenderToTextureOptions options)
{
_rtt_options = options;
}
int RenderSurface::getRenderToTextureMipMapLevel() const
{
return _rtt_mipmap;
}
void RenderSurface::setRenderToTextureMipMapLevel(int level)
{
_rtt_mipmap = level;
_rtt_dirty_mipmap = true;
}
RenderSurface::CubeMapFace RenderSurface::getRenderToTextureFace() const
{
return _rtt_face;
}
void RenderSurface::setRenderToTextureFace(CubeMapFace face)
{
_rtt_face = face;
_rtt_dirty_face = true;
}
const std::vector<int> &RenderSurface::getPBufferUserAttributes() const
{
return _user_pbattr;
}
std::vector<int> &RenderSurface::getPBufferUserAttributes()
{
return _user_pbattr;
}
void RenderSurface::useOverrideRedirect(bool flag)
{
_overrideRedirectFlag = flag;
}
bool RenderSurface::usesOverrideRedirect()
{
return _overrideRedirectFlag;
}
_______________________________________________
osg-users mailing list
[email protected]
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org
