Changeset 845a2cb in opengl-game

Timestamp:

Apr 22, 2020, 12:58:07 AM (4 years ago)

Author:

Dmitry Portnoy <dmitry.portnoy@…>

Branches:

points-test

Parents:

73a10ca

Message:

test point size

Files:

• gl-shaders/explosion.vert (modified) (2 diffs)
• graphics-pipeline_vulkan.hpp (modified) (4 diffs)
• main-vulkan.cpp (modified) (1 diff)
• new-game.cpp (modified) (2 diffs)
• shaders/explosion.frag (added)
• shaders/explosion.vert (added)
• vulkan-game.cpp (modified) (17 diffs)
• vulkan-game.hpp (modified) (9 diffs)

gl-shaders/explosion.vert

@@ -19 +19 @@
 
 void main() {
+   /*
    float duration = 0.5;
    float t = cur_time - explosion_start_time[ubo_index] - start_time;
@@ -36 +37 @@
    }
 
-   vec3 p = vec3(0.0, 0.0, 0.0); //  this is the center of the explosion
-   vec3 a = vec3(0.0, 0.1, 0.0);
-   p += normalize(v_i) * mod(t, duration) / duration * 0.3; // allow time to loop around so particle emitter keeps going
+   //  this is the center of the explosion
+   // allow time to loop around so particle emitter keeps going
+   vec3 p = normalize(v_i) * mod(t, duration) / duration * 0.3;
 
    gl_Position = proj * view * model_mats[ubo_index] * vec4(p, 1.0);
-   gl_PointSize = 15.0; // size in pixels
+   */
+   opacity = 1.0;
+   gl_Position = vec4(0.0, 0.0, 0.0, 1.0);
+   gl_PointSize = 100.0; // size in pixels
 }

graphics-pipeline_vulkan.hpp

@@ -49 +49 @@
       // if it will never change, just pass it in the constructor and save it
       // If it does change, I could add an updateSwapchainImageCount() function
-      GraphicsPipeline_Vulkan(VkPhysicalDevice physicalDevice, VkDevice device, VkRenderPass renderPass,
-         Viewport viewport, vector<VkImage>& swapChainImages,
+      GraphicsPipeline_Vulkan(VkPrimitiveTopology topology, VkPhysicalDevice physicalDevice, VkDevice device,
+         VkRenderPass renderPass, Viewport viewport, vector<VkImage>& swapChainImages,
          size_t vertexCapacity, size_t indexCapacity, size_t objectCapacity);
       ~GraphicsPipeline_Vulkan();
@@ -86 +86 @@
    
    private:
+      VkPrimitiveTopology topology;
       VkPhysicalDevice physicalDevice;
       VkDevice device;
@@ -136 +137 @@
 template<class VertexType, class SSBOType>
 GraphicsPipeline_Vulkan<VertexType, SSBOType>::GraphicsPipeline_Vulkan(
-      VkPhysicalDevice physicalDevice, VkDevice device,
+      VkPrimitiveTopology topology, VkPhysicalDevice physicalDevice, VkDevice device,
       VkRenderPass renderPass, Viewport viewport, vector<VkImage>& swapChainImages,
       size_t vertexCapacity, size_t indexCapacity, size_t objectCapacity) {
+   this->topology = topology;
    this->physicalDevice = physicalDevice;
    this->device = device;
@@ -274 +276 @@
    VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
    inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
-   inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+   inputAssembly.topology = this->topology;
    inputAssembly.primitiveRestartEnable = VK_FALSE;
 

main-vulkan.cpp

@@ -25 +25 @@
 
    try {
-      game.run(800, 600, GUI_FLAGS_WINDOW_FULLSCREEN);
+      game.run(800, 600, 0);
    } catch (const exception& e) {
       cerr << e.what() << endl;

new-game.cpp

@@ -254 +254 @@
 
 const int KEY_STATE_UNCHANGED = -1;
+/*** START OF REFACTORED CODE ***/
 const bool FULLSCREEN = false;
 const int EXPLOSION_PARTICLE_COUNT = 300;
+/*** END OF REFACTORED CODE ***/
 unsigned int MAX_UNIFORMS = 0; // Requires OpenGL constants only available at runtime, so it can't be const
 
@@ -262 +264 @@
 
 /*** START OF REFACTORED CODE ***/
-int windowWidth = 640;
-int windowHeight = 480;
+int windowWidth = 800;
+int windowHeight = 600;
 
 vec3 cam_pos;

vulkan-game.cpp

@@ -3 +3 @@
 #include <array>
 #include <iostream>
+#include <numeric>
 #include <set>
 
@@ -28 +29 @@
    this->asteroid_VP_mats = {};
    this->laser_VP_mats = {};
+   this->explosion_UBO = {};
 }
 
@@ -519 +521 @@
       }, false);
 
