1 #ifndef MSP_GL_VULKAN_H_
2 #define MSP_GL_VULKAN_H_
4 #include <vulkan/vulkan.h>
5 #include <msp/graphics/vulkancontext.h>
11 template<typename T> struct HandleTraits;
12 template<> struct HandleTraits<VkBuffer> { using NativeHandle = ::VkBuffer; };
13 template<> struct HandleTraits<::VkBuffer> { using Wrapper = VkBuffer; };
14 template<> struct HandleTraits<VkCommandBuffer> { using NativeHandle = ::VkCommandBuffer; };
15 template<> struct HandleTraits<::VkCommandBuffer> { using Wrapper = VkCommandBuffer; };
16 template<> struct HandleTraits<VkCommandPool> { using NativeHandle = ::VkCommandPool; };
17 template<> struct HandleTraits<::VkCommandPool> { using Wrapper = VkCommandPool; };
18 template<> struct HandleTraits<VkDevice> { using NativeHandle = ::VkDevice; };
19 template<> struct HandleTraits<::VkDevice> { using Wrapper = VkDevice; };
20 template<> struct HandleTraits<VkDescriptorPool> { using NativeHandle = ::VkDescriptorPool; };
21 template<> struct HandleTraits<::VkDescriptorPool> { using Wrapper = VkDescriptorPool; };
22 template<> struct HandleTraits<VkDescriptorSet> { using NativeHandle = ::VkDescriptorSet; };
23 template<> struct HandleTraits<::VkDescriptorSet> { using Wrapper = VkDescriptorSet; };
24 template<> struct HandleTraits<VkDescriptorSetLayout> { using NativeHandle = ::VkDescriptorSetLayout; };
25 template<> struct HandleTraits<::VkDescriptorSetLayout> { using Wrapper = VkDescriptorSetLayout; };
26 template<> struct HandleTraits<VkDeviceMemory> { using NativeHandle = ::VkDeviceMemory; };
27 template<> struct HandleTraits<::VkDeviceMemory> { using Wrapper = VkDeviceMemory; };
28 template<> struct HandleTraits<VkFence> { using NativeHandle = ::VkFence; };
29 template<> struct HandleTraits<::VkFence> { using Wrapper = VkFence; };
30 template<> struct HandleTraits<VkFramebuffer> { using NativeHandle = ::VkFramebuffer; };
31 template<> struct HandleTraits<::VkFramebuffer> { using Wrapper = VkFramebuffer; };
32 template<> struct HandleTraits<VkImage> { using NativeHandle = ::VkImage; };
33 template<> struct HandleTraits<::VkImage> { using Wrapper = VkImage; };
34 template<> struct HandleTraits<VkImageView> { using NativeHandle = ::VkImageView; };
35 template<> struct HandleTraits<::VkImageView> { using Wrapper = VkImageView; };
36 template<> struct HandleTraits<VkPhysicalDevice> { using NativeHandle = ::VkPhysicalDevice; };
37 template<> struct HandleTraits<::VkPhysicalDevice> { using Wrapper = VkPhysicalDevice; };
38 template<> struct HandleTraits<VkPipeline> { using NativeHandle = ::VkPipeline; };
39 template<> struct HandleTraits<::VkPipeline> { using Wrapper = VkPipeline; };
40 template<> struct HandleTraits<VkPipelineCache> { using NativeHandle = ::VkPipelineCache; };
41 template<> struct HandleTraits<::VkPipelineCache> { using Wrapper = VkPipelineCache; };
42 template<> struct HandleTraits<VkPipelineLayout> { using NativeHandle = ::VkPipelineLayout; };
43 template<> struct HandleTraits<::VkPipelineLayout> { using Wrapper = VkPipelineLayout; };
44 template<> struct HandleTraits<VkQueue> { using NativeHandle = ::VkQueue; };
45 template<> struct HandleTraits<::VkQueue> { using Wrapper = VkQueue; };
46 template<> struct HandleTraits<VkRenderPass> { using NativeHandle = ::VkRenderPass; };
47 template<> struct HandleTraits<::VkRenderPass> { using Wrapper = VkRenderPass; };
48 template<> struct HandleTraits<VkSampler> { using NativeHandle = ::VkSampler; };
49 template<> struct HandleTraits<::VkSampler> { using Wrapper = VkSampler; };
50 template<> struct HandleTraits<VkSemaphore> { using NativeHandle = ::VkSemaphore; };
51 template<> struct HandleTraits<::VkSemaphore> { using Wrapper = VkSemaphore; };
52 template<> struct HandleTraits<VkShaderModule> { using NativeHandle = ::VkShaderModule; };
53 template<> struct HandleTraits<::VkShaderModule> { using Wrapper = VkShaderModule; };
54 template<> struct HandleTraits<VkSurface> { using NativeHandle = ::VkSurfaceKHR; };
55 template<> struct HandleTraits<::VkSurfaceKHR> { using Wrapper = VkSurface; };
56 template<> struct HandleTraits<VkSwapchain> { using NativeHandle = ::VkSwapchainKHR; };
57 template<> struct HandleTraits<::VkSwapchainKHR> { using Wrapper = VkSwapchain; };
60 T handle_cast(typename HandleTraits<T>::Wrapper handle)
61 { return reinterpret_cast<T>(handle); }
64 T handle_cast(typename HandleTraits<T>::NativeHandle handle)
65 { return reinterpret_cast<T>(handle); }
68 T handle_cast(typename HandleTraits<typename std::remove_pointer<T>::type>::Wrapper *handle)
69 { return reinterpret_cast<T>(handle); }
72 T handle_cast(const typename HandleTraits<typename std::remove_const<typename std::remove_pointer<T>::type>::type>::Wrapper *handle)
73 { return reinterpret_cast<T>(handle); }
84 Result(VkResult r, const char *f): result(r), function(f) { }
85 Result(Result &&r): result(r.result), function(r.function) { r.result = VK_SUCCESS; }
86 ~Result() noexcept(false) { if(!checked) check(); }
88 bool operator==(VkResult r) { bool m = (result==r); checked |= m; return m; }
89 void check() { if(result!=VK_SUCCESS) throw Graphics::vulkan_error(result, function); }
96 const Graphics::VulkanContext &context;
98 ::VkPhysicalDevice physicalDevice;
99 ::VkQueue graphicsQueue;
101 PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; // 5.1
102 PFN_vkCreateCommandPool vkCreateCommandPool = 0; // 6.2
103 PFN_vkResetCommandPool vkResetCommandPool = 0; // 6.2
104 PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; // 6.2
105 PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; // 6.3
106 PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; // 6.4
107 PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; // 6.4
108 PFN_vkQueueSubmit vkQueueSubmit = 0; // 6.5
109 PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; // 6.7
110 PFN_vkCreateFence vkCreateFence = 0; // 7.3
111 PFN_vkDestroyFence vkDestroyFence = 0; // 7.3
112 PFN_vkGetFenceStatus vkGetFenceStatus = 0; // 7.3
113 PFN_vkResetFences vkResetFences = 0; // 7.3
114 PFN_vkWaitForFences vkWaitForFences = 0; // 7.3
115 PFN_vkCreateSemaphore vkCreateSemaphore = 0; // 7.4
116 PFN_vkDestroySemaphore vkDestroySemaphore = 0; // 7.4
117 PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; // 7.6
118 PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; // 7.8
119 PFN_vkCreateRenderPass vkCreateRenderPass = 0; // 8.1
120 PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0; // 8.1
121 PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; // 8.1
122 PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; // 8.3
123 PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; // 8.3
124 PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; // 8.4
125 PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; // 8.4
126 PFN_vkCreateShaderModule vkCreateShaderModule = 0; // 9.1
127 PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; // 9.1
128 PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; // 10.1
129 PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; // 10.2
130 PFN_vkDestroyPipeline vkDestroyPipeline = 0; // 10.4
131 PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; // 10.10
132 PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; // 11.2.1
133 PFN_vkAllocateMemory vkAllocateMemory = 0; // 11.2.3
134 PFN_vkFreeMemory vkFreeMemory = 0; // 11.2.8
135 PFN_vkMapMemory vkMapMemory = 0; // 11.2.9
136 PFN_vkUnmapMemory vkUnmapMemory = 0; // 11.2.9
137 PFN_vkCreateBuffer vkCreateBuffer = 0; // 12.1
138 PFN_vkDestroyBuffer vkDestroyBuffer = 0; // 12.1
139 PFN_vkCreateImage vkCreateImage = 0; // 12.3
140 PFN_vkDestroyImage vkDestroyImage = 0; // 12.3
141 PFN_vkCreateImageView vkCreateImageView = 0; // 12.5
142 PFN_vkDestroyImageView vkDestroyImageView = 0; // 12.5
143 PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; // 12.7
144 PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; // 12.7
145 PFN_vkBindBufferMemory vkBindBufferMemory = 0; // 12.7
146 PFN_vkBindImageMemory vkBindImageMemory = 0; // 12.7
147 PFN_vkCreateSampler vkCreateSampler = 0; // 13
148 PFN_vkDestroySampler vkDestroySampler = 0; // 13
149 PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; // 14.2.1
150 PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; // 14.2.1
151 PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; // 14.2.2
152 PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; // 14.2.2
153 PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; // 14.2.3
154 PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; // 14.2.3
155 PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; // 14.2.3
156 PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; // 14.2.4
157 PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; // 14.2.7
158 PFN_vkCmdPushConstants vkCmdPushConstants = 0; // 14.2.10
159 PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; // 19.2
160 PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; // 19.4
161 PFN_vkCmdBlitImage vkCmdBlitImage = 0; // 19.5
162 PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; // 20.3
163 PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; // 20.3
164 PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; // 21.2
165 PFN_vkCmdSetViewport vkCmdSetViewport = 0; // 24.5
166 PFN_vkCmdSetScissor vkCmdSetScissor = 0; // 26.1
167 PFN_vkCmdDispatch vkCmdDispatch = 0; // 28
168 PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilities = 0; // 30.5.1
169 PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormats = 0; // 30.5.2
170 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModes = 0; // 30.5.3
171 PFN_vkCreateSwapchainKHR vkCreateSwapchain = 0; // 30.8
172 PFN_vkDestroySwapchainKHR vkDestroySwapchain = 0; // 30.8
173 PFN_vkGetSwapchainImagesKHR vkGetSwapchainImages = 0; // 30.8
174 PFN_vkAcquireNextImageKHR vkAcquireNextImage = 0; // 30.8
175 PFN_vkQueuePresentKHR vkQueuePresent = 0; // 30.8
176 PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; // 39.2
177 PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectName = 0; // 45.1.1
180 VulkanFunctions(const Graphics::VulkanContext &);
182 // Chapter 5: Devices and Queues
183 void GetPhysicalDeviceProperties(VkPhysicalDeviceProperties &rProperties) const
184 { vkGetPhysicalDeviceProperties(physicalDevice, &rProperties); }
186 // Chapter 6: Command Buffers
187 Result CreateCommandPool(const VkCommandPoolCreateInfo &rCreateInfo, VkCommandPool &rCommandPool) const
188 { return { vkCreateCommandPool(device, &rCreateInfo, 0, handle_cast<::VkCommandPool *>(&rCommandPool)), "vkCreateCommandPool" }; }
190 Result ResetCommandPool(VkCommandPool commandPool, VkCommandPoolResetFlags flags) const
191 { return { vkResetCommandPool(device, handle_cast<::VkCommandPool>(commandPool), flags), "vkResetCommandPool" }; }
193 void DestroyCommandPool(VkCommandPool commandPool) const
194 { vkDestroyCommandPool(device, handle_cast<::VkCommandPool>(commandPool), 0); }
196 Result AllocateCommandBuffers(const VkCommandBufferAllocateInfo &rAllocateInfo, VkCommandBuffer *pCommandBuffers) const
197 { return { vkAllocateCommandBuffers(device, &rAllocateInfo, handle_cast<::VkCommandBuffer *>(pCommandBuffers)), "vkAllocateCommandBuffers" }; }
199 Result BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo &rBeginInfo) const
200 { return { vkBeginCommandBuffer(handle_cast<::VkCommandBuffer>(commandBuffer), &rBeginInfo), "vkBeginCommandBuffer" }; }
202 Result EndCommandBuffer(VkCommandBuffer commandBuffer) const
203 { return { vkEndCommandBuffer(handle_cast<::VkCommandBuffer>(commandBuffer)), "vkEndCommandBuffer" }; }
205 Result QueueSubmit(std::uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) const
206 { return { vkQueueSubmit(graphicsQueue, submitCount, pSubmits, handle_cast<::VkFence>(fence)), "vkQueueSubmit" }; }
208 void CmdExecuteCommands(VkCommandBuffer commandBuffer, std::uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) const
209 { vkCmdExecuteCommands(handle_cast<::VkCommandBuffer>(commandBuffer), commandBufferCount, handle_cast<const ::VkCommandBuffer *>(pCommandBuffers)); }
211 // Chapter 7: Synchronization and Cache Control
212 Result CreateFence(const VkFenceCreateInfo &rCreateInfo, VkFence &rFence) const
213 { return { vkCreateFence(device, &rCreateInfo, 0, handle_cast<::VkFence *>(&rFence)), "vkCreateFence" }; }
215 void DestroyFence(VkFence fence) const
216 { vkDestroyFence(device, handle_cast<::VkFence>(fence), 0); }
218 Result GetFenceStatus(VkFence fence) const
219 { return { vkGetFenceStatus(device, handle_cast<::VkFence>(fence)), "vkGetFenceStatus" }; }
221 Result ResetFences(std::uint32_t fenceCount, const VkFence *pFences) const
222 { return { vkResetFences(device, fenceCount, handle_cast<const ::VkFence *>(pFences)), "vkResetFences" }; }
224 Result WaitForFences(std::uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll, std::uint64_t timeout) const
225 { return { vkWaitForFences(device, fenceCount, handle_cast<const ::VkFence *>(pFences), waitAll, timeout), "vkWaitForFences" }; }
227 Result CreateSemaphore(const VkSemaphoreCreateInfo &rCreateInfo, VkSemaphore &rSemaphore) const
228 { return { vkCreateSemaphore(device, &rCreateInfo, 0, handle_cast<::VkSemaphore *>(&rSemaphore)), "vkCreateSemaphore" }; }
230 void DestroySemaphore(VkSemaphore semaphore) const
231 { vkDestroySemaphore(device, handle_cast<::VkSemaphore>(semaphore), 0); }
233 void CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) const
234 { vkCmdPipelineBarrier(handle_cast<::VkCommandBuffer>(commandBuffer), srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); }
236 Result QueueWaitIdle() const
237 { return { vkQueueWaitIdle(graphicsQueue), "vkQueueWaitIdle" }; }
239 // Chapter 8: Render Pass
240 Result CreateRenderPass(const VkRenderPassCreateInfo &rCreateInfo, VkRenderPass &rRenderPass) const
241 { return { vkCreateRenderPass(device, &rCreateInfo, 0, handle_cast<::VkRenderPass *>(&rRenderPass)), "vkCreateRenderPass" }; }
243 Result CreateRenderPass2(const VkRenderPassCreateInfo2 &rCreateInfo, VkRenderPass &rRenderPass) const
244 { return { vkCreateRenderPass2(device, &rCreateInfo, 0, handle_cast<::VkRenderPass *>(&rRenderPass)), "vkCreateRenderPass2" }; }
246 void DestroyRenderPass(VkRenderPass renderPass) const
247 { vkDestroyRenderPass(device, handle_cast<::VkRenderPass>(renderPass), 0); }
249 Result CreateFramebuffer(const VkFramebufferCreateInfo &rCreateInfo, VkFramebuffer &rFramebuffer) const
250 { return { vkCreateFramebuffer(device, &rCreateInfo, 0, handle_cast<::VkFramebuffer *>(&rFramebuffer)), "vkCreateFramebuffer" }; }
252 void DestroyFramebuffer(VkFramebuffer framebuffer) const
253 { vkDestroyFramebuffer(device, handle_cast<::VkFramebuffer>(framebuffer), 0); }
255 void CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo &rRenderPassBegin, VkSubpassContents contents) const
256 { vkCmdBeginRenderPass(handle_cast<::VkCommandBuffer>(commandBuffer), &rRenderPassBegin, contents); }
258 void CmdEndRenderPass(VkCommandBuffer commandBuffer) const
259 { vkCmdEndRenderPass(handle_cast<::VkCommandBuffer>(commandBuffer)); }
261 // Chapter 9: Shaders
262 Result CreateShaderModule(const VkShaderModuleCreateInfo &rCreateInfo, VkShaderModule &rShaderModule) const
263 { return { vkCreateShaderModule(device, &rCreateInfo, 0, handle_cast<::VkShaderModule *>(&rShaderModule)), "vkCreateShaderModule" }; }
265 void DestroyShaderModule(VkShaderModule shaderModule) const
266 { vkDestroyShaderModule(device, handle_cast<::VkShaderModule>(shaderModule), 0); }
268 // Chapter 10: Pipelines
269 Result CreateComputePipelines(VkPipelineCache pipelineCache, std::uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, VkPipeline *pPipelines) const
270 { return { vkCreateComputePipelines(device, handle_cast<::VkPipelineCache>(pipelineCache), createInfoCount, pCreateInfos, 0, handle_cast<::VkPipeline *>(pPipelines)), "vkCreateComputePipelines" }; }
272 Result CreateGraphicsPipelines(VkPipelineCache pipelineCache, std::uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, VkPipeline *pPipelines) const
273 { return { vkCreateGraphicsPipelines(device, handle_cast<::VkPipelineCache>(pipelineCache), createInfoCount, pCreateInfos, 0, handle_cast<::VkPipeline *>(pPipelines)), "vkCreateGraphicsPipelines" }; }
275 void DestroyPipeline(VkPipeline pipeline) const
276 { vkDestroyPipeline(device, handle_cast<::VkPipeline>(pipeline), 0); }
278 void CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const
279 { vkCmdBindPipeline(handle_cast<::VkCommandBuffer>(commandBuffer), pipelineBindPoint, handle_cast<::VkPipeline>(pipeline)); }
281 // Chapter 11: Memory Allocation
282 void GetPhysicalDeviceMemoryProperties(VkPhysicalDeviceMemoryProperties &rMemoryProperties) const
283 { vkGetPhysicalDeviceMemoryProperties(physicalDevice, &rMemoryProperties); }
285 Result AllocateMemory(const VkMemoryAllocateInfo &rAllocateInfo, VkDeviceMemory &rMemory) const
286 { return { vkAllocateMemory(device, &rAllocateInfo, 0, handle_cast<::VkDeviceMemory *>(&rMemory)), "vkAllocateMemory" }; }
288 Result MapMemory(VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void **ppData) const
289 { return { vkMapMemory(device, handle_cast<::VkDeviceMemory>(memory), offset, size, flags, ppData), "vkMapMemory" }; }
291 void UnmapMemory(VkDeviceMemory memory) const
292 { vkUnmapMemory(device, handle_cast<::VkDeviceMemory>(memory)); }
294 void FreeMemory(VkDeviceMemory memory) const
295 { vkFreeMemory(device, handle_cast<::VkDeviceMemory>(memory), 0); }
297 // Chapter 12: Resource Creation
298 Result CreateBuffer(const VkBufferCreateInfo &rCreateInfo, VkBuffer &rBuffer) const
299 { return { vkCreateBuffer(device, &rCreateInfo, 0, handle_cast<::VkBuffer *>(&rBuffer)), "vkCreateBuffer" }; }
301 void DestroyBuffer(VkBuffer image) const
302 { vkDestroyBuffer(device, handle_cast<::VkBuffer>(image), 0); }
304 Result CreateImage(const VkImageCreateInfo &rCreateInfo, VkImage &rImage) const
305 { return { vkCreateImage(device, &rCreateInfo, 0, handle_cast<::VkImage *>(&rImage)), "vkCreateImage" }; }
307 void DestroyImage(VkImage image) const
308 { vkDestroyImage(device, handle_cast<::VkImage>(image), 0); }
310 Result CreateImageView(const VkImageViewCreateInfo &rCreateInfo, VkImageView &rView) const
311 { return { vkCreateImageView(device, &rCreateInfo, 0, handle_cast<::VkImageView *>(&rView)), "vkCreateImageView" }; }
313 void DestroyImageView(VkImageView imageView) const
314 { vkDestroyImageView(device, handle_cast<::VkImageView>(imageView), 0); }
316 void GetBufferMemoryRequirements(VkBuffer image, VkMemoryRequirements &rMemoryRequirements) const
317 { vkGetBufferMemoryRequirements(device, handle_cast<::VkBuffer>(image), &rMemoryRequirements); }
319 void GetImageMemoryRequirements(VkImage image, VkMemoryRequirements &rMemoryRequirements) const
320 { vkGetImageMemoryRequirements(device, handle_cast<::VkImage>(image), &rMemoryRequirements); }
322 Result BindBufferMemory(VkBuffer image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const
323 { return { vkBindBufferMemory(device, handle_cast<::VkBuffer>(image), handle_cast<::VkDeviceMemory>(memory), memoryOffset), "vkBindBufferMemory" }; }
325 Result BindImageMemory(VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const
326 { return { vkBindImageMemory(device, handle_cast<::VkImage>(image), handle_cast<::VkDeviceMemory>(memory), memoryOffset), "vkBindImageMemory" }; }
328 // Chapter 13: Samplers
329 Result CreateSampler(const VkSamplerCreateInfo &rCreateInfo, VkSampler &rSampler) const
330 { return { vkCreateSampler(device, &rCreateInfo, 0, handle_cast<::VkSampler *>(&rSampler)), "vkCreateSampler" }; }
332 void DestroySampler(VkSampler sampler) const
333 { vkDestroySampler(device, handle_cast<::VkSampler>(sampler), 0); }
335 // Chapter 14: Resource Descriptors
336 Result CreateDescriptorSetLayout(const VkDescriptorSetLayoutCreateInfo &rCreateInfo, VkDescriptorSetLayout &rSetLayout) const
337 { return { vkCreateDescriptorSetLayout(device, &rCreateInfo, 0, handle_cast<::VkDescriptorSetLayout *>(&rSetLayout)), "vkCreateDescriptorSetLayout" }; }
339 void DestroyDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout) const
340 { vkDestroyDescriptorSetLayout(device, handle_cast<::VkDescriptorSetLayout>(descriptorSetLayout), 0); }
342 Result CreatePipelineLayout(const VkPipelineLayoutCreateInfo &rCreateInfo, VkPipelineLayout &rPipelineLayout) const
343 { return { vkCreatePipelineLayout(device, &rCreateInfo, 0, handle_cast<::VkPipelineLayout *>(&rPipelineLayout)), "vkCreatePipelineLayout" }; }
345 void DestroyPipelineLayout(VkPipelineLayout pipelineLayout) const
346 { vkDestroyPipelineLayout(device, handle_cast<::VkPipelineLayout>(pipelineLayout), 0); }
348 Result CreateDescriptorPool(const VkDescriptorPoolCreateInfo &rCreateInfo, VkDescriptorPool &rDescriptorPool) const
349 { return { vkCreateDescriptorPool(device, &rCreateInfo, 0, handle_cast<::VkDescriptorPool *>(&rDescriptorPool)), "vkCreateDescriptorPool" }; }
351 void DestroyDescriptorPool(VkDescriptorPool descriptorPool) const
352 { vkDestroyDescriptorPool(device, handle_cast<::VkDescriptorPool>(descriptorPool), 0); }
354 Result AllocateDescriptorSets(const VkDescriptorSetAllocateInfo &rAllocateInfo, VkDescriptorSet *pDescriptorSets) const
355 { return { vkAllocateDescriptorSets(device, &rAllocateInfo, handle_cast<::VkDescriptorSet *>(pDescriptorSets)), "vkAllocateDescriptorSets" }; }
357 void UpdateDescriptorSets(std::uint32_t descriptorWriteCount, const VkWriteDescriptorSet *pDescriptorWrites, std::uint32_t descriptorCopyCount, const VkCopyDescriptorSet *pDescriptorCopies) const
358 { vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); }
360 void CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, std::uint32_t firstSet, std::uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, std::uint32_t dynamicOffsetCount, const std::uint32_t *pDynamicOffsets) const
361 { vkCmdBindDescriptorSets(handle_cast<::VkCommandBuffer>(commandBuffer), pipelineBindPoint, handle_cast<::VkPipelineLayout>(layout), firstSet, descriptorSetCount, handle_cast<const ::VkDescriptorSet *>(pDescriptorSets), dynamicOffsetCount, pDynamicOffsets); }
363 void CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, std::uint32_t offset, std::uint32_t size, const void *pValues) const
364 { vkCmdPushConstants(handle_cast<::VkCommandBuffer>(commandBuffer), handle_cast<::VkPipelineLayout>(layout), stageFlags, offset, size, pValues); }
366 // Chapter 19: Copy Commands
367 void CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, std::uint32_t regionCount, const VkBufferCopy *pRegions) const
368 { vkCmdCopyBuffer(handle_cast<::VkCommandBuffer>(commandBuffer), handle_cast<::VkBuffer>(srcBuffer), handle_cast<::VkBuffer>(dstBuffer), regionCount, pRegions); }
370 void CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, std::uint32_t regionCount, const VkBufferImageCopy *pRegions) const
371 { vkCmdCopyBufferToImage(handle_cast<::VkCommandBuffer>(commandBuffer), handle_cast<::VkBuffer>(srcBuffer), handle_cast<::VkImage>(dstImage), dstImageLayout, regionCount, pRegions); }
373 void CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter) const
374 { vkCmdBlitImage(handle_cast<::VkCommandBuffer>(commandBuffer), handle_cast<::VkImage>(srcImage), srcImageLayout, handle_cast<::VkImage>(dstImage), dstImageLayout, regionCount, pRegions, filter); }
376 // Chapter 20: Drawing Commands
377 void CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const
378 { vkCmdBindIndexBuffer(handle_cast<::VkCommandBuffer>(commandBuffer), handle_cast<::VkBuffer>(buffer), offset, indexType); }
380 void CmdDrawIndexed(VkCommandBuffer commandBuffer, std::uint32_t indexCount, std::uint32_t instanceCount, std::uint32_t firstIndex, std::int32_t vertexOffset, std::uint32_t firstInstance) const
381 { vkCmdDrawIndexed(handle_cast<::VkCommandBuffer>(commandBuffer), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); }
383 // Chapter 21: Fixed-Function Vertex Processing
384 void CmdBindVertexBuffers(VkCommandBuffer commandBuffer, std::uint32_t firstBinding, std::uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) const
385 { vkCmdBindVertexBuffers(handle_cast<::VkCommandBuffer>(commandBuffer), firstBinding, bindingCount, handle_cast<const ::VkBuffer *>(pBuffers), pOffsets); }
387 // Chapter 24: Fixed-Function Vertex Post-Processing
388 void CmdSetViewport(VkCommandBuffer commandBuffer, std::uint32_t firstViewport, std::uint32_t viewportCount, const VkViewport *pViewports) const
389 { vkCmdSetViewport(handle_cast<::VkCommandBuffer>(commandBuffer), firstViewport, viewportCount, pViewports); }
391 // Chapter 26: Fragment Operations
392 void CmdSetScissor(VkCommandBuffer commandBuffer, std::uint32_t firstScissor, std::uint32_t scissorCount, const VkRect2D *pScissors) const
393 { vkCmdSetScissor(handle_cast<::VkCommandBuffer>(commandBuffer), firstScissor, scissorCount, pScissors); }
395 // Chapter 28: Dispatching Commands
396 void CmdDispatch(VkCommandBuffer commandBuffer, std::uint32_t groupCountX, std::uint32_t groupCountY, std::uint32_t groupCountZ) const
397 { vkCmdDispatch(handle_cast<::VkCommandBuffer>(commandBuffer), groupCountX, groupCountY, groupCountZ); }
399 // Chapter 30: Window System Integration (WSI)
400 Result GetPhysicalDeviceSurfaceCapabilities(VkSurface surface, VkSurfaceCapabilitiesKHR &rSurfaceCapabilities) const
401 { return { vkGetPhysicalDeviceSurfaceCapabilities(physicalDevice, handle_cast<::VkSurfaceKHR>(surface), &rSurfaceCapabilities), "vkGetPhysicalDeviceSurfaceCapabilities" }; }
403 Result GetPhysicalDeviceSurfaceFormats(VkSurface surface, std::uint32_t &rSurfaceFormatCount, VkSurfaceFormatKHR *pSurfaceFormats) const
404 { return { vkGetPhysicalDeviceSurfaceFormats(physicalDevice, handle_cast<::VkSurfaceKHR>(surface), &rSurfaceFormatCount, pSurfaceFormats), "vkGetPhysicalDeviceSurfaceFormats" }; }
406 Result GetPhysicalDeviceSurfacePresentModes(VkSurface surface, std::uint32_t &rPresentModeCount, VkPresentModeKHR *pPresentModes) const
407 { return { vkGetPhysicalDeviceSurfacePresentModes(physicalDevice, handle_cast<::VkSurfaceKHR>(surface), &rPresentModeCount, pPresentModes), "vkGetPhysicalDeviceSurfacePresentModes" }; }
409 Result CreateSwapchain(const VkSwapchainCreateInfoKHR &rCreateInfo, VkSwapchain &rSwapchain) const
410 { return { vkCreateSwapchain(device, &rCreateInfo, 0, handle_cast<::VkSwapchainKHR *>(&rSwapchain)), "vkCreateSwapchain" }; }
412 void DestroySwapchain(VkSwapchain swapchain) const
413 { vkDestroySwapchain(device, handle_cast<::VkSwapchainKHR>(swapchain), 0); }
415 void GetSwapchainImages(VkSwapchain swapchain, std::uint32_t &rSwapchainImageCount, VkImage *pSwapchainImages) const
416 { vkGetSwapchainImages(device, handle_cast<::VkSwapchainKHR>(swapchain), &rSwapchainImageCount, handle_cast<::VkImage *>(pSwapchainImages)); }
418 Result AcquireNextImage(VkSwapchain swapchain, std::uint64_t timeout, VkSemaphore semaphore, VkFence fence, std::uint32_t &rImageIndex) const
419 { return { vkAcquireNextImageKHR(device, handle_cast<::VkSwapchainKHR>(swapchain), timeout, handle_cast<::VkSemaphore>(semaphore), handle_cast<::VkFence>(fence), &rImageIndex), "vkAcquireNextImageKHR" }; }
421 Result QueuePresent(const VkPresentInfoKHR &rPresentInfo) const
422 { return { vkQueuePresent(graphicsQueue, &rPresentInfo), "vkQueuePresent" }; }
424 // Chapter 39: Formats
425 void GetPhysicalDeviceFormatProperties(VkFormat format, VkFormatProperties &rFormatProperties) const
426 { vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &rFormatProperties); }
428 // Chapter 45: Debugging
429 Result SetDebugUtilsObjectName(const VkDebugUtilsObjectNameInfoEXT &rNameInfo) const
430 { return { vkSetDebugUtilsObjectName(device, &rNameInfo), "vkSetDebugUtilsObjectName" }; }
433 class VulkanCommandRecorder
436 const VulkanFunctions &vk;
437 VkCommandBuffer commandBuffer;
440 VulkanCommandRecorder(const VulkanFunctions &v, VkCommandBuffer b): vk(v), commandBuffer(b) { }
442 void ExecuteCommands(std::uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) const
443 { vk.CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); }
445 void PipelineBarrier(VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) const
446 { vk.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); }
448 void BeginRenderPass(const VkRenderPassBeginInfo &rRenderPassBegin, VkSubpassContents contents) const
449 { vk.CmdBeginRenderPass(commandBuffer, rRenderPassBegin, contents); }
451 void EndRenderPass() const
452 { vk.CmdEndRenderPass(commandBuffer); }
454 void BindPipeline(VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const
455 { vk.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); }
457 void BindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, std::uint32_t firstSet, std::uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets, std::uint32_t dynamicOffsetCount, const std::uint32_t *pDynamicOffsets) const
458 { vk.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); }
460 void PushConstants(VkPipelineLayout layout, VkShaderStageFlags stageFlags, std::uint32_t offset, std::uint32_t size, const void *pValues) const
461 { vk.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); }
463 void CopyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, std::uint32_t regionCount, const VkBufferCopy *pRegions) const
464 { vk.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); }
466 void CopyBufferToImage(VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, std::uint32_t regionCount, const VkBufferImageCopy *pRegions) const
467 { vk.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); }
469 void BlitImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit *pRegions, VkFilter filter) const
470 { vk.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); }
472 void BindIndexBuffer(VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const
473 { vk.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); }
475 void DrawIndexed(std::uint32_t indexCount, std::uint32_t instanceCount, std::uint32_t firstIndex, std::int32_t vertexOffset, std::uint32_t firstInstance) const
476 { vk.CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); }
478 void BindVertexBuffers(std::uint32_t firstBinding, std::uint32_t bindingCount, const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) const
479 { vk.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); }
481 void SetViewport(std::uint32_t firstViewport, std::uint32_t viewportCount, const VkViewport *pViewports) const
482 { vk.CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); }
484 void SetScissor(std::uint32_t firstScissor, std::uint32_t scissorCount, const VkRect2D *pScissors) const
485 { vk.CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); }
487 void Dispatch(std::uint32_t groupCountX, std::uint32_t groupCountY, std::uint32_t groupCountZ) const
488 { vk.CmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); }