-
Notifications
You must be signed in to change notification settings - Fork 0
/
renderer.h
206 lines (162 loc) · 6.24 KB
/
renderer.h
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
#ifndef TANKS_RENDERER_H
#define TANKS_RENDERER_H
#include <QOpenGLExtraFunctions>
#include <QtOpenGLWidgets/QOpenGLWidget>
#include <glm/glm.hpp>
#include <vector>
#include <filesystem>
// Forward declared so that this header doesn't need to include the game object header
class GameObject;
#include "Obstacle.h"
#include "shader.h"
#include "mesh.h"
#include "texture.h"
/**
* @brief The renderer is a QWidget responsible for drawing 3D graphics to the window
* @author Tyson Cox
*
* It inherits from the QOpenGLWidget to create a drawing context, and it also inherits
* from the QOpenGLExtraFunctions to gain access to the GL drawing functions required
*/
class Renderer : public QOpenGLWidget, public QOpenGLExtraFunctions {
public:
enum class CameraMode {
Static,
Chasing,
Periscope,
Orbiting,
};
protected:
enum class DrawCommandType {
Player,
Enemy,
Obstacle,
Bullet
};
struct DrawCommand {
DrawCommandType type;
ObstacleType obstacleType;
glm::mat4 transform;
glm::vec3 forwardPoint;
};
std::unordered_map<std::string, Mesh> meshes;
std::unordered_map<std::string, Shader> shaders;
std::unordered_map<std::string, Texture> textures;
// The list of draw commands for the last complete frame, and the currently being built frame
// They are separate to ensure it never draws a half frame
std::vector<DrawCommand> lastFrame;
std::vector<DrawCommand> curFrame;
CameraMode camMode;
float cameraTime;
glm::vec3 freeCamPos;
glm::vec3 freeCamAngle;
glm::mat4 view;
glm::mat4 projection;
/**
* @brief a utility function to check if a texture is known to the renderer
* @param name The texture to look for
* @return whether the texture exists
*/
bool textureExists(const char* name);
/**
* @brief a utility function to check if a texture is known to the renderer
* @param name The texture to look for
* @return whether the texture exists
*/
bool textureExists(const std::string& name);
/**
* @brief Used to compute the camera position when in orbiting camera mode
*/
void advanceCamera();
/**
* Executes a draw command to draw a player tank
* @param cmd the command to execute
*/
void drawPlayerTank(const DrawCommand& cmd);
/**
* Executes a draw command to draw an enemy tank
* @param cmd the command to execute
*/
void drawEnemyTank(const DrawCommand& cmd);
/**
* Executes a draw command to draw a projectile
* @param cmd the command to execute
*/
void drawProjectile(const DrawCommand& cmd);
/**
* Executes a draw command to draw an obstacle
* @param cmd the command to execute
*/
void drawObstacle(const DrawCommand& cmd);
/** Draws the ground plane */
void drawGround();
/** Draws the skybox */
void drawSkybox();
/**
* Handles setting any parameters that any dynamic cameras need for the current frame
*/
void frameSetCamera();
/**
* @brief Handles binding the shader/mesh and executing the draw call
* @param mesh The mesh to display
* @param mvp The model-view-projection matrix for the the draw
* @param texture The texture, if available, or 0 (the GL id for no texture) if not
* @param color an array of three floats for RGB, of nullptr if not available
*/
void drawMesh(Mesh& mesh, const glm::mat4& mvp, Texture* texture = nullptr, float* color = nullptr);
/**
* @brief Handles any special case adjustments that some draw calls may require (such as nudging some meshes)
* @param cmd The command to adjust
*/
void specialCaseAdjusment(DrawCommand& cmd);
// The following are configuration parameters that can be easily tweaked
// The field of view of the camera, in degrees
static const float constexpr cameraFOVDegrees = 45.0f;
// The color of the window's background (visible when nothing is drawn)
static const float constexpr backgroundRed = 0.0f;
static const float constexpr backgroundGreen = 0.0f;
static const float constexpr backgroundBlue = 0.0f;
// The radius the orbiting camera orbits, and its speed
static const float constexpr cameraRadius = 20.0f;
static const float constexpr cameraSpeed = 0.01f;
// The position the static camera looks at, and where it is
static const glm::vec3 constexpr cameraTopLookPos = glm::vec3(0, 0, 0);
static const glm::vec3 constexpr cameraTopPosition = glm::vec3(0, 55, -1);
// The distance backward the chasing camera follows, and at what height
static const float constexpr cameraChaseDistance = 25.0f;
static const float constexpr cameraChaseHeight = 25.0f;
// How high off the ground the first person (periscope) view is set
static const float constexpr periscopeHeight = 0.25f;
// How big, and far up/down the ground is set
static const float constexpr groundScale = 25.0f;
static const float constexpr groundHeight = -0.5f;
// How large and dense the grass is
static const int constexpr grassShells = 16;
static const float constexpr grassShellHeightStep = 0.04f;
static const float constexpr grassShellDensityStep = 0.15f;
static const float constexpr grassScale = 400.0f;
// How large the skybox mesh is
static const float constexpr skyboxSize = 200.0f;
// Where the scene's light source is, and how bright unlit surfaces are (the ambient light intensity)
static const glm::vec3 constexpr lightPos = glm::vec3(10, 5, 7);
static const float constexpr ambientLightIntensity = 0.2;
public:
~Renderer() override;
/**
* Draw an object to the screen
* @param object the object to draw
*/
void drawObject(const GameObject* object);
/** Called when all objects for the frame have been drawn */
void doneWithFrame();
/**
* Set the renderer's camera mode. Note that cameras currently are not deltatime synced,
* and so are frame-rate dependent.
* @param mode The Renderer::CameraMode to use
*/
void setCameraMode(CameraMode mode);
void initializeGL() override;
void paintGL() override;
void resizeGL(int w, int h) override;
};
#endif //TANKS_RENDERER_H