+   ship.model_base =
+      translate(mat4(1.0f), vec3(0.0f, -1.2f, 1.65f)) *
+      scale(mat4(1.0f), vec3(0.1f, 0.1f, 0.1f));
+   ship.modified = true;
+
    shipPipeline.createDescriptorSetLayout();
    shipPipeline.createPipeline("shaders/ship-vert.spv", "shaders/ship-frag.spv");
@@ -559 +566 @@
    laserPipeline.createDescriptorSets(swapChainImages);
 
+   explosionPipeline.addAttribute(VK_FORMAT_R32G32B32_SFLOAT, offset_of(&ExplosionVertex::particleStartVelocity));
+   explosionPipeline.addAttribute(VK_FORMAT_R32_SFLOAT, offset_of(&ExplosionVertex::particleStartTime));
+   explosionPipeline.addAttribute(VK_FORMAT_R32_UINT, offset_of(&ExplosionVertex::objIndex));
+
+   createBufferSet(sizeof(UBO_Explosion), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+      uniformBuffers_explosionPipeline, uniformBuffersMemory_explosionPipeline, uniformBufferInfoList_explosionPipeline);
+
+   explosionPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+      VK_SHADER_STAGE_VERTEX_BIT, &uniformBufferInfoList_explosionPipeline);
+   explosionPipeline.addStorageDescriptor(VK_SHADER_STAGE_VERTEX_BIT);
+
+   explosionPipeline.createDescriptorSetLayout();
+   explosionPipeline.createPipeline("shaders/explosion-vert.spv", "shaders/explosion-frag.spv");
+   explosionPipeline.createDescriptorPool(swapChainImages);
+   explosionPipeline.createDescriptorSets(swapChainImages);
+
    cout << "Created all the graphics pipelines" << endl;
 
@@ -564 +587 @@
 
    createSyncObjects();
