libQGLViewer standardCamera example

Home Download Gallery Documentation Developer

# The standardCamera example

A 'standard' Camera with fixed near and far planes.

A new `StandardCamera` class is derived from `Camera`. Its near and far planes distances are set to fixed values (instead of being fit to scene dimensions as is done in the `QGLViewer::Camera`).

The orthographic frustum dimensions are fixed instead of depending on the distance to the `pivotPoint()`. Since this may be needed for some applications, you may want to use this `standardCamera` class in your code.

## standardCamera.h

    #include <QGLViewer/camera.h>

    class StandardCamera : public qglviewer::Camera {
    public:
      StandardCamera();

      virtual qreal zNear() const;
      virtual qreal zFar() const;

      void toggleMode() { standard = !standard; }
      bool isStandard() { return standard; }

      void changeOrthoFrustumSize(int delta);
      virtual void getOrthoWidthHeight(GLdouble &halfWidth,
                                       GLdouble &halfHeight) const;

    private:
      bool standard;
      float orthoSize;
    };

## standardCamera.cpp

    #include "standardCamera.h"

    #include <QWheelEvent>

    using namespace qglviewer;

    StandardCamera::StandardCamera() {
      standard = true;
      orthoSize = 1.0;
    }

    qreal StandardCamera::zNear() const {
      if (standard)
        return 0.001;
      else
        return Camera::zNear();
    }

    qreal StandardCamera::zFar() const {
      if (standard)
        return 1000.0;
      else
        return Camera::zFar();
    }

    void StandardCamera::changeOrthoFrustumSize(int delta) {
      if (delta > 0)
        orthoSize *= 1.1;
      else
        orthoSize /= 1.1;
    }

    void StandardCamera::getOrthoWidthHeight(GLdouble &halfWidth,
                                             GLdouble &halfHeight) const {
      if (standard) {
        halfHeight = orthoSize;
        halfWidth = aspectRatio() * orthoSize;
      } else
        Camera::getOrthoWidthHeight(halfWidth, halfHeight);
    }

## cameraViewer.h

    #include <QGLViewer/qglviewer.h>

    class CameraViewer : public QGLViewer {
    public:
      CameraViewer(qglviewer::Camera *camera);

    protected:
      virtual void draw();
      virtual void init();

    private:
      qglviewer::Camera *c;
    };

## viewer.h

    #include <QGLViewer/qglviewer.h>

    class StandardCamera;

    class Viewer : public QGLViewer {
      Q_OBJECT

    public:
      Viewer(StandardCamera *camera);

    public:
    Q_SIGNALS:
      void cameraChanged();

    protected:
      virtual void draw();
      virtual void init();
      virtual QString helpString() const;
      virtual void keyPressEvent(QKeyEvent *e);
      virtual void wheelEvent(QWheelEvent *e);

    private:
      void showMessage();
    };

## cameraViewer.cpp

    #include "cameraViewer.h"

    using namespace qglviewer;

    CameraViewer::CameraViewer(Camera *camera) : c(camera){};

    void CameraViewer::draw() {
      // Exactly the same draw than for 'Viewer'. The two viewers could also share a
      // 'Scene' instance.
      const float nbSteps = 200.0;

      glBegin(GL_QUAD_STRIP);
      for (int i = 0; i < nbSteps; ++i) {
        const float ratio = i / nbSteps;
        const float angle = 21.0 * ratio;
        const float c = cos(angle);
        const float s = sin(angle);
        const float r1 = 1.0 - 0.8f * ratio;
        const float r2 = 0.8f - 0.8f * ratio;
        const float alt = ratio - 0.5f;
        const float nor = 0.5f;
        const float up = sqrt(1.0 - nor * nor);
        glColor3f(1.0 - ratio, 0.2f, ratio);
        glNormal3f(nor * c, up, nor * s);
        glVertex3f(r1 * c, alt, r1 * s);
        glVertex3f(r2 * c, alt + 0.05f, r2 * s);
      }
      glEnd();

      // Draws the other viewer's camera
      glDisable(GL_LIGHTING);
      glLineWidth(4.0);
      glColor4f(1.0, 1.0, 1.0, 0.5);
      c->draw();
      glEnable(GL_LIGHTING);
    }

    void CameraViewer::init() {
      // Places the cameraViewer's camera far away in order to see the (other
      // viewer) camera.
      if (!restoreStateFromFile()) {
        // Make near and far planes much further from scene in order not to clip c's
        // display.
        camera()->setZClippingCoefficient(50.0);
        camera()->setViewDirection(qglviewer::Vec(0.0, -1.0, 0.0));
        showEntireScene();
      }

      // Enable semi-transparent culling planes
      glEnable(GL_BLEND);
      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    }

## main.cpp

    #include "cameraViewer.h"
    #include "standardCamera.h"
    #include "viewer.h"

    #include <QApplication>
    #include <QGLViewer/manipulatedCameraFrame.h>

    int main(int argc, char **argv) {
      QApplication application(argc, argv);

      // Instantiate the two viewers.
      StandardCamera *sc = new StandardCamera();
      Viewer viewer(sc);
      CameraViewer cviewer(sc);

      // Make sure every v camera movement updates the camera viewer
      QObject::connect(viewer.camera()->frame(), SIGNAL(manipulated()), &cviewer,
                       SLOT(updateGL()));
      QObject::connect(viewer.camera()->frame(), SIGNAL(spun()), &cviewer,
                       SLOT(updateGL()));
      // Also update on camera change (type or mode)
      QObject::connect(&viewer, SIGNAL(cameraChanged()), &cviewer,
                       SLOT(updateGL()));

      viewer.setWindowTitle("standardCamera");
      cviewer.setWindowTitle("Camera viewer");

      cviewer.show();
      viewer.show();

      return application.exec();
    }

