Re: [osg-users] Enable/Disable stereo during runtime

[Andreas Roth]

Hi,

i'm still trying to enable or disable stereo during runtime. I created a small 
app, which simply recreates the graphic context when you press g.
It does not enable or disable stereo at all (due to lack of stereo hw at the 
moment), but i think the actual stereo on/off can be easily added when this app 
is working properly.


Code:

#include "stdafx.h"
#include <osgDB/ReadFile>
#include <osgViewer/CompositeViewer>
#include <osgGA/TrackballManipulator>

class GCEventHandler : public osgGA::GUIEventHandler
{
public:
    GCEventHandler(osgViewer::CompositeViewer * viewer, osgViewer::View * view)
        : m_viewer(viewer)
        , m_view(view)
        , m_x(200)
        , m_y(200)
        , m_width(800)
        , m_height(600)
        , m_recreateContext(false)
    {
    }

    void preFrame()
    {
        if(m_recreateContext)
        {
            m_recreateContext = false;
            destroyCamera();
            recreateContext();
            createCamera();
        }
    }

    bool createContext()
    {
        osg::ref_ptr<osg::GraphicsContext::Traits> traits = new 
osg::GraphicsContext::Traits;

        traits->readDISPLAY();
        if (traits->displayNum<0)
            traits->displayNum = 0;

        traits->screenNum = 0;
        traits->x = m_x;
        traits->y = m_y;
        traits->width = m_width;
        traits->height = m_height;
        traits->alpha = 0;
        traits->stencil = 0;
        traits->windowDecoration = true;
        traits->doubleBuffer = true;
        traits->sharedContext = 0;

        osg::ref_ptr<osg::GraphicsContext> gc = 
osg::GraphicsContext::createGraphicsContext(traits.get());
        if(gc.valid())
        {
            m_gw = dynamic_cast<osgViewer::GraphicsWindow*>(gc.get());
            m_viewer->addView(m_view);
        }
        return gc.valid();
    }

    void destroyContext()
    {
        m_viewer->removeView(m_view);
        m_viewer->stopThreading();
        if(m_gw.valid())
        {
            m_gw->close();
            m_gw = NULL;
        }
        
    }

    bool recreateContext()
    {
        destroyContext();
        return createContext();
    }
    void destroyCamera()
    {
        osg::Camera * camera = m_view->getCamera();
        osg::ref_ptr<osg::GraphicsContext> gc = camera->getGraphicsContext();
        if(gc.valid())
        {
            m_gw = dynamic_cast<osgViewer::GraphicsWindow*>(gc.get());
        }
        camera->setGraphicsContext(NULL);
    }

    void createCamera()
    {
        osg::Camera * camera = m_view->getCamera();

        camera->setGraphicsContext( m_gw.get() );
        camera->setProjectionMatrixAsPerspective( 30.0f, 
static_cast<double>(m_width) / static_cast<double>(m_height), 1.0, 1000.0);
        camera->setViewport( new osg::Viewport( 0, 0, m_width, m_height));
    }


    virtual bool handle(const osgGA::GUIEventAdapter& 
ea,osgGA::GUIActionAdapter& aa, osg::Object*, osg::NodeVisitor*)
    {
        switch(ea.getEventType())
        {
        case osgGA::GUIEventAdapter::KEYUP:
            {
                switch(ea.getKey())
                {
                case 'g':
                    m_recreateContext = true;
                    break;
                }
            }
            break;
        }
        return osgGA::GUIEventHandler::handle(ea,aa);
    }

private:
    osgViewer::CompositeViewer * m_viewer;
    osgViewer::View * m_view;
    osg::ref_ptr<osgViewer::GraphicsWindow> m_gw;
    int m_x;
    int m_y;
    int m_width;
    int m_height;
    bool m_recreateContext;
};

int main(int argc, char** argv)
{
    // use an ArgumentParser object to manage the program arguments.
    osg::ArgumentParser arguments(&argc,argv);

    osgViewer::CompositeViewer viewer(arguments);

    // report any errors if they have occurred when parsing the program 
arguments.
    if (arguments.errors())
    {
        arguments.writeErrorMessages(std::cout);
        return 1;
    }

    if (arguments.argc()<=1)
    {
        
arguments.getApplicationUsage()->write(std::cout,osg::ApplicationUsage::COMMAND_LINE_OPTION);
        return 1;
    }

    osg::ref_ptr<osgViewer::View> view = new osgViewer::View();
    viewer.addView(view);

    view->setCameraManipulator( new osgGA::TrackballManipulator );

    // add the GC handler
    osg::ref_ptr<GCEventHandler> gchandler = new GCEventHandler(&viewer, view);
    view->addEventHandler(gchandler);

    gchandler->createContext();
    gchandler->createCamera();

    // load the data
    osg::ref_ptr<osg::Node> loadedModel = osgDB::readNodeFiles(arguments);
    if (!loadedModel) 
    {
        std::cout << arguments.getApplicationName() <<": No data loaded" << 
std::endl;
        return 1;
    }

    // any option left unread are converted into errors to write out later.
    arguments.reportRemainingOptionsAsUnrecognized();

    // report any errors if they have occurred when parsing the program 
arguments.
    if (arguments.errors())
    {
        arguments.writeErrorMessages(std::cout);
        return 1;
    }

    view->setSceneData(loadedModel.get());

    viewer.realize();

    while(!viewer.done())
    {
        gchandler->preFrame();

        if(!viewer.isRealized())
        {
            view->setSceneData(NULL);
            view->setSceneData(loadedModel.get());
            viewer.realize();
        }
        viewer.frame();
    }

    return 0;
}








The application recreates the graphic context, but with the second graphic 
context all textures are gone. Any ideas?


Regards,
Andreas[/code]

------------------
Read this topic online here:
http://forum.openscenegraph.org/viewtopic.php?p=31008#31008





_______________________________________________
osg-users mailing list
osg-users@lists.openscenegraph.org
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org