-
-   ship.model_base =
-      translate(mat4(1.0f), vec3(0.0f, -1.2f, 1.65f)) *
-      scale(mat4(1.0f), vec3(0.1f, 0.1f, 0.1f));
-   ship.modified = true;
 }
 
 void VulkanGame::initGraphicsPipelines() {
-   overlayPipeline = GraphicsPipeline_Vulkan<OverlayVertex, void*>(physicalDevice, device, renderPass,
+   overlayPipeline = GraphicsPipeline_Vulkan<OverlayVertex, void*>(
+      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, physicalDevice, device, renderPass,
       { 0, 0, (int)swapChainExtent.width, (int)swapChainExtent.height }, swapChainImages, 4, 6, 0);
 
-   modelPipeline = GraphicsPipeline_Vulkan<ModelVertex, SSBO_ModelObject>(physicalDevice, device, renderPass,
+   modelPipeline = GraphicsPipeline_Vulkan<ModelVertex, SSBO_ModelObject>(
+      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, physicalDevice, device, renderPass,
       { 0, 0, (int)swapChainExtent.width, (int)swapChainExtent.height }, swapChainImages, 16, 24, 10);
 
-   shipPipeline = GraphicsPipeline_Vulkan<ShipVertex, SSBO_ModelObject>(physicalDevice, device, renderPass,
+   shipPipeline = GraphicsPipeline_Vulkan<ShipVertex, SSBO_ModelObject>(
+      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, physicalDevice, device, renderPass,
       { 0, 0, (int)swapChainExtent.width, (int)swapChainExtent.height }, swapChainImages, 138, 138, 10);
 
-   asteroidPipeline = GraphicsPipeline_Vulkan<AsteroidVertex, SSBO_Asteroid>(physicalDevice, device, renderPass,
+   asteroidPipeline = GraphicsPipeline_Vulkan<AsteroidVertex, SSBO_Asteroid>(
+      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, physicalDevice, device, renderPass,
       { 0, 0, (int)swapChainExtent.width, (int)swapChainExtent.height }, swapChainImages, 24, 36, 10);
 
-   laserPipeline = GraphicsPipeline_Vulkan<LaserVertex, SSBO_Laser>(physicalDevice, device, renderPass,
+   laserPipeline = GraphicsPipeline_Vulkan<LaserVertex, SSBO_Laser>(
+      VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, physicalDevice, device, renderPass,
       { 0, 0, (int)swapChainExtent.width, (int)swapChainExtent.height }, swapChainImages, 8, 18, 2);
+
+   explosionPipeline = GraphicsPipeline_Vulkan<ExplosionVertex, SSBO_Explosion>(
+      VK_PRIMITIVE_TOPOLOGY_POINT_LIST, physicalDevice, device, renderPass,
+      { 0, 0, (int)swapChainExtent.width, (int)swapChainExtent.height },
+      swapChainImages, EXPLOSION_PARTICLE_COUNT, EXPLOSION_PARTICLE_COUNT, 2);
 }
 
@@ -616 +644 @@
    laser_VP_mats.view = viewMat;
    laser_VP_mats.proj = projMat;
+
+   explosion_UBO.view = viewMat;
+   explosion_UBO.proj = projMat;
 }
 
@@ -732 +763 @@
                break;
             case UI_EVENT_UNKNOWN:
-               cout << "Unknown event type: 0x" << hex << e.unknown.eventType << dec << endl;
+               //cout << "Unknown event type: 0x" << hex << e.unknown.eventType << dec << endl;
                break;
             default:
@@ -813 +844 @@
          vec3 objCenter = vec3(viewMat * vec4(asteroid.center, 1.0f));
 
-         if ((objCenter.z - asteroid.radius) > -NEAR_CLIP || asteroid.ssbo.hp <= 0.0f) {
+         if (asteroid.ssbo.hp <= 0.0f) {
             asteroid.ssbo.deleted = true;
 
-            // TODO: Create explosion here
+            // TODO: Optimize this so I don't recalculate the camera rotation every time
+            // TODO: Also, avoid re-declaring cam_pitch
+            float cam_pitch = -50.0f;
+            mat4 pitch_mat = rotate(mat4(1.0f), radians(cam_pitch), vec3(1.0f, 0.0f, 0.0f));
+            mat4 model_mat = translate(mat4(1.0f), asteroid.center) * pitch_mat;
+
+            addExplosion(model_mat, 0.5f, curTime);
+
+            // TODO: Increment player's score here
+         } else if ((objCenter.z - asteroid.radius) > -NEAR_CLIP) {
+            asteroid.ssbo.deleted = true;
          } else {
             asteroid.model_transform =
@@ -933 +974 @@
    }
 
+   for (size_t i = 0; i < explosionObjects.size(); i++) {
+      if (explosionObjects[i].modified) {
+         updateObject(explosionObjects, explosionPipeline, i);
+      }
+   }
+
+   explosion_UBO.cur_time = curTime;
+
    VulkanUtils::copyDataToMemory(device, uniformBuffersMemory_modelPipeline[currentImage], 0, object_VP_mats);
 
@@ -940 +989 @@
 
    VulkanUtils::copyDataToMemory(device, uniformBuffersMemory_laserPipeline[currentImage], 0, laser_VP_mats);
+
+   VulkanUtils::copyDataToMemory(device, uniformBuffersMemory_explosionPipeline[currentImage], 0, explosion_UBO);
 }
 
@@ -1046 +1097 @@
    asteroidPipeline.cleanupBuffers();
    laserPipeline.cleanupBuffers();
+   explosionPipeline.cleanupBuffers();
 
    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
@@ -1538 +1590 @@
       asteroidPipeline.createRenderCommands(commandBuffers[i], i);
       laserPipeline.createRenderCommands(commandBuffers[i], i);
+      explosionPipeline.createRenderCommands(commandBuffers[i], i);
 
       // Always render this pipeline last
@@ -1571 +1624 @@
 }
 
-void VulkanGame::addLaser( vec3 start, vec3 end, vec3 color, float width) {
+void VulkanGame::addLaser(vec3 start, vec3 end, vec3 color, float width) {
    vec3 ray = end - start;
    float length = glm::length(ray);
@@ -1792 +1845 @@
 }
 
+void VulkanGame::addExplosion(mat4 model_mat, float duration, float cur_time) {
+   cout << "Adding explosion..." << endl;
+
+   vector<ExplosionVertex> vertices;
+   vertices.reserve(EXPLOSION_PARTICLE_COUNT);
+
+   float particlestart_time = 0.0f;
+
+   for (int i = 0; i < EXPLOSION_PARTICLE_COUNT; i++) {
+      float randx = ((float)rand() / (float)RAND_MAX) - 0.5f;
+      float randy = ((float)rand() / (float)RAND_MAX) - 0.5f;
+
+      vertices.push_back({ vec3(randx, randy, 0.0f), particlestart_time});
+
+      particlestart_time += 0.01f;
+   }
+
+   // Fill the indices with the the first EXPLOSION_PARTICLE_COUNT ints
+   vector<uint16_t> indices(EXPLOSION_PARTICLE_COUNT);
+   iota(indices.begin(), indices.end(), 0);
+
+   SceneObject<ExplosionVertex, SSBO_Explosion>& explosion = addObject(
+      explosionObjects, explosionPipeline,
+      addObjectIndex(explosionObjects.size(), vertices),
+      indices, {
+         mat4(1.0f),
+         cur_time,
+         duration,
+         false
+      }, true);
+
+   explosion.model_base = model_mat;
+   explosion.model_transform = mat4(1.0f);
+
+   explosion.modified = true;
+}
+
 // TODO: Fix the crash that happens when alt-tabbing
 void VulkanGame::recreateSwapChain() {
@@ -1853 +1943 @@
    laserPipeline.createDescriptorPool(swapChainImages);
    laserPipeline.createDescriptorSets(swapChainImages);
+
+   createBufferSet(sizeof(UBO_Explosion), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
+      uniformBuffers_explosionPipeline, uniformBuffersMemory_explosionPipeline, uniformBufferInfoList_explosionPipeline);
+
+   explosionPipeline.updateRenderPass(renderPass);
+   explosionPipeline.createPipeline("shaders/explosion-vert.spv", "shaders/explosion-frag.spv");
+   explosionPipeline.createDescriptorPool(swapChainImages);
+   explosionPipeline.createDescriptorSets(swapChainImages);
 
    createCommandBuffers();
@@ -1871 +1969 @@
    asteroidPipeline.cleanup();
    laserPipeline.cleanup();
+   explosionPipeline.cleanup();
 
    for (size_t i = 0; i < uniformBuffers_modelPipeline.size(); i++) {
@@ -1892 +1991 @@
    }
 
+   for (size_t i = 0; i < uniformBuffers_explosionPipeline.size(); i++) {
+      vkDestroyBuffer(device, uniformBuffers_explosionPipeline[i], nullptr);
+      vkFreeMemory(device, uniformBuffersMemory_explosionPipeline[i], nullptr);
+   }
+
    vkDestroyRenderPass(device, renderPass, nullptr);
 

vulkan-game.hpp

@@ -57 +57 @@
 };
 
-struct UBO_VP_mats {
-   alignas(16) mat4 view;
-   alignas(16) mat4 proj;
+struct ExplosionVertex {
+   vec3 particleStartVelocity;
+   float particleStartTime;
+   unsigned int objIndex;
 };
 
@@ -76 +77 @@
    alignas(4) vec3 color;
    alignas(4) unsigned int deleted;
+};
+
+struct SSBO_Explosion {
+   alignas(16) mat4 model;
+   alignas(4) float explosionStartTime;
+   alignas(4) float explosionDuration;
+   alignas(4) unsigned int deleted;
+};
+
+struct UBO_VP_mats {
+   alignas(16) mat4 view;
+   alignas(16) mat4 proj;
+};
+
+struct UBO_Explosion {
+   alignas(16) mat4 view;
+   alignas(16) mat4 proj;
+   alignas(4) float cur_time;
 };
 
@@ -175 +194 @@
 
    private:
+      // TODO: Make these consts static
+
       const int MAX_FRAMES_IN_FLIGHT;
 
@@ -180 +201 @@
       const float FAR_CLIP = 100.0f;
       const float FOV_ANGLE = 67.0f; // means the camera lens goes from -33 deg to 33 def
+
+      const int EXPLOSION_PARTICLE_COUNT = 300;
 
       vec3 cam_pos;
@@ -285 +308 @@
 
       UBO_VP_mats laser_VP_mats;
+
+      GraphicsPipeline_Vulkan<ExplosionVertex, SSBO_Explosion> explosionPipeline;
+      vector<SceneObject<ExplosionVertex, SSBO_Explosion>> explosionObjects;
+
+      vector<VkBuffer> uniformBuffers_explosionPipeline;
+      vector<VkDeviceMemory> uniformBuffersMemory_explosionPipeline;
+      vector<VkDescriptorBufferInfo> uniformBufferInfoList_explosionPipeline;
+
+      UBO_Explosion explosion_UBO;
 
       vector<BaseEffectOverTime*> effects;
@@ -334 +366 @@
       void createSyncObjects();
 
-      void addLaser(vec3 start, vec3 end, vec3 color, float width);
-      void translateLaser(size_t index, const vec3& translation);
-      void updateLaserTarget(size_t index);
-      bool getLaserAndAsteroidIntersection(SceneObject<AsteroidVertex, SSBO_Asteroid>& asteroid,
-            vec3& start, vec3& end, vec3& intersection);
-
       // TODO: Since addObject() returns a reference to the new object now,
       // stop using objects.back() to access the object that was just created
@@ -366 +392 @@
       void centerObject(SceneObject<VertexType, SSBOType>& object);
 
+      void addLaser(vec3 start, vec3 end, vec3 color, float width);
+      void translateLaser(size_t index, const vec3& translation);
+      void updateLaserTarget(size_t index);
+      bool getLaserAndAsteroidIntersection(SceneObject<AsteroidVertex, SSBO_Asteroid>& asteroid,
+            vec3& start, vec3& end, vec3& intersection);
+
+      void addExplosion(mat4 model_mat, float duration, float cur_time);
+
       void createBufferSet(VkDeviceSize bufferSize, VkBufferUsageFlags flags,
             vector<VkBuffer>& buffers, vector<VkDeviceMemory>& buffersMemory,
@@ -380 +414 @@
             void* pUserData);
 };
+
+// Start of specialized no-op functions
+
+template<>
+inline void VulkanGame::centerObject(SceneObject<ExplosionVertex, SSBO_Explosion>& object) {
+}
+
+// End of specialized no-op functions
 
 // TODO: Right now, it's basically necessary to pass the identity matrix in for ssbo.model
@@ -407 +449 @@
    SceneObject<VertexType, SSBOType>& obj = objects.back();
 
-   if (!is_same_v<VertexType, LaserVertex>) {
+   if (!is_same_v<VertexType, LaserVertex> && !is_same_v<VertexType, ExplosionVertex>) {
       centerObject(obj);
    }