QtBaseViewer.cc

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *      Copyright (C) 2001-2009 by Computer Graphics Group, RWTH Aachen      *
 *                           www.openflipper.org                             *
 *                                                                           *
 *---------------------------------------------------------------------------*
 *  This file is part of OpenFlipper.                                        *
 *                                                                           *
 *  OpenFlipper is free software: you can redistribute it and/or modify      *
 *  it under the terms of the GNU Lesser General Public License as           *
 *  published by the Free Software Foundation, either version 3 of           *
 *  the License, or (at your option) any later version with the              *
 *  following exceptions:                                                    *
 *                                                                           *
 *  If other files instantiate templates or use macros                       *
 *  or inline functions from this file, or you compile this file and         *
 *  link it with other files to produce an executable, this file does        *
 *  not by itself cause the resulting executable to be covered by the        *
 *  GNU Lesser General Public License. This exception does not however       *
 *  invalidate any other reasons why the executable file might be            *
 *  covered by the GNU Lesser General Public License.                        *
 *                                                                           *
 *  OpenFlipper 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            *
 *  GNU Lesser General Public License for more details.                      *
 *                                                                           *
 *  You should have received a copy of the GNU LesserGeneral Public          *
 *  License along with OpenFlipper. If not,                                  *
 *  see <http://www.gnu.org/licenses/>.                                      *
 *                                                                           *
\*===========================================================================*/

/*===========================================================================*\
 *                                                                           *
 *   $Revision$                                                         *
 *   $Author$                                                      *
 *   $Date$                   *
 *                                                                           *
\*===========================================================================*/




//=============================================================================
//
//  CLASS glViewer - IMPLEMENTATION
//
//=============================================================================


//== INCLUDES =================================================================

#include "QtBaseViewer.hh"
#include "QtGLViewerLayout.hh"
#include "CursorPainter.hh"
#include <ACG/QtWidgets/QtWheel.hh>
#include <ACG/Scenegraph/DrawModes.hh>
#include <ACG/GL/gl.hh>

#include <iostream>
#include <string>
#include <assert.h>

#include <QMimeData>
#include <QToolButton>
#include <QFrame>

#include <QClipboard>
#include <QApplication>
#include <QSplitter>
#include <QLayout>
#include <QPushButton>
#include <QLabel>
#include <QImage>
#include <QColorDialog>
#include <QFileDialog>
#include <QToolTip>
#include <QTextStream>
#include <QDateTime>
#include <QTimer>

#include <QDesktopWidget>
#include <QMouseEvent>
#include <QVBoxLayout>
#include <QKeyEvent>
#include <QGridLayout>
#include <QContextMenuEvent>
#include <QWheelEvent>
#include <QDropEvent>
#include <QPixmap>
#include <QMenu>
#include <QVariant>
#include <QButtonGroup>
#include <QToolBar>

#include <QGraphicsView>
#include <QGraphicsScene>
#include <QGraphicsWidget>
#include <QGraphicsGridLayout>
#include <QGraphicsProxyWidget>
#include <QPainter>
#include <QPaintEngine>

#ifdef max
#  undef max
#endif

#ifdef min
#  undef min
#endif

#include <OpenFlipper/BasePlugin/PluginFunctions.hh>
#include <OpenFlipper/common/ViewObjectMarker.hh>

#include <OpenFlipper/common/GlobalOptions.hh>

#include <QGLFramebufferObject>

//== NAMESPACES ===============================================================



//== IMPLEMENTATION ==========================================================

static const char          VIEW_MAGIC[] =
  "ACG::QtWidgets::QGLViewerWidget encoded view";

//== IMPLEMENTATION ==========================================================


