Hi Guys,
I managed to find a way to take snapshots of the openGL state ( gDEBugger )
and it seems that QT calls
glEnableClientState(GL_VERTEX_ARRAY) and
glDisableClientState(GL_VERTEX_ARRAY) during the drawLine
command. However, OSG requires the vertex array to be enabled. Adding the
line glEnableClientState(GL_VERTEX_ARRAY) to the paintEvent
method before calling any OSG commands seems to fix the problem ( at least
in this case ).
.....
// Do our OSG stuff...
glEnableClientState( GL_VERTEX_ARRAY );
resizeGL( width(), height() );
updateCamera();
m_scene->update();
m_scene->cull();
m_scene->draw();
.....
Is there a nice way to get OSG to reset the OpenGL state to what it expects?
Cheers,
Pete.
On 6/12/07, Peter O < [EMAIL PROTECTED]> wrote:
> Hi Can,
>
> I'm glad I'm not the only one struggling with this ;)
>
> One of our longer term options is to re-implement some of our visuals in
OSG. However, unfortunately we have too many to do that in the short term.
>
> I think you must be right about the state change. I couldn't find any way
of dumping the whole OpenGL state but I did try outputting the model, view,
projection, and window matrices which all seem to be O.K.
>
> Cheers,
>
> Pete.
>
>
>
> On 6/12/07, Can Özmen < [EMAIL PROTECTED]> wrote:
> > Hi Peter,
> >
> > I was struggling with the same thing last week, but I gave up after a
> > few days. I ended up writing a class derived from QObject that
> > contains a osg::Camera node with orthographic projection to do the
> > drawing with OSG. Fortunately I have only a handful of widgets to
> > convert.
> >
> > BTW, is there a way to dump the OpenGL state after calling QPainter's
> > drawing methods? The .begin() and .end() by themselves don't seem to
> > cause any problems but maybe some state change is happening?
> >
> > Regards,
> > Can.
> >
> >
> > On 6/12/07, Peter O < [EMAIL PROTECTED]> wrote:
> > > No problem Robert. Thanks for having a look.
> > >
> > > Anyone else got any ideas?
> > >
> > > Cheers,
> > >
> > > Pete.
> > >
> > > On 6/12/07, Robert Osfield < [EMAIL PROTECTED]> wrote:
> > > > I'm afraid you're off the map w.r.t my experience with QT.
> > > >
> > > > On 6/12/07, Peter O < [EMAIL PROTECTED] > wrote:
> > > > > Hi Robert,
> > > > >
> > > > > Normally you would use paintGL. However, the QT overpainting
example
> > > says
> > > > > that to get overpainting to work you need to implement the
paintEvent
> > > method
> > > > > instead (which normally calls paintGL). The osg rendering code is
in
> > > that
> > > > > method sandwitched between the QPainter stuff.
> > > > >
> > > > > From the example doc:
> > > > >
> > > > > "In this example, we implement paintEvent() rather than paintGL()
to
> > > render
> > > > > our scene. When drawing on a QGLWidget, the paint engine used by
> > > QPainter
> > > > > performs certain operations that change the states of the OpenGL
> > > > > implementation's matrix and property stacks. Therefore, it is
necessary
> > > to
> > > > > construct a QPainter for use on the widget before making any
OpenGL
> > > calls."
> > > > >
> > > > >
http://doc.trolltech.com/4.3/opengl-overpainting.html
> > > > >
> > > > > Thanks again for helping.
> > > > >
> > > > > Cheers,
> > > > >
> > > > >
> > > > > Pete.
> > > > >
> > > > > On 6/12/07, Robert Osfield < [EMAIL PROTECTED] > wrote:
> > > > > > Why do you comment out the paintGL? This is what should be
redrawing.
> > > >
> > > > > >
> > > > > > On 6/12/07, Peter O < [EMAIL PROTECTED]> wrote:
> > > > > > > Hi Robert,
> > > > > > >
> > > > > > > Sorry, I didn't want to just fire a lot of code at you but I
guess
> > > it
> > > > > would
> > > > > > > actually be quite helpful to see the whole thing ;) I've
attached
> > > the
> > > > > main
> > > > > > > viewer code at the end of this email.
> > > > > > >
> > > > > > > At the moment, when mouse moves cause the camera to change
the
> > > update()
> > > > > > > method is called, triggering a paintEvent. Additionally, if
the
> > > window
> > > > > is
> > > > > > > resized a paintEvent will be triggered by QT.
> > > > > > >
> > > > > > > Cheers,
> > > > > > >
> > > > > > > Pete.
> > > > > > >
> > > > > > > P.S. I think you met one of my work collegues (Paul
Fotheringham) at
> > > the
> > > > > > > last Highland Gathering :)
> > > > > > >
> > > > > > > main.cpp
> > > > > > >
> > > > > > > int main( int argc, char **argv )
> > > > > > > {
> > > > > > > QApplication a( argc, argv );
> > > > > > >
> > > > > > > Viewer viewer( 0 );
> > > > > > > viewer.setMaximumSize ( 500, 500 );
> > > > > > > viewer.show();
> > > > > > >
> > > > > > > for ( int i = 1; i < argc; ++i )
> > > > > > > {
> > > > > > > viewer.loadMesh( argv[ i ] );
> > > > > > > }
> > > > > > >
> > > > > > > return a.exec();
> > > > > > > }
> > > > > > >
> > > > > > > Viewer.h
> > > > > > >
> > > > > > > class Viewer : public QGLWidget
> > > > > > > {
> > > > > > > Q_OBJECT
> > > > > > >
> > > > > > > public:
> > > > > > > Viewer( QWidget* parent );
> > > > > > >
> > > > > > > void loadMesh( const QString& );
> > > > > > >
> > > > > > > osgUtil::SceneView* sceneView() { return
> > > m_scene.get();
> > > > > }
> > > > > > > const osgUtil::SceneView* sceneView() const { return
> > > m_scene.get();
> > > > > }
> > > > > > >
> > > > > > > protected:
> > > > > > > virtual void initializeGL();
> > > > > > > virtual void resizeGL( int, int );
> > > > > > > //virtual void paintGL();
> > > > > > >
> > > > > > > virtual void paintEvent ( QPaintEvent * );
> > > > > > > virtual void keyPressEvent ( QKeyEvent * );
> > > > > > > virtual void mousePressEvent ( QMouseEvent * );
> > > > > > > virtual void mouseReleaseEvent ( QMouseEvent * );
> > > > > > > virtual void mouseDoubleClickEvent ( QMouseEvent * );
> > > > > > > virtual void mouseMoveEvent ( QMouseEvent * );
> > > > > > >
> > > > > > > private:
> > > > > > > void updateCamera();
> > > > > > > void zoom ( int dy );
> > > > > > > void rotate( int dx, int dy );
> > > > > > > void pan ( int dx, int dy );
> > > > > > >
> > > > > > > // Data
> > > > > > >
> > > > > > > // Mouse
> > > > > > > QPoint m_prevMouse;
> > > > > > >
> > > > > > > // Camera
> > > > > > > osg::Quat m_cameraR;
> > > > > > > osg::Vec3 m_orbitCentre;
> > > > > > > float m_dolly;
> > > > > > >
> > > > > > > // OSG scene
> > > > > > > osg::ref_ptr< osgUtil::SceneView > m_scene;
> > > > > > > };
> > > > > > >
> > > > > > > Viewer.cpp
> > > > > > >
> > > > > > > QGLFormat getPixelFormat()
> > > > > > > {
> > > > > > > QGLFormat fmt;
> > > > > > > fmt.setStencil(true);
> > > > > > > return fmt;
> > > > > > > }
> > > > > > >
> > > > > > > Viewer::Viewer( QWidget* parent )
> > > > > > > : QGLWidget( getPixelFormat(), parent )
> > > > > > > , m_dolly( 0.2 )
> > > > > > > {
> > > > > > > setFocusPolicy( Qt::StrongFocus );
> > > > > > > setAttribute( Qt::WA_NoSystemBackground );
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::loadMesh( const QString& fileName )
> > > > > > > {
> > > > > > > qDebug() << "Attempting to load: " << fileName;
> > > > > > >
> > > > > > > osg::Node*const mesh = osgDB::readNodeFile(
> > > fileName.toStdString()
> > > > > );
> > > > > > > if ( !mesh )
> > > > > > > {
> > > > > > > qWarning( "Mesh not loaded!" );
> > > > > > > }
> > > > > > >
> > > > > > >
m_scene->getSceneData()->asGroup()->addChild(
> > > mesh
> > > > > );
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::initializeGL()
> > > > > > > {
> > > > > > > m_scene = new osgUtil::SceneView;
> > > > > > >
> > > > > > > m_scene->setDefaults();
> > > > > > > m_scene->setClearColor( osg::Vec4( 247.0 / 255.0, 150.0 /
255.0,
> > > > > 150.0 /
> > > > > > > 255.0, 1.0) );
> > > > > > > m_scene->getState()->setContextID(
> > > > > > > osg::GraphicsContext::createNewContextID() );
> > > > > > >
> > > > > > > m_scene->setNearFarRatio( 0.02f );
> > > > > > >
> > > > > > > m_scene->setSceneData( new osg::Group );
> > > > > > >
> > > > > > > updateCamera();
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::resizeGL( int w, int h)
> > > > > > > {
> > > > > > > qDebug() << "ResizeGL: " << w << " " << h;
> > > > > > >
> > > > > > > m_scene->setViewport( 0, 0, w, h );
> > > > > > >
> > > > > > > const float VFOV = 30.f;
> > > > > > > const float ASPECT_RATIO = static_cast< float >( w ) /
> > > > > > > static_cast<
float
> > > >( h
> > > > > );
> > > > > > > const float Z_N = 0.002f;
> > > > > > > const float Z_F = 1.000f;
> > > > > > >
> > > > > > > osg::Matrix projection;
> > > > > > > projection.makePerspective( VFOV, ASPECT_RATIO, Z_N, Z_F
);
> > > > > > >
> > > > > > > m_scene->setProjectionMatrix( projection );
> > > > > > > }
> > > > > > >
> > > > > > >
> > > > > > > void Viewer::paintEvent( QPaintEvent * )
> > > > > > > {
> > > > > > > qDebug() << "PaintEvent";
> > > > > > >
> > > > > > > QPainter painter;
> > > > > > > painter.begin(this);
> > > > > > > painter.setRenderHint(QPainter::Antialiasing);
> > > > > > > painter.setBrush( Qt::red );
> > > > > > >
> > > > > > > // Preserve the current GL state.
> > > > > > > glPushAttrib( GL_ALL_ATTRIB_BITS );
> > > > > > > glMatrixMode(GL_PROJECTION);
> > > > > > > glPushMatrix();
> > > > > > > glMatrixMode(GL_TEXTURE);
> > > > > > > glPushMatrix();
> > > > > > > glMatrixMode(GL_MODELVIEW);
> > > > > > > glPushMatrix();
> > > > > > >
> > > > > > > // Do our OSG stuff...
> > > > > > > resizeGL( width(), height() );
> > > > > > > updateCamera();
> > > > > > >
> > > > > > > m_scene->update();
> > > > > > > m_scene->cull();
> > > > > > > m_scene->draw();
> > > > > > >
> > > > > > > // Restore the old GL state.
> > > > > > > glMatrixMode(GL_TEXTURE);
> > > > > > > glPopMatrix();
> > > > > > > glMatrixMode(GL_PROJECTION);
> > > > > > > glPopMatrix();
> > > > > > > glMatrixMode(GL_MODELVIEW);
> > > > > > > glPopMatrix();
> > > > > > > glPopAttrib();
> > > > > > >
> > > > > > > // Comment out the following line to make everything work.
> > > > > > > painter.drawLine( 0, 0, width(), height() );
> > > > > > >
> > > > > > > painter.end();
> > > > > > >
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::keyPressEvent ( QKeyEvent * k )
> > > > > > > {
> > > > > > > switch ( k->key() )
> > > > > > > {
> > > > > > > case Qt::Key_Q:
> > > > > > > QApplication::exit();
> > > > > > > break;
> > > > > > > }
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::mousePressEvent( QMouseEvent * e )
> > > > > > > {
> > > > > > > qDebug() << "mousePressEvent:";
> > > > > > >
> > > > > > > m_prevMouse = e->pos();
> > > > > > >
> > > > > > > e->accept();
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::mouseReleaseEvent( QMouseEvent * e )
> > > > > > > {
> > > > > > > e->accept();
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::mouseDoubleClickEvent( QMouseEvent * e )
> > > > > > > {
> > > > > > > e->ignore();
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::mouseMoveEvent( QMouseEvent * e )
> > > > > > > {
> > > > > > > const int dx = e->x() - m_prevMouse.x();
> > > > > > > const int dy = e->y() - m_prevMouse.y();
> > > > > > >
> > > > > > > m_prevMouse = e->pos();
> > > > > > >
> > > > > > > const bool panFlag = ( e->buttons() & Qt::MidButton
);
> > > > > > > const bool rotateFlag = ( e->buttons() & Qt::LeftButton
);
> > > > > > > const bool zoomFlag = ( e->buttons() & Qt::RightButton
);
> > > > > > >
> > > > > > >
> > > > > > > if ( zoomFlag )
> > > > > > > {
> > > > > > > zoom( dy );
> > > > > > > }
> > > > > > > else if ( rotateFlag )
> > > > > > > {
> > > > > > > rotate( dx, dy );
> > > > > > > }
> > > > > > > else if ( panFlag )
> > > > > > > {
> > > > > > > pan( dx, dy );
> > > > > > > }
> > > > > > >
> > > > > > > updateCamera();
> > > > > > > update();
> > > > > > >
> > > > > > > e->accept();
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::updateCamera()
> > > > > > > {
> > > > > > > qDebug() << "Update Camera";
> > > > > > >
> > > > > > > osg::Matrix vm = osg::Matrix::translate( -m_orbitCentre );
> > > > > > > vm *= osg::Matrix::rotate( m_cameraR.conj() );
> > > > > > > vm.setTrans( vm.getTrans () + osg::Vec3( 0., 0., -m_dolly
) );
> > > > > > >
> > > > > > > m_scene->setViewMatrix( vm );
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::rotate( int dx, int dy )
> > > > > > > {
> > > > > > > const double ROTATE_FACTOR = 0.002 * osg::PI;
> > > > > > >
> > > > > > > const float cameraYawChange = -dx * ROTATE_FACTOR;
> > > > > > > const float cameraPitchChange = -dy * ROTATE_FACTOR;
> > > > > > >
> > > > > > > m_cameraR = osg::Quat( cameraPitchChange, osg::Vec3( 1.,
0., 0.
> > > ) )
> > > > > *
> > > > > > > m_cameraR;
> > > > > > > m_cameraR *= osg::Quat( cameraYawChange , osg::Vec3( 0.,
1., 0.
> > > )
> > > > > );
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::zoom( int dy )
> > > > > > > {
> > > > > > > const float MIN_DOLLY = 5.e-2f;
> > > > > > > const float MAX_DOLLY = 2.e+0f;
> > > > > > > const float ZOOM_SCALE = 0.002;
> > > > > > >
> > > > > > > if ( m_dolly <= MIN_DOLLY && dy < 0 )
> > > > > > > {
> > > > > > > const double PAN_FORWARD_FACTOR = ZOOM_SCALE *
MIN_DOLLY;
> > > > > > >
> > > > > > > const osg::Vec3 cameraZInWorld = m_cameraR *
osg::Vec3( 0.,
> > > 0.,
> > > > > 1.
> > > > > > > );
> > > > > > >
> > > > > > > m_orbitCentre += cameraZInWorld * ( dy *
PAN_FORWARD_FACTOR
> > > );
> > > > > > >
> > > > > > > m_dolly = MIN_DOLLY;
> > > > > > > }
> > > > > > > else if ( m_dolly >= MAX_DOLLY && dy > 0 )
> > > > > > > {
> > > > > > > m_dolly = MAX_DOLLY;
> > > > > > > }
> > > > > > > else
> > > > > > > {
> > > > > > > const float deltaDolly = dy * ZOOM_SCALE * m_dolly;
> > > > > > >
> > > > > > > m_dolly += deltaDolly;
> > > > > > >
> > > > > > > if ( m_dolly > MAX_DOLLY )
> > > > > > > m_dolly = MAX_DOLLY;
> > > > > > > else if ( m_dolly < MIN_DOLLY )
> > > > > > > m_dolly = MIN_DOLLY;
> > > > > > > }
> > > > > > > }
> > > > > > >
> > > > > > > void Viewer::pan( int dx, int dy )
> > > > > > > {
> > > > > > > const float PAN_FACTOR = 0.002;
> > > > > > >
> > > > > > > const osg::Vec3 cameraXInWorld = m_cameraR * osg::Vec3(
1., 0.,
> > > 0.
> > > > > );
> > > > > > > const osg::Vec3 cameraYInWorld = m_cameraR * osg::Vec3(
0., 1.,
> > > 0.
> > > > > );
> > > > > > >
> > > > > > > double deltaPanX = double( dx ) * PAN_FACTOR * m_dolly;
> > > > > > > m_orbitCentre -= cameraXInWorld * deltaPanX;
> > > > > > >
> > > > > > > double deltaPanY = double( -dy ) * PAN_FACTOR * m_dolly;
> > > > > > > m_orbitCentre -= cameraYInWorld * deltaPanY;
> > > > > > >
> > > > > > > }
> > > > > > >
> > > > > > > On 6/12/07, Robert Osfield < [EMAIL PROTECTED] > wrote:
> > > > > > > > Hi Peter,
> > > > > > > >
> > > > > > > > How do you call the OSG to rendering i.e. your paintGL()
method ?
> > > I
> > > > > > > > can only see set up code in you snippets.
> > > > > > > >
> > > > > > > > On 6/12/07, Peter O <[EMAIL PROTECTED] > wrote:
> > > > > > > > > Hi Robert,
> > > > > > > > >
> > > > > > > > > Thanks for the reply.
> > > > > > > > >
> > > > > > > > > Basically, we have a big QT based application with 2D
visuals
> > > which
> > > > > > > appear
> > > > > > > > > in normal QT widgets and 3D visuals which we draw using
OSG
> > > inside
> > > > > > > > > QGLWidgets. However, ultimately we would like to be able
to draw
> > > the
> > > > > 2D
> > > > > > > > > visuals directly over the 3D scene.
> > > > > > > > >
> > > > > > > > > We are using QT 4.3.0 and OSG 1.2.
> > > > > > > > >
> > > > > > > > > My update camera method just sets the view matrix based on
some
> > > > > current
> > > > > > > > > dolly and rotation parameters.
> > > > > > > > >
> > > > > > > > > void Viewer::updateCamera()
> > > > > > > > > {
> > > > > > > > > qDebug() << "Update Camera";
> > > > > > > > >
> > > > > > > > > osg::Matrix vm = osg::Matrix::translate( -orbitCentre
);
> > > > > > > > > vm *= osg::Matrix::rotate( cameraR.conj() );
> > > > > > > > > vm.setTrans( vm.getTrans() + osg::Vec3( 0., 0., -dolly
) );
> > > > > > > > >
> > > > > > > > > m_scene->setViewMatrix( vm );
> > > > > > > > > }
> > > > > > > > >
> > > > > > > > > The resizeGL method updates the viewport and projection
matrix.
> > > > > > > > >
> > > > > > > > > void Viewer::resizeGL( int w, int h)
> > > > > > > > > {
> > > > > > > > > qDebug() << "ResizeGL: " << w << " " << h;
> > > > > > > > >
> > > > > > > > > m_scene->setViewport( 0, 0, w, h );
> > > > > > > > >
> > > > > > > > > const float VFOV = 30.f;
> > > > > > > > > const float ASPECT_RATIO = static_cast< float >( w ) /
> > > > > > > > >
static_cast<
> > > float
> > > > > >( h
> > > > > > > );
> > > > > > > > > const float Z_N = 0.002f;
> > > > > > > > > const float Z_F = 1.000f;
> > > > > > > > >
> > > > > > > > > osg::Matrix projection;
> > > > > > > > > projection.makePerspective( VFOV, ASPECT_RATIO, Z_N,
Z_F );
> > > > > > > > >
> > > > > > > > > m_scene->setProjectionMatrix( projection );
> > > > > > > > > }
> > > > > > > > >
> > > > > > > > > The m_scene variable in the paint event method is a
> > > > > osgUtil::SceneView
> > > > > > > which
> > > > > > > > > is set up in the initializeGL method.
> > > > > > > > >
> > > > > > > > > void Viewer::initializeGL()
> > > > > > > > > {
> > > > > > > > > m_scene = new osgUtil::SceneView;
> > > > > > > > >
> > > > > > > > > m_scene->setDefaults();
> > > > > > > > > m_scene->setClearColor( osg::Vec4( 247.0 / 255.0,
150.0 /
> > > 255.0,
> > > > > > > 150.0 /
> > > > > > > > > 255.0, 1.0) );
> > > > > > > > > m_scene->getState()->setContextID(
> > > > > > > > >
osg::GraphicsContext::createNewContextID() );
> > > > > > > > >
> > > > > > > > > m_scene->setNearFarRatio( 0.02f );
> > > > > > > > >
> > > > > > > > > m_scene->setSceneData( new osg::Group );
> > > > > > > > >
> > > > > > > > > updateCamera();
> > > > > > > > > }
> > > > > > > > >
> > > > > > > > > If the drawLine command is commented out of the paintEvent
> > > > > everything
> > > > > > > works
> > > > > > > > > otherwise as I said the 3D mesh only appears to be drawn
on the
> > > > > first
> > > > > > > paint
> > > > > > > > > event after it is loaded then on the next paint event it
> > > disappears.
> > > > > > > > >
> > > > > > > > > The mesh is added to the scene view using:
> > > > > > > > >
> > > > > > > > >
m_scene->getSceneData()->asGroup()->addChild(
> > > mesh
> > > > > );
> > > > > > > > >
> > > > > > > > > Thanks for any help / suggestions,
> > > > > > > > >
> > > > > > > > > Pete.
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > On 6/12/07, Robert Osfield < [EMAIL PROTECTED]>
wrote:
> > > > > > > > > > Hi Peter,
> > > > > > > > > >
> > > > > > > > > > What be hidden inside the updateCamera() call???
> > > > > > > > > >
> > > > > > > > > > Why use overpainting? What effect are you after?
> > > > > > > > > >
> > > > > > > > > > Robert.
> > > > > > > > > >
> > > > > > > > > > On 6/11/07, Peter O < [EMAIL PROTECTED] >
wrote:
> > > > > > > > > > > Hi,
> > > > > > > > > > >
> > > > > > > > > > > I'm trying to adapt the QT overpainting example (
drawing 2D
> > > > > > > primitives
> > > > > > > > > and
> > > > > > > > > > > text over a 3D scene ) to use osg instead of raw
openGL.
> > > > > However,
> > > > > > > the
> > > > > > > > > mesh
> > > > > > > > > > > I'm drawing only appears for the first paintEvent and
then
> > > > > > > disappears
> > > > > > > > > from
> > > > > > > > > > > the view. If I comment out any qpainter draw commands
the
> > > mesh
> > > > > is
> > > > > > > > > correctly
> > > > > > > > > > > redrawn and can be rotated etc.
> > > > > > > > > > >
> > > > > > > > > > > Has anyone managed to get overpainting to work with
osg?
> > > > > > > > > > >
> > > > > > > > > > > Here is my paintEvent method in case anyone can spot
any
> > > obvious
> > > > > > > errors:
> > > > > > > > > > >
> > > > > > > > > > > void Viewer::paintEvent( QPaintEvent * )
> > > > > > > > > > > {
> > > > > > > > > > > qDebug() << "PaintEvent";
> > > > > > > > > > >
> > > > > > > > > > > QPainter painter;
> > > > > > > > > > > painter.begin(this);
> > > > > > > > > > > painter.setRenderHint (QPainter::Antialiasing);
> > > > > > > > > > > painter.setBrush( Qt::red );
> > > > > > > > > > >
> > > > > > > > > > > // Preserve the current GL state.
> > > > > > > > > > > glPushAttrib( GL_ALL_ATTRIB_BITS );
> > > > > > > > > > > glMatrixMode(GL_PROJECTION);
> > > > > > > > > > > glPushMatrix();
> > > > > > > > > > > glMatrixMode(GL_TEXTURE);
> > > > > > > > > > > glPushMatrix();
> > > > > > > > > > > glMatrixMode(GL_MODELVIEW);
> > > > > > > > > > > glPushMatrix();
> > > > > > > > > > >
> > > > > > > > > > > // Do our OSG stuff...
> > > > > > > > > > > /resizeGL( width(), height() );
> > > > > > > > > > > updateCamera();
> > > > > > > > > > >
> > > > > > > > > > > m_scene->update();
> > > > > > > > > > > m_scene->cull();
> > > > > > > > > > > m_scene->draw();
> > > > > > > > > > >
> > > > > > > > > > > // Restore the old GL state.
> > > > > > > > > > > glMatrixMode(GL_TEXTURE);
> > > > > > > > > > > glPopMatrix();
> > > > > > > > > > > glMatrixMode(GL_PROJECTION);
> > > > > > > > > > > glPopMatrix();
> > > > > > > > > > > glMatrixMode(GL_MODELVIEW);
> > > > > > > > > > > glPopMatrix();
> > > > > > > > > > > glPopAttrib();
> > > > > > > > > > >
> > > > > > > > > > > painter.drawLine ( 0, 0, width(), height() );
> > > > > > > > > > >
> > > > > > > > > > > painter.end();
> > > > > > > > > > >
> > > > > > > > > > > }
> > > > > > > > > > >
> > > > > > > > > > > Thanks in advance for any tips or help.
> > > > > > > > > > >
> > > > > > > > > > > Pete.
> > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > >
> > > _______________________________________________
> > > > > > > > > > > osg-users mailing list
> > > > > > > > > > > osg-users@openscenegraph.net
> > > > > > > > > > >
> > > > > > >
> > > http://openscenegraph.net/mailman/listinfo/osg-users
> > > > > > > > > > > http://www.openscenegraph.org/
> > > > > > > > > > >
> > > > > > > > > >
> > > _______________________________________________
> > > > > > > > > > osg-users mailing list
> > > > > > > > > > osg-users@openscenegraph.net
> > > > > > > > > >
> > > > >
http://openscenegraph.net/mailman/listinfo/osg-users
> > > > > > > > > > http://www.openscenegraph.org/
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > >
> > > > > > >
> > > > > > >
> > > > > >
> > > > >
> > > > >
> > > >
> > >
> > >
> > > _______________________________________________
> > > osg-users mailing list
> > > osg-users@openscenegraph.net
> > > http://openscenegraph.net/mailman/listinfo/osg-users
> > > http://www.openscenegraph.org/
> > >
> >
> >
> > --
> > Can Ozmen
> > ________________________
> > Computer Graphics Lab.
> > Sabanci University, Turkey
> >
> > phone: +(90) 216 483 9000 ext 2321
> > http://graphics.sabanciuniv.edu
> > http://students.sabanciuniv.edu/~canozmen
> > _______________________________________________
> > osg-users mailing list
> > osg-users@openscenegraph.net
> > http://openscenegraph.net/mailman/listinfo/osg-users
> > http://www.openscenegraph.org/
> >
>
>
_______________________________________________
osg-users mailing list
osg-users@openscenegraph.net
http://openscenegraph.net/mailman/listinfo/osg-users
http://www.openscenegraph.org/
