Changeset 58453c3 in opengl-game for graphics-pipeline_vulkan.hpp

Timestamp:

May 20, 2021, 3:50:12 PM (4 years ago)

Author:

Dmitry Portnoy <dportnoy@…>

Branches:

feature/imgui-sdl

Children:

567fa88

Parents:

c163d81

git-author:

Dmitry Portnoy <dportnoy@…> (05/20/21 15:48:15)

git-committer:

Dmitry Portnoy <dportnoy@…> (05/20/21 15:50:12)

Message:

Remove the swapChainImages parameter from the GraphicsPipeline_Vulkan constructor and modify createDescriptorPool(), createDescriptorSets(), and updateDescriptorInfo() to accept a size paramter instead of accepting a vector of swap chain images and getting the size from that

File:

• graphics-pipeline_vulkan.hpp (modified) (8 diffs)

graphics-pipeline_vulkan.hpp

@@ -39 +39 @@
       GraphicsPipeline_Vulkan();
 
-      // TODO: swapChainImages is only ever used to get its size. Check how that is determined and,
-      // 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(VkPrimitiveTopology topology, VkPhysicalDevice physicalDevice, VkDevice device,
-         VkRenderPass renderPass, Viewport viewport, vector<VkImage>& swapChainImages,
-         size_t vertexCapacity, size_t indexCapacity);
+         VkRenderPass renderPass, Viewport viewport, size_t vertexCapacity, size_t indexCapacity);
       ~GraphicsPipeline_Vulkan();
 
@@ -60 +56 @@
       void addDescriptorInfo(VkDescriptorType type, VkShaderStageFlags stageFlags, VkDescriptorImageInfo* imageData);
 
-      void updateDescriptorInfo(uint32_t index, vector<VkDescriptorBufferInfo>* bufferData,
-                                vector<VkImage>& swapChainImages);
-      // TODO: Maybe make an analogous one for updating image info
+      void updateDescriptorInfo(uint32_t index, vector<VkDescriptorBufferInfo>* bufferData, uint32_t size);
 
       void createPipeline(string vertShaderFile, string fragShaderFile);
       void createDescriptorSetLayout();
-      void createDescriptorPool(vector<VkImage>& swapChainImages);
-      void createDescriptorSets(vector<VkImage>& swapChainImages);
+      void createDescriptorPool(uint32_t size);
+      void createDescriptorSets(uint32_t size);
 
       void createRenderCommands(VkCommandBuffer& commandBuffer, uint32_t currentImage);
@@ -128 +122 @@
                                                              VkPhysicalDevice physicalDevice, VkDevice device,
                                                              VkRenderPass renderPass, Viewport viewport,
-                                                             vector<VkImage>& swapChainImages, size_t vertexCapacity,
-                                                             size_t indexCapacity)
+                                                             size_t vertexCapacity, size_t indexCapacity)
                                                             : topology(topology)
                                                             , physicalDevice(physicalDevice)
@@ -190 +183 @@
 
 template<class VertexType>
