source: opengl-game/vulkan-utils.hpp

feature/imgui-sdl
Last change on this file was 2f4ff8c, checked in by Dmitry Portnoy <dportnoy@…>, 3 years ago

Change the uniform buffers to always be mapped instead of mapping them every time data needs to be copied
  • Property mode set to 100644
File size: 11.3 KB
Line 
1#ifndef _VULKAN_UTILS_H
2#define _VULKAN_UTILS_H
3
4#include <optional>
5#include <sstream>
6#include <stdexcept>
7#include <string>
8#include <vector>
9
10#include <vulkan/vulkan.h>
11
12// TODO: Ideally, vulkan-utils should not have things speciic to windowing apis (glfw, sdl, sfml, etc.).
13// Check what these inclydes are for and if that functionality can be moved
14#include <SDL2/SDL.h>
15#include <SDL2/SDL_vulkan.h>
16
17using namespace std;
18
19struct QueueFamilyIndices {
20 optional<uint32_t> graphicsFamily;
21 optional<uint32_t> presentFamily;
22
23 bool isComplete() {
24 return graphicsFamily.has_value() && presentFamily.has_value();
25 }
26};
27
28struct VulkanImage {
29 VkImage image;
30 VkDeviceMemory imageMemory;
31 VkImageView imageView;
32};
33
34class VulkanUtils {
35 public:
36 static string resultString(VkResult result);
37
38 static bool checkValidationLayerSupport(const vector<const char*> &validationLayers);
39
40 static VkResult createDebugUtilsMessengerEXT(VkInstance instance,
41 const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
42 const VkAllocationCallbacks* pAllocator,
43 VkDebugUtilsMessengerEXT* pDebugMessenger);
44
45 static void destroyDebugUtilsMessengerEXT(VkInstance instance,
46 VkDebugUtilsMessengerEXT debugMessenger,
47 const VkAllocationCallbacks* pAllocator);
48
49 static QueueFamilyIndices findQueueFamilies(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface);
50 static bool checkDeviceExtensionSupport(VkPhysicalDevice physicalDevice,
51 const vector<const char*>& deviceExtensions);
52 static VkSurfaceCapabilitiesKHR querySwapChainCapabilities(VkPhysicalDevice physicalDevice,
53 VkSurfaceKHR surface);
54 static vector<VkSurfaceFormatKHR> querySwapChainFormats(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface);
55 static vector<VkPresentModeKHR> querySwapChainPresentModes(VkPhysicalDevice physicalDevice,
56 VkSurfaceKHR surface);
57 static VkSurfaceFormatKHR chooseSwapSurfaceFormat(const vector<VkSurfaceFormatKHR>& availableFormats,
58 const vector<VkFormat>& requestedFormats, VkColorSpaceKHR requestedColorSpace);
59 static VkPresentModeKHR chooseSwapPresentMode(const vector<VkPresentModeKHR>& availablePresentModes,
60 const vector<VkPresentModeKHR>& requestedPresentModes);
61 static VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, int width, int height);
62 static VkImageView createImageView(VkDevice device, VkImage image, VkFormat format,
63 VkImageAspectFlags aspectFlags);
64 static VkFormat findSupportedFormat(VkPhysicalDevice physicalDevice, const vector<VkFormat>& candidates,
65 VkImageTiling tiling, VkFormatFeatureFlags features);
66 static void createBuffer(VkDevice device, VkPhysicalDevice physicalDevice, VkDeviceSize size,
67 VkBufferUsageFlags usage, VkMemoryPropertyFlags properties, VkBuffer& buffer,
68 VkDeviceMemory& bufferMemory);
69 static uint32_t findMemoryType(VkPhysicalDevice physicalDevice, uint32_t typeFilter,
70 VkMemoryPropertyFlags properties);
71
72 static void createVulkanImageFromFile(VkDevice device, VkPhysicalDevice physicalDevice,
73 VkCommandPool commandPool, string filename, VulkanImage& image,
74 VkQueue graphicsQueue);
75 static void createVulkanImageFromSDLTexture(VkDevice device, VkPhysicalDevice physicalDevice,
76 SDL_Texture* texture, VulkanImage& image);
77 static void populateVulkanImageFromSDLTexture(VkDevice device, VkPhysicalDevice physicalDevice,
78 VkCommandPool commandPool, SDL_Texture* texture,
79 SDL_Renderer* renderer, VulkanImage& image, VkQueue graphicsQueue);
80 static void createDepthImage(VkDevice device, VkPhysicalDevice physicalDevice, VkCommandPool commandPool,
81 VkFormat depthFormat, VkExtent2D extent, VulkanImage& image, VkQueue graphicsQueue);
82 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);
85
86 static void transitionImageLayout(VkDevice device, VkCommandPool commandPool, VkImage image,
87 VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout,
88 VkQueue graphicsQueue);
89 static VkCommandBuffer beginSingleTimeCommands(VkDevice device, VkCommandPool commandPool);
90 static void endSingleTimeCommands(VkDevice device, VkCommandPool commandPool,
91 VkCommandBuffer commandBuffer, VkQueue graphicsQueue);
92 static void copyBufferToImage(VkDevice device, VkCommandPool commandPool, VkBuffer buffer, VkImage image,
93 uint32_t width, uint32_t height, VkQueue graphicsQueue);
94
95 template<class DataType>
96 static void copyDataToBuffer(VkDevice device, VkPhysicalDevice physicalDevice, VkCommandPool commandPool,
97 const vector<DataType>& srcData, VkBuffer dstBuffer, size_t dstVertexOffset,
98 VkQueue graphicsQueue);
99
100 static void copyBuffer(VkDevice device, VkCommandPool commandPool, VkBuffer srcBuffer, VkBuffer dstBuffer,
101 VkDeviceSize srcOffset, VkDeviceSize dstOffset, VkDeviceSize size,
102 VkQueue graphicsQueue);
103
104 template<class DataType>
105 static void copyDataToMemory(VkDevice device, DataType* srcData, VkDeviceMemory bufferMemory,
106 VkDeviceSize offset, VkDeviceSize size, bool flush);
107
108 template<class DataType>
109 static void copyDataToMappedMemory(VkDevice device, DataType* srcData, void* mappedData,
110 VkDeviceMemory bufferMemory, VkDeviceSize size, bool flush);
111
112 static bool hasStencilComponent(VkFormat format);
113
114 static void destroyVulkanImage(VkDevice& device, VulkanImage& image);
115};
116
117template<class DataType>
118void VulkanUtils::copyDataToBuffer(VkDevice device, VkPhysicalDevice physicalDevice, VkCommandPool commandPool,
119 const vector<DataType>& srcData, VkBuffer dstBuffer, size_t dstVertexOffset,
120 VkQueue graphicsQueue) {
121 VkDeviceSize srcDataSize = srcData.size() * sizeof(DataType);
122
123 VkBuffer stagingBuffer;
124 VkDeviceMemory stagingBufferMemory;
125 createBuffer(device, physicalDevice, srcDataSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
126 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
127 stagingBuffer, stagingBufferMemory);
128
129 void* data;
130 vkMapMemory(device, stagingBufferMemory, 0, srcDataSize, 0, &data);
131 memcpy(data, srcData.data(), (size_t)srcDataSize);
132 vkUnmapMemory(device, stagingBufferMemory);
133
134 copyBuffer(device, commandPool, stagingBuffer, dstBuffer, 0, dstVertexOffset * sizeof(DataType), srcDataSize,
135 graphicsQueue);
136
137 vkDestroyBuffer(device, stagingBuffer, nullptr);
138 vkFreeMemory(device, stagingBufferMemory, nullptr);
139}
140
141template<class DataType>
142void VulkanUtils::copyDataToMemory(VkDevice device, DataType* srcData, VkDeviceMemory bufferMemory,
143 VkDeviceSize offset, VkDeviceSize size, bool flush) {
144 void* data;
145
146 vkMapMemory(device, bufferMemory, offset, size, 0, &data);
147
148 memcpy(data, srcData, size);
149
150 if (flush) {
151 VkMappedMemoryRange memoryRange{};
152 memoryRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
153 memoryRange.memory = bufferMemory;
154 memoryRange.size = size;
155
156 vkFlushMappedMemoryRanges(device, 1, &memoryRange);
157 }
158
159 vkUnmapMemory(device, bufferMemory);
160}
161
162template<class DataType>
163void VulkanUtils::copyDataToMappedMemory(VkDevice device, DataType* srcData, void* mappedData,
164 VkDeviceMemory bufferMemory, VkDeviceSize size, bool flush) {
165 memcpy(mappedData, srcData, size);
166
167 if (flush) {
168 VkMappedMemoryRange memoryRange{};
169 memoryRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
170 memoryRange.memory = bufferMemory;
171 memoryRange.size = VK_WHOLE_SIZE; // memoryRange.size = size;
172
173 // TODO: Think about the best approach here, and when creating a Vulka buffer.
174 // The issue arises when calling vkMapMemory, because the size passed to it needs to be
175 // VK_WHOLE_SIZE or a multiple of some Vulkan constant. When I create a buffer and matching memory,
176 // the memory size (I believe) needs to be a multiple of the same or a similar constant, while
177 // the buffer can bind to only a part of the memory and I don't think has a size restriction.
178 // As long as I save the actual zize of the allocated memory, I can use that for things
179 // like vkMapMemory, but still continue to use the buffer's size for most operations
180
181 vkFlushMappedMemoryRanges(device, 1, &memoryRange);
182 }
183}
184
185// TODO: Use this in vulkan-utils itself as well
186#define VKUTIL_CHECK_RESULT(f, msg) { \
187 VkResult res = (f); \
188 \
189 if (res != VK_SUCCESS) { \
190 ostringstream oss; \
191 oss << msg << " VkResult is \"" << VulkanUtils::resultString(res) << "\" in " << __FILE__ << " at line " << __LINE__;\
192 \
193 if (res < 0) { \
194 throw runtime_error("Fatal: " + oss.str()); \
195 } else { \
196 cerr << oss.str(); \
197 } \
198 } \
199}
200
201#endif // _VULKAN_UTILS_H
Note: See TracBrowser for help on using the repository browser.