glvertex_qt_glwidget.h

Go to the documentation of this file.

// (c) by Stefan Roettger, licensed under MIT license
 
#ifndef GLVERTEX_QT_GLWIDGET_H
#define GLVERTEX_QT_GLWIDGET_H
 
#include "glvertex_qt.h"
 
#include <QTime>
#include <QElapsedTimer>
#include <QKeyEvent>
 
#if (QT_VERSION>=QT_VERSION_CHECK(5, 9, 0)) && !defined(LGL_GLES)
#   define LGL_USE_QOPENGLWIDGET
#endif
 
#ifndef LGL_USE_QOPENGLWIDGET
#   include <QGLWidget>
#   define LGL_QGLWIDGET QGLWidget
#else
#   include <QOpenGLWidget>
#   define LGL_QGLWIDGET QOpenGLWidget
#endif
 
class lgl_Qt_GLWidget: public LGL_QGLWIDGET
{
public:
 
   lgl_Qt_GLWidget(QWidget *parent = NULL,
                   bool core = true)
      : LGL_QGLWIDGET(parent),
        core_(core),
        time_(0),
        speedup_(1),
        background_(false),
        red_(0), green_(0), blue_(0), alpha_(1),
        animation_(true),
        override_(false),
        ztest_(true),
        culling_(false),
        blending_(false),
        atest_(false),
        wireframe_(false),
        fullscreen_(false),
        timerid_(-1)
   {
      setFocusPolicy(Qt::ClickFocus);
 
#if (LGL_OPENGL_VERSION>=30) || defined(LGL_GLES)
#ifndef LGL_USE_QOPENGLWIDGET
      QGLFormat format(QGL::DoubleBuffer | QGL::DepthBuffer);
      format.setSwapInterval(1);
      if (core_)
      {
#if (LGL_OPENGL_VERSION >= 30)
#if (LGL_OPENGL_VERSION >= 32) && !defined(__APPLE__)
         format.setVersion(3, 2);
#else
         format.setVersion(3, 0);
#endif
#else
         format.setVersion(2, 0);
#endif
#ifndef FORCE_COMPATIBILITY_PROFILE
         format.setProfile(QGLFormat::CoreProfile);
#else
         format.setProfile(QGLFormat::CompatibilityProfile);
#endif
      }
      setFormat(format);
#else
      QSurfaceFormat format;
      format.setDepthBufferSize(24);
      format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
#if (QT_VERSION >= QT_VERSION_CHECK(5, 3, 0))
      format.setSwapInterval(1);
#endif
      if (core_)
      {
#if (LGL_OPENGL_VERSION >= 30)
#if (LGL_OPENGL_VERSION >= 32) && !defined(__APPLE__)
         format.setVersion(3, 2);
#else
         format.setVersion(3, 0);
#endif
#else
         format.setVersion(2, 0);
#endif
#ifndef FORCE_COMPATIBILITY_PROFILE
         format.setProfile(QSurfaceFormat::CoreProfile);
#else
         format.setProfile(QSurfaceFormat::CompatibilityProfile);
#endif
      }
      setFormat(format);
#endif
#endif
 
#ifdef QT_DEBUG
 
#if (LGL_OPENGL_VERSION >= 30)
      std::cerr << "Creating QGLWidget with"
                << std::endl
                << " opengl "
#ifndef LGL_USE_QOPENGLWIDGET
                << (format.profile()==QGLFormat::CoreProfile? "core" : "compatibility")
#else
                << (format.profile()==QSurfaceFormat::CoreProfile? "core" : "compatibility")
#endif
                << " profile"
                << std::endl
                << " version "
                << format.majorVersion() << "." << format.minorVersion()
                << std::endl
                << std::endl;
#endif
 
#endif
 
      setFPS(30);
   }
 
   virtual ~lgl_Qt_GLWidget()
   {
      finish();
   }
 
   void setFPS(double rate)
   {
      fps_ = rate;
 
      if (fps_ > 0)
         timerid_ = startTimer((int)(1000/fps_));
      else
      {
         if (timerid_ >= 0) killTimer(timerid_);
         timerid_ = -1;
      }
 
      timer_.start();
      update();
   }
 
   void setTimeLapse(double speedup)
   {
      speedup_ = speedup;
   }
 
   void background(double red, double green, double blue, double alpha=1)
   {
      background_ = true;
      red_ = red;
      green_ = green;
      blue_ = blue;
      alpha_ = alpha;
      update();
   }
 
   void toggle_background()
   {
      if (red_+green_+blue_ > 1.5)
         background(0,0,0);
      else
         background(1,1,1);
   }
 
   void animation(bool on)
   {
      animation_ = on;
      if (animation_) timer_.start();
      update();
   }
 
   void toggle_animation()
   {
      animation(!animation_);
   }
 
   void ztest(bool on)
   {
      if (on != ztest_)
      {
         override_ = true;
         ztest_ = on;
         update();
      }
   }
 
   void toggle_ztest()
   {
      ztest(!ztest_);
   }
 
