OpenGL-Tutorial/TutorialRenderer.h at main · Ilethas/OpenGL-Tutorial · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#ifndef TUTORIALRENDERER_H
#define TUTORIALRENDERER_H
#include <QObject>
#include <QQuickWindow>
#include <Qtime>
#include <QDir>
#include <QtMath>
#include <QOpenGLFunctions_3_3_Core>
#include <QOpenGLShaderProgram>
#include "Camera.h"
#include "Model.h"
#include "MovementSanitizer.h"
#include "LightModel.h"


class TutorialRenderer : public QObject, protected QOpenGLFunctions_3_3_Core
{
    Q_OBJECT
    Q_PROPERTY(LightModel* lightModel READ lightModel)
    Q_PROPERTY(float maxLights READ maxLights)
    Q_PROPERTY(bool lightPilotMode READ lightPilotMode WRITE setLightPilotMode NOTIFY lightPilotModeChanged)
    Q_PROPERTY(int currentLight READ currentLight WRITE setCurrentLight NOTIFY currentLightChanged)
    Q_PROPERTY(ShadingType currentShadingType READ currentShadingType WRITE setCurrentShadingType NOTIFY currentShadingTypeChanged)
    Q_PROPERTY(float shininess READ shininess WRITE setShininess NOTIFY shininessChanged)

    public:
        enum ShadingType
        {
            Phong,
            BlinnPhong
        };
        Q_ENUM(ShadingType)

        TutorialRenderer();
        virtual ~TutorialRenderer();

        virtual void initialize();

        virtual void mousePressEvent(QMouseEvent*);
        virtual void mouseReleaseEvent(QMouseEvent*);
        virtual void mouseDoubleClickEvent(QMouseEvent*);
        virtual void mouseMoveEvent(QMouseEvent*);
        virtual void keyPressEvent(QKeyEvent*);
        virtual void keyReleaseEvent(QKeyEvent*);

        void setViewportPosition(const QPoint& position);
        void setViewportSize(const QSize& size);
        void setWindow(QQuickWindow* window);

        virtual QString getOptionsUrl() const { return ""; }
        virtual QString getDescriptionUrl() const { return ""; }
        virtual float maxLights() const;
        LightModel* lightModel();

        bool lightPilotMode() const;
        void setLightPilotMode(bool active);

        bool currentLight() const;
        void setCurrentLight(int index);

        ShadingType currentShadingType() const;
        void setCurrentShadingType(ShadingType type);

        float shininess() const;
        void setShininess(float shininess);

    signals:
        void lightPilotModeChanged(bool active);
        void currentLightChanged(int index);
        void currentShadingTypeChanged(ShadingType type);
        void shininessChanged(float shininess);

    public slots:
        virtual void paint();
        void updateRenderer();

    protected:
        QPoint viewportPosition;
        QSize viewportSize;
        QQuickWindow* window = nullptr;

        QPoint oldCursorPosition;
        bool isLeftMouseButtonPressed = false;
        bool isRightMouseButtonPressed = false;

        float cameraYaw = 0.0f;
        float cameraPitch = 0.0f;
        float maxPitch = 90.0f;
        Camera camera;
        MovementSanitizer cameraMovement;
        float cameraRotationSpeed = 0.3f;
        float cameraMovementSpeed = 15.0f;

        LightModel lights;
        ShadingType shadingType = Phong;
        float phongShininess = 100.0f;

        bool isLightPilotActive = false;
        int currentlySelectedLight = -1;

        unsigned int skyboxCubemap;
        Model simpleCube;
        QOpenGLShaderProgram* skyboxProgram = nullptr;

        Model arrowModel;
        Transform arrowTransform;
        QOpenGLShaderProgram* gizmosProgram = nullptr;

        virtual void update(float deltaTime);
        void paintSkybox(Transform& cameraTransform);
        void paintGizmos(Transform& cameraTransform);
        void cameraLookAt(Camera& camera, QVector3D direction);
        void cameraLookAtLight(int lightIndex);

        void updateLightUniforms(QOpenGLShaderProgram* program);
        void updateCameraUniforms(QOpenGLShaderProgram* program, Transform& cameraTransform);
        void updateObjectUniforms(QOpenGLShaderProgram* program, Transform& objectTransform,
                                  QQuaternion rotationOffset = QQuaternion(1.0f, 0.0f, 0.0f, 0.0f),
                                  float additionalScale = 1.0f,
                                  QVector3D offset = QVector3D(0.0f, 0.0f, 0.0f));

        void loadShaderForProgram(QOpenGLShaderProgram* program, QOpenGLShader::ShaderTypeBit type, QString fileName);
        bool initialized() const;

    private:
        bool isRendererInitialized = false;
        bool isOpenGLInitialized = false;
        QTime lastUpdateTime;

};


#endif // TUTORIALRENDERER_H