## viewer.cpp

    #include "viewer.h"
    #include "standardCamera.h"

    #include <QKeyEvent>

    #if QT_VERSION > QT_VERSION_CHECK(6, 0, 0)
    #define MidButton MiddleButton
    #endif

    using namespace std;
    using namespace qglviewer;

    Viewer::Viewer(StandardCamera *nfc) {
      // Change the camera.
      Camera *c = camera();
      setCamera(nfc);
      delete c;
    }

    // Draws a spiral
    void Viewer::draw() {
      const float nbSteps = 200.0;

      glBegin(GL_QUAD_STRIP);
      for (int i = 0; i < nbSteps; ++i) {
        const float ratio = i / nbSteps;
        const float angle = 21.0 * ratio;
        const float c = cos(angle);
        const float s = sin(angle);
        const float r1 = 1.0 - 0.8f * ratio;
        const float r2 = 0.8f - 0.8f * ratio;
        const float alt = ratio - 0.5f;
        const float nor = 0.5f;
        const float up = sqrt(1.0 - nor * nor);
        glColor3f(1.0 - ratio, 0.2f, ratio);
        glNormal3f(nor * c, up, nor * s);
        glVertex3f(r1 * c, alt, r1 * s);
        glVertex3f(r2 * c, alt + 0.05f, r2 * s);
      }
      glEnd();
    }

    void Viewer::init() {
      // Restore previous viewer state.
      if (!restoreStateFromFile())
        showEntireScene();

      setKeyDescription(Qt::Key_T,
                        "Toggles camera type (perspective or orthographic)");
      setKeyDescription(Qt::Key_M, "Toggles camera mode (standard or QGLViewer)");

      setMouseBindingDescription(
          Qt::ShiftModifier, Qt::MidButton,
          "Change frustum size (for standard camera in orthographic mode)");

      // Display help window.
      help();
    }

    void Viewer::showMessage() {
      QString std = ((StandardCamera *)camera())->isStandard() ? "Standard camera"
                                                               : "QGLViewer camera";
      QString type =
          camera()->type() == Camera::PERSPECTIVE ? "Perspective" : "Orthographic";
      displayMessage(std + " - " + type);
      Q_EMIT cameraChanged();
    }

    void Viewer::keyPressEvent(QKeyEvent *e) {
      if (e->key() == Qt::Key_M) {
        // 'M' changes mode : standard or QGLViewer camera
        ((StandardCamera *)camera())->toggleMode();
        showMessage();
      } else if (e->key() == Qt::Key_T) {
        // 'T' changes the projection type : perspective or orthogonal
        if (camera()->type() == Camera::ORTHOGRAPHIC)
          camera()->setType(Camera::PERSPECTIVE);
        else
          camera()->setType(Camera::ORTHOGRAPHIC);
        showMessage();
      } else
        QGLViewer::keyPressEvent(e);
    }

    void Viewer::wheelEvent(QWheelEvent *e) {
      if ((camera()->type() == Camera::ORTHOGRAPHIC) &&
          (((StandardCamera *)camera())->isStandard()) &&
          (e->modifiers() & Qt::ShiftModifier)) {
    #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
        ((StandardCamera *)camera())->changeOrthoFrustumSize(e->delta());
    #else
        ((StandardCamera *)camera())->changeOrthoFrustumSize(e->angleDelta().y());
    #endif
        Q_EMIT cameraChanged();
        update();
      } else
        QGLViewer::wheelEvent(e);
    }

    QString Viewer::helpString() const {
      QString text("<h2>S t a n d a r d C a m e r a</h2>");
      text += "An overloaded <code>Camera</code> class is used, that reproduces "
              "the 'standard' OpenGL settings.<br><br>";

      text += "With this camera, the near and (resp. far) plane distance is set to "
              "a very small (resp. very large) value. ";
      text += "With the orthographic camera type, the frustum dimensions are "
              "fixed. Use <code>Shift</code> and the mouse wheel to change "
              "them.<br><br>";

      text += "On the other hand, the QGLViewer camera fits the near and far "
              "distances to the scene radius. ";
      text += "Fine tuning is available using <code>zClippingCoefficient()</code> "
              "and <code>zNearCoefficient()</code>. ";
      text += "However, visual results do not seem to be impacted by this zBuffer "
              "fitted range.<br><br>";
      text += "The QGLViewer camera also adapts the orthographic frustum "
              "dimensions to the distance to the <code>pivotPoint()</code> to "
              "mimic a perspective camera. ";
      text += "Since this behavior may not be needed, this example shows how to "
              "override it.<br><br>";

      text += "The second viewer displays the first one's camera to show its "
              "configuration.<br><br>";

      text += "Use <b>M</b> to switch between 'standard' and QGLViewer camera "
              "behavior.<br>";
      text += "Use <b>T</b> to switch between perspective and orthographic camera "
              "type.<br><br>";

      text += "Use <b>Shift+wheel</b> to change standard camera orthographic size.";

      return text;
    }

Back to the examples main page.