glViewer::glViewer( QGraphicsScene* _scene,
                    QGLWidget* _glWidget,
                    Viewer::ViewerProperties& _properties,
                    QGraphicsWidget* _parent) :
  QGraphicsWidget(_parent),
  glareaGrabbed_(false),
  projectionUpdateLocked_(false),
  blending_(true),
  glScene_(_scene),
  glWidget_(_glWidget),
  cursorPainter_(0),
  cursorPositionValid_(false),
  pickCache_(0),
  updatePickCache_(true),
  pickCacheSupported_(true),
  clickEvent_(QEvent::MouseButtonPress, QPoint (), Qt::NoButton, Qt::NoButton, Qt::NoModifier),
  properties_(_properties),
  glstate_(0),
  initialized_(false)
{

  // widget stuff
  createWidgets();

  // bind GL context to GL state class
  glstate_ = new ACG::GLState();
  properties_.setglState( glstate_ );

  // state
  orthoWidth_       = 2.0;
  isRotating_       = false;
  near_             = 0.1;
  far_              = 100.0;
  fovy_             = 45.0;

  sceneGraphRoot_   = 0;

  normalsMode_      = DONT_TOUCH_NORMALS;
  projectionMode_   = PERSPECTIVE_PROJECTION;
  navigationMode_	= NORMAL_NAVIGATION;


  light_matrix_.identity();

  trackMouse_ = false;

  // stereo
  stereo_ = false;

  // Note: we start locked (initialization of updateLocked_)
  // will be unlocked in initializeGL()

  QSizePolicy sp = sizePolicy();
  sp.setHorizontalPolicy( QSizePolicy::Expanding );
  sp.setVerticalPolicy( QSizePolicy::Expanding );
  sp.setHorizontalStretch( 1 );
  sp.setVerticalStretch( 1 );
  setSizePolicy( sp );

  redrawTime_.start ();

  // timer for animation
  timer_ = new QTimer( this );
  connect( timer_, SIGNAL(timeout()), this, SLOT( slotAnimation()) );

  allowRotation_ = true;


  connect( &properties_,SIGNAL(updated()), this, SLOT( slotPropertiesUpdated() ) );


  //check for updated properties once
  slotPropertiesUpdated();

  setAcceptDrops(true);

  setHome();

  // initialize custom anaglyph stereo
  agTexWidth_ = 0;
  agTexHeight_ = 0;
  agTexture_[0] = 0;
  agTexture_[1] = 0;
  agProgram_ = 0;
  customAnaglyphSupported_ = false;

  clickTimer_.setSingleShot (true);
  connect (&clickTimer_, SIGNAL(timeout ()), this, SLOT(slotClickTimeout ()));
}


//-----------------------------------------------------------------------------


glViewer::~glViewer()
{
  finiCustomAnaglyphStereo ();
  delete glstate_;
}


//-----------------------------------------------------------------------------


QSize
glViewer::sizeHint() const
{
  return QSize( 600, 600 );
}

//-----------------------------------------------------------------------------


void glViewer::makeCurrent() {
  glWidget_->makeCurrent();
}

void glViewer::swapBuffers() {
  glWidget_->swapBuffers();
}


//-----------------------------------------------------------------------------


void glViewer::sceneGraph(ACG::SceneGraph::BaseNode* _root, const bool _setCenter)
{
//   if (sceneGraphRoot_ == _root)
//     return;

  sceneGraphRoot_ = _root;

  if (sceneGraphRoot_ )
  {
    // get scene size
    ACG::SceneGraph::BoundingBoxAction act;
    ACG::SceneGraph::traverse(sceneGraphRoot_, act);

    ACG::Vec3d bbmin = (ACG::Vec3d) act.bbMin();
    ACG::Vec3d bbmax = (ACG::Vec3d) act.bbMax();

    if ( ( bbmin[0] > bbmax[0] ) ||
         ( bbmin[1] > bbmax[1] ) ||
         ( bbmin[2] > bbmax[2] )   )
      setScenePos( ACG::Vec3d( 0.0,0.0,0.0 ) , 1.0, _setCenter );
    else
      setScenePos( ( bbmin + bbmax )        * 0.5,
                   ( bbmax - bbmin ).norm() * 0.5,
                   _setCenter);
  }

  updateGL();

  emit(signalSceneGraphChanged(sceneGraphRoot_));
}


//-----------------------------------------------------------------------------


void glViewer::trackMouse(bool _track)
{
  trackMouse_ = _track;
}


//-----------------------------------------------------------------------------

void glViewer::perspectiveProjection()
{
  projectionMode(PERSPECTIVE_PROJECTION);
  updateGL();
}


void glViewer::orthographicProjection()
{
  projectionMode(ORTHOGRAPHIC_PROJECTION);
  updateGL();
}


void glViewer::toggleProjectionMode()
{
  if (projectionMode_ == ORTHOGRAPHIC_PROJECTION)
    projectionMode(PERSPECTIVE_PROJECTION);
  else
    projectionMode(ORTHOGRAPHIC_PROJECTION);

  updateGL();
}


void glViewer::projectionMode(ProjectionMode _p)
{
  if ((projectionMode_ = _p) == ORTHOGRAPHIC_PROJECTION)
    emit projectionModeChanged( true );
  else
    emit projectionModeChanged( false );

  updateProjectionMatrix();
}

