glwidget.h

#ifndef GLWIDGET_H
#define GLWIDGET_H

#include "trackfile.h"
#include "camera.h"

#include <QOpenGLWidget>
#include <QOpenGLFunctions_4_0_Core>
#include <QOpenGLDebugLogger>
#include <QTimer>
#include <QElapsedTimer>
#include <QOpenGLShaderProgram>
#include <QOpenGLBuffer>
#include <QOpenGLVertexArrayObject>
#include <QMatrix4x4>
#include <QOpenGLTexture>

class GLWidget : public QOpenGLWidget, QOpenGLFunctions_4_0_Core
{
    Q_OBJECT

    public:
        GLWidget(QWidget* parent = Q_NULLPTR, int updateRate = 60, bool sampleShading = true, int anisotropy = 1);

        ~GLWidget();

        virtual void setTrackData(const QVector<Track>&& tracks);

    public slots:

        virtual void setWireframe(bool enabled)
        {
            wireframe = enabled;
        }

        virtual void setThickness(int p_thickness) {
            thickness = p_thickness;
        }

        virtual void setHalo(int p_halo) {
            halo = p_halo;
        }

        virtual void setStripDepth(int p_stripDepth){
            stripDepth = p_stripDepth;
        }

        virtual void setDepthCueing(int p_depthCueing){
            depthCueing = p_depthCueing;
        }

    protected slots:

        virtual void updateFrame();

        virtual void paintGL() Q_DECL_OVERRIDE;

        virtual void initializeGL() Q_DECL_OVERRIDE;

        virtual void resizeGL(int w, int h) Q_DECL_OVERRIDE;

    signals:

        void frameRate(int fps);

    protected:

        void keyPressEvent(QKeyEvent* event) Q_DECL_OVERRIDE;

        void mousePressEvent(QMouseEvent *event) override;

        void mouseMoveEvent(QMouseEvent *event) override;

        void wheelEvent(QWheelEvent* event) Q_DECL_OVERRIDE;

    private:

        QOpenGLShaderProgram* createShaderProgram(const QString& pathVS, const QString& pathFS, const QString& pathGS = "");

        // Logger
        QOpenGLDebugLogger* logger = Q_NULLPTR;

        // Counter for frames
        int frameCounter = 0;

        // Called every second to compute fps
        QTimer fpsTimer;

        // Updates the widget periodically, to force paintGL() invocation
        // Also calls updateFrame()
        QTimer updateTimer;

        // Timer to compute delta time
        QElapsedTimer frameTimer;

        // Flag for sample shading
        const bool sampleShading;

        // Maximum number of samples used for anisotropic filtering
        const int anisotropy;

        // Flag for wireframe mode
        bool wireframe = false;

        // Line thickness value
        int thickness = 0;

        // Halo size value
        int halo = 0;

        // Depth cueing value
        int depthCueing = 0;

        // Strip depth value
        int stripDepth = 0;

        // Indicates if loaded tracks should be filtered by just considering
        // tracks that intersect with z = 0
        bool filterTracks = false;

        // The current track data
        QVector<Track> tracks;

        // Texture for the strips
        QOpenGLTexture* textureStroke = Q_NULLPTR;

        // Texture for the tapering stencil mask
        QOpenGLTexture* textureStripMask = Q_NULLPTR;

        // Program for rendering
        QOpenGLShaderProgram* program = Q_NULLPTR;

        // Vertex buffer
        QOpenGLBuffer vbo;

        // UV buffer
        QOpenGLBuffer uvBuffer;

        // Directions buffer
        QOpenGLBuffer dirBuffer;

        // Vertex array object
        QOpenGLVertexArrayObject vao;

        // Camera
        Camera* camera = nullptr;

        // View model matrix
        QMatrix4x4 matViewModel;

        // Proj matrix
        QMatrix4x4 matProj;

        // Number of vertices (for current dataset)
        int numVertices = 0;

        // Last mouse position (for camera movement)
        QPoint m_lastPos;

        float interpolateSliderValue(int value, float min, float max);

        QVector3D normalizedPoint(QVector3D point, QVector3D min, QVector3D range, float scale);
};

#endif // GLWIDGET_H