Changes in / [756162f:cb6fabb] in opengl-game


Ignore:
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • compile.sh

    r756162f rcb6fabb  
    11# TODO: Figure out why calling this from a makefile gives an error about shopt not being found
    22
    3 cd shaders
     3OS=$(uname)
    44
    55shopt -s nullglob
    … …  
    1616   glslangValidator -V $f -o $fOut
    1717done
    18 
    19 cd ..

  • docs/README.txt

    r756162f rcb6fabb  
    1 --------------------
    2 CONTROLS
    3 --------------------
    4 
    5 Use left and right arrow keys to move your ship
    6 Use Z and X to fire your left and right lasers at the cubes (asteroids)
    7 
    81--------------------
    92VULKAN INSTRUCTIOS

  • graphics-pipeline_vulkan.hpp

    r756162f rcb6fabb  
    3232};
    3333
    34 // TODO: Use this struct for uniform buffers as well and rename it to VulkanBuffer (maybe move it to VulkanUtils)
    35 // Also, probably better to make this a vector of structs where each struct
    36 // has a VkBuffer, VkDeviceMemory, and VkDescriptorBufferInfo
     34// TODO: Use this struct for uniform buffers as well (maybe move it to VulkanUtils)
    3735struct StorageBufferSet {
    3836   vector<VkBuffer> buffers;
    … …  
    6664      void addStorageDescriptor(VkShaderStageFlags stageFlags);
    6765
    68       // TODO: I might be able to use a single VkDescriptorBufferInfo here and reuse it when creating the descriptor sets
    69       void addDescriptorInfo(VkDescriptorType type, VkShaderStageFlags stageFlags,
    70                              vector<VkDescriptorBufferInfo>* bufferData);
     66      void addDescriptorInfo(VkDescriptorType type, VkShaderStageFlags stageFlags, vector<VkDescriptorBufferInfo>* bufferData);
    7167      void addDescriptorInfo(VkDescriptorType type, VkShaderStageFlags stageFlags, VkDescriptorImageInfo* imageData);
    7268
    … …  
    7975
    8076      bool addObject(const vector<VertexType>& vertices, vector<uint16_t> indices, SSBOType& ssbo,
    81                      VkCommandPool commandPool, VkQueue graphicsQueue);
     77         VkCommandPool commandPool, VkQueue graphicsQueue);
    8278
    8379      void updateObject(size_t objIndex, SSBOType& ssbo);
    8480
    8581      void updateObjectVertices(size_t objIndex, const vector<VertexType>& vertices, VkCommandPool commandPool,
    86                                 VkQueue graphicsQueue);
     82         VkQueue graphicsQueue);
    8783
    8884      void cleanup();
    … …  
    460456         switch (descriptorWrites[j].descriptorType) {
    461457            case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
    462             case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
    463458            case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
    464459               descriptorWrites[j].pBufferInfo = &(*this->descriptorInfoList[j].bufferDataList)[i];
    … …  
    479474void GraphicsPipeline_Vulkan<VertexType, SSBOType>::createRenderCommands(VkCommandBuffer& commandBuffer,
    480475      uint32_t currentImage) {
    481 
    482476   vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
    483 
    484477   vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1,
    485478      &descriptorSets[currentImage], 0, nullptr);
    … …  
    550543}
    551544
    552 // TODO: Allow a swapchain index to be passed in instead of updating all of them
    553 // Actually, since I'm in the process of replacing SSBOs with dynamic UBOs, I can ignore that for this function
    554545template<class VertexType, class SSBOType>
    555546void GraphicsPipeline_Vulkan<VertexType, SSBOType>::updateObject(size_t objIndex, SSBOType& ssbo) {
    556547   if (!is_same_v<SSBOType, void*>) {
    557548      for (size_t i = 0; i < storageBufferSet.memory.size(); i++) {
    558          VulkanUtils::copyDataToMemory(this->device, ssbo, storageBufferSet.memory[i], objIndex * sizeof(SSBOType));
     549         VulkanUtils::copyDataToMemory(this->device, storageBufferSet.memory[i], objIndex * sizeof(SSBOType), ssbo);
    559550      }
    560551   }

  • makefile

    r756162f rcb6fabb  
    7474.PHONY: shaders
    7575shaders:
    76         ./compile.sh
     76        cd shaders && ../compile.sh && cd ..
    7777
    7878clean:

  • sdl-game.cpp

    r756162f rcb6fabb  
    7878
    7979void VulkanGame::run(int width, int height, unsigned char guiFlags) {
     80   cout << "DEBUGGING IS " << (ENABLE_VALIDATION_LAYERS ? "ON" : "OFF") << endl;
     81
    8082   cout << "Vulkan Game" << endl;
    81 
    82    cout << "DEBUGGING IS " << (ENABLE_VALIDATION_LAYERS ? "ON" : "OFF") << endl;
    8383
    8484   if (initUI(width, height, guiFlags) == RTWO_ERROR) {
    … …  
    103103   modelPipeline.addAttribute(VK_FORMAT_R32_UINT, offset_of(&ModelVertex::objIndex));
    104104
    105    createBufferSet(uniformBuffers_modelPipeline, uniformBuffersMemory_modelPipeline, sizeof(UBO_VP_mats),
    106       VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
    107       uniformBufferInfoList_modelPipeline);
     105   createBufferSet(sizeof(UBO_VP_mats), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
     106      uniformBuffers_modelPipeline, uniformBuffersMemory_modelPipeline, uniformBufferInfoList_modelPipeline);
    108107
    109108   modelPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
    … …  
    114113
    115114   SceneObject<ModelVertex, SSBO_ModelObject>* texturedSquare = nullptr;
    116 
    117    // TODO: Ideally, avoid having to make the squares as modified upon creation
    118115
    119116   texturedSquare = &addObject(modelObjects, modelPipeline,
    … …  
    449446   }
    450447
    451    VulkanUtils::copyDataToMemory(device, object_VP_mats, uniformBuffersMemory_modelPipeline[imageIndex], 0);
     448   VulkanUtils::copyDataToMemory(device, uniformBuffersMemory_modelPipeline[imageIndex], 0, object_VP_mats);
    452449}
    453450
    … …  
    10831080}
    10841081
    1085 void VulkanGame::createBufferSet(vector<VkBuffer>& buffers, vector<VkDeviceMemory>& buffersMemory,
    1086                                  VkDeviceSize bufferSize, VkBufferUsageFlags flags, VkMemoryPropertyFlags properties,
     1082void VulkanGame::createBufferSet(VkDeviceSize bufferSize, VkBufferUsageFlags flags,
     1083                                 vector<VkBuffer>& buffers, vector<VkDeviceMemory>& buffersMemory,
    10871084                                 vector<VkDescriptorBufferInfo>& bufferInfoList) {
    10881085   buffers.resize(swapChainImageCount);
    … …  
    10911088
    10921089   for (size_t i = 0; i < swapChainImageCount; i++) {
    1093       VulkanUtils::createBuffer(device, physicalDevice, bufferSize, flags, properties, buffers[i], buffersMemory[i]);
     1090      VulkanUtils::createBuffer(device, physicalDevice, bufferSize, flags,
     1091         VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
     1092         buffers[i], buffersMemory[i]);
    10941093
    10951094      bufferInfoList[i].buffer = buffers[i];
    … …  
    12301229   // instead of recreated every time
    12311230
    1232    createBufferSet(uniformBuffers_modelPipeline, uniformBuffersMemory_modelPipeline, sizeof(UBO_VP_mats),
    1233       VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
    1234       uniformBufferInfoList_modelPipeline);
     1231   createBufferSet(sizeof(UBO_VP_mats), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
     1232      uniformBuffers_modelPipeline, uniformBuffersMemory_modelPipeline, uniformBufferInfoList_modelPipeline);
    12351233
    12361234   modelPipeline.updateRenderPass(renderPass);

  • sdl-game.hpp

    r756162f rcb6fabb  
    276276      void cleanupImGuiOverlay();
    277277
    278       void createBufferSet(vector<VkBuffer>& buffers, vector<VkDeviceMemory>& buffersMemory, VkDeviceSize bufferSize,
    279                            VkBufferUsageFlags flags, VkMemoryPropertyFlags properties,
    280                            vector<VkDescriptorBufferInfo>& bufferInfoList);
     278      void createBufferSet(VkDeviceSize bufferSize, VkBufferUsageFlags flags,
     279         vector<VkBuffer>& buffers, vector<VkDeviceMemory>& buffersMemory,
     280         vector<VkDescriptorBufferInfo>& bufferInfoList);
    281281
    282282      // TODO: Since addObject() returns a reference to the new object now,
    283283      // stop using objects.back() to access the object that was just created
    284284      template<class VertexType, class SSBOType>
    285       SceneObject<VertexType, SSBOType>& addObject(vector<SceneObject<VertexType, SSBOType>>& objects,
    286                                                    GraphicsPipeline_Vulkan<VertexType, SSBOType>& pipeline,
    287                                                    const vector<VertexType>& vertices, vector<uint16_t> indices,
    288                                                    SSBOType ssbo, bool pipelinesCreated);
     285      SceneObject<VertexType, SSBOType>& addObject(
     286         vector<SceneObject<VertexType, SSBOType>>& objects,
     287         GraphicsPipeline_Vulkan<VertexType, SSBOType>& pipeline,
     288         const vector<VertexType>& vertices, vector<uint16_t> indices, SSBOType ssbo,
     289         bool pipelinesCreated);
    289290
    290291      template<class VertexType>
    … …  
    298299
    299300      template<class VertexType, class SSBOType>
    300       void updateObject(vector<SceneObject<VertexType, SSBOType>>& objects, GraphicsPipeline_Vulkan<VertexType,
    301                        SSBOType>& pipeline, size_t index);
     301      void updateObject(vector<SceneObject<VertexType, SSBOType>>& objects,
     302         GraphicsPipeline_Vulkan<VertexType, SSBOType>& pipeline, size_t index);
    302303
    303304      void renderFrame(ImDrawData* draw_data);
    … …  
    457458// TODO: Just pass in the single object instead of a list of all of them
    458459template<class VertexType, class SSBOType>
    459 void VulkanGame::updateObject(vector<SceneObject<VertexType, SSBOType>>& objects, GraphicsPipeline_Vulkan<VertexType,
    460                              SSBOType>& pipeline, size_t index) {
     460void VulkanGame::updateObject(vector<SceneObject<VertexType, SSBOType>>& objects,
     461   GraphicsPipeline_Vulkan<VertexType, SSBOType>& pipeline, size_t index) {
    461462   SceneObject<VertexType, SSBOType>& obj = objects[index];
    462463

  • vulkan-game.cpp

    r756162f rcb6fabb  
    9292   seedRandomNums();
    9393
     94   cout << "DEBUGGING IS " << (ENABLE_VALIDATION_LAYERS ? "ON" : "OFF") << endl;
     95
    9496   cout << "Vulkan Game" << endl;
    95 
    96    cout << "DEBUGGING IS " << (ENABLE_VALIDATION_LAYERS ? "ON" : "OFF") << endl;
    9797
    9898   if (initUI(width, height, guiFlags) == RTWO_ERROR) {
    … …  
    10591059   explosion_UBO.cur_time = curTime;
    10601060
    1061    VulkanUtils::copyDataToMemory(device, object_VP_mats, uniformBuffersMemory_modelPipeline[imageIndex], 0);
    1062 
    1063    VulkanUtils::copyDataToMemory(device, ship_VP_mats, uniformBuffersMemory_shipPipeline[imageIndex], 0);
    1064 
    1065    VulkanUtils::copyDataToMemory(device, asteroid_VP_mats, uniformBuffersMemory_asteroidPipeline[imageIndex], 0);
    1066 
    1067    VulkanUtils::copyDataToMemory(device, laser_VP_mats, uniformBuffersMemory_laserPipeline[imageIndex], 0);
    1068 
    1069    VulkanUtils::copyDataToMemory(device, explosion_UBO, uniformBuffersMemory_explosionPipeline[imageIndex], 0);
     1061   VulkanUtils::copyDataToMemory(device, uniformBuffersMemory_modelPipeline[imageIndex], 0, object_VP_mats);
     1062
     1063   VulkanUtils::copyDataToMemory(device, uniformBuffersMemory_shipPipeline[imageIndex], 0, ship_VP_mats);
     1064
     1065   VulkanUtils::copyDataToMemory(device, uniformBuffersMemory_asteroidPipeline[imageIndex], 0, asteroid_VP_mats);
     1066
     1067   VulkanUtils::copyDataToMemory(device, uniformBuffersMemory_laserPipeline[imageIndex], 0, laser_VP_mats);
     1068
     1069   VulkanUtils::copyDataToMemory(device, uniformBuffersMemory_explosionPipeline[imageIndex], 0, explosion_UBO);
    10701070}
    10711071

  • vulkan-game.hpp

    r756162f rcb6fabb  
    198198   UIValue(UIValueType _type, string _label, void* _value) : type(_type), label(_label), value(_value) {}
    199199};
    200 
    201 /* TODO: The following syntax (note the const keyword) means the function will not modify
    202  * its params. I should use this where appropriate
    203  *
    204  * [return-type] [func-name](params...) const { ... }
    205  */
    206200
    207201class VulkanGame {

  • vulkan-utils.hpp

    r756162f rcb6fabb  
    3939
    4040      static VkResult createDebugUtilsMessengerEXT(VkInstance instance,
    41                                                    const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
    42                                                    const VkAllocationCallbacks* pAllocator,
    43                                                    VkDebugUtilsMessengerEXT* pDebugMessenger);
     41            const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
     42            const VkAllocationCallbacks* pAllocator,
     43            VkDebugUtilsMessengerEXT* pDebugMessenger);
    4444
    4545      static void destroyDebugUtilsMessengerEXT(VkInstance instance,
    46                                                 VkDebugUtilsMessengerEXT debugMessenger,
    47                                                 const VkAllocationCallbacks* pAllocator);
     46            VkDebugUtilsMessengerEXT debugMessenger,
     47            const VkAllocationCallbacks* pAllocator);
    4848
    4949      static QueueFamilyIndices findQueueFamilies(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface);
    5050      static bool checkDeviceExtensionSupport(VkPhysicalDevice physicalDevice,
    51                                               const vector<const char*>& deviceExtensions);
     51            const vector<const char*>& deviceExtensions);
    5252      static VkSurfaceCapabilitiesKHR querySwapChainCapabilities(VkPhysicalDevice physicalDevice,
    53                                                                  VkSurfaceKHR surface);
     53         VkSurfaceKHR surface);
    5454      static vector<VkSurfaceFormatKHR> querySwapChainFormats(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface);
    5555      static vector<VkPresentModeKHR> querySwapChainPresentModes(VkPhysicalDevice physicalDevice,
    56                                                                  VkSurfaceKHR surface);
     56         VkSurfaceKHR surface);
    5757      static VkSurfaceFormatKHR chooseSwapSurfaceFormat(const vector<VkSurfaceFormatKHR>& availableFormats,
    58                                                         const vector<VkFormat>& requestedFormats, VkColorSpaceKHR requestedColorSpace);
     58         const vector<VkFormat>& requestedFormats, VkColorSpaceKHR requestedColorSpace);
    5959      static VkPresentModeKHR chooseSwapPresentMode(const vector<VkPresentModeKHR>& availablePresentModes,
    60                                                     const vector<VkPresentModeKHR>& requestedPresentModes);
     60         const vector<VkPresentModeKHR>& requestedPresentModes);
    6161      static VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, int width, int height);
    6262      static VkImageView createImageView(VkDevice device, VkImage image, VkFormat format,
    63                                          VkImageAspectFlags aspectFlags);
     63            VkImageAspectFlags aspectFlags);
    6464      static VkFormat findSupportedFormat(VkPhysicalDevice physicalDevice, const vector<VkFormat>& candidates,
    65                                           VkImageTiling tiling, VkFormatFeatureFlags features);
     65            VkImageTiling tiling, VkFormatFeatureFlags features);
    6666      static void createBuffer(VkDevice device, VkPhysicalDevice physicalDevice, VkDeviceSize size,
    67                                VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer,
    68                                VkDeviceMemory& bufferMemory);
     67            VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer,
     68            VkDeviceMemory& bufferMemory);
    6969      static uint32_t findMemoryType(VkPhysicalDevice physicalDevice, uint32_t typeFilter,
    70                                      VkMemoryPropertyFlags properties);
     70            VkMemoryPropertyFlags properties);
    7171
    7272      static void createVulkanImageFromFile(VkDevice device, VkPhysicalDevice physicalDevice,
    73                                             VkCommandPool commandPool, string filename, VulkanImage& image,
    74                                             VkQueue graphicsQueue);
     73            VkCommandPool commandPool, string filename, VulkanImage& image, VkQueue graphicsQueue);
    7574      static void createVulkanImageFromSDLTexture(VkDevice device, VkPhysicalDevice physicalDevice,
    76                                                   SDL_Texture* texture, VulkanImage& image);
     75            SDL_Texture* texture, VulkanImage& image);
    7776      static void populateVulkanImageFromSDLTexture(VkDevice device, VkPhysicalDevice physicalDevice,
    78                                                     VkCommandPool commandPool, SDL_Texture* texture,
    79                                                     SDL_Renderer* renderer, VulkanImage& image, VkQueue graphicsQueue);
     77            VkCommandPool commandPool, SDL_Texture* texture, SDL_Renderer* renderer, VulkanImage& image,
     78            VkQueue graphicsQueue);
    8079      static void createDepthImage(VkDevice device, VkPhysicalDevice physicalDevice, VkCommandPool commandPool,
    81                                    VkFormat depthFormat, VkExtent2D extent, VulkanImage& image, VkQueue graphicsQueue);
     80            VkFormat depthFormat, VkExtent2D extent, VulkanImage& image, VkQueue graphicsQueue);
    8281      static void createImage(VkDevice device, VkPhysicalDevice physicalDevice, uint32_t width, uint32_t height,
    83                               VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage,
    84                               VkMemoryPropertyFlags properties, VulkanImage& image);
     82            VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties,
     83            VulkanImage& image);
    8584
    8685      static void transitionImageLayout(VkDevice device, VkCommandPool commandPool, VkImage image,
    87                                         VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout,
    88                                         VkQueue graphicsQueue);
     86            VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout, VkQueue graphicsQueue);
    8987      static VkCommandBuffer beginSingleTimeCommands(VkDevice device, VkCommandPool commandPool);
    9088      static void endSingleTimeCommands(VkDevice device, VkCommandPool commandPool,
    91                                         VkCommandBuffer commandBuffer, VkQueue graphicsQueue);
     89            VkCommandBuffer commandBuffer, VkQueue graphicsQueue);
    9290      static void copyBufferToImage(VkDevice device, VkCommandPool commandPool, VkBuffer buffer, VkImage image,
    93                                     uint32_t width, uint32_t height, VkQueue graphicsQueue);
     91            uint32_t width, uint32_t height, VkQueue graphicsQueue);
    9492
    9593      template<class DataType>
    9694      static void copyDataToBuffer(VkDevice device, VkPhysicalDevice physicalDevice, VkCommandPool commandPool,
    97                                    const vector<DataType>& srcData, VkBuffer dstBuffer, size_t dstVertexOffset,
    98                                    VkQueue graphicsQueue);
     95            const vector<DataType>& srcData, VkBuffer dstBuffer, size_t dstVertexOffset, VkQueue graphicsQueue);
    9996
    10097      static void copyBuffer(VkDevice device, VkCommandPool commandPool, VkBuffer srcBuffer, VkBuffer dstBuffer,
    101                              VkDeviceSize srcOffset, VkDeviceSize dstOffset, VkDeviceSize size,
    102                              VkQueue graphicsQueue);
     98            VkDeviceSize srcOffset, VkDeviceSize dstOffset, VkDeviceSize size, VkQueue graphicsQueue);
    10399
    104100      template<class DataType>
    105       static void copyDataToMemory(VkDevice device, const DataType& srcData, VkDeviceMemory bufferMemory,
    106                                    VkDeviceSize offset);
    107 
    108       template<class DataType>
    109       static void copyDataToMemory(VkDevice device, const DataType& srcData, VkDeviceMemory bufferMemory,
    110                                    VkDeviceSize offset, VkDeviceSize size);
     101      static void copyDataToMemory(VkDevice device, VkDeviceMemory bufferMemory, VkDeviceSize offset,
     102            const DataType& srcData);
    111103
    112104      static bool hasStencilComponent(VkFormat format);
    … …  
    139131
    140132template<class DataType>
    141 void VulkanUtils::copyDataToMemory(VkDevice device, const DataType& srcData, VkDeviceMemory bufferMemory,
    142    VkDeviceSize offset) {
    143    copyDataToMemory(device, srcData, bufferMemory, offset, sizeof(DataType));
    144 }
    145 
    146 template<class DataType>
    147 void VulkanUtils::copyDataToMemory(VkDevice device, const DataType& srcData, VkDeviceMemory bufferMemory,
    148                                    VkDeviceSize offset, VkDeviceSize size) {
     133void VulkanUtils::copyDataToMemory(VkDevice device, VkDeviceMemory bufferMemory, VkDeviceSize offset,
     134      const DataType& srcData) {
    149135   void* data;
    150136
    151    vkMapMemory(device, bufferMemory, offset, size, 0, &data);
    152    memcpy(data, &srcData, size);
     137   vkMapMemory(device, bufferMemory, offset, sizeof(DataType), 0, &data);
     138   memcpy(data, &srcData, sizeof(DataType));
    153139   vkUnmapMemory(device, bufferMemory);
    154140}
    155141
    156 // TODO: Use this in vulkan-utils itself as well
    157142#define VKUTIL_CHECK_RESULT(f, msg) {                                                                                      \
    158143   VkResult res = (f);                                                                                                     \
Note: See TracChangeset for help on using the changeset viewer.