void glViewer::toggleNavigationMode()
{
  if (navigationMode_ == NORMAL_NAVIGATION)
    navigationMode(EGOSHOOTER_NAVIGATION);
  else
    navigationMode(NORMAL_NAVIGATION);
}


void glViewer::navigationMode(NavigationMode _n)
{
  if ((navigationMode_ = _n) == NORMAL_NAVIGATION)
    emit navigationModeChanged( true );
  else
    emit navigationModeChanged( false );
}


void glViewer::updateProjectionMatrix()
{
  if( projectionUpdateLocked_ )
    return;

  makeCurrent();

  glstate_->reset_projection();

  // In scereo mode we have to use a perspective matrix
  if (stereo_ || projectionMode_ == PERSPECTIVE_PROJECTION)
  {
    double aspect;

    if (isVisible() && glWidth() && glHeight())
      aspect = (double) glWidth() / (double) glHeight();
    else
      aspect = 1.0;

    glstate_->perspective(fovy_, (GLdouble) aspect,
                          near_, far_);
  }
  else
  {
    double aspect;

    if (isVisible() && glWidth() && glHeight())
      aspect = (double) glWidth() / (double) glHeight();
    else
      aspect = 1.0;

    glstate_->ortho( -orthoWidth_, orthoWidth_,
                     -orthoWidth_/aspect, orthoWidth_/aspect,
                     near_, far_ );
  }
}


//-----------------------------------------------------------------------------


void glViewer::setScenePos(const ACG::Vec3d& _center, double _radius, const bool _setCenter)
{
	if(_setCenter) {
		scene_center_ = trackball_center_ = _center;
	}

	scene_radius_ = trackball_radius_ = _radius;

// 	orthoWidth_ = 2.0   * scene_radius_;
	near_       = 0.001 * scene_radius_;
	far_        = 10.0  * scene_radius_;

	updateProjectionMatrix();
	updateGL();
}

//-----------------------------------------------------------------------------

void glViewer::setSceneCenter( const ACG::Vec3d& _center ) {

	scene_center_ = trackball_center_ = _center;
}

//----------------------------------------------------------------------------


void glViewer::viewingDirection( const ACG::Vec3d& _dir, const ACG::Vec3d& _up )
{
  // calc eye point for this direction
  ACG::Vec3d eye = scene_center_ - _dir*(3.0*scene_radius_);

  glstate_->reset_modelview();
  glstate_->lookAt((ACG::Vec3d)eye, (ACG::Vec3d)scene_center_, (ACG::Vec3d)_up);
}


//-----------------------------------------------------------------------------


void glViewer::normalsMode(NormalsMode _mode)
{
  makeCurrent();

  switch(normalsMode_ = _mode)
  {
    case DONT_TOUCH_NORMALS:
      glDisable(GL_NORMALIZE);
      break;

    case NORMALIZE_NORMALS:
      glEnable(GL_NORMALIZE);
      break;
  }

  updateGL();
}


//-----------------------------------------------------------------------------


void
glViewer::copyToImage( QImage& _image,
		       unsigned int _l, unsigned int _t,
		       unsigned int _w, unsigned int _h,
			   GLenum /* _buffer */ )
{

//    qApp->processEvents();
//    makeCurrent();

  _image = glWidget_->grabFrameBuffer(true).copy (_l, _t, _w, _h).convertToFormat (QImage::Format_RGB32);
}


//-----------------------------------------------------------------------------


void glViewer::updateGL()
{
  if (!properties_.updateLocked() && isVisible() )
  {
    updatePickCache_ = true;
    update();

    emit viewUpdated();
  }
}



//-----------------------------------------------------------------------------


void glViewer::drawScene()
{
  QTime  timer;
  timer.start();


  // *****************************************************************
  // Adjust clipping planes
  // *****************************************************************
  // Far plane
  ACG::Vec3d c = glstate_->modelview().transform_point(scene_center_);

  // Set far plane
  far_    = std::max(0.0002f * scene_radius_,  -(c[2] - scene_radius_));

  // Set near plane
  near_   = std::max(0.0001f * scene_radius_,  -(c[2] + scene_radius_));

  // measure distance from scene center ( as projection onto the z-Axis )
//   if ( -c[2] < scene_radius_ ) {
//     std::cerr << "Camera in scene radius" << std::endl;
//
//   }
//
//   std::cerr << "-c[2]   : " << -c[2] << std::endl;
//   std::cerr << "radius  : " << scene_radius_ << std::endl;
//   std::cerr << "z-range : " << far_ - near_ << std::endl;
//   std::cerr << "Near    : " << near_ << std::endl;
//   std::cerr << "Far     : " << far_ << std::endl;
//   near_   = std::max(far_ / 256.0f,  -(c[2] + scene_radius_));

  updateProjectionMatrix();

  // store time since last repaint in gl state and restart timer
  glstate_->set_msSinceLastRedraw (redrawTime_.restart ());

  // draw mono or stereo
  makeCurrent();
  if (stereo_) drawScene_stereo();
  else         drawScene_mono();

  glFinish();
  frame_time_ = timer.elapsed();


}


