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


Ignore:
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • compile.sh

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

  • docs/README.txt

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

  • graphics-pipeline_vulkan.hpp

    rcb6fabb r756162f  
    3232};
    3333
    34 // TODO: Use this struct for uniform buffers as well (maybe move it to VulkanUtils)
     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
    3537struct StorageBufferSet {
    3638   vector<VkBuffer> buffers;
    … …  
    6466      void addStorageDescriptor(VkShaderStageFlags stageFlags);
    6567
    66       void addDescriptorInfo(VkDescriptorType type, VkShaderStageFlags stageFlags, vector<VkDescriptorBufferInfo>* bufferData);
     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);
    6771      void addDescriptorInfo(VkDescriptorType type, VkShaderStageFlags stageFlags, VkDescriptorImageInfo* imageData);
    6872
    … …  
    7579
    7680      bool addObject(const vector<VertexType>& vertices, vector<uint16_t> indices, SSBOType& ssbo,
    77          VkCommandPool commandPool, VkQueue graphicsQueue);
     81                     VkCommandPool commandPool, VkQueue graphicsQueue);
    7882
    7983      void updateObject(size_t objIndex, SSBOType& ssbo);
    8084
    8185      void updateObjectVertices(size_t objIndex, const vector<VertexType>& vertices, VkCommandPool commandPool,
    82          VkQueue graphicsQueue);
     86                                VkQueue graphicsQueue);
    8387
    8488      void cleanup();
    … …  
    456460         switch (descriptorWrites[j].descriptorType) {
    457461            case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
     462            case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
    458463            case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
    459464               descriptorWrites[j].pBufferInfo = &(*this->descriptorInfoList[j].bufferDataList)[i];
    … …  
    474479void GraphicsPipeline_Vulkan<VertexType, SSBOType>::createRenderCommands(VkCommandBuffer& commandBuffer,
    475480      uint32_t currentImage) {
     481
    476482   vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
     483
    477484   vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1,
    478485      &descriptorSets[currentImage], 0, nullptr);
    … …  
    543550}
    544551
     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
    545554template<class VertexType, class SSBOType>
    546555void GraphicsPipeline_Vulkan<VertexType, SSBOType>::updateObject(size_t objIndex, SSBOType& ssbo) {
    547556   if (!is_same_v<SSBOType, void*>) {
    548557      for (size_t i = 0; i < storageBufferSet.memory.size(); i++) {
    549          VulkanUtils::copyDataToMemory(this->device, storageBufferSet.memory[i], objIndex * sizeof(SSBOType), ssbo);
     558         VulkanUtils::copyDataToMemory(this->device, ssbo, storageBufferSet.memory[i], objIndex * sizeof(SSBOType));
    550559      }
    551560   }

  • makefile

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

  • sdl-game.cpp

    rcb6fabb r756162f  
    7878
    7979void VulkanGame::run(int width, int height, unsigned char guiFlags) {
     80   cout << "Vulkan Game" << endl;
     81
    8082   cout << "DEBUGGING IS " << (ENABLE_VALIDATION_LAYERS ? "ON" : "OFF") << endl;
    81 
    82    cout << "Vulkan Game" << endl;
    8383
    8484   if (initUI(width, height, guiFlags) == RTWO_ERROR) {
    … …  
    103103   modelPipeline.addAttribute(VK_FORMAT_R32_UINT, offset_of(&ModelVertex::objIndex));
    104104
    105    createBufferSet(sizeof(UBO_VP_mats), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
    106       uniformBuffers_modelPipeline, uniformBuffersMemory_modelPipeline, uniformBufferInfoList_modelPipeline);
     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);
    107108
    108109   modelPipeline.addDescriptorInfo(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
    … …  
    113114
    114115   SceneObject<ModelVertex, SSBO_ModelObject>* texturedSquare = nullptr;
     116
     117   // TODO: Ideally, avoid having to make the squares as modified upon creation
    115118
    116119   texturedSquare = &addObject(modelObjects, modelPipeline,
    … …  
    446449   }
    447450
    448    VulkanUtils::copyDataToMemory(device, uniformBuffersMemory_modelPipeline[imageIndex], 0, object_VP_mats);
     451   VulkanUtils::copyDataToMemory(device, object_VP_mats, uniformBuffersMemory_modelPipeline[imageIndex], 0);
    449452}
    450453
    … …  
    10801083}
    10811084
    1082 void VulkanGame::createBufferSet(VkDeviceSize bufferSize, VkBufferUsageFlags flags,
    1083                                  vector<VkBuffer>& buffers, vector<VkDeviceMemory>& buffersMemory,
     1085void VulkanGame::createBufferSet(vector<VkBuffer>& buffers, vector<VkDeviceMemory>& buffersMemory,
     1086                                 VkDeviceSize bufferSize, VkBufferUsageFlags flags, VkMemoryPropertyFlags properties,
    10841087                                 vector<VkDescriptorBufferInfo>& bufferInfoList) {
    10851088   buffers.resize(swapChainImageCount);
    … …  
    10881091
    10891092   for (size_t i = 0; i < swapChainImageCount; 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]);
     1093      VulkanUtils::createBuffer(device, physicalDevice, bufferSize, flags, properties, buffers[i], buffersMemory[i]);
    10931094
    10941095      bufferInfoList[i].buffer = buffers[i];
    … …  
    12291230   // instead of recreated every time
    12301231
    1231    createBufferSet(sizeof(UBO_VP_mats), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
    1232       uniformBuffers_modelPipeline, uniformBuffersMemory_modelPipeline, uniformBufferInfoList_modelPipeline);
     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);
    12331235
    12341236   modelPipeline.updateRenderPass(renderPass);

  • sdl-game.hpp

    rcb6fabb r756162f  
    276276      void cleanupImGuiOverlay();
    277277
    278       void createBufferSet(VkDeviceSize bufferSize, VkBufferUsageFlags flags,
    279          vector<VkBuffer>& buffers, vector<VkDeviceMemory>& buffersMemory,
    280          vector<VkDescriptorBufferInfo>& bufferInfoList);
     278      void createBufferSet(vector<VkBuffer>& buffers, vector<VkDeviceMemory>& buffersMemory, VkDeviceSize bufferSize,
     279                           VkBufferUsageFlags flags, VkMemoryPropertyFlags properties,
     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(
    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);
     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);
    290289
    291290      template<class VertexType>
    … …  
    299298
    300299      template<class VertexType, class SSBOType>
    301       void updateObject(vector<SceneObject<VertexType, SSBOType>>& objects,
    302          GraphicsPipeline_Vulkan<VertexType, SSBOType>& pipeline, size_t index);
     300      void updateObject(vector<SceneObject<VertexType, SSBOType>>& objects, GraphicsPipeline_Vulkan<VertexType,
     301                       SSBOType>& pipeline, size_t index);
    303302
    304303      void renderFrame(ImDrawData* draw_data);
    … …  
    458457// TODO: Just pass in the single object instead of a list of all of them
    459458template<class VertexType, class SSBOType>
    460 void VulkanGame::updateObject(vector<SceneObject<VertexType, SSBOType>>& objects,
    461    GraphicsPipeline_Vulkan<VertexType, SSBOType>& pipeline, size_t index) {
     459void VulkanGame::updateObject(vector<SceneObject<VertexType, SSBOType>>& objects, GraphicsPipeline_Vulkan<VertexType,
     460                             SSBOType>& pipeline, size_t index) {
    462461   SceneObject<VertexType, SSBOType>& obj = objects[index];
    463462

  • vulkan-game.cpp

    rcb6fabb r756162f  
    9292   seedRandomNums();
    9393
     94   cout << "Vulkan Game" << endl;
     95
    9496   cout << "DEBUGGING IS " << (ENABLE_VALIDATION_LAYERS ? "ON" : "OFF") << endl;
    95 
    96    cout << "Vulkan Game" << endl;
    9797
    9898   if (initUI(width, height, guiFlags) == RTWO_ERROR) {
    … …  
    10591059   explosion_UBO.cur_time = curTime;
    10601060
    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);
     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);
    10701070}
    10711071

  • vulkan-game.hpp

    rcb6fabb r756162f  
    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 */
    200206
    201207class VulkanGame {

  • vulkan-utils.hpp

    rcb6fabb r756162f  
    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, VkQueue graphicsQueue);
     73                                            VkCommandPool commandPool, string filename, VulkanImage& image,
     74                                            VkQueue graphicsQueue);
    7475      static void createVulkanImageFromSDLTexture(VkDevice device, VkPhysicalDevice physicalDevice,
    75             SDL_Texture* texture, VulkanImage& image);
     76                                                  SDL_Texture* texture, VulkanImage& image);
    7677      static void populateVulkanImageFromSDLTexture(VkDevice device, VkPhysicalDevice physicalDevice,
    77             VkCommandPool commandPool, SDL_Texture* texture, SDL_Renderer* renderer, VulkanImage& image,
    78             VkQueue graphicsQueue);
     78                                                    VkCommandPool commandPool, SDL_Texture* texture,
     79                                                    SDL_Renderer* renderer, VulkanImage& image, VkQueue graphicsQueue);
    7980      static void createDepthImage(VkDevice device, VkPhysicalDevice physicalDevice, VkCommandPool commandPool,
    80             VkFormat depthFormat, VkExtent2D extent, VulkanImage& image, VkQueue graphicsQueue);
     81                                   VkFormat depthFormat, VkExtent2D extent, VulkanImage& image, VkQueue graphicsQueue);
    8182      static void createImage(VkDevice device, VkPhysicalDevice physicalDevice, uint32_t width, uint32_t height,
    82             VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties,
    83             VulkanImage& image);
     83                              VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage,
     84                              VkMemoryPropertyFlags properties, VulkanImage& image);
    8485
    8586      static void transitionImageLayout(VkDevice device, VkCommandPool commandPool, VkImage image,
    86             VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout, VkQueue graphicsQueue);
     87                                        VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout,
     88                                        VkQueue graphicsQueue);
    8789      static VkCommandBuffer beginSingleTimeCommands(VkDevice device, VkCommandPool commandPool);
    8890      static void endSingleTimeCommands(VkDevice device, VkCommandPool commandPool,
    89             VkCommandBuffer commandBuffer, VkQueue graphicsQueue);
     91                                        VkCommandBuffer commandBuffer, VkQueue graphicsQueue);
    9092      static void copyBufferToImage(VkDevice device, VkCommandPool commandPool, VkBuffer buffer, VkImage image,
    91             uint32_t width, uint32_t height, VkQueue graphicsQueue);
     93                                    uint32_t width, uint32_t height, VkQueue graphicsQueue);
    9294
    9395      template<class DataType>
    9496      static void copyDataToBuffer(VkDevice device, VkPhysicalDevice physicalDevice, VkCommandPool commandPool,
    95             const vector<DataType>& srcData, VkBuffer dstBuffer, size_t dstVertexOffset, VkQueue graphicsQueue);
     97                                   const vector<DataType>& srcData, VkBuffer dstBuffer, size_t dstVertexOffset,
     98                                   VkQueue graphicsQueue);
    9699
    97100      static void copyBuffer(VkDevice device, VkCommandPool commandPool, VkBuffer srcBuffer, VkBuffer dstBuffer,
    98             VkDeviceSize srcOffset, VkDeviceSize dstOffset, VkDeviceSize size, VkQueue graphicsQueue);
     101                             VkDeviceSize srcOffset, VkDeviceSize dstOffset, VkDeviceSize size,
     102                             VkQueue graphicsQueue);
    99103
    100104      template<class DataType>
    101       static void copyDataToMemory(VkDevice device, VkDeviceMemory bufferMemory, VkDeviceSize offset,
    102             const DataType& srcData);
     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);
    103111
    104112      static bool hasStencilComponent(VkFormat format);
    … …  
    131139
    132140template<class DataType>
    133 void VulkanUtils::copyDataToMemory(VkDevice device, VkDeviceMemory bufferMemory, VkDeviceSize offset,
    134       const DataType& srcData) {
     141void VulkanUtils::copyDataToMemory(VkDevice device, const DataType& srcData, VkDeviceMemory bufferMemory,
     142   VkDeviceSize offset) {
     143   copyDataToMemory(device, srcData, bufferMemory, offset, sizeof(DataType));
     144}
     145
     146template<class DataType>
     147void VulkanUtils::copyDataToMemory(VkDevice device, const DataType& srcData, VkDeviceMemory bufferMemory,
     148                                   VkDeviceSize offset, VkDeviceSize size) {
    135149   void* data;
    136150
    137    vkMapMemory(device, bufferMemory, offset, sizeof(DataType), 0, &data);
    138    memcpy(data, &srcData, sizeof(DataType));
     151   vkMapMemory(device, bufferMemory, offset, size, 0, &data);
     152   memcpy(data, &srcData, size);
    139153   vkUnmapMemory(device, bufferMemory);
    140154}
    141155
     156// TODO: Use this in vulkan-utils itself as well
    142157#define VKUTIL_CHECK_RESULT(f, msg) {                                                                                      \
    143158   VkResult res = (f);                                                                                                     \
Note: See TracChangeset for help on using the changeset viewer.