   void culling(bool on)
   {
      if (on != culling_)
      {
         override_ = true;
         culling_ = on;
         update();
      }
   }
 
   void toggle_culling()
   {
      culling(!culling_);
   }
 
   void blending(bool on)
   {
      if (on != blending_)
      {
         override_ = true;
         blending_ = on;
         update();
      }
   }
 
   void toggle_blending()
   {
      blending(!blending_);
   }
 
   void atest(bool on)
   {
      if (on != atest_)
      {
         override_ = true;
         atest_ = on;
         update();
      }
   }
 
   void toggle_atest()
   {
      atest(!atest_);
   }
 
   void wireframe(bool on)
   {
      if (on != wireframe_)
      {
         override_ = true;
         wireframe_ = on;
         update();
      }
   }
 
   void toggle_wireframe()
   {
      wireframe(!wireframe_);
   }
 
   void override(bool on)
   {
      override_ = on;
      if (!override_) background_ = false;
      update();
   }
 
   void fullscreen(bool on)
   {
      if (on != fullscreen_)
      {
         fullscreen_ = on;
         if (fullscreen_) showFullScreen();
         else showNormal();
         setFocus();
         update();
      }
   }
 
   void toggle_fullscreen()
   {
      fullscreen(!fullscreen_);
   }
 
   void restart()
   {
      time_ = 0;
   }
 
protected:
 
   bool core_; // OpenGL core profile?
 
   double time_; // elapsed time
 
   double fps_; // animated frames per second
   double speedup_; // time lapse speedup
 
   bool background_;
   double red_, green_, blue_, alpha_;
 
   bool animation_;
   bool override_;
   bool ztest_;
   bool culling_;
   bool blending_;
   bool atest_;
   bool wireframe_;
   bool fullscreen_;
 
   QElapsedTimer timer_;
   int timerid_;
 
   void initializeGL()
   {
      initialize();
 
#ifndef LGL_USE_QOPENGLWIDGET
      qglClearColor(Qt::black);
#else
      glClearColor(0,0,0,1);
#endif
 
      initializeOpenGL();
   }
 
   void resizeGL(int, int)
   {
      lglViewport(0, 0, width(), height());
 
      if (fullscreen_)
         setFocus();
   }
 
   void paintGL()
   {
      if (override_)
      {
         lglDepthTest(ztest_);
         lglBackFaceCulling(culling_);
         lglBlendMode(blending_?LGL_BLEND_ALPHA:LGL_BLEND_NONE);
         lglAlphaTest(atest_);
         lglPolygonMode(wireframe_?LGL_LINE:LGL_FILL);
      }
 
      if (background_)
      {
         lglClearColor(red_, green_, blue_, alpha_);
         lglClear();
      }
 
      double dt = 0.001*timer_.elapsed();
      if (!animation_) dt = 0;
      else dt *= speedup_;
 
      timer_.start();
 
      prepareOpenGL(dt);
      renderOpenGL(dt);
      updateOpenGL(dt);
      finishOpenGL(time_+=dt);
 
      if (fps_ <= 0)
         if (animation_)
            update();
   }
 
   void keyPressEvent(QKeyEvent *event)
   {
#ifndef __APPLE__
      Qt::KeyboardModifier ctrl = Qt::ControlModifier;
#else
      Qt::KeyboardModifier ctrl = Qt::MetaModifier;
#endif
 
      if (event->modifiers() & ctrl)
         if (event->key() == Qt::Key_Space)
         {
            animation(!animation_);
         }
         else if (event->key() == Qt::Key_Z)
         {
            ztest(!ztest_);
         }
         else if (event->key() == Qt::Key_C)
         {
            culling(!culling_);
         }
         else if (event->key() == Qt::Key_B)
         {
            blending(!blending_);
         }
         else if (event->key() == Qt::Key_A)
         {
            atest(!atest_);
         }
         else if (event->key() == Qt::Key_W)
         {
            wireframe(!wireframe_);
         }
         else if (event->key() == Qt::Key_0)
         {
            background(0,0,0);
         }
         else if (event->key() == Qt::Key_1)
         {
            background(1,1,1);
         }
         else if (event->key() == Qt::Key_2)
         {
            background(0.5,0.5,0.5);
         }
         else if (event->key() == Qt::Key_O)
         {
            override(!override_);
         }
         else if (event->key() == Qt::Key_F)
         {
            fullscreen(!fullscreen_);
         }
         else
            event->ignore();
      else
         event->ignore();
   }
 
   void timerEvent(QTimerEvent *)
   {
      if (animation_)
         update();
   }
 
   virtual void initialize() {lglInitializeOpenGL();}
 
   virtual void initializeOpenGL() = 0;
 
   virtual void renderOpenGL(double dt) = 0;
 
   virtual void prepareOpenGL(double dt) {}
 
   virtual void updateOpenGL(double dt) {}
 
   virtual void finishOpenGL(double t) {}
 
   virtual void finish() {}
};
 
#endif