//-----------------------------------------------------------------------------


void glViewer::drawScene_mono()
{
  if (sceneGraphRoot_)
  {
    if (! properties_.renderPicking() ) {

      ViewObjectMarker *oM = properties_.objectMarker();
      GLuint refBits = 0;
      QSet<GLuint> references;

      if (oM)
      {
        glClear (GL_STENCIL_BUFFER_BIT);
        glEnable (GL_STENCIL_TEST);
        glStencilOp (GL_KEEP, GL_KEEP, GL_ZERO);
        glStencilFunc (GL_ALWAYS, 0, ~0);

        for (PluginFunctions::ObjectIterator o_it(PluginFunctions::ALL_OBJECTS, DATA_ALL) ;
                                             o_it != PluginFunctions::objectsEnd(); ++o_it)
        {
          bool ok;
          GLuint ref;

          ok = oM->stencilRefForObject(*o_it, ref);

          if (ok)
          {
            o_it->stencilRefNode ()->setReference (ref);
            o_it->stencilRefNode ()->show ();
            refBits |= ref;
            references << ref;
          }
          else
            o_it->stencilRefNode ()->hide ();
        }
      }

      ACG::SceneGraph::DrawAction action( properties_.drawMode() , false);
      ACG::SceneGraph::traverse(sceneGraphRoot_, action, *glstate_, properties_.drawMode() );

      if( blending_ )
      {
        ACG::SceneGraph::DrawAction action(properties_.drawMode(), true);
        ACG::SceneGraph::traverse(sceneGraphRoot_, action, *glstate_, properties_.drawMode());
      }

      if (oM)
      {
        if (oM->type() == ViewObjectMarker::PerBit)
        {
          references.clear ();
          for (unsigned int i = 0; i < sizeof (GLuint) * 8; i++)
            if (refBits & (1 << i))
              references << (1 << i);
        }

        glPushAttrib(GL_ALL_ATTRIB_BITS);

        glEnable(GL_BLEND);
        glDisable(GL_DEPTH_TEST);
        glDisable(GL_LIGHTING);
        glDisable(GL_DITHER);

        int vp_l, vp_b, vp_w, vp_h;
        glstate_->get_viewport (vp_l, vp_b, vp_w, vp_h);

        glMatrixMode(GL_PROJECTION);
        glPushMatrix ();
        glLoadIdentity();
        glOrtho(0, vp_w, vp_h, 0, 0, 1.0);
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix ();
        glLoadIdentity();

        glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);

        foreach (unsigned int ref, references)
        {
          bool ok;
          GLenum sfactor;
          GLenum dfactor;
          ACG::Vec4f color;
          unsigned int mask = ~0;

          if (oM->type() == ViewObjectMarker::PerBit)
          {
            ok = oM->blendForStencilRefBit (ref, sfactor, dfactor, color);
            mask = ref;
          }
          else
            ok = oM->blendForStencilRefNumber (ref, sfactor, dfactor, color);

          if (!ok)
            continue;

          glStencilFunc (GL_EQUAL, ref, mask);

          glBlendFunc (sfactor, dfactor);
          glColor4f (color[0], color [1], color [2], color[3]);

          glBegin (GL_QUADS);
          glVertex2i(0, 0);
          glVertex2i(0, vp_h);
          glVertex2i(vp_w, vp_h);
          glVertex2i(vp_w, 0);
          glEnd ();

        }

        glMatrixMode(GL_PROJECTION);
        glPopMatrix ();
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix ();

        glPopAttrib ();
        glDisable (GL_STENCIL_TEST);
      }
    } else {

      // prepare GL state
      makeCurrent();

      glDisable(GL_LIGHTING);
      glDisable(GL_BLEND);
      glClear(GL_DEPTH_BUFFER_BIT);
      glInitNames();
      glPushName((GLuint) 0);

      // do the picking
      glstate_->pick_init (true);
      ACG::SceneGraph::PickAction action(*glstate_, properties_.renderPickingMode(), properties_.drawMode());
      ACG::SceneGraph::traverse(sceneGraphRoot_, action);

      glEnable(GL_LIGHTING);
      glEnable(GL_BLEND);
    }
  }

  if (cursorPainter_ && cursorPainter_->enabled () && cursorPositionValid_)
  {
    glstate_->push_modelview_matrix ();
    // reset view transformation
    glstate_->reset_modelview ();
    // translate cursor position to 0,0
    glstate_->translate (cursorPoint3D_[0], cursorPoint3D_[1], cursorPoint3D_[2]);
    // paint cursor
    cursorPainter_->paintCursor (glstate_);
    glstate_->pop_modelview_matrix ();
  }

  draw_lights();
}


