Hi Aurelien,

It seems that already works! I attached code...

Code:

_qtViewer = new osgGenerals::ViewerQT(this);
ui.OSGRenderLayout->addWidget(_qtViewer);
_qtViewer->updateCamera(center,eye,up);
_qtViewer->setSceneData(_mainLogic->getRootGroup());
_qtViewer->startRendering();




Thank you!

Cheers,
Aitor

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



#ifndef _OSG_QT_RENDER_H_
#define _OSG_QT_RENDER_H_

#include <osgViewer/Viewer>
#include <osgViewer/GraphicsWindow>
#include <osgViewer/CompositeViewer>
#include <osgViewer/ViewerEventHandlers>
#include <osgGA/TrackballManipulator>
#include <osg/Notify>

#define USE_QT4 1

#if USE_QT4

    #include <QtCore/QString>
    #include <QtCore/QTimer>
    #include <QtGui/QKeyEvent>
    #include <QtOpenGL/QGLWidget>
        #include <QtCore/QThread>
        #include <QtCore/QMutex>
    
    using Qt::WindowFlags;

#else

    class QWidget;
    #include <qtimer.h>
    #include <qgl.h>
    #include <qapplication.h>

    #define WindowFlags WFlags

#endif

#include <iostream>

namespace osgGenerals{

class LogFileHandler : public osg::NotifyHandler
{
public:
        LogFileHandler( const std::string& file )
        { _log.open( file.c_str() ); }
        virtual ~LogFileHandler() { _log.close(); }
        virtual void notify(osg::NotifySeverity severity,
        const char* msg)
        { _log << msg; }
protected:
        std::ofstream _log;
};

class ViewerQT;
class GLPainter : public QObject
 {
     Q_OBJECT
 public:
     GLPainter(ViewerQT *widget);
     void stop();
     void resizeViewport(const QSize &size);
         void updateCamera(osg::Vec3f center, osg::Vec3f eye, osg::Vec3f up);

 public slots:
     void start();

 protected:
     void timerEvent(QTimerEvent *event);

 private:
     QMutex mutex;
     ViewerQT *glWidget;
     bool doRendering;
 };
class AdapterWidget : public QGLWidget
{
    public:

        AdapterWidget( QWidget * parent = 0, const char * name = 0, const 
QGLWidget * shareWidget = 0, WindowFlags f = 0 );

        virtual ~AdapterWidget() {}

        osgViewer::GraphicsWindow* getGraphicsWindow() { return _gw.get(); }
        const osgViewer::GraphicsWindow* getGraphicsWindow() const { return 
_gw.get(); }

    protected:

        void init();

        virtual void resizeGL( int width, int height );
        virtual void keyPressEvent( QKeyEvent* event );
        virtual void keyReleaseEvent( QKeyEvent* event );
        virtual void mousePressEvent( QMouseEvent* event );
        virtual void mouseReleaseEvent( QMouseEvent* event );
        virtual void mouseMoveEvent( QMouseEvent* event );
        virtual void wheelEvent(QWheelEvent *event);
        osg::ref_ptr<osgViewer::GraphicsWindowEmbedded> _gw;
};

class ViewerQT : public osgViewer::Viewer, public AdapterWidget
{
    public:

        ViewerQT(QWidget * parent = 0, const char * name = 0, const QGLWidget * 
shareWidget = 0, WindowFlags f = 0);
                ~ViewerQT();
                
                void startRendering();
                void stopRendering();
                virtual void paintGL();
                void updateCamera(osg::Vec3f center, osg::Vec3f eye, osg::Vec3f 
up);
    
    protected:
                void resizeEvent(QResizeEvent *evt);
                void paintEvent(QPaintEvent *);
        void closeEvent(QCloseEvent *evt);

                GLPainter glPainter;
                QThread glThread;
};

}
#endif
ÿþ#include "OSGQtRender.h"





using namespace osgGenerals;



GLPainter::GLPainter(ViewerQT *widget)

     : glWidget(widget)

     , doRendering(true)

 {

 }



 void GLPainter::start()

 {

	 glWidget->AdapterWidget::makeCurrent();

     startTimer(10);

 }



 void GLPainter::stop()

 {

     QMutexLocker locker(&mutex);

     doRendering = false;

 }



void GLPainter::resizeViewport(const QSize &size)

{

	QMutexLocker locker(&mutex);

	glWidget->getCamera()->setViewport(new osg::Viewport(0,0,size.width(),size.height()));

}



void GLPainter::timerEvent(QTimerEvent *event)

{

	QMutexLocker locker(&mutex);

	if (!doRendering) {

		killTimer(event->timerId());

		QThread::currentThread()->quit();

		return;

	}

	glWidget->updateGL();

}

void GLPainter::updateCamera(osg::Vec3f center, osg::Vec3f eye, osg::Vec3f up)

{

	QMutexLocker locker(&mutex);

	glWidget->getCamera()->setViewMatrixAsLookAt(eye, center, up);

}

AdapterWidget::AdapterWidget( QWidget * parent, const char * name, const QGLWidget * shareWidget, WindowFlags f):