-void GraphicsPipeline_Vulkan<VertexType>::addDescriptorInfo(VkDescriptorType type,
-      VkShaderStageFlags stageFlags, vector<VkDescriptorBufferInfo>* bufferData) {
+void GraphicsPipeline_Vulkan<VertexType>::addDescriptorInfo(VkDescriptorType type, VkShaderStageFlags stageFlags,
+                                                            vector<VkDescriptorBufferInfo>* bufferData) {
    this->descriptorInfoList.push_back({ type, stageFlags, bufferData, nullptr });
 }
 
 template<class VertexType>
-void GraphicsPipeline_Vulkan<VertexType>::addDescriptorInfo(VkDescriptorType type,
-      VkShaderStageFlags stageFlags, VkDescriptorImageInfo* imageData) {
+void GraphicsPipeline_Vulkan<VertexType>::addDescriptorInfo(VkDescriptorType type, VkShaderStageFlags stageFlags,
+                                                            VkDescriptorImageInfo* imageData) {
    this->descriptorInfoList.push_back({ type, stageFlags, nullptr, imageData });
 }
 
+// TODO: Maybe make an analogous one for updating image info
+// Also, I may want to rewrite this function to call vkUpdateDescriptorSets once and call it once
+// per swapchain image from VulkanGame
 template<class VertexType>
 void GraphicsPipeline_Vulkan<VertexType>::updateDescriptorInfo(uint32_t index,
                                                                vector<VkDescriptorBufferInfo>* bufferData,
-                                                               vector<VkImage>& swapChainImages) {
+                                                               uint32_t size) {
    this->descriptorInfoList[index].bufferDataList = bufferData;
 
    // TODO: This code was mostly copied from createDescriptorSets. I should make some common function they both use
    // for updating descriptor sets
-   for (size_t i = 0; i < swapChainImages.size(); i++) {
+   for (size_t i = 0; i < size; i++) {
       VkWriteDescriptorSet descriptorWrite = {};
 
@@ -237 +233 @@
       }
 
-      // TODO: Instead, assert that (bufferData->size() == swapChainImages.size()
-      if (bufferData->size() != swapChainImages.size()) {
+      // TODO: Instead, assert that (bufferData->size() == swapChainImages.size() (now just changed to size)
+      if (bufferData->size() != size) {
          cout << "ALERT ALERT ALERT: SIZE MISMATCH!!!!!!!" << endl;
       }
@@ -410 +406 @@
 
 template<class VertexType>
-void GraphicsPipeline_Vulkan<VertexType>::createDescriptorPool(vector<VkImage>& swapChainImages) {
+void GraphicsPipeline_Vulkan<VertexType>::createDescriptorPool(uint32_t size) {
    vector<VkDescriptorPoolSize> poolSizes(this->descriptorInfoList.size());
 
    for (size_t i = 0; i < poolSizes.size(); i++) {
       poolSizes[i].type = this->descriptorInfoList[i].type;
-      poolSizes[i].descriptorCount = static_cast<uint32_t>(swapChainImages.size());
+      poolSizes[i].descriptorCount = size;
    }
 
@@ -422 +418 @@
    poolInfo.poolSizeCount = static_cast<uint32_t>(poolSizes.size());
    poolInfo.pPoolSizes = poolSizes.data();
-   poolInfo.maxSets = static_cast<uint32_t>(swapChainImages.size());
+   poolInfo.maxSets = size;
 
    if (vkCreateDescriptorPool(this->device, &poolInfo, nullptr, &this->descriptorPool) != VK_SUCCESS) {
@@ -429 +425 @@
 }
 
-// TODO: Since I only need the size of the swapChainImages array, I should just pass that in instead of the whole array
-template<class VertexType>
-void GraphicsPipeline_Vulkan<VertexType>::createDescriptorSets(vector<VkImage>& swapChainImages) {
-   vector<VkDescriptorSetLayout> layouts(swapChainImages.size(), this->descriptorSetLayout);
+template<class VertexType>
+void GraphicsPipeline_Vulkan<VertexType>::createDescriptorSets(uint32_t size) {
+   vector<VkDescriptorSetLayout> layouts(size, this->descriptorSetLayout);
 
    VkDescriptorSetAllocateInfo allocInfo = {};
    allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
    allocInfo.descriptorPool = this->descriptorPool;
-   allocInfo.descriptorSetCount = static_cast<uint32_t>(swapChainImages.size());
+   allocInfo.descriptorSetCount = size;
    allocInfo.pSetLayouts = layouts.data();
 
-   this->descriptorSets.resize(swapChainImages.size());
+   this->descriptorSets.resize(size);
    if (vkAllocateDescriptorSets(device, &allocInfo, this->descriptorSets.data()) != VK_SUCCESS) {
       throw runtime_error("failed to allocate descriptor sets!");
    }
 
-   for (size_t i = 0; i < swapChainImages.size(); i++) {
+   for (size_t i = 0; i < size; i++) {
       vector<VkWriteDescriptorSet> descriptorWrites(this->descriptorInfoList.size());