//-----------------------------------------------------------------------------


void
glViewer::drawScene_stereo()
{
  if (OpenFlipper::Options::stereoMode () == OpenFlipper::Options::OpenGL && OpenFlipper::Options::glStereo ())
  {
    drawScene_glStereo ();
    return;
  }
  else if (OpenFlipper::Options::stereoMode () == OpenFlipper::Options::AnaglyphCustom && customAnaglyphSupported_)
  {
    drawScene_customAnaglyphStereo ();

    // if somthing went wrong, fallback to normal anaglyph
    if (customAnaglyphSupported_)
      return;
  }

  drawScene_anaglyphStereo ();
}


//-----------------------------------------------------------------------------


void glViewer::setHome()
{
  home_modelview_          = glstate_->modelview();
  home_inverse_modelview_  = glstate_->inverse_modelview();
  homeOrthoWidth_          = orthoWidth_;
  home_center_             = trackball_center_;
  home_radius_             = trackball_radius_;
}


void glViewer::home()
{
  makeCurrent();
  glstate_->set_modelview(home_modelview_, home_inverse_modelview_);
  orthoWidth_ = homeOrthoWidth_;
  trackball_center_ = home_center_;
  trackball_radius_ = home_radius_;
  updateProjectionMatrix();
  updateGL();

}


//-----------------------------------------------------------------------------


void glViewer::viewAll()
{
	makeCurrent();

	// update scene graph (get new bounding box and set projection right, including near and far plane)
	properties_.lockUpdate();

	// move center (in camera coords) to origin and translate in -z dir
	translate(-(glstate_->modelview().transform_point(scene_center_))
			- ACG::Vec3d(0.0, 0.0, 3.0 * scene_radius_));

	orthoWidth_ = 1.1 * scene_radius_;
	double aspect = (double) glWidth() / (double) glHeight();
	if (aspect > 1.0)
		orthoWidth_ *= aspect;

	sceneGraph(PluginFunctions::getSceneGraphRootNode(), true);

	properties_.unLockUpdate();
	updateProjectionMatrix();
	updateGL();

}


//-----------------------------------------------------------------------------


void glViewer::flyTo(const QPoint& _pos, bool _move_back)
{
  makeCurrent();

  unsigned int nodeIdx, targetIdx;
  ACG::Vec3d hitPoint;

  if (pick( ACG::SceneGraph::PICK_ANYTHING, _pos, nodeIdx, targetIdx, &hitPoint))
  {
    if (projectionMode_ == PERSPECTIVE_PROJECTION)
    {
      ACG::Vec3d eye(glstate_->eye());
      ACG::Vec3d t = hitPoint - eye;
      ACG::Vec3d e = eye + t * (_move_back ? -0.5f : 0.5f);
      flyTo(e, hitPoint, 300);
    }
    else
    {
      // Zoom in or out?
      orthoWidth_ *= _move_back ? 2.0 : 0.5;

      // Set the double click point as the new trackball center
      // Rotations will use this point as the center.
      trackball_center_ = hitPoint;

      /// @todo : Translate view such that hitpoint is in center of viewport

      // Update the projection matrix
      updateProjectionMatrix();

      // Redraw scene
      updateGL();
    }


  }
}