#if USE_QT4

    QGLWidget(parent, shareWidget, f)

#else

    QGLWidget(parent, name, shareWidget, f)

#endif

{

    _gw = new osgViewer::GraphicsWindowEmbedded(0,0,width(),height());

#if USE_QT4

    setFocusPolicy(Qt::ClickFocus);

#else

    setFocusPolicy(QWidget::ClickFocus);

#endif

}





void AdapterWidget::resizeGL( int width, int height )

{

    _gw->getEventQueue()->windowResize(0, 0, width, height );

    _gw->resized(0,0,width,height);

}



void AdapterWidget::keyPressEvent( QKeyEvent* event )

{

#if USE_QT4

    _gw->getEventQueue()->keyPress( (osgGA::GUIEventAdapter::KeySymbol) *(event->text().toAscii().data() ) );

#else

    _gw->getEventQueue()->keyPress( (osgGA::GUIEventAdapter::KeySymbol) event->ascii() );

#endif

}



void AdapterWidget::keyReleaseEvent( QKeyEvent* event )

{

#if USE_QT4

    _gw->getEventQueue()->keyRelease( (osgGA::GUIEventAdapter::KeySymbol) *(event->text().toAscii().data() ) );

#else

    _gw->getEventQueue()->keyRelease( (osgGA::GUIEventAdapter::KeySymbol) event->ascii() );

#endif

}



void AdapterWidget::mousePressEvent( QMouseEvent* event )

{

    int button = 0;

    switch(event->button())

    {

        case(Qt::LeftButton): button = 1; break;

        case(Qt::MidButton): button = 2; break;

        case(Qt::RightButton): button = 3; break;

        case(Qt::NoButton): button = 0; break;

        default: button = 0; break;

    }

    _gw->getEventQueue()->mouseButtonPress(event->x(), event->y(), button);

}



void AdapterWidget::mouseReleaseEvent( QMouseEvent* event )

{

    int button = 0;

    switch(event->button())

    {

        case(Qt::LeftButton): button = 1; break;

        case(Qt::MidButton): button = 2; break;

        case(Qt::RightButton): button = 3; break;

        case(Qt::NoButton): button = 0; break;

        default: button = 0; break;

    }

    _gw->getEventQueue()->mouseButtonRelease(event->x(), event->y(), button);

}



void AdapterWidget::mouseMoveEvent( QMouseEvent* event )

{

    _gw->getEventQueue()->mouseMotion(event->x(), event->y());

}



void AdapterWidget::wheelEvent(QWheelEvent *event)

{    

    _gw->getEventQueue()->mouseScroll((event->delta()>0) ?             

            osgGA::GUIEventAdapter::SCROLL_UP : osgGA::GUIEventAdapter::SCROLL_DOWN);

}







ViewerQT::ViewerQT(QWidget * parent, const char * name, const QGLWidget * shareWidget, WindowFlags f)

	:AdapterWidget( parent, name, shareWidget, f )

	, glThread(this)

	, glPainter(this)

{

	osg::setNotifyLevel( osg::INFO );

	osg::setNotifyHandler( new LogFileHandler("OSGRender_Output.txt") );

	

	getCamera()->setViewport(new osg::Viewport(0,0,width(),height()));

	getCamera()->setProjectionMatrixAsPerspective(60.0f, static_cast<double>(width())/static_cast<double>(height()), 1.0f, 10000.0f);

	getCamera()->setGraphicsContext(getGraphicsWindow());



	setThreadingModel(osgViewer::Viewer::SingleThreaded);



	QGLFormat fmt;

	QGLFormat::setDefaultFormat(fmt);

	fmt.setSamples(4);

	fmt.setSampleBuffers(true);

	setFormat(fmt);		//antialiasing activated              provoca error en modo debug al cerrar



	this->doneCurrent();

	

	osg::notify(osg::INFO)<<"  GraphicsWindow has been created successfully."<<std::endl;

}

ViewerQT::~ViewerQT()

{

	stopRendering();

}

void ViewerQT::startRendering()

{

	glPainter.moveToThread(&glThread);

	connect(&glThread, SIGNAL(started()), &glPainter, SLOT(start()));

	glThread.start();

}



void ViewerQT::stopRendering()

{

	glPainter.stop();

	glThread.wait();

}

void ViewerQT::paintGL()

{

	//AdapterWidget::makeCurrent();

	frame();

//	printf("paintGL frame%d\n", QThread::currentThreadId());

}

void ViewerQT::resizeEvent(QResizeEvent *evt)

{

	glPainter.resizeViewport(evt->size());

}

    

void ViewerQT::paintEvent(QPaintEvent *)

{

        // Handled by the GLThread.

}

    

void ViewerQT::closeEvent(QCloseEvent *evt)

{

	stopRendering();

	QGLWidget::closeEvent(evt);

}

void ViewerQT::updateCamera(osg::Vec3f eye, osg::Vec3f center, osg::Vec3f up)

{

	glPainter.updateCamera(center,eye,up);

}
_______________________________________________
osg-users mailing list
[email protected]
http://lists.openscenegraph.org/listinfo.cgi/osg-users-openscenegraph.org

Reply via email to