qt_gl_widget.h

#pragma once
 
#include <QOpenGLWidget>
#include <QMouseEvent>
#include <QOpenGLFunctions>
#include <QOpenGLVertexArrayObject>
#include <QOpenGLBuffer>
#include <QMatrix4x4>
#include <QtWidgets/QSlider>
#include <QOpenGLShaderProgram>
 
namespace bmpf {
 
    class QTGLWidget : public QOpenGLWidget, protected QOpenGLFunctions {
    public:
 
        explicit QTGLWidget(QWidget *parent = nullptr);
 
        virtual void cleanup();
 
        QSize minimumSizeHint() const Q_DECL_OVERRIDE;
 
        QSize sizeHint() const Q_DECL_OVERRIDE;
 
        virtual void setXRotation(int angle) = 0;
 
        virtual void setYRotation(int angle) = 0;
 
        virtual void setZRotation(int angle) = 0;
 
    protected:
 
        virtual void init() = 0;
 
        virtual void paint() = 0;
 
        void initializeGL() Q_DECL_OVERRIDE;
 
        void paintGL() Q_DECL_OVERRIDE;
 
        void mousePressEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
 
        void mouseMoveEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
 
        int xAngle;
        int yAngle;
        int zAngle;
 
        bool _isTransparent;
        bool _core;
 
        QPoint _lastMousePos;
        QMatrix4x4 _worldTransform;
        QOpenGLShaderProgram *_program;
        QWidget *_parent;
        int _projMatrixLoc{};
        int _mvMatrixLoc{};
        int _normalMatrixLoc{};
        int _lightPosLoc{};
        QMatrix4x4 _camera;
        std::string _caption;
    };
 
 
    static const char *vertexShaderSourceCore =
            "#version 150\n"
            "in vec4 vertex;\n"
            "in vec3 normal;\n"
            "out vec3 vert;\n"
            "out vec3 vertNormal;\n"
            "uniform mat4 projMatrix;\n"
            "uniform mat4 mvMatrix;\n"
            "uniform mat3 normalMatrix;\n"
            "void main() {\n"
            "   vert = vertex.xyz;\n"
            "   vertNormal = normalMatrix * normal;\n"
            "   gl_Position = projMatrix * mvMatrix * vertex;\n"
            "}\n";
 
    static const char *fragmentShaderSourceCore =
            "#version 150\n"
            "in highp vec3 vert;\n"
            "in highp vec3 vertNormal;\n"
            "out highp vec4 fragColor;\n"
            "uniform highp vec3 lightPos;\n"
            "void main() {\n"
            "   highp vec3 L = normalize(lightPos - vert);\n"
            "   highp float NL = max(dot(normalize(vertNormal), L), 0.0);\n"
            "   highp vec3 color = vec3(0.39, 1.0, 0.0);\n"
            "   highp vec3 col = clamp(color * 0.2 + color * 0.8 * NL, 0.0, 1.0);\n"
            "   fragColor = vec4(col, 1.0);\n"
            "}\n";
 
    static const char *vertexShaderSource =
            "attribute vec4 vertex;\n"
            "attribute vec3 normal;\n"
            "varying vec3 vert;\n"
            "varying vec3 vertNormal;\n"
            "uniform mat4 projMatrix;\n"
            "uniform mat4 mvMatrix;\n"
            "uniform mat3 normalMatrix;\n"
            "void main() {\n"
            "   vert = vertex.xyz;\n"
            "   vertNormal = normalMatrix * normal;\n"
            "   gl_Position = projMatrix * mvMatrix * vertex;\n"
            "}\n";
 
    static const char *fragmentShaderSource =
            "varying highp vec3 vert;\n"
            "varying highp vec3 vertNormal;\n"
            "uniform highp vec3 lightPos;\n"
            "void main() {\n"
            "   highp vec3 L = normalize(lightPos - vert);\n"
            "   highp float NL = max(dot(normalize(vertNormal), L), 0.0);\n"
            "   highp vec3 color = vec3(0.39, 1.0, 0.0);\n"
            "   highp vec3 col = clamp(color * 0.2 + color * 0.8 * NL, 0.0, 1.0);\n"
            "   gl_FragColor = vec4(col, 1.0);\n"
            "}\n";
 
 
    static void qNormalizeAngle(int &angle) {
        while (angle < 0)
            angle += 360 * 16;
        while (angle > 360 * 16)
            angle -= 360 * 16;
    }
 
}