void glViewer::flyTo(const ACG::Vec3d&  _position,
			 const ACG::Vec3d&  _center,
			 double        _time)
{
  makeCurrent();

  // compute rotation
  ACG::Vec3d c = glstate_->modelview().transform_point(_center);
  ACG::Vec3d p = glstate_->modelview().transform_point(_position);
  ACG::Vec3d view =(p-c).normalize();
  ACG::Vec3d z(0,0,1);
  ACG::Vec3d axis = (z % -view).normalize();
  double angle = acos(std::max(-1.0,
			      std::min(1.0,
				       (z | view)))) / M_PI * 180.0;

  if (angle > 175)
    axis  = ACG::Vec3d(0,1,0);


  // compute translation
  ACG::Vec3d target = glstate_->modelview().transform_point(_center);
  ACG::Vec3d trans ( -target[0],
		-target[1],
		-target[2] - (_position-_center).norm() );



  // how many frames in _time ms ?
  unsigned int  frames = (unsigned int)(_time / frame_time_);
  if (frames > 1000) frames=1000;




  // animate it
  if (frames > 10)
  {
    ACG::Vec3d t = trans / (double)frames;
    double a = angle / (double)frames;

    for (unsigned int i=0; i<frames; ++i)
    {
      translate(t);
      if (fabs(a) > FLT_MIN)
	     rotate(axis, a, _center);

      update();
      qApp->processEvents();
    }
    updatePickCache_ = true;
  }


  // no animation
  else
  {
    translate(trans);
    if (fabs(angle) > FLT_MIN)
      rotate(axis, angle, _center);

    updateGL();
  }


  trackball_center_ = _center;
  trackball_radius_ = std::max(scene_radius_,
			       (_center-_position).norm()*0.9f);
}


//-----------------------------------------------------------------------------


void glViewer::setView(const ACG::GLMatrixd& _modelview,
			                  const ACG::GLMatrixd& _inverse_modelview)
{
  makeCurrent();
  glstate_->set_modelview(_modelview, _inverse_modelview);
  updateGL();
}


//-----------------------------------------------------------------------------


void glViewer::initializeGL()
{

  // lock update
  properties_.lockUpdate();

  // init GL state
  glstate_->initialize();

  // OpenGL state
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_LIGHTING);
  glDisable(GL_DITHER);
  glShadeModel( GL_FLAT );


  projectionMode(   projectionMode_   );
  normalsMode(      normalsMode_      );

  // Update all settings which would require a redraw
  applyProperties();

  // light sources
  light_matrix_.identity();
  update_lights();


  // scene pos and size
  scene_center_ = trackball_center_ = ACG::Vec3d( 0.0, 0.0, 0.0 );
  scene_radius_ = trackball_radius_ = 1.0;
  orthoWidth_   = 2.0;


  // modelview
  glstate_->translate(0.0, 0.0, -3.0);
  setHome();


  // pixel transfer
  glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
  glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
  glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glPixelStorei(GL_PACK_ROW_LENGTH, 0);
  glPixelStorei(GL_PACK_SKIP_ROWS, 0);
  glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
  glPixelStorei(GL_PACK_ALIGNMENT, 1);


  // unlock update (we started locked)
  properties_.unLockUpdate();

  customAnaglyphSupported_ = glewIsSupported("GL_ARB_fragment_program") &&
      (glewIsSupported("GL_ARB_texture_rectangle") ||
       glewIsSupported("GL_EXT_texture_rectangle") ||
       glewIsSupported("GL_NV_texture_rectangle"));

  initialized_ = true;

  if (sceneGraphRoot_)
  {
    sceneGraph(sceneGraphRoot_, true);
    viewAll ();
  }
}


//-----------------------------------------------------------------------------

/**
 *
 */
void  glViewer::draw_lights() {
//   makeCurrent();
// //
//   glMatrixMode(GL_MODELVIEW);
//   glPushMatrix();
//   glLoadIdentity();
//   glMultMatrixd(light_matrix_.data());
//
//   std::cerr << "light_matrix_\n" << light_matrix_ << std::endl;
// //
//   glPointSize(3);
// //
//   glColor3f(1.0,1.0,1.0);
// //   glDisable(GL_LIGHTING);
// //   glDisable(GL_BLEND);
//   glBegin(GL_LINES);
//     glVertex3f(0.0,  0.0, -1000.0);
//     glVertex3f(0.0,  0.0, 10000.0);
//     glVertex3f(0.0, -1000.0,0.0);
//     glVertex3f(0.0, 1000.0,0.0);
//     glVertex3f(1000.0,0.0,0.0);
//     glVertex3f(-1000.0,0.0,0.0);
// //     glVertex3d(0.0,  0.0, 1.1);
// //     glVertex3d(-1.0,  1.0, 0.8);
// //     glVertex3d( 1.0,  1.0, 0.8);
//
//   glEnd();
// //   glEnable(GL_LIGHTING);
// //   glEnable(GL_BLEND);