source: opengl-game/vulkan-game.hpp@ 2d87297

feature/imgui-sdl points-test
Last change on this file since 2d87297 was 2d87297, checked in by Dmitry Portnoy <dmitry.portnoy@…>, 5 years ago

In VulkanGame, add an ssbo field to SceneObject to hold per-object ssbo info, and add a new SSBOType template parameter to SceneObject and GraphicsPipeline_Vulkan
  • Property mode set to 100644
File size: 10.4 KB
Line 
1#ifndef _VULKAN_GAME_H
2#define _VULKAN_GAME_H
3
4#define GLM_FORCE_RADIANS
5#define GLM_FORCE_DEPTH_ZERO_TO_ONE // Since, in Vulkan, the depth range is 0 to 1 instead of -1 to 1
6#define GLM_FORCE_RIGHT_HANDED
7
8#include <glm/glm.hpp>
9#include <glm/gtc/matrix_transform.hpp>
10
11#include "game-gui-sdl.hpp"
12#include "graphics-pipeline_vulkan.hpp"
13
14#include "vulkan-utils.hpp"
15
16using namespace glm;
17
18#ifdef NDEBUG
19 const bool ENABLE_VALIDATION_LAYERS = false;
20#else
21 const bool ENABLE_VALIDATION_LAYERS = true;
22#endif
23
24struct OverlayVertex {
25 vec3 pos;
26 vec2 texCoord;
27};
28
29struct ModelVertex {
30 vec3 pos;
31 vec3 color;
32 vec2 texCoord;
33 unsigned int objIndex;
34};
35
36struct ShipVertex {
37 vec3 pos;
38 vec3 color;
39 vec3 normal;
40 unsigned int objIndex;
41};
42
43struct AsteroidVertex {
44 vec3 pos;
45 vec3 color;
46 vec3 normal;
47 unsigned int objIndex;
48};
49
50// TODO: Change the index type to uint32_t and check the Vulkan Tutorial loading model section as a reference
51// TODO: Create a typedef for index type so I can easily change uin16_t to something else later
52template<class VertexType, class SSBOType>
53struct SceneObject {
54 vector<VertexType> vertices;
55 vector<uint16_t> indices;
56 SSBOType ssbo;
57
58 mat4 model_base;
59 mat4 model_transform;
60};
61
62struct UBO_VP_mats {
63 alignas(16) mat4 view;
64 alignas(16) mat4 proj;
65};
66
67struct SSBO_ModelObject {
68 alignas(16) mat4 model;
69};
70
71struct SSBO_Asteroid {
72 alignas(16) mat4 model;
73 alignas(4) float hp;
74 alignas(4) unsigned int deleted;
75};
76
77class VulkanGame {
78 public:
79 VulkanGame(int maxFramesInFlight);
80 ~VulkanGame();
81
82 void run(int width, int height, unsigned char guiFlags);
83
84 private:
85 const int MAX_FRAMES_IN_FLIGHT;
86
87 const float NEAR_CLIP = 0.1f;
88 const float FAR_CLIP = 100.0f;
89 const float FOV_ANGLE = 67.0f; // means the camera lens goes from -33 deg to 33 def
90
91 vec3 cam_pos;
92
93 GameGui* gui;
94
95 SDL_version sdlVersion;
96 SDL_Window* window = nullptr;
97 SDL_Renderer* renderer = nullptr;
98
99 SDL_Texture* uiOverlay = nullptr;
100
101 VkInstance instance;
102 VkDebugUtilsMessengerEXT debugMessenger;
103 VkSurfaceKHR surface; // TODO: Change the variable name to vulkanSurface
104 VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
105 VkDevice device;
106
107 VkQueue graphicsQueue;
108 VkQueue presentQueue;
109
110 VkSwapchainKHR swapChain;
111 vector<VkImage> swapChainImages;
112 VkFormat swapChainImageFormat;
113 VkExtent2D swapChainExtent;
114 vector<VkImageView> swapChainImageViews;
115 vector<VkFramebuffer> swapChainFramebuffers;
116
117 VkRenderPass renderPass;
118 VkCommandPool commandPool;
119 vector<VkCommandBuffer> commandBuffers;
120
121 VulkanImage depthImage;
122
123 VkSampler textureSampler;
124
125 VulkanImage floorTextureImage;
126 VkDescriptorImageInfo floorTextureImageDescriptor;
127
128 VulkanImage sdlOverlayImage;
129 VkDescriptorImageInfo sdlOverlayImageDescriptor;
130
131 TTF_Font* font;
132 SDL_Texture* fontSDLTexture;
133
134 SDL_Texture* imageSDLTexture;
135
136 vector<VkSemaphore> imageAvailableSemaphores;
137 vector<VkSemaphore> renderFinishedSemaphores;
138 vector<VkFence> inFlightFences;
139
140 size_t currentFrame;
141
142 bool framebufferResized;
143
144 // TODO: I should probably rename the uniformBuffer* and storageBuffer*
145 // variables to better reflect the data they hold
146
147 // TODO: Create a struct that holds the buffers, memory, and info objects (Probably in VulkanUtils)
148
149 GraphicsPipeline_Vulkan<OverlayVertex, void*> overlayPipeline;
150
151 vector<SceneObject<OverlayVertex, void*>> overlayObjects;
152
153 // TODO: Rename all the variables related to modelPipeline to use the same pipelie name
154
155 GraphicsPipeline_Vulkan<ModelVertex, SSBO_ModelObject> modelPipeline;
156
157 vector<SceneObject<ModelVertex, SSBO_ModelObject>> modelObjects;
158
159 vector<VkBuffer> uniformBuffers_scenePipeline;
160 vector<VkDeviceMemory> uniformBuffersMemory_scenePipeline;
161 vector<VkDescriptorBufferInfo> uniformBufferInfoList_scenePipeline;
162
163 vector<VkBuffer> storageBuffers_scenePipeline;
164 vector<VkDeviceMemory> storageBuffersMemory_scenePipeline;
165 vector<VkDescriptorBufferInfo> storageBufferInfoList_scenePipeline;
166
167 UBO_VP_mats object_VP_mats;
168 SSBO_ModelObject so_Object;
169
170 GraphicsPipeline_Vulkan<ShipVertex, SSBO_ModelObject> shipPipeline;
171
172 vector<SceneObject<ShipVertex, SSBO_ModelObject>> shipObjects;
173
174 vector<VkBuffer> uniformBuffers_shipPipeline;
175 vector<VkDeviceMemory> uniformBuffersMemory_shipPipeline;
176 vector<VkDescriptorBufferInfo> uniformBufferInfoList_shipPipeline;
177
178 vector<VkBuffer> storageBuffers_shipPipeline;
179 vector<VkDeviceMemory> storageBuffersMemory_shipPipeline;
180 vector<VkDescriptorBufferInfo> storageBufferInfoList_shipPipeline;
181
182 UBO_VP_mats ship_VP_mats;
183 SSBO_ModelObject so_Ship;
184
185 GraphicsPipeline_Vulkan<AsteroidVertex, SSBO_Asteroid> asteroidPipeline;
186
187 vector<SceneObject<AsteroidVertex, SSBO_Asteroid>> asteroidObjects;
188
189 vector<VkBuffer> uniformBuffers_asteroidPipeline;
190 vector<VkDeviceMemory> uniformBuffersMemory_asteroidPipeline;
191 vector<VkDescriptorBufferInfo> uniformBufferInfoList_asteroidPipeline;
192
193 vector<VkBuffer> storageBuffers_asteroidPipeline;
194 vector<VkDeviceMemory> storageBuffersMemory_asteroidPipeline;
195 vector<VkDescriptorBufferInfo> storageBufferInfoList_asteroidPipeline;
196
197 UBO_VP_mats asteroid_VP_mats;
198 SSBO_Asteroid so_Asteroid;
199
200 Uint64 curTime, prevTime;
201 double elapsedTime;
202
203 bool initWindow(int width, int height, unsigned char guiFlags);
204 void initVulkan();
205 void initGraphicsPipelines();
206 void initMatrices();
207 void mainLoop();
208 void updateScene(uint32_t currentImage);
209 void renderUI();
210 void renderScene();
211 void cleanup();
212
213 void createVulkanInstance(const vector<const char*> &validationLayers);
214 void setupDebugMessenger();
215 void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo);
216 void createVulkanSurface();
217 void pickPhysicalDevice(const vector<const char*>& deviceExtensions);
218 bool isDeviceSuitable(VkPhysicalDevice physicalDevice, const vector<const char*>& deviceExtensions);
219 void createLogicalDevice(
220 const vector<const char*> validationLayers,
221 const vector<const char*>& deviceExtensions);
222 void createSwapChain();
223 void createImageViews();
224 void createRenderPass();
225 VkFormat findDepthFormat();
226 void createCommandPool();
227 void createImageResources();
228
229 void createTextureSampler();
230 void createFramebuffers();
231 void createCommandBuffers();
232 void createSyncObjects();
233
234 template<class VertexType, class SSBOType>
235 void addObject(vector<SceneObject<VertexType, SSBOType>>& objects,
236 GraphicsPipeline_Vulkan<VertexType, SSBOType>& pipeline,
237 const vector<VertexType>& vertices, vector<uint16_t> indices, SSBOType ssbo);
238
239 template<class VertexType>
240 vector<VertexType> addVertexNormals(vector<VertexType> vertices);
241
242 template<class VertexType>
243 vector<VertexType> addObjectIndex(unsigned int objIndex, vector<VertexType> vertices);
244
245 template<class VertexType>
246 vector<VertexType> centerObject(vector<VertexType> vertices);
247
248 template<class VertexType, class SSBOType>
249 void transformObject(SceneObject<VertexType, SSBOType>& obj, mat4 mat);
250
251 void createBufferSet(VkDeviceSize bufferSize, VkBufferUsageFlags flags,
252 vector<VkBuffer>& buffers, vector<VkDeviceMemory>& buffersMemory, vector<VkDescriptorBufferInfo>& bufferInfoList);
253
254 void recreateSwapChain();
255
256 void cleanupSwapChain();
257
258 static VKAPI_ATTR VkBool32 VKAPI_CALL debugCallback(
259 VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
260 VkDebugUtilsMessageTypeFlagsEXT messageType,
261 const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
262 void* pUserData);
263};
264
265template<class VertexType, class SSBOType>
266void VulkanGame::addObject(vector<SceneObject<VertexType, SSBOType>>& objects,
267 GraphicsPipeline_Vulkan<VertexType, SSBOType>& pipeline,
268 const vector<VertexType>& vertices, vector<uint16_t> indices, SSBOType ssbo) {
269 size_t numVertices = pipeline.getNumVertices();
270
271 for (uint16_t& idx : indices) {
272 idx += numVertices;
273 }
274
275 objects.push_back({ vertices, indices, ssbo, mat4(1.0f), mat4(1.0f) });
276
277 pipeline.addVertices(vertices, indices, commandPool, graphicsQueue);
278}
279
280template<class VertexType>
281vector<VertexType> VulkanGame::addVertexNormals(vector<VertexType> vertices) {
282 for (unsigned int i = 0; i < vertices.size(); i += 3) {
283 vec3 p1 = vertices[i].pos;
284 vec3 p2 = vertices[i+1].pos;
285 vec3 p3 = vertices[i+2].pos;
286
287 vec3 normal = normalize(cross(p2 - p1, p3 - p1));
288
289 // Add the same normal for all 3 vertices
290 vertices[i].normal = normal;
291 vertices[i+1].normal = normal;
292 vertices[i+2].normal = normal;
293 }
294
295 return vertices;
296}
297
298template<class VertexType>
299vector<VertexType> VulkanGame::addObjectIndex(unsigned int objIndex, vector<VertexType> vertices) {
300 for (VertexType& vertex : vertices) {
301 vertex.objIndex = objIndex;
302 }
303
304 return vertices;
305}
306
307template<class VertexType>
308vector<VertexType> VulkanGame::centerObject(vector<VertexType> vertices) {
309 float min_x = vertices[0].pos.x;
310 float max_x = vertices[0].pos.x;
311 float min_y = vertices[0].pos.y;
312 float max_y = vertices[0].pos.y;
313 float min_z = vertices[0].pos.z;
314 float max_z = vertices[0].pos.z;
315
316 // start from the second point
317 for (unsigned int i = 1; i < vertices.size(); i++) {
318 if (min_x > vertices[i].pos.x) {
319 min_x = vertices[i].pos.x;
320 } else if (max_x < vertices[i].pos.x) {
321 max_x = vertices[i].pos.x;
322 }
323
324 if (min_y > vertices[i].pos.y) {
325 min_y = vertices[i].pos.y;
326 } else if (max_y < vertices[i].pos.y) {
327 max_y = vertices[i].pos.y;
328 }
329
330 if (min_z > vertices[i].pos.z) {
331 min_z = vertices[i].pos.z;
332 } else if (max_z < vertices[i].pos.z) {
333 max_z = vertices[i].pos.z;
334 }
335 }
336
337 vec3 center = vec3(min_x + max_x, min_y + max_y, min_z + max_z) / 2.0f;
338
339 for (unsigned int i = 0; i < vertices.size(); i++) {
340 vertices[i].pos -= center;
341 }
342
343 return vertices;
344}
345
346template<class VertexType, class SSBOType>
347void VulkanGame::transformObject(SceneObject<VertexType, SSBOType>& obj, mat4 mat) {
348 obj.model_transform = mat * obj.model_transform;
349}
350
351#endif // _VULKAN_GAME_H
Note: See TracBrowser for help on using the repository browser.