UDocumentation UE5.7 10.02.2026 (Source)
API documentation for Unreal Engine 5.7
VulkanCommandWrappers.h
Go to the documentation of this file.
1// Copyright Epic Games, Inc. All Rights Reserved.
2
3/*=============================================================================
4 VulkanCommandWrappers.h: Wrap all Vulkan API functions so we can add our own 'layers'
5=============================================================================*/
6
7#pragma once
8
9#include "VulkanConfiguration.h"
10#include "VulkanLoader.h"
11#include "VulkanThirdParty.h"
12
13#if !VULKAN_COMMANDWRAPPERS_ENABLE
14 #if VULKAN_DYNAMICALLYLOADED
15 // Bring functions from VulkanDynamicAPI to VulkanRHI
16 #define VK_DYNAMICAPI_TO_VULKANRHI(Type,Func) using VulkanDynamicAPI::Func;
17
18 namespace VulkanRHI
19 {
20 ENUM_VK_ENTRYPOINTS_ALL(VK_DYNAMICAPI_TO_VULKANRHI);
21 }
22 #else // VULKAN_DYNAMICALLYLOADED
23 #error "Statically linked vulkan api must be wrapped!"
24 #endif // VULKAN_DYNAMICALLYLOADED
25
26#else // VULKAN_COMMANDWRAPPERS_ENABLE
27
28#if VULKAN_DYNAMICALLYLOADED
29 // Vulkan API is defined in VulkanDynamicAPI namespace.
30 #define VULKANAPINAMESPACE VulkanDynamicAPI
31#else
32 // Vulkan API is in the global namespace.
33 #define VULKANAPINAMESPACE
34#endif
35
36#if VULKAN_ENABLE_WRAP_LAYER
37 #define VULKAN_LAYER_BODY ;
38 #define VULKAN_EXTERN_EXPORT VULKANRHI_API
39#else
40 #define VULKAN_LAYER_BODY {}
41 #define VULKAN_EXTERN_EXPORT
42#endif
43
44struct FWrapLayer
45{
46 // Pass in VK_RESULT_MAX_ENUM for Prolog calls; for Epilog use a different value or the actual Result if available
47
48 static void CreateInstance(VkResult Result, const VkInstanceCreateInfo* CreateInfo, VkInstance* Instance) VULKAN_LAYER_BODY
49 static void DestroyInstance(VkResult Result, VkInstance Instance) VULKAN_LAYER_BODY
50 static void EnumeratePhysicalDevices(VkResult Result, VkInstance Instance, uint32* PhysicalDeviceCount, VkPhysicalDevice* PhysicalDevices) VULKAN_LAYER_BODY
51 static void EnumerateInstanceVersion(VkResult Result, uint32_t* ApiVersion) VULKAN_LAYER_BODY
52 static void GetPhysicalDeviceFeatures(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceFeatures* Features) VULKAN_LAYER_BODY
53 static void GetPhysicalDeviceFormatProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, VkFormat Format, VkFormatProperties* FormatProperties) VULKAN_LAYER_BODY
54 static void GetPhysicalDeviceFormatProperties2(VkResult Result, VkPhysicalDevice PhysicalDevice, VkFormat Format, VkFormatProperties2* FormatProperties) VULKAN_LAYER_BODY
55 static void GetPhysicalDeviceImageFormatProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, VkFormat Format, VkImageType Type, VkImageTiling Tiling, VkImageUsageFlags Usage, VkImageCreateFlags Flags, VkImageFormatProperties* pImageFormatProperties) VULKAN_LAYER_BODY
56 static void GetPhysicalDeviceImageFormatProperties2(VkResult Result, VkPhysicalDevice PhysicalDevice, const VkPhysicalDeviceImageFormatInfo2* FormatInfo, VkImageFormatProperties2* FormatProperties) VULKAN_LAYER_BODY
57 static void GetPhysicalDeviceProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceProperties* FormatProperties) VULKAN_LAYER_BODY
58 static void GetPhysicalDeviceQueueFamilyProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32* QueueFamilyPropertyCount, VkQueueFamilyProperties* QueueFamilyProperties) VULKAN_LAYER_BODY
59 static void GetPhysicalDeviceQueueFamilyProperties2(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32* QueueFamilyPropertyCount, VkQueueFamilyProperties2* QueueFamilyProperties) VULKAN_LAYER_BODY
60 static void GetPhysicalDeviceMemoryProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceMemoryProperties* Properties) VULKAN_LAYER_BODY
61 static void GetInstanceProcAddr(VkResult Result, VkInstance Instance, const char* Name, PFN_vkVoidFunction VoidFunction) VULKAN_LAYER_BODY
62 VULKAN_EXTERN_EXPORT static void GetDeviceProcAddr(VkResult Result, VkDevice Device, const char* Name, PFN_vkVoidFunction VoidFunction) VULKAN_LAYER_BODY
63 static void CreateDevice(VkResult Result, VkPhysicalDevice PhysicalDevice, const VkDeviceCreateInfo* CreateInfo, VkDevice* Device) VULKAN_LAYER_BODY
64 static void DestroyDevice(VkResult Result, VkDevice Device) VULKAN_LAYER_BODY
65 VULKAN_EXTERN_EXPORT static void EnumerateInstanceExtensionProperties(VkResult Result, const char* LayerName, uint32* PropertyCount, VkExtensionProperties* Properties) VULKAN_LAYER_BODY
66 VULKAN_EXTERN_EXPORT static void EnumerateDeviceExtensionProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, const char* LayerName, uint32* PropertyCount, VkExtensionProperties* Properties) VULKAN_LAYER_BODY
67 static void EnumerateInstanceLayerProperties(VkResult Result, uint32* PropertyCount, VkLayerProperties* Properties) VULKAN_LAYER_BODY
68 static void EnumerateDeviceLayerProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32* PropertyCount, VkLayerProperties* Properties) VULKAN_LAYER_BODY
69 static void GetDeviceQueue(VkResult Result, VkDevice Device, uint32 QueueFamilyIndex, uint32 QueueIndex, VkQueue* Queue) VULKAN_LAYER_BODY
70 static void QueueSubmit(VkResult Result, VkQueue Queue, uint32 SubmitCount, const VkSubmitInfo* Submits, VkFence Fence) VULKAN_LAYER_BODY
71 static void QueueWaitIdle(VkResult Result, VkQueue Queue) VULKAN_LAYER_BODY
72 static void DeviceWaitIdle(VkResult Result, VkDevice Device) VULKAN_LAYER_BODY
73 static void AllocateMemory(VkResult Result, VkDevice Device, const VkMemoryAllocateInfo* AllocateInfo, VkDeviceMemory* Memory) VULKAN_LAYER_BODY
74 static void FreeMemory(VkResult Result, VkDevice Device, VkDeviceMemory Memory) VULKAN_LAYER_BODY
75 static void MapMemory(VkResult Result, VkDevice Device, VkDeviceMemory Memory, VkDeviceSize Offset, VkDeviceSize Size, VkMemoryMapFlags Flags, void** Data) VULKAN_LAYER_BODY
76 static void UnmapMemory(VkResult Result, VkDevice Device, VkDeviceMemory Memory) VULKAN_LAYER_BODY
77 static void FlushMappedMemoryRanges(VkResult Result, VkDevice Device, uint32 MemoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) VULKAN_LAYER_BODY
78 static void InvalidateMappedMemoryRanges(VkResult Result, VkDevice Device, uint32 MemoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) VULKAN_LAYER_BODY
79 static void GetDeviceMemoryCommitment(VkResult Result, VkDevice Device, VkDeviceMemory Memory, VkDeviceSize* pCommittedMemoryInBytes) VULKAN_LAYER_BODY
80 static void BindBufferMemory(VkResult Result, VkDevice Device, VkBuffer Buffer, VkDeviceMemory Memory, VkDeviceSize MemoryOffset) VULKAN_LAYER_BODY
81 VULKAN_EXTERN_EXPORT static void BindImageMemory(VkResult Result, VkDevice Device, VkImage Image, VkDeviceMemory Memory, VkDeviceSize MemoryOffset) VULKAN_LAYER_BODY
82 static void GetBufferMemoryRequirements(VkResult Result, VkDevice Device, VkBuffer Buffer, VkMemoryRequirements* MemoryRequirements) VULKAN_LAYER_BODY
83 static void GetImageMemoryRequirements(VkResult Result, VkDevice Device, VkImage Image, VkMemoryRequirements* MemoryRequirements) VULKAN_LAYER_BODY
84 static void GetImageSparseMemoryRequirements(VkResult Result, VkDevice Device, VkImage Image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) VULKAN_LAYER_BODY
85 static void GetPhysicalDeviceSparseImageFormatProperties(VkResult Result, VkPhysicalDevice PhysicalDevice, VkFormat Format, VkImageType Type, VkSampleCountFlagBits Samples, VkImageUsageFlags Usage, VkImageTiling Tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) VULKAN_LAYER_BODY
86 static void QueueBindSparse(VkResult Result, VkQueue Queue, uint32_t BindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence Fence) VULKAN_LAYER_BODY
87 static void CreateFence(VkResult Result, VkDevice Device, const VkFenceCreateInfo* CreateInfo, VkFence* Fence) VULKAN_LAYER_BODY
88 static void DestroyFence(VkResult Result, VkDevice Device, VkFence Fence) VULKAN_LAYER_BODY
89 static void ResetFences(VkResult Result, VkDevice Device, uint32 FenceCount, const VkFence* Fences) VULKAN_LAYER_BODY
90 static void GetFenceStatus(VkResult Result, VkDevice Device, VkFence Fence) VULKAN_LAYER_BODY
91 static void WaitForFences(VkResult Result, VkDevice Device, uint32 FenceCount, const VkFence* Fences, VkBool32 bWaitAll, uint64_t Timeout) VULKAN_LAYER_BODY
92 static void CreateSemaphore(VkResult Result, VkDevice Device, const VkSemaphoreCreateInfo* CreateInfo, VkSemaphore* Semaphore) VULKAN_LAYER_BODY
93 static void DestroySemaphore(VkResult Result, VkDevice Device, VkSemaphore Semaphore) VULKAN_LAYER_BODY
94 static void CreateEvent(VkResult Result, VkDevice Device, const VkEventCreateInfo* CreateInfo, VkEvent* Event) VULKAN_LAYER_BODY
95 static void DestroyEvent(VkResult Result, VkDevice Device, VkEvent Event) VULKAN_LAYER_BODY
96 static void GetEventStatus(VkResult Result, VkDevice Device, VkEvent Event) VULKAN_LAYER_BODY
97 static void SetEvent(VkResult Result, VkDevice Device, VkEvent Event) VULKAN_LAYER_BODY
98 static void ResetEvent(VkResult Result, VkDevice Device, VkEvent Event) VULKAN_LAYER_BODY
99 static void CreateQueryPool(VkResult Result, VkDevice Device, const VkQueryPoolCreateInfo* CreateInfo, VkQueryPool* QueryPool) VULKAN_LAYER_BODY
100 static void DestroyQueryPool(VkResult Result, VkDevice Device, VkQueryPool QueryPool) VULKAN_LAYER_BODY
101 static void GetQueryPoolResults(VkResult Result, VkDevice Device, VkQueryPool QueryPool, uint32 FirstQuery, uint32 QueryCount, size_t DataSize, void* Data, VkDeviceSize Stride, VkQueryResultFlags Flags) VULKAN_LAYER_BODY
102 static void CreateBuffer(VkResult Result, VkDevice Device, const VkBufferCreateInfo* CreateInfo, VkBuffer* Buffer) VULKAN_LAYER_BODY
103 static void DestroyBuffer(VkResult Result, VkDevice Device, VkBuffer Buffer) VULKAN_LAYER_BODY
104 static void CreateBufferView(VkResult Result, VkDevice Device, const VkBufferViewCreateInfo* CreateInfo, VkBufferView* BufferView) VULKAN_LAYER_BODY
105 static void DestroyBufferView(VkResult Result, VkDevice Device, VkBufferView BufferView) VULKAN_LAYER_BODY
106 VULKAN_EXTERN_EXPORT static void CreateImage(VkResult Result, VkDevice Device, const VkImageCreateInfo* CreateInfo, VkImage* Image) VULKAN_LAYER_BODY
107 VULKAN_EXTERN_EXPORT static void DestroyImage(VkResult Result, VkDevice Device, VkImage Image) VULKAN_LAYER_BODY
108 static void GetImageSubresourceLayout(VkResult Result, VkDevice Device, VkImage Image, const VkImageSubresource* Subresource, VkSubresourceLayout* Layout) VULKAN_LAYER_BODY
109 static void GetImageSubresourceLayout2(VkResult Result, VkDevice Device, VkImage Image, const VkImageSubresource2KHR* Subresource, VkSubresourceLayout2KHR* Layout) VULKAN_LAYER_BODY
110 VULKAN_EXTERN_EXPORT static void CreateImageView(VkResult Result, VkDevice Device, const VkImageViewCreateInfo* CreateInfo, VkImageView* ImageView) VULKAN_LAYER_BODY
111 VULKAN_EXTERN_EXPORT static void DestroyImageView(VkResult Result, VkDevice Device, VkImageView ImageView) VULKAN_LAYER_BODY
112 static void CreateShaderModule(VkResult Result, VkDevice Device, const VkShaderModuleCreateInfo* CreateInfo, VkShaderModule* ShaderModule) VULKAN_LAYER_BODY
113 static void DestroyShaderModule(VkResult Result, VkDevice Device, VkShaderModule ShaderModule) VULKAN_LAYER_BODY
114 static void CreatePipelineCache(VkResult Result, VkDevice Device, const VkPipelineCacheCreateInfo* CreateInfo, VkPipelineCache* PipelineCache) VULKAN_LAYER_BODY
115 static void DestroyPipelineCache(VkResult Result, VkDevice Device, VkPipelineCache PipelineCache) VULKAN_LAYER_BODY
116 static void GetPipelineCacheData(VkResult Result, VkDevice Device, VkPipelineCache PipelineCache, size_t* DataSize, void* Data) VULKAN_LAYER_BODY
117 static void MergePipelineCaches(VkResult Result, VkDevice Device, VkPipelineCache DestCache, uint32 SourceCacheCount, const VkPipelineCache* SrcCaches) VULKAN_LAYER_BODY
118 static void CreateGraphicsPipelines(VkResult Result, VkDevice Device, VkPipelineCache PipelineCache, uint32 CreateInfoCount, const VkGraphicsPipelineCreateInfo* CreateInfos, VkPipeline* Pipelines) VULKAN_LAYER_BODY
119 static void CreateComputePipelines(VkResult Result, VkDevice Device, VkPipelineCache PipelineCache, uint32 CreateInfoCount, const VkComputePipelineCreateInfo* CreateInfos, VkPipeline* Pipelines) VULKAN_LAYER_BODY
120 static void DestroyPipeline(VkResult Result, VkDevice Device, VkPipeline Pipeline) VULKAN_LAYER_BODY
121 static void CreatePipelineLayout(VkResult Result, VkDevice Device, const VkPipelineLayoutCreateInfo* CreateInfo, VkPipelineLayout* PipelineLayout) VULKAN_LAYER_BODY
122 static void DestroyPipelineLayout(VkResult Result, VkDevice Device, VkPipelineLayout PipelineLayout) VULKAN_LAYER_BODY
123 VULKAN_EXTERN_EXPORT static void CreateSampler(VkResult Result, VkDevice Device, const VkSamplerCreateInfo* CreateInfo, VkSampler* Sampler) VULKAN_LAYER_BODY
124 VULKAN_EXTERN_EXPORT static void DestroySampler(VkResult Result, VkDevice Device, VkSampler Sampler) VULKAN_LAYER_BODY
125 static void CreateDescriptorSetLayout(VkResult Result, VkDevice Device, const VkDescriptorSetLayoutCreateInfo* CreateInfo, VkDescriptorSetLayout* SetLayout) VULKAN_LAYER_BODY
126 static void DestroyDescriptorSetLayout(VkResult Result, VkDevice Device, VkDescriptorSetLayout DescriptorSetLayout) VULKAN_LAYER_BODY
127 static void CreateDescriptorPool(VkResult Result, VkDevice Device, const VkDescriptorPoolCreateInfo* CreateInfo, VkDescriptorPool* DescriptorPool) VULKAN_LAYER_BODY
128 static void DestroyDescriptorPool(VkResult Result, VkDevice Device, VkDescriptorPool DescriptorPool) VULKAN_LAYER_BODY
129 static void ResetDescriptorPool(VkResult Result, VkDevice Device, VkDescriptorPool DescriptorPool, VkDescriptorPoolResetFlags Flags) VULKAN_LAYER_BODY
130 static void AllocateDescriptorSets(VkResult Result, VkDevice Device, const VkDescriptorSetAllocateInfo* AllocateInfo, VkDescriptorSet* DescriptorSets) VULKAN_LAYER_BODY
131 static void FreeDescriptorSets(VkResult Result, VkDevice Device, VkDescriptorPool DescriptorPool, uint32 DescriptorSetCount, const VkDescriptorSet* DescriptorSets) VULKAN_LAYER_BODY
132 static void UpdateDescriptorSets(VkResult Result, VkDevice Device, uint32 DescriptorWriteCount, const VkWriteDescriptorSet* DescriptorWrites, uint32 DescriptorCopyCount, const VkCopyDescriptorSet* DescriptorCopies) VULKAN_LAYER_BODY
133 static void CreateFramebuffer(VkResult Result, VkDevice Device, const VkFramebufferCreateInfo* CreateInfo, VkFramebuffer* Framebuffer) VULKAN_LAYER_BODY
134 static void DestroyFramebuffer(VkResult Result, VkDevice Device, VkFramebuffer Framebuffer) VULKAN_LAYER_BODY
135 static void CreateRenderPass(VkResult Result, VkDevice Device, const VkRenderPassCreateInfo* CreateInfo, VkRenderPass* RenderPass) VULKAN_LAYER_BODY
136 static void CreateRenderPass2KHR(VkResult Result, VkDevice Device, const VkRenderPassCreateInfo2* CreateInfo, VkRenderPass* RenderPass) VULKAN_LAYER_BODY
137 static void DestroyRenderPass(VkResult Result, VkDevice Device, VkRenderPass RenderPass) VULKAN_LAYER_BODY
138 static void GetRenderAreaGranularity(VkResult Result, VkDevice Device, VkRenderPass RenderPass, VkExtent2D* pGranularity) VULKAN_LAYER_BODY
139 static void CreateCommandPool(VkResult Result, VkDevice Device, const VkCommandPoolCreateInfo* CreateInfo, VkCommandPool* CommandPool) VULKAN_LAYER_BODY
140 static void DestroyCommandPool(VkResult Result, VkDevice Device, VkCommandPool CommandPool) VULKAN_LAYER_BODY
141 static void ResetCommandPool(VkResult Result, VkDevice Device, VkCommandPool CommandPool, VkCommandPoolResetFlags Flags) VULKAN_LAYER_BODY
142 static void TrimCommandPool(VkResult Result, VkDevice Device, VkCommandPool CommandPool, VkCommandPoolTrimFlags Flags) VULKAN_LAYER_BODY
143 static void AllocateCommandBuffers(VkResult Result, VkDevice Device, const VkCommandBufferAllocateInfo* AllocateInfo, VkCommandBuffer* CommandBuffers) VULKAN_LAYER_BODY
144 static void FreeCommandBuffers(VkResult Result, VkDevice Device, VkCommandPool CommandPool, uint32 CommandBufferCount, const VkCommandBuffer* CommandBuffers) VULKAN_LAYER_BODY
145 static void BeginCommandBuffer(VkResult Result, VkCommandBuffer CommandBuffer, const VkCommandBufferBeginInfo* BeginInfo) VULKAN_LAYER_BODY
146 static void EndCommandBuffer(VkResult Result, VkCommandBuffer CommandBuffer) VULKAN_LAYER_BODY
147 static void ResetCommandBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkCommandBufferResetFlags Flags) VULKAN_LAYER_BODY
148
149 static void CmdBindPipeline(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineBindPoint PipelineBindPoint, VkPipeline Pipeline) VULKAN_LAYER_BODY
150 static void CmdSetViewport(VkResult Result, VkCommandBuffer CommandBuffer, uint32 FirstViewport, uint32 ViewportCount, const VkViewport* Viewports) VULKAN_LAYER_BODY
151 static void CmdSetScissor(VkResult Result, VkCommandBuffer CommandBuffer, uint32 FirstScissor, uint32 ScissorCount, const VkRect2D* Scissors) VULKAN_LAYER_BODY
152 static void CmdSetLineWidth(VkResult Result, VkCommandBuffer CommandBuffer, float LineWidth) VULKAN_LAYER_BODY
153 static void CmdSetDepthBias(VkResult Result, VkCommandBuffer CommandBuffer, float DepthBiasConstantFactor, float DepthBiasClamp, float DepthBiasSlopeFactor) VULKAN_LAYER_BODY
154 static void CmdSetBlendConstants(VkResult Result, VkCommandBuffer CommandBuffer, const float BlendConstants[4]) VULKAN_LAYER_BODY
155 static void CmdSetDepthBounds(VkResult Result, VkCommandBuffer CommandBuffer, float MinDepthBounds, float MaxDepthBounds) VULKAN_LAYER_BODY
156 static void CmdSetStencilCompareMask(VkResult Result, VkCommandBuffer CommandBuffer, VkStencilFaceFlags FaceMask, uint32 CompareMask) VULKAN_LAYER_BODY
157 static void CmdSetStencilWriteMask(VkResult Result, VkCommandBuffer CommandBuffer, VkStencilFaceFlags FaceMask, uint32 WriteMask) VULKAN_LAYER_BODY
158 static void CmdSetStencilReference(VkResult Result, VkCommandBuffer CommandBuffer, VkStencilFaceFlags FaceMask, uint32 Reference) VULKAN_LAYER_BODY
159 static void CmdBindDescriptorSets(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineBindPoint PipelineBindPoint, VkPipelineLayout Layout, uint32 FirstSet, uint32 DescriptorSetCount, const VkDescriptorSet* DescriptorSets, uint32 DynamicOffsetCount, const uint32* DynamicOffsets) VULKAN_LAYER_BODY
160 static void CmdBindIndexBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer IndexBuffer, VkDeviceSize Offset, VkIndexType IndexType) VULKAN_LAYER_BODY
161 static void CmdBindVertexBuffers(VkResult Result, VkCommandBuffer CommandBuffer, uint32 FirstBinding, uint32 BindingCount, const VkBuffer* Buffers, const VkDeviceSize* pOffsets) VULKAN_LAYER_BODY
162 static void CmdDraw(VkResult Result, VkCommandBuffer CommandBuffer, uint32 VertexCount, uint32 InstanceCount, uint32 FirstVertex, uint32 FirstInstance) VULKAN_LAYER_BODY
163 static void CmdDrawIndexed(VkResult Result, VkCommandBuffer CommandBuffer, uint32 IndexCount, uint32 InstanceCount, uint32 FirstIndex, int32_t VertexOffset, uint32 FirstInstance) VULKAN_LAYER_BODY
164 static void CmdDrawIndirect(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer Buffer, VkDeviceSize Offset, uint32 DrawCount, uint32 Stride) VULKAN_LAYER_BODY
165 static void CmdDrawIndexedIndirect(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer Buffer, VkDeviceSize Offset, uint32 DrawCount, uint32 Stride) VULKAN_LAYER_BODY
166 static void CmdDispatch(VkResult Result, VkCommandBuffer CommandBuffer, uint32 X, uint32 Y, uint32 Z) VULKAN_LAYER_BODY
167 static void CmdDispatchIndirect(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer Buffer, VkDeviceSize Offset) VULKAN_LAYER_BODY
168 static void CmdCopyBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer SrcBuffer, VkBuffer DstBuffer, uint32 RegionCount, const VkBufferCopy* Regions) VULKAN_LAYER_BODY
169 static void CmdCopyImage(VkResult Result, VkCommandBuffer CommandBuffer, VkImage SrcImage, VkImageLayout SrcImageLayout, VkImage DstImage, VkImageLayout DstImageLayout, uint32 RegionCount, const VkImageCopy* Regions) VULKAN_LAYER_BODY
170 VULKAN_EXTERN_EXPORT static void CmdBlitImage(VkResult Result, VkCommandBuffer CommandBuffer, VkImage SrcImage, VkImageLayout SrcImageLayout, VkImage DstImage, VkImageLayout DstImageLayout, uint32 RegionCount, const VkImageBlit* Regions, VkFilter Filter) VULKAN_LAYER_BODY
171 static void CmdCopyBufferToImage(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer SrcBuffer, VkImage DstImage, VkImageLayout DstImageLayout, uint32 RegionCount, const VkBufferImageCopy* Regions) VULKAN_LAYER_BODY
172 static void CmdCopyImageToBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkImage SrcImage, VkImageLayout SrcImageLayout, VkBuffer DstBuffer, uint32 RegionCount, const VkBufferImageCopy* Regions) VULKAN_LAYER_BODY
173 static void CmdUpdateBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer DstBuffer, VkDeviceSize DstOffset, VkDeviceSize DataSize, const void* pData) VULKAN_LAYER_BODY
174 static void CmdFillBuffer(VkResult Result, VkCommandBuffer CommandBuffer, VkBuffer DstBuffer, VkDeviceSize DstOffset, VkDeviceSize Size, uint32 Data) VULKAN_LAYER_BODY
175 VULKAN_EXTERN_EXPORT static void CmdClearColorImage(VkResult Result, VkCommandBuffer CommandBuffer, VkImage Image, VkImageLayout ImageLayout, const VkClearColorValue* ColorValue, uint32 RangeCount, const VkImageSubresourceRange* Ranges) VULKAN_LAYER_BODY
176 VULKAN_EXTERN_EXPORT static void CmdClearDepthStencilImage(VkResult Result, VkCommandBuffer CommandBuffer, VkImage Image, VkImageLayout ImageLayout, const VkClearDepthStencilValue* DepthStencil, uint32 RangeCount, const VkImageSubresourceRange* Ranges) VULKAN_LAYER_BODY
177 static void CmdClearAttachments(VkResult Result, VkCommandBuffer CommandBuffer, uint32 AttachmentCount, const VkClearAttachment* Attachments, uint32 RectCount, const VkClearRect* Rects) VULKAN_LAYER_BODY
178 static void CmdResolveImage(VkResult Result, VkCommandBuffer CommandBuffer, VkImage SrcImage, VkImageLayout SrcImageLayout, VkImage DstImage, VkImageLayout DstImageLayout, uint32 RegionCount, const VkImageResolve* Regions) VULKAN_LAYER_BODY
179 static void CmdSetEvent(VkResult Result, VkCommandBuffer CommandBuffer, VkEvent Event, VkPipelineStageFlags StageMask) VULKAN_LAYER_BODY
180 static void CmdResetEvent(VkResult Result, VkCommandBuffer CommandBuffer, VkEvent Event, VkPipelineStageFlags StageMask) VULKAN_LAYER_BODY
181 static void CmdWaitEvents(VkResult Result, VkCommandBuffer CommandBuffer, uint32 EventCount, const VkEvent* Events, VkPipelineStageFlags SrcStageMask, VkPipelineStageFlags DstStageMask, uint32 MemoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32 BufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32 ImageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) VULKAN_LAYER_BODY
182 static void CmdPipelineBarrier(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineStageFlags SrcStageMask, VkPipelineStageFlags DstStageMask, VkDependencyFlags DependencyFlags, uint32 MemoryBarrierCount, const VkMemoryBarrier* MemoryBarriers, uint32 BufferMemoryBarrierCount, const VkBufferMemoryBarrier* BufferMemoryBarriers, uint32 ImageMemoryBarrierCount, const VkImageMemoryBarrier* ImageMemoryBarriers) VULKAN_LAYER_BODY
183 static void CmdBeginQuery(VkResult Result, VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 Query, VkQueryControlFlags Flags) VULKAN_LAYER_BODY
184 static void CmdEndQuery(VkResult Result, VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 Query) VULKAN_LAYER_BODY
185 static void CmdResetQueryPool(VkResult Result, VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 FirstQuery, uint32 QueryCount) VULKAN_LAYER_BODY
186 static void CmdWriteTimestamp(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineStageFlagBits PipelineStage, VkQueryPool QueryPool, uint32 Query) VULKAN_LAYER_BODY
187 static void CmdCopyQueryPoolResults(VkResult Result, VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 FirstQuery, uint32 QueryCount, VkBuffer DstBuffer, VkDeviceSize DstOffset, VkDeviceSize Stride, VkQueryResultFlags Flags) VULKAN_LAYER_BODY
188 static void CmdPushConstants(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineLayout Layout, VkShaderStageFlags StageFlags, uint32_t Offset, uint32_t Size, const void* pValues) VULKAN_LAYER_BODY
189 static void CmdBeginRenderPass(VkResult Result, VkCommandBuffer CommandBuffer, const VkRenderPassBeginInfo* RenderPassBegin, VkSubpassContents Contents) VULKAN_LAYER_BODY
190 static void CmdBeginRenderPass2KHR(VkResult Result, VkCommandBuffer CommandBuffer, const VkRenderPassBeginInfo* RenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) VULKAN_LAYER_BODY
191 static void CmdNextSubpass(VkResult Result, VkCommandBuffer CommandBuffer, VkSubpassContents Contents) VULKAN_LAYER_BODY
192 static void CmdEndRenderPass(VkResult Result, VkCommandBuffer CommandBuffer) VULKAN_LAYER_BODY
193 static void CmdBeginRenderingKHR(VkResult Result, VkCommandBuffer CommandBuffer, const VkRenderingInfo* RenderingInfo) VULKAN_LAYER_BODY
194 static void CmdEndRenderingKHR(VkResult Result, VkCommandBuffer CommandBuffer) VULKAN_LAYER_BODY
195 static void CmdExecuteCommands(VkResult Result, VkCommandBuffer CommandBuffer, uint32 CommandBufferCount, const VkCommandBuffer* pCommandBuffers) VULKAN_LAYER_BODY
196
197
198 static void QueuePresent(VkResult Result, VkQueue Queue, const VkPresentInfoKHR* PresentInfo) VULKAN_LAYER_BODY
199 static void GetSwapChainImagesKHR(VkResult Result, VkDevice Device, VkSwapchainKHR Swapchain, uint32_t* SwapchainImageCount, VkImage* SwapchainImages) VULKAN_LAYER_BODY
200 static void CreateSwapchainKHR(VkResult Result, VkDevice Device, const VkSwapchainCreateInfoKHR* CreateInfo, VkSwapchainKHR* Swapchain) VULKAN_LAYER_BODY
201 static void AcquireNextImageKHR(VkResult Result, VkDevice Device, VkSwapchainKHR Swapchain, uint64_t Timeout, VkSemaphore Semaphore, VkFence Fence, uint32_t* ImageIndex) VULKAN_LAYER_BODY
202 static void DestroySurfaceKHR(VkResult Result, VkInstance Instance, VkSurfaceKHR SurfaceKHR) VULKAN_LAYER_BODY
203 static void DestroySwapchainKHR(VkResult Result, VkDevice Device, VkSwapchainKHR Swapchain) VULKAN_LAYER_BODY
204 static void GetImageMemoryRequirements2(VkResult Result, VkDevice Device, const VkImageMemoryRequirementsInfo2* Info, VkMemoryRequirements2* MemoryRequirements) VULKAN_LAYER_BODY
205 static void GetBufferMemoryRequirements2(VkResult Result, VkDevice Device, const VkBufferMemoryRequirementsInfo2* Info, VkMemoryRequirements2* MemoryRequirements) VULKAN_LAYER_BODY
206
207 VULKAN_EXTERN_EXPORT static void GetPhysicalDeviceMemoryProperties2(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceMemoryProperties2* MemoryProperties) VULKAN_LAYER_BODY
208 VULKAN_EXTERN_EXPORT static void GetPhysicalDeviceProperties2(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceProperties2* Properties) VULKAN_LAYER_BODY
209 VULKAN_EXTERN_EXPORT static void GetPhysicalDeviceFeatures2(VkResult Result, VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceFeatures2* Features) VULKAN_LAYER_BODY
210 VULKAN_EXTERN_EXPORT static void GetPhysicalDeviceFragmentShadingRatesKHR(VkResult, VkPhysicalDevice PhysicalDevice, uint32* FragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* FragmentShadingRates) VULKAN_LAYER_BODY
211 static void GetPhysicalDeviceSurfaceCapabilitiesKHR(VkResult Result, VkPhysicalDevice PhysicalDevice, VkSurfaceKHR Surface, VkSurfaceCapabilitiesKHR* SurfaceCapabilities) VULKAN_LAYER_BODY
212 static void GetPhysicalDeviceSurfaceFormatsKHR(VkResult Result, VkPhysicalDevice PhysicalDevice, VkSurfaceKHR Surface, uint32_t* SurfaceFormatCountPtr, VkSurfaceFormatKHR* SurfaceFormats) VULKAN_LAYER_BODY
213 static void GetPhysicalDeviceSurfaceSupportKHR(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32_t QueueFamilyIndex, VkSurfaceKHR Surface, VkBool32* SupportedPtr) VULKAN_LAYER_BODY
214 static void GetPhysicalDeviceSurfacePresentModesKHR(VkResult Result, VkPhysicalDevice PhysicalDevice, VkSurfaceKHR Surface, uint32_t* PresentModeCountPtr, VkPresentModeKHR* PresentModesPtr) VULKAN_LAYER_BODY
215#if VULKAN_USE_CREATE_ANDROID_SURFACE
216 static void CreateAndroidSurfaceKHR(VkResult Result, VkInstance Instance, const VkAndroidSurfaceCreateInfoKHR* CreateInfo, VkSurfaceKHR* Surface) VULKAN_LAYER_BODY
217#endif
218#if VULKAN_USE_CREATE_WIN32_SURFACE
219 static void CreateWin32SurfaceKHR(VkResult Result, VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, VkSurfaceKHR* pSurface);
220#endif
221
222 static void CreateAccelerationStructureKHR(VkResult Result, VkDevice Device, const VkAccelerationStructureCreateInfoKHR* CreateInfo, const VkAllocationCallbacks* Allocator, VkAccelerationStructureKHR* AccelerationStructure) VULKAN_LAYER_BODY
223 static void DestroyAccelerationStructureKHR(VkResult Result, VkDevice Device, VkAccelerationStructureKHR AccelerationStructure, const VkAllocationCallbacks* Allocator) VULKAN_LAYER_BODY
224 static void CmdBuildAccelerationStructuresKHR(VkResult Result, VkCommandBuffer CommandBuffer, uint32 InfoCount, const VkAccelerationStructureBuildGeometryInfoKHR* Infos, const VkAccelerationStructureBuildRangeInfoKHR* const* BuildRangeInfos) VULKAN_LAYER_BODY
225 static void GetAccelerationStructureBuildSizesKHR(VkResult Result, VkDevice Device, VkAccelerationStructureBuildTypeKHR BuildType, const VkAccelerationStructureBuildGeometryInfoKHR* BuildInfo, const uint32* MaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* SizeInfo) VULKAN_LAYER_BODY
226 static void GetAccelerationStructureDeviceAddressKHR(VkResult Result, VkDevice Device, const VkAccelerationStructureDeviceAddressInfoKHR* Info) VULKAN_LAYER_BODY
227 static void CmdTraceRaysKHR(VkResult Result, VkCommandBuffer CommandBuffer, const VkStridedDeviceAddressRegionKHR* RaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* MissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* HitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* CallableShaderBindingTable, uint32 width, uint32 height, uint32 depth) VULKAN_LAYER_BODY
228 static void CmdTraceRaysIndirectKHR(VkResult Result, VkCommandBuffer CommandBuffer, const VkStridedDeviceAddressRegionKHR* RaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* MissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* HitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* CallableShaderBindingTable, VkDeviceAddress IndirectDeviceAddress) VULKAN_LAYER_BODY
229 static void CmdTraceRaysIndirect2KHR(VkResult Result, VkCommandBuffer CommandBuffer, VkDeviceAddress IndirectDeviceAddress) VULKAN_LAYER_BODY
230 static void CreateRayTracingPipelinesKHR(VkResult Result, VkDevice Device, VkDeferredOperationKHR DeferredOperation, VkPipelineCache PipelineCache, uint32_t CreateInfoCount, const VkRayTracingPipelineCreateInfoKHR* CreateInfos, const VkAllocationCallbacks* Allocator, VkPipeline* Pipelines) VULKAN_LAYER_BODY
231 static void GetRayTracingShaderGroupHandlesKHR(VkResult Result, VkDevice Device, VkPipeline Pipeline, uint32_t FirstGroup, uint32_t GroupCount, size_t DataSize, void* Data) VULKAN_LAYER_BODY
232 static void CmdWriteAccelerationStructuresPropertiesKHR(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t AccelerationStructureCount, const VkAccelerationStructureKHR* AccelerationStructures, VkQueryType QueryType, VkQueryPool QueryPool, uint32_t FirstQuery) VULKAN_LAYER_BODY
233 static void CmdCopyAccelerationStructureKHR(VkResult Result, VkCommandBuffer CommandBuffer, const VkCopyAccelerationStructureInfoKHR* Info) VULKAN_LAYER_BODY
234
235 static void GetBufferDeviceAddressKHR(VkResult Result, VkDevice Device, const VkBufferDeviceAddressInfo* Info) VULKAN_LAYER_BODY
236 static void GetDeviceImageMemoryRequirementsKHR(VkResult Result, VkDevice Device, const VkDeviceImageMemoryRequirements* Info, VkMemoryRequirements2* MemoryRequirements) VULKAN_LAYER_BODY
237 static void GetDeviceBufferMemoryRequirementsKHR(VkResult Result, VkDevice Device, const VkDeviceBufferMemoryRequirements* Info, VkMemoryRequirements2* MemoryRequirements) VULKAN_LAYER_BODY
238 static void ResetQueryPoolEXT(VkResult Result, VkDevice Device, VkQueryPool QueryPool, uint32_t FirstQuery, uint32_t QueryCount) VULKAN_LAYER_BODY
239 static void GetPhysicalDeviceCalibrateableTimeDomainsEXT(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32_t* TimeDomainCount, VkTimeDomainEXT* TimeDomains) VULKAN_LAYER_BODY
240 static void GetCalibratedTimestampsEXT(VkResult Result, VkDevice Device, uint32_t TimestampCount, const VkCalibratedTimestampInfoEXT* TimestampInfos, uint64_t* Timestamps, uint64_t* MaxDeviation) VULKAN_LAYER_BODY
241 static void BindBufferMemory2(VkResult Result, VkDevice Device, uint32_t BindInfoCount, const VkBindBufferMemoryInfo* BindInfos) VULKAN_LAYER_BODY
242 static void BindImageMemory2(VkResult Result, VkDevice Device, uint32_t BindInfoCount, const VkBindImageMemoryInfo* BindInfos) VULKAN_LAYER_BODY
243 static void CmdPipelineBarrier2KHR(VkResult Result, VkCommandBuffer CommandBuffer, const VkDependencyInfo* DependencyInfo) VULKAN_LAYER_BODY
244 static void CmdResetEvent2KHR(VkResult Result, VkCommandBuffer CommandBuffer, VkEvent Event, VkPipelineStageFlags2 StageMask) VULKAN_LAYER_BODY
245 static void CmdSetEvent2KHR(VkResult Result, VkCommandBuffer CommandBuffer, VkEvent Event, const VkDependencyInfo* DependencyInfo) VULKAN_LAYER_BODY
246 static void CmdWaitEvents2KHR(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t EventCount, const VkEvent* Events, const VkDependencyInfo* DependencyInfos) VULKAN_LAYER_BODY
247 static void QueueSubmit2KHR(VkResult Result, VkQueue Queue, uint32_t SubmitCount, const VkSubmitInfo2* Submits, VkFence Fence) VULKAN_LAYER_BODY
248 static void GetDescriptorSetLayoutSizeEXT(VkResult Result, VkDevice Device, VkDescriptorSetLayout Layout, VkDeviceSize* OutLayoutSizeInBytes) VULKAN_LAYER_BODY
249 static void GetDescriptorSetLayoutBindingOffsetEXT(VkResult Result, VkDevice Device, VkDescriptorSetLayout Layout, uint32_t Binding, VkDeviceSize* Offset) VULKAN_LAYER_BODY
250 static void CmdBindDescriptorBuffersEXT(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t BufferCount, const VkDescriptorBufferBindingInfoEXT* BindingInfos) VULKAN_LAYER_BODY
251 static void CmdSetDescriptorBufferOffsetsEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkPipelineBindPoint PipelineBindPoint, VkPipelineLayout Layout, uint32_t FirstSet, uint32_t SetCount, const uint32_t* BufferIndices, const VkDeviceSize* Offsets) VULKAN_LAYER_BODY
252 static void GetDescriptorEXT(VkResult Result, VkDevice Device, const VkDescriptorGetInfoEXT* DescriptorInfo, size_t DataSize, void* Descriptor) VULKAN_LAYER_BODY
253 static void CreateDeferredOperationKHR(VkResult Result, VkDevice Device, const VkAllocationCallbacks* Allocator, VkDeferredOperationKHR* DeferredOperation) VULKAN_LAYER_BODY
254 static void DestroyDeferredOperationKHR(VkResult Result, VkDevice Device, VkDeferredOperationKHR DeferredOperation, const VkAllocationCallbacks* Allocator) VULKAN_LAYER_BODY
255 static void DeferredOperationJoinKHR(VkResult Result, VkDevice Device, VkDeferredOperationKHR DeferredOperation) VULKAN_LAYER_BODY
256 static void GetDeferredOperationMaxConcurrencyKHR(VkResult Result, VkDevice Device, VkDeferredOperationKHR DeferredOperation) VULKAN_LAYER_BODY
257 static void GetDeferredOperationResultKHR(VkResult Result, VkDevice Device, VkDeferredOperationKHR DeferredOperation) VULKAN_LAYER_BODY
258 static void GetDeviceFaultInfoEXT(VkResult Result, VkDevice Device, VkDeviceFaultCountsEXT* FaultCounts, VkDeviceFaultInfoEXT* FaultInfo) VULKAN_LAYER_BODY
259 static void GetPhysicalDeviceToolPropertiesEXT(VkResult Result, VkPhysicalDevice PhysicalDevice, uint32_t* ToolCount, VkPhysicalDeviceToolProperties* ToolProperties) VULKAN_LAYER_BODY
260 static void CreateSamplerYcbcrConversion(VkResult Result, VkDevice Device, const VkSamplerYcbcrConversionCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkSamplerYcbcrConversion* YcbcrConversion) VULKAN_LAYER_BODY
261 static void DestroySamplerYcbcrConversion(VkResult Result, VkDevice Device, VkSamplerYcbcrConversion YcbcrConversion, const VkAllocationCallbacks* Allocator) VULKAN_LAYER_BODY
262#if PLATFORM_ANDROID
263 static void GetAndroidHardwareBufferPropertiesANDROID(VkResult Result, VkDevice Device, const struct AHardwareBuffer* Buffer, VkAndroidHardwareBufferPropertiesANDROID* Properties) VULKAN_LAYER_BODY
264#endif
265 static void GetSemaphoreCounterValueKHR(VkResult Result, VkDevice Device, VkSemaphore Semaphore, uint64_t* Value) VULKAN_LAYER_BODY
266 static void WaitSemaphoresKHR(VkResult Result, VkDevice Device, const VkSemaphoreWaitInfo* WaitInfo, uint64_t Timeout) VULKAN_LAYER_BODY
267 static void SignalSemaphoreKHR(VkResult Result, VkDevice Device, const VkSemaphoreSignalInfo* SignalInfo) VULKAN_LAYER_BODY
268
269 static void CreateShadersEXT(VkResult Result, VkDevice Device, uint32_t CreateInfoCount, const VkShaderCreateInfoEXT* CreateInfos, const VkAllocationCallbacks* Allocator, VkShaderEXT* Shaders) VULKAN_LAYER_BODY
270 static void DestroyShaderEXT(VkResult Result, VkDevice Device, VkShaderEXT Shader, const VkAllocationCallbacks* Allocator) VULKAN_LAYER_BODY
271 static void GetShaderBinaryDataEXT(VkResult Result, VkDevice Device, VkShaderEXT Shader, size_t* DataSize, void* Data) VULKAN_LAYER_BODY
272 static void CmdBindShadersEXT(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t StageCount, const VkShaderStageFlagBits* Stages, const VkShaderEXT* Shaders) VULKAN_LAYER_BODY
273 static void CmdBindVertexBuffers2EXT(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t FirstBinding, uint32_t BindingCount, const VkBuffer* Buffers, const VkDeviceSize* Offsets, const VkDeviceSize* Sizes, const VkDeviceSize* Strides) VULKAN_LAYER_BODY
274 static void CmdSetCullModeEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkCullModeFlags CullMode) VULKAN_LAYER_BODY
275 static void CmdSetColorBlendEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t FirstAttachment, uint32_t AttachmentCount, const VkBool32* ColorBlendEnables) VULKAN_LAYER_BODY
276 static void CmdSetColorBlendEquationEXT(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t FirstAttachment, uint32_t AttachmentCount, const VkColorBlendEquationEXT* ColorBlendEquations) VULKAN_LAYER_BODY
277 static void CmdSetColorWriteMaskEXT(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t FirstAttachment, uint32_t AttachmentCount, const VkColorComponentFlags* ColorWriteMasks) VULKAN_LAYER_BODY
278 static void CmdSetFrontFaceEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkFrontFace FrontFace) VULKAN_LAYER_BODY
279 static void CmdSetPolygonModeEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkPolygonMode PolygonMode) VULKAN_LAYER_BODY
280 static void CmdSetPrimitiveTopologyEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkPrimitiveTopology PrimitiveTopology) VULKAN_LAYER_BODY
281 static void CmdSetRasterizationSamplesEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkSampleCountFlagBits RasterizationSamples) VULKAN_LAYER_BODY
282 static void CmdSetScissorWithCountEXT(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t ScissorCount, const VkRect2D* Scissors) VULKAN_LAYER_BODY
283 static void CmdSetStencilOpEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkStencilFaceFlags FaceMask, VkStencilOp FailOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) VULKAN_LAYER_BODY
284 static void CmdSetStencilTestEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkBool32 StencilTestEnable) VULKAN_LAYER_BODY
285 static void CmdSetVertexInputEXT(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t VertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) VULKAN_LAYER_BODY
286 static void CmdSetViewportWithCountEXT(VkResult Result, VkCommandBuffer CommandBuffer, uint32_t ViewportCount, const VkViewport* pViewports) VULKAN_LAYER_BODY
287 static void CmdSetDepthBiasEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkBool32 DepthBiasEnable) VULKAN_LAYER_BODY
288 static void CmdSetDepthBoundsTestEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkBool32 DepthBoundsTestEnable) VULKAN_LAYER_BODY
289 static void CmdSetDepthClampEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkBool32 DepthClampEnable) VULKAN_LAYER_BODY
290 static void CmdSetDepthCompareOpEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkCompareOp DepthCompareOp) VULKAN_LAYER_BODY
291 static void CmdSetDepthTestEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkBool32 DepthTestEnable) VULKAN_LAYER_BODY
292 static void CmdSetDepthWriteEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkBool32 DepthWriteEnable) VULKAN_LAYER_BODY
293 static void CmdSetRasterizerDiscardEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkBool32 RasterizerDiscardEnable) VULKAN_LAYER_BODY
294 static void CmdSetPrimitiveRestartEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkBool32 PrimitiveRestartEnable) VULKAN_LAYER_BODY
295 static void CmdSetLogicOpEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkBool32 LogicOpEnable) VULKAN_LAYER_BODY
296 static void CmdSetAlphaToCoverageEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkBool32 AlphaToCoverageEnable) VULKAN_LAYER_BODY
297 static void CmdSetAlphaToOneEnableEXT(VkResult Result, VkCommandBuffer CommandBuffer, VkBool32 AlphaToOneEnable) VULKAN_LAYER_BODY
298
299 static void CopyMemoryToImageEXT(VkResult Result, VkDevice Device, const VkCopyMemoryToImageInfo* CopyMemoryToImageInfo) VULKAN_LAYER_BODY
300 static void TransitionImageLayoutEXT(VkResult Result, VkDevice Device, uint32_t TransitionCount, const VkHostImageLayoutTransitionInfo* Transitions) VULKAN_LAYER_BODY
301};
302
303
304#undef VULKAN_LAYER_BODY
305
306namespace VulkanRHI
307{
308 void FlushDebugWrapperLog();
309
310 FORCEINLINE_DEBUGGABLE VkResult vkCreateInstance(const VkInstanceCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkInstance* Instance)
311 {
312 FWrapLayer::CreateInstance(VK_RESULT_MAX_ENUM, CreateInfo, Instance);
313 VkResult Result = VULKANAPINAMESPACE::vkCreateInstance(CreateInfo, Allocator, Instance);
314 FWrapLayer::CreateInstance(Result, CreateInfo, Instance);
315 return Result;
316 }
317
318 static FORCEINLINE_DEBUGGABLE void vkDestroyInstance(VkInstance Instance, const VkAllocationCallbacks* Allocator)
319 {
320 FWrapLayer::DestroyInstance(VK_RESULT_MAX_ENUM, Instance);
321 VULKANAPINAMESPACE::vkDestroyInstance(Instance, Allocator);
322 FWrapLayer::DestroyInstance(VK_SUCCESS, Instance);
323 }
324
325 static FORCEINLINE_DEBUGGABLE VkResult vkEnumeratePhysicalDevices(VkInstance Instance, uint32* PhysicalDeviceCount, VkPhysicalDevice* PhysicalDevices)
326 {
327 FWrapLayer::EnumeratePhysicalDevices(VK_RESULT_MAX_ENUM, Instance, PhysicalDeviceCount, PhysicalDevices);
328 VkResult Result = VULKANAPINAMESPACE::vkEnumeratePhysicalDevices(Instance, PhysicalDeviceCount, PhysicalDevices);
329 FWrapLayer::EnumeratePhysicalDevices(Result, Instance, PhysicalDeviceCount, PhysicalDevices);
330 return Result;
331 }
332
333 static FORCEINLINE_DEBUGGABLE VkResult vkEnumerateInstanceVersion(uint32_t* ApiVersion)
334 {
335 FWrapLayer::EnumerateInstanceVersion(VK_RESULT_MAX_ENUM, ApiVersion);
336 const VkResult Result = VULKANAPINAMESPACE::vkEnumerateInstanceVersion(ApiVersion);
337 FWrapLayer::EnumerateInstanceVersion(Result, ApiVersion);
338 return Result;
339 }
340
341 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceFeatures(VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceFeatures* Features)
342 {
343 FWrapLayer::GetPhysicalDeviceFeatures(VK_RESULT_MAX_ENUM, PhysicalDevice, Features);
344 VULKANAPINAMESPACE::vkGetPhysicalDeviceFeatures(PhysicalDevice, Features);
345 FWrapLayer::GetPhysicalDeviceFeatures(VK_SUCCESS, PhysicalDevice, Features);
346 }
347
348 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice PhysicalDevice, VkFormat Format, VkFormatProperties* FormatProperties)
349 {
350 FWrapLayer::GetPhysicalDeviceFormatProperties(VK_RESULT_MAX_ENUM, PhysicalDevice, Format, FormatProperties);
351 VULKANAPINAMESPACE::vkGetPhysicalDeviceFormatProperties(PhysicalDevice, Format, FormatProperties);
352 FWrapLayer::GetPhysicalDeviceFormatProperties(VK_SUCCESS, PhysicalDevice, Format, FormatProperties);
353 }
354
355 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice PhysicalDevice, VkFormat Format, VkFormatProperties2* FormatProperties)
356 {
357 FWrapLayer::GetPhysicalDeviceFormatProperties2(VK_RESULT_MAX_ENUM, PhysicalDevice, Format, FormatProperties);
358 VULKANAPINAMESPACE::vkGetPhysicalDeviceFormatProperties2(PhysicalDevice, Format, FormatProperties);
359 FWrapLayer::GetPhysicalDeviceFormatProperties2(VK_SUCCESS, PhysicalDevice, Format, FormatProperties);
360 }
361
362 static FORCEINLINE_DEBUGGABLE VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice PhysicalDevice, VkFormat Format, VkImageType Type, VkImageTiling Tiling, VkImageUsageFlags Usage, VkImageCreateFlags Flags, VkImageFormatProperties* pImageFormatProperties)
363 {
364 FWrapLayer::GetPhysicalDeviceImageFormatProperties(VK_RESULT_MAX_ENUM, PhysicalDevice, Format, Type, Tiling, Usage, Flags, pImageFormatProperties);
365 VkResult Result = VULKANAPINAMESPACE::vkGetPhysicalDeviceImageFormatProperties(PhysicalDevice, Format, Type, Tiling, Usage, Flags, pImageFormatProperties);
366 FWrapLayer::GetPhysicalDeviceImageFormatProperties(Result, PhysicalDevice, Format, Type, Tiling, Usage, Flags, pImageFormatProperties);
367 return Result;
368 }
369
370 static FORCEINLINE_DEBUGGABLE VkResult vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice PhysicalDevice, const VkPhysicalDeviceImageFormatInfo2* FormatInfo, VkImageFormatProperties2* FormatProperties)
371 {
372 FWrapLayer::GetPhysicalDeviceImageFormatProperties2(VK_RESULT_MAX_ENUM, PhysicalDevice, FormatInfo, FormatProperties);
373 VkResult Result = VULKANAPINAMESPACE::vkGetPhysicalDeviceImageFormatProperties2(PhysicalDevice, FormatInfo, FormatProperties);
374 FWrapLayer::GetPhysicalDeviceImageFormatProperties2(Result, PhysicalDevice, FormatInfo, FormatProperties);
375 return Result;
376 }
377
378 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceProperties(VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceProperties* Properties)
379 {
380 FWrapLayer::GetPhysicalDeviceProperties(VK_RESULT_MAX_ENUM, PhysicalDevice, Properties);
381 VULKANAPINAMESPACE::vkGetPhysicalDeviceProperties(PhysicalDevice, Properties);
382 FWrapLayer::GetPhysicalDeviceProperties(VK_SUCCESS, PhysicalDevice, Properties);
383 }
384
385 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceMemoryProperties2(VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
386 {
387 FWrapLayer::GetPhysicalDeviceMemoryProperties2(VK_RESULT_MAX_ENUM, PhysicalDevice, pMemoryProperties);
388 VULKANAPINAMESPACE::vkGetPhysicalDeviceMemoryProperties2(PhysicalDevice, pMemoryProperties);
389 FWrapLayer::GetPhysicalDeviceMemoryProperties2(VK_SUCCESS, PhysicalDevice, pMemoryProperties);
390 }
391
392 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceProperties2(VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceProperties2* Properties)
393 {
394 FWrapLayer::GetPhysicalDeviceProperties2(VK_RESULT_MAX_ENUM, PhysicalDevice, Properties);
395 VULKANAPINAMESPACE::vkGetPhysicalDeviceProperties2(PhysicalDevice, Properties);
396 FWrapLayer::GetPhysicalDeviceProperties2(VK_SUCCESS, PhysicalDevice, Properties);
397 }
398
399 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceFeatures2(VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceFeatures2* Features)
400 {
401 FWrapLayer::GetPhysicalDeviceFeatures2(VK_RESULT_MAX_ENUM, PhysicalDevice, Features);
402 VULKANAPINAMESPACE::vkGetPhysicalDeviceFeatures2(PhysicalDevice, Features);
403 FWrapLayer::GetPhysicalDeviceFeatures2(VK_SUCCESS, PhysicalDevice, Features);
404 }
405
406 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice PhysicalDevice, uint32* FragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* FragmentShadingRates)
407 {
408 FWrapLayer::GetPhysicalDeviceFragmentShadingRatesKHR(VK_RESULT_MAX_ENUM, PhysicalDevice, FragmentShadingRateCount, FragmentShadingRates);
409 VULKANAPINAMESPACE::vkGetPhysicalDeviceFragmentShadingRatesKHR(PhysicalDevice, FragmentShadingRateCount, FragmentShadingRates);
410 FWrapLayer::GetPhysicalDeviceFragmentShadingRatesKHR(VK_SUCCESS, PhysicalDevice, FragmentShadingRateCount, FragmentShadingRates);
411 }
412
413 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice PhysicalDevice, uint32* QueueFamilyPropertyCount, VkQueueFamilyProperties* QueueFamilyProperties)
414 {
415 FWrapLayer::GetPhysicalDeviceQueueFamilyProperties(VK_RESULT_MAX_ENUM, PhysicalDevice, QueueFamilyPropertyCount, QueueFamilyProperties);
416 VULKANAPINAMESPACE::vkGetPhysicalDeviceQueueFamilyProperties(PhysicalDevice, QueueFamilyPropertyCount, QueueFamilyProperties);
417 FWrapLayer::GetPhysicalDeviceQueueFamilyProperties(VK_SUCCESS, PhysicalDevice, QueueFamilyPropertyCount, QueueFamilyProperties);
418 }
419
420 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice PhysicalDevice, uint32* QueueFamilyPropertyCount, VkQueueFamilyProperties2* QueueFamilyProperties)
421 {
422 FWrapLayer::GetPhysicalDeviceQueueFamilyProperties2(VK_RESULT_MAX_ENUM, PhysicalDevice, QueueFamilyPropertyCount, QueueFamilyProperties);
423 VULKANAPINAMESPACE::vkGetPhysicalDeviceQueueFamilyProperties2(PhysicalDevice, QueueFamilyPropertyCount, QueueFamilyProperties);
424 FWrapLayer::GetPhysicalDeviceQueueFamilyProperties2(VK_SUCCESS, PhysicalDevice, QueueFamilyPropertyCount, QueueFamilyProperties);
425 }
426
427 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice PhysicalDevice, VkPhysicalDeviceMemoryProperties* MemoryProperties)
428 {
429 FWrapLayer::GetPhysicalDeviceMemoryProperties(VK_RESULT_MAX_ENUM, PhysicalDevice, MemoryProperties);
430 VULKANAPINAMESPACE::vkGetPhysicalDeviceMemoryProperties(PhysicalDevice, MemoryProperties);
431 FWrapLayer::GetPhysicalDeviceMemoryProperties(VK_SUCCESS, PhysicalDevice, MemoryProperties);
432 }
433
434 static FORCEINLINE_DEBUGGABLE PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance Instance, const char* Name)
435 {
436 FWrapLayer::GetInstanceProcAddr(VK_RESULT_MAX_ENUM, Instance, Name, nullptr);
437 PFN_vkVoidFunction Function = VULKANAPINAMESPACE::vkGetInstanceProcAddr(Instance, Name);
438 FWrapLayer::GetInstanceProcAddr(VK_SUCCESS, Instance, Name, Function);
439 return Function;
440 }
441
442 static FORCEINLINE_DEBUGGABLE PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice Device, const char* Name)
443 {
444 FWrapLayer::GetDeviceProcAddr(VK_RESULT_MAX_ENUM, Device, Name, nullptr);
445 PFN_vkVoidFunction Function = VULKANAPINAMESPACE::vkGetDeviceProcAddr(Device, Name);
446 FWrapLayer::GetDeviceProcAddr(VK_SUCCESS, Device, Name, Function);
447 return Function;
448 }
449
450 static FORCEINLINE_DEBUGGABLE VkResult vkCreateDevice(VkPhysicalDevice PhysicalDevice, const VkDeviceCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkDevice* Device)
451 {
452 FWrapLayer::CreateDevice(VK_RESULT_MAX_ENUM, PhysicalDevice, CreateInfo, Device);
453 VkResult Result = VULKANAPINAMESPACE::vkCreateDevice(PhysicalDevice, CreateInfo, Allocator, Device);
454 FWrapLayer::CreateDevice(Result, PhysicalDevice, CreateInfo, Device);
455 return Result;
456 }
457
458 static FORCEINLINE_DEBUGGABLE void vkDestroyDevice(VkDevice Device, const VkAllocationCallbacks* Allocator)
459 {
460 FWrapLayer::DestroyDevice(VK_RESULT_MAX_ENUM, Device);
461 VULKANAPINAMESPACE::vkDestroyDevice(Device, Allocator);
462 FWrapLayer::DestroyDevice(VK_SUCCESS, Device);
463 }
464
465 static FORCEINLINE_DEBUGGABLE VkResult vkEnumerateInstanceExtensionProperties(const char* LayerName, uint32* PropertyCount, VkExtensionProperties* Properties)
466 {
467 FWrapLayer::EnumerateInstanceExtensionProperties(VK_RESULT_MAX_ENUM, LayerName, PropertyCount, Properties);
468 VkResult Result = VULKANAPINAMESPACE::vkEnumerateInstanceExtensionProperties(LayerName, PropertyCount, Properties);
469 //FWrapLayer::EnumerateInstanceExtensionProperties(VK_SUCCESS, LayerName, PropertyCount, Properties);
470 return Result;
471 }
472
473 static FORCEINLINE_DEBUGGABLE VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice PhysicalDevice, const char* LayerName, uint32* PropertyCount, VkExtensionProperties* Properties)
474 {
475 FWrapLayer::EnumerateDeviceExtensionProperties(VK_RESULT_MAX_ENUM, PhysicalDevice, LayerName, PropertyCount, Properties);
476 VkResult Result = VULKANAPINAMESPACE::vkEnumerateDeviceExtensionProperties(PhysicalDevice, LayerName, PropertyCount, Properties);
477 FWrapLayer::EnumerateDeviceExtensionProperties(VK_SUCCESS, PhysicalDevice, LayerName, PropertyCount, Properties);
478 return Result;
479 }
480
481 static FORCEINLINE_DEBUGGABLE VkResult vkEnumerateInstanceLayerProperties(uint32* PropertyCount, VkLayerProperties* Properties)
482 {
483 FWrapLayer::EnumerateInstanceLayerProperties(VK_RESULT_MAX_ENUM, PropertyCount, Properties);
484 VkResult Result = VULKANAPINAMESPACE::vkEnumerateInstanceLayerProperties(PropertyCount, Properties);
485 FWrapLayer::EnumerateInstanceLayerProperties(VK_SUCCESS, PropertyCount, Properties);
486 return Result;
487 }
488
489 static FORCEINLINE_DEBUGGABLE VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice PhysicalDevice, uint32* PropertyCount, VkLayerProperties* Properties)
490 {
491 FWrapLayer::EnumerateDeviceLayerProperties(VK_RESULT_MAX_ENUM, PhysicalDevice, PropertyCount, Properties);
492 VkResult Result = VULKANAPINAMESPACE::vkEnumerateDeviceLayerProperties(PhysicalDevice, PropertyCount, Properties);
493 FWrapLayer::EnumerateDeviceLayerProperties(VK_SUCCESS, PhysicalDevice, PropertyCount, Properties);
494 return Result;
495 }
496
497 static FORCEINLINE_DEBUGGABLE void vkGetDeviceQueue(VkDevice Device, uint32 QueueFamilyIndex, uint32 QueueIndex, VkQueue* Queue)
498 {
499 FWrapLayer::GetDeviceQueue(VK_RESULT_MAX_ENUM, Device, QueueFamilyIndex, QueueIndex, Queue);
500 VULKANAPINAMESPACE::vkGetDeviceQueue(Device, QueueFamilyIndex, QueueIndex, Queue);
501 FWrapLayer::GetDeviceQueue(VK_SUCCESS, Device, QueueFamilyIndex, QueueIndex, Queue);
502 }
503
504 static FORCEINLINE_DEBUGGABLE VkResult vkQueueSubmit(VkQueue Queue, uint32 SubmitCount, const VkSubmitInfo* Submits, VkFence Fence)
505 {
506 FWrapLayer::QueueSubmit(VK_RESULT_MAX_ENUM, Queue, SubmitCount, Submits, Fence);
507 VkResult Result = VULKANAPINAMESPACE::vkQueueSubmit(Queue, SubmitCount, Submits, Fence);
508 FWrapLayer::QueueSubmit(Result, Queue, SubmitCount, Submits, Fence);
509 return Result;
510 }
511 static FORCEINLINE_DEBUGGABLE VkResult vkQueueWaitIdle(VkQueue Queue)
512 {
513 FWrapLayer::QueueWaitIdle(VK_RESULT_MAX_ENUM, Queue);
514 VkResult Result = VULKANAPINAMESPACE::vkQueueWaitIdle(Queue);
515 FWrapLayer::QueueWaitIdle(Result, Queue);
516 return Result;
517 }
518
519 static FORCEINLINE_DEBUGGABLE VkResult vkDeviceWaitIdle(VkDevice Device)
520 {
521 FWrapLayer::DeviceWaitIdle(VK_RESULT_MAX_ENUM, Device);
522 VkResult Result = VULKANAPINAMESPACE::vkDeviceWaitIdle(Device);
523 FWrapLayer::DeviceWaitIdle(VK_SUCCESS, Device);
524 return Result;
525 }
526
527 static FORCEINLINE_DEBUGGABLE VkResult vkAllocateMemory(VkDevice Device, const VkMemoryAllocateInfo* AllocateInfo, const VkAllocationCallbacks* Allocator, VkDeviceMemory* Memory)
528 {
529 FWrapLayer::AllocateMemory(VK_RESULT_MAX_ENUM, Device, AllocateInfo, Memory);
530 VkResult Result = VULKANAPINAMESPACE::vkAllocateMemory(Device, AllocateInfo, Allocator, Memory);
531 FWrapLayer::AllocateMemory(Result, Device, AllocateInfo, Memory);
532 return Result;
533 }
534
535 static FORCEINLINE_DEBUGGABLE void vkFreeMemory(VkDevice Device, VkDeviceMemory Memory, const VkAllocationCallbacks* Allocator)
536 {
537 FWrapLayer::FreeMemory(VK_RESULT_MAX_ENUM, Device, Memory);
538 VULKANAPINAMESPACE::vkFreeMemory(Device, Memory, Allocator);
539 FWrapLayer::FreeMemory(VK_SUCCESS, Device, Memory);
540 }
541
542 static FORCEINLINE_DEBUGGABLE VkResult vkMapMemory(VkDevice Device, VkDeviceMemory Memory, VkDeviceSize Offset, VkDeviceSize Size, VkMemoryMapFlags Flags, void** Data)
543 {
544 FWrapLayer::MapMemory(VK_RESULT_MAX_ENUM, Device, Memory, Offset, Size, Flags, Data);
545 VkResult Result = VULKANAPINAMESPACE::vkMapMemory(Device, Memory, Offset, Size, Flags, Data);
546 FWrapLayer::MapMemory(Result, Device, Memory, Offset, Size, Flags, Data);
547 return Result;
548 }
549
550 static FORCEINLINE_DEBUGGABLE void vkUnmapMemory(VkDevice Device, VkDeviceMemory Memory)
551 {
552 FWrapLayer::UnmapMemory(VK_RESULT_MAX_ENUM, Device, Memory);
553 VULKANAPINAMESPACE::vkUnmapMemory(Device, Memory);
554 FWrapLayer::UnmapMemory(VK_SUCCESS, Device, Memory);
555 }
556
557 static FORCEINLINE_DEBUGGABLE VkResult vkFlushMappedMemoryRanges(VkDevice Device, uint32 MemoryRangeCount, const VkMappedMemoryRange* MemoryRanges)
558 {
559 FWrapLayer::FlushMappedMemoryRanges(VK_RESULT_MAX_ENUM, Device, MemoryRangeCount, MemoryRanges);
560 VkResult Result = VULKANAPINAMESPACE::vkFlushMappedMemoryRanges(Device, MemoryRangeCount, MemoryRanges);
561 FWrapLayer::FlushMappedMemoryRanges(Result, Device, MemoryRangeCount, MemoryRanges);
562 return Result;
563 }
564
565 static FORCEINLINE_DEBUGGABLE VkResult vkInvalidateMappedMemoryRanges(VkDevice Device, uint32 MemoryRangeCount, const VkMappedMemoryRange* MemoryRanges)
566 {
567 FWrapLayer::InvalidateMappedMemoryRanges(VK_RESULT_MAX_ENUM, Device, MemoryRangeCount, MemoryRanges);
568 VkResult Result = VULKANAPINAMESPACE::vkInvalidateMappedMemoryRanges(Device, MemoryRangeCount, MemoryRanges);
569 FWrapLayer::InvalidateMappedMemoryRanges(Result, Device, MemoryRangeCount, MemoryRanges);
570 return Result;
571 }
572
573 static FORCEINLINE_DEBUGGABLE void vkGetDeviceMemoryCommitment(VkDevice Device, VkDeviceMemory Memory, VkDeviceSize* pCommittedMemoryInBytes)
574 {
575 FWrapLayer::GetDeviceMemoryCommitment(VK_RESULT_MAX_ENUM, Device, Memory, pCommittedMemoryInBytes);
576 VULKANAPINAMESPACE::vkGetDeviceMemoryCommitment(Device, Memory, pCommittedMemoryInBytes);
577 FWrapLayer::GetDeviceMemoryCommitment(VK_SUCCESS, Device, Memory, pCommittedMemoryInBytes);
578 }
579
580 static FORCEINLINE_DEBUGGABLE VkResult vkBindBufferMemory(VkDevice Device, VkBuffer Buffer, VkDeviceMemory Memory, VkDeviceSize MemoryOffset)
581 {
582 FWrapLayer::BindBufferMemory(VK_RESULT_MAX_ENUM, Device, Buffer, Memory, MemoryOffset);
583 VkResult Result = VULKANAPINAMESPACE::vkBindBufferMemory(Device, Buffer, Memory, MemoryOffset);
584 FWrapLayer::BindBufferMemory(Result, Device, Buffer, Memory, MemoryOffset);
585 return Result;
586 }
587
588 static FORCEINLINE_DEBUGGABLE VkResult vkBindImageMemory(VkDevice Device, VkImage Image, VkDeviceMemory Memory, VkDeviceSize MemoryOffset)
589 {
590 FWrapLayer::BindImageMemory(VK_RESULT_MAX_ENUM, Device, Image, Memory, MemoryOffset);
591 VkResult Result = VULKANAPINAMESPACE::vkBindImageMemory(Device, Image, Memory, MemoryOffset);
592 FWrapLayer::BindImageMemory(Result, Device, Image, Memory, MemoryOffset);
593 return Result;
594 }
595
596 static FORCEINLINE_DEBUGGABLE void vkGetBufferMemoryRequirements(VkDevice Device, VkBuffer Buffer, VkMemoryRequirements* MemoryRequirements)
597 {
598 FWrapLayer::GetBufferMemoryRequirements(VK_RESULT_MAX_ENUM, Device, Buffer, MemoryRequirements);
599 VULKANAPINAMESPACE::vkGetBufferMemoryRequirements(Device, Buffer, MemoryRequirements);
600 FWrapLayer::GetBufferMemoryRequirements(VK_SUCCESS, Device, Buffer, MemoryRequirements);
601 }
602
603 static FORCEINLINE_DEBUGGABLE void vkGetImageMemoryRequirements(VkDevice Device, VkImage Image, VkMemoryRequirements* MemoryRequirements)
604 {
605 FWrapLayer::GetImageMemoryRequirements(VK_RESULT_MAX_ENUM, Device, Image, MemoryRequirements);
606 VULKANAPINAMESPACE::vkGetImageMemoryRequirements(Device, Image, MemoryRequirements);
607 FWrapLayer::GetImageMemoryRequirements(VK_SUCCESS, Device, Image, MemoryRequirements);
608 }
609
610 static FORCEINLINE_DEBUGGABLE void vkGetImageSparseMemoryRequirements(VkDevice Device, VkImage Image, uint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
611 {
612 FWrapLayer::GetImageSparseMemoryRequirements(VK_RESULT_MAX_ENUM, Device, Image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
613 VULKANAPINAMESPACE::vkGetImageSparseMemoryRequirements(Device, Image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
614 FWrapLayer::GetImageSparseMemoryRequirements(VK_SUCCESS, Device, Image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
615 }
616
617 static FORCEINLINE_DEBUGGABLE void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice PhysicalDevice, VkFormat Format, VkImageType Type, VkSampleCountFlagBits Samples, VkImageUsageFlags Usage, VkImageTiling Tiling, uint32* pPropertyCount, VkSparseImageFormatProperties* pProperties)
618 {
619 FWrapLayer::GetPhysicalDeviceSparseImageFormatProperties(VK_RESULT_MAX_ENUM, PhysicalDevice, Format, Type, Samples, Usage, Tiling, pPropertyCount, pProperties);
620 VULKANAPINAMESPACE::vkGetPhysicalDeviceSparseImageFormatProperties(PhysicalDevice, Format, Type, Samples, Usage, Tiling, pPropertyCount, pProperties);
621 FWrapLayer::GetPhysicalDeviceSparseImageFormatProperties(VK_SUCCESS, PhysicalDevice, Format, Type, Samples, Usage, Tiling, pPropertyCount, pProperties);
622 }
623
624 static FORCEINLINE_DEBUGGABLE VkResult vkQueueBindSparse(VkQueue Queue, uint32 BindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence Fence)
625 {
626 FWrapLayer::QueueBindSparse(VK_RESULT_MAX_ENUM, Queue, BindInfoCount, pBindInfo, Fence);
627 VkResult Result = VULKANAPINAMESPACE::vkQueueBindSparse(Queue, BindInfoCount, pBindInfo, Fence);
628 FWrapLayer::QueueBindSparse(Result, Queue, BindInfoCount, pBindInfo, Fence);
629 return Result;
630 }
631
632 static FORCEINLINE_DEBUGGABLE VkResult vkCreateFence(VkDevice Device, const VkFenceCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkFence* Fence)
633 {
634 FWrapLayer::CreateFence(VK_RESULT_MAX_ENUM, Device, CreateInfo, Fence);
635 VkResult Result = VULKANAPINAMESPACE::vkCreateFence(Device, CreateInfo, Allocator, Fence);
636 FWrapLayer::CreateFence(Result, Device, CreateInfo, Fence);
637 return Result;
638 }
639
640 static FORCEINLINE_DEBUGGABLE void vkDestroyFence(VkDevice Device, VkFence Fence, const VkAllocationCallbacks* Allocator)
641 {
642 FWrapLayer::DestroyFence(VK_RESULT_MAX_ENUM, Device, Fence);
643 VULKANAPINAMESPACE::vkDestroyFence(Device, Fence, Allocator);
644 FWrapLayer::DestroyFence(VK_SUCCESS, Device, Fence);
645 }
646
647 static FORCEINLINE_DEBUGGABLE VkResult vkResetFences(VkDevice Device, uint32 FenceCount, const VkFence* Fences)
648 {
649 FWrapLayer::ResetFences(VK_RESULT_MAX_ENUM, Device, FenceCount, Fences);
650 VkResult Result = VULKANAPINAMESPACE::vkResetFences(Device, FenceCount, Fences);
651 FWrapLayer::ResetFences(Result, Device, FenceCount, Fences);
652 return Result;
653 }
654
655 static FORCEINLINE_DEBUGGABLE VkResult vkGetFenceStatus(VkDevice Device, VkFence Fence)
656 {
657 FWrapLayer::GetFenceStatus(VK_RESULT_MAX_ENUM, Device, Fence);
658 VkResult Result = VULKANAPINAMESPACE::vkGetFenceStatus(Device, Fence);
659 FWrapLayer::GetFenceStatus(Result, Device, Fence);
660 return Result;
661 }
662
663 static FORCEINLINE_DEBUGGABLE VkResult vkWaitForFences(VkDevice Device, uint32 FenceCount, const VkFence* Fences, VkBool32 bWaitAll, uint64_t Timeout)
664 {
665 FWrapLayer::WaitForFences(VK_RESULT_MAX_ENUM, Device, FenceCount, Fences, bWaitAll, Timeout);
666 VkResult Result = VULKANAPINAMESPACE::vkWaitForFences(Device, FenceCount, Fences, bWaitAll, Timeout);
667 FWrapLayer::WaitForFences(Result, Device, FenceCount, Fences, bWaitAll, Timeout);
668 return Result;
669 }
670
671 static FORCEINLINE_DEBUGGABLE VkResult vkCreateSemaphore(VkDevice Device, const VkSemaphoreCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkSemaphore* Semaphore)
672 {
673 FWrapLayer::CreateSemaphore(VK_RESULT_MAX_ENUM, Device, CreateInfo, Semaphore);
674 VkResult Result = VULKANAPINAMESPACE::vkCreateSemaphore(Device, CreateInfo, Allocator, Semaphore);
675 FWrapLayer::CreateSemaphore(Result, Device, CreateInfo, Semaphore);
676 return Result;
677 }
678
679
680 static FORCEINLINE_DEBUGGABLE void vkDestroySemaphore(VkDevice Device, VkSemaphore Semaphore, const VkAllocationCallbacks* Allocator)
681 {
682 FWrapLayer::DestroySemaphore(VK_RESULT_MAX_ENUM, Device, Semaphore);
683 VULKANAPINAMESPACE::vkDestroySemaphore(Device, Semaphore, Allocator);
684 FWrapLayer::DestroySemaphore(VK_SUCCESS, Device, Semaphore);
685 }
686
687 static FORCEINLINE_DEBUGGABLE VkResult vkCreateEvent(VkDevice Device, const VkEventCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkEvent* Event)
688 {
689 FWrapLayer::CreateEvent(VK_RESULT_MAX_ENUM, Device, CreateInfo, Event);
690 VkResult Result = VULKANAPINAMESPACE::vkCreateEvent(Device, CreateInfo, Allocator, Event);
691 FWrapLayer::CreateEvent(Result, Device, CreateInfo, Event);
692 return Result;
693 }
694
695 static FORCEINLINE_DEBUGGABLE void vkDestroyEvent(VkDevice Device, VkEvent Event, const VkAllocationCallbacks* Allocator)
696 {
697 FWrapLayer::DestroyEvent(VK_RESULT_MAX_ENUM, Device, Event);
698 VULKANAPINAMESPACE::vkDestroyEvent(Device, Event, Allocator);
699 FWrapLayer::DestroyEvent(VK_SUCCESS, Device, Event);
700 }
701
702 static FORCEINLINE_DEBUGGABLE VkResult vkGetEventStatus(VkDevice Device, VkEvent Event)
703 {
704 FWrapLayer::GetEventStatus(VK_RESULT_MAX_ENUM, Device, Event);
705 VkResult Result = VULKANAPINAMESPACE::vkGetEventStatus(Device, Event);
706 FWrapLayer::GetEventStatus(Result, Device, Event);
707 return Result;
708 }
709
710 static FORCEINLINE_DEBUGGABLE VkResult vkSetEvent(VkDevice Device, VkEvent Event)
711 {
712 FWrapLayer::SetEvent(VK_RESULT_MAX_ENUM, Device, Event);
713 VkResult Result = VULKANAPINAMESPACE::vkSetEvent(Device, Event);
714 FWrapLayer::SetEvent(Result, Device, Event);
715 return Result;
716 }
717
718 static FORCEINLINE_DEBUGGABLE VkResult vkResetEvent(VkDevice Device, VkEvent Event)
719 {
720 FWrapLayer::ResetEvent(VK_RESULT_MAX_ENUM, Device, Event);
721 VkResult Result = VULKANAPINAMESPACE::vkResetEvent(Device, Event);
722 FWrapLayer::ResetEvent(Result, Device, Event);
723 return Result;
724 }
725
726 static FORCEINLINE_DEBUGGABLE VkResult vkCreateQueryPool(VkDevice Device, const VkQueryPoolCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkQueryPool* QueryPool)
727 {
728 FWrapLayer::CreateQueryPool(VK_RESULT_MAX_ENUM, Device, CreateInfo, QueryPool);
729 VkResult Result = VULKANAPINAMESPACE::vkCreateQueryPool(Device, CreateInfo, Allocator, QueryPool);
730 FWrapLayer::CreateQueryPool(Result, Device, CreateInfo, QueryPool);
731 return Result;
732 }
733
734 static FORCEINLINE_DEBUGGABLE void vkDestroyQueryPool(VkDevice Device, VkQueryPool QueryPool, const VkAllocationCallbacks* Allocator)
735 {
736 FWrapLayer::DestroyQueryPool(VK_RESULT_MAX_ENUM, Device, QueryPool);
737 VULKANAPINAMESPACE::vkDestroyQueryPool(Device, QueryPool, Allocator);
738 FWrapLayer::DestroyQueryPool(VK_SUCCESS, Device, QueryPool);
739 }
740
741 static FORCEINLINE_DEBUGGABLE VkResult vkGetQueryPoolResults(VkDevice Device, VkQueryPool QueryPool,
742 uint32 FirstQuery, uint32 QueryCount, size_t DataSize, void* Data, VkDeviceSize Stride, VkQueryResultFlags Flags)
743 {
744 FWrapLayer::GetQueryPoolResults(VK_RESULT_MAX_ENUM, Device, QueryPool, FirstQuery, QueryCount, DataSize, Data, Stride, Flags);
745 VkResult Result = VULKANAPINAMESPACE::vkGetQueryPoolResults(Device, QueryPool, FirstQuery, QueryCount, DataSize, Data, Stride, Flags);
746 FWrapLayer::GetQueryPoolResults(Result, Device, QueryPool, FirstQuery, QueryCount, DataSize, Data, Stride, Flags);
747 return Result;
748 }
749
750 static FORCEINLINE_DEBUGGABLE VkResult vkCreateBuffer(VkDevice Device, const VkBufferCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkBuffer* Buffer)
751 {
752 FWrapLayer::CreateBuffer(VK_RESULT_MAX_ENUM, Device, CreateInfo, Buffer);
753 VkResult Result = VULKANAPINAMESPACE::vkCreateBuffer(Device, CreateInfo, Allocator, Buffer);
754 FWrapLayer::CreateBuffer(Result, Device, CreateInfo, Buffer);
755 return Result;
756 }
757
758 static FORCEINLINE_DEBUGGABLE void vkDestroyBuffer(VkDevice Device, VkBuffer Buffer, const VkAllocationCallbacks* Allocator)
759 {
760 FWrapLayer::DestroyBuffer(VK_RESULT_MAX_ENUM, Device, Buffer);
761 VULKANAPINAMESPACE::vkDestroyBuffer(Device, Buffer, Allocator);
762 FWrapLayer::DestroyBuffer(VK_SUCCESS, Device, Buffer);
763 }
764
765 static FORCEINLINE_DEBUGGABLE VkResult vkCreateBufferView(VkDevice Device, const VkBufferViewCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkBufferView* View)
766 {
767 FWrapLayer::CreateBufferView(VK_RESULT_MAX_ENUM, Device, CreateInfo, View);
768 VkResult Result = VULKANAPINAMESPACE::vkCreateBufferView(Device, CreateInfo, Allocator, View);
769 FWrapLayer::CreateBufferView(Result, Device, CreateInfo, View);
770 return Result;
771 }
772
773 static FORCEINLINE_DEBUGGABLE void vkDestroyBufferView(VkDevice Device, VkBufferView BufferView, const VkAllocationCallbacks* Allocator)
774 {
775 FWrapLayer::DestroyBufferView(VK_RESULT_MAX_ENUM, Device, BufferView);
776 VULKANAPINAMESPACE::vkDestroyBufferView(Device, BufferView, Allocator);
777 FWrapLayer::DestroyBufferView(VK_RESULT_MAX_ENUM, Device, BufferView);
778 }
779
780 static FORCEINLINE_DEBUGGABLE VkResult vkCreateImage(VkDevice Device, const VkImageCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkImage* Image)
781 {
782 FWrapLayer::CreateImage(VK_RESULT_MAX_ENUM, Device, CreateInfo, Image);
783 VkResult Result = VULKANAPINAMESPACE::vkCreateImage(Device, CreateInfo, Allocator, Image);
784 FWrapLayer::CreateImage(Result, Device, CreateInfo, Image);
785 return Result;
786 }
787
788 static FORCEINLINE_DEBUGGABLE void vkDestroyImage(VkDevice Device, VkImage Image, const VkAllocationCallbacks* Allocator)
789 {
790 FWrapLayer::DestroyImage(VK_RESULT_MAX_ENUM, Device, Image);
791 VULKANAPINAMESPACE::vkDestroyImage(Device, Image, Allocator);
792 FWrapLayer::DestroyImage(VK_SUCCESS, Device, Image);
793 }
794
795 static FORCEINLINE_DEBUGGABLE void vkGetImageSubresourceLayout(VkDevice Device, VkImage Image, const VkImageSubresource* Subresource, VkSubresourceLayout* Layout)
796 {
797 FWrapLayer::GetImageSubresourceLayout(VK_RESULT_MAX_ENUM, Device, Image, Subresource, Layout);
798 VULKANAPINAMESPACE::vkGetImageSubresourceLayout(Device, Image, Subresource, Layout);
799 FWrapLayer::GetImageSubresourceLayout(VK_SUCCESS, Device, Image, Subresource, Layout);
800 }
801
802 static FORCEINLINE_DEBUGGABLE void vkGetImageSubresourceLayout2KHR(VkDevice Device, VkImage Image, const VkImageSubresource2KHR* Subresource, VkSubresourceLayout2KHR* Layout)
803 {
804 FWrapLayer::GetImageSubresourceLayout2(VK_RESULT_MAX_ENUM, Device, Image, Subresource, Layout);
805 VULKANAPINAMESPACE::vkGetImageSubresourceLayout2KHR(Device, Image, Subresource, Layout);
806 FWrapLayer::GetImageSubresourceLayout2(VK_SUCCESS, Device, Image, Subresource, Layout);
807 }
808
809 static FORCEINLINE_DEBUGGABLE VkResult vkCreateImageView(VkDevice Device, const VkImageViewCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkImageView* View)
810 {
811 FWrapLayer::CreateImageView(VK_RESULT_MAX_ENUM, Device, CreateInfo, View);
812 VkResult Result = VULKANAPINAMESPACE::vkCreateImageView(Device, CreateInfo, Allocator, View);
813 FWrapLayer::CreateImageView(Result, Device, CreateInfo, View);
814 return Result;
815 }
816
817 static FORCEINLINE_DEBUGGABLE void vkDestroyImageView(VkDevice Device, VkImageView ImageView, const VkAllocationCallbacks* Allocator)
818 {
819 FWrapLayer::DestroyImageView(VK_RESULT_MAX_ENUM, Device, ImageView);
820 VULKANAPINAMESPACE::vkDestroyImageView(Device, ImageView, Allocator);
821 FWrapLayer::DestroyImageView(VK_SUCCESS, Device, ImageView);
822 }
823
824 static FORCEINLINE_DEBUGGABLE VkResult vkCreateShaderModule(VkDevice Device, const VkShaderModuleCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkShaderModule* ShaderModule)
825 {
826 FWrapLayer::CreateShaderModule(VK_RESULT_MAX_ENUM, Device, CreateInfo, ShaderModule);
827 VkResult Result = VULKANAPINAMESPACE::vkCreateShaderModule(Device, CreateInfo, Allocator, ShaderModule);
828 FWrapLayer::CreateShaderModule(Result, Device, CreateInfo, ShaderModule);
829 return Result;
830 }
831
832 static FORCEINLINE_DEBUGGABLE void vkDestroyShaderModule(VkDevice Device, VkShaderModule ShaderModule, const VkAllocationCallbacks* Allocator)
833 {
834 FWrapLayer::DestroyShaderModule(VK_RESULT_MAX_ENUM, Device, ShaderModule);
835 VULKANAPINAMESPACE::vkDestroyShaderModule(Device, ShaderModule, Allocator);
836 FWrapLayer::DestroyShaderModule(VK_SUCCESS, Device, ShaderModule);
837 }
838
839 static FORCEINLINE_DEBUGGABLE VkResult vkCreatePipelineCache(VkDevice Device, const VkPipelineCacheCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkPipelineCache* PipelineCache)
840 {
841 FWrapLayer::CreatePipelineCache(VK_RESULT_MAX_ENUM, Device, CreateInfo, PipelineCache);
842 VkResult Result = VULKANAPINAMESPACE::vkCreatePipelineCache(Device, CreateInfo, Allocator, PipelineCache);
843 FWrapLayer::CreatePipelineCache(Result, Device, CreateInfo, PipelineCache);
844 return Result;
845 }
846
847 static FORCEINLINE_DEBUGGABLE void vkDestroyPipelineCache(VkDevice Device, VkPipelineCache PipelineCache, const VkAllocationCallbacks* Allocator)
848 {
849 FWrapLayer::DestroyPipelineCache(VK_RESULT_MAX_ENUM, Device, PipelineCache);
850 VULKANAPINAMESPACE::vkDestroyPipelineCache(Device, PipelineCache, Allocator);
851 FWrapLayer::DestroyPipelineCache(VK_SUCCESS, Device, PipelineCache);
852 }
853
854 static FORCEINLINE_DEBUGGABLE VkResult vkGetPipelineCacheData(VkDevice Device, VkPipelineCache PipelineCache, size_t* DataSize, void* Data)
855 {
856 FWrapLayer::GetPipelineCacheData(VK_RESULT_MAX_ENUM, Device, PipelineCache, DataSize, Data);
857 VkResult Result = VULKANAPINAMESPACE::vkGetPipelineCacheData(Device, PipelineCache, DataSize, Data);
858 FWrapLayer::GetPipelineCacheData(Result, Device, PipelineCache, DataSize, Data);
859 return Result;
860 }
861
862 static FORCEINLINE_DEBUGGABLE VkResult vkMergePipelineCaches(VkDevice Device, VkPipelineCache DestCache, uint32 SourceCacheCount, const VkPipelineCache* SrcCaches)
863 {
864 FWrapLayer::MergePipelineCaches(VK_RESULT_MAX_ENUM, Device, DestCache, SourceCacheCount, SrcCaches);
865 VkResult Result = VULKANAPINAMESPACE::vkMergePipelineCaches(Device, DestCache, SourceCacheCount, SrcCaches);
866 FWrapLayer::MergePipelineCaches(Result, Device, DestCache, SourceCacheCount, SrcCaches);
867 return Result;
868 }
869
870 static FORCEINLINE_DEBUGGABLE VkResult vkCreateGraphicsPipelines(VkDevice Device, VkPipelineCache PipelineCache, uint32 CreateInfoCount, const VkGraphicsPipelineCreateInfo* CreateInfos, const VkAllocationCallbacks* Allocator, VkPipeline* Pipelines)
871 {
872 FWrapLayer::CreateGraphicsPipelines(VK_RESULT_MAX_ENUM, Device, PipelineCache, CreateInfoCount, CreateInfos, Pipelines);
873 VkResult Result = VULKANAPINAMESPACE::vkCreateGraphicsPipelines(Device, PipelineCache, CreateInfoCount, CreateInfos, Allocator, Pipelines);
874 FWrapLayer::CreateGraphicsPipelines(Result, Device, PipelineCache, CreateInfoCount, CreateInfos, Pipelines);
875 return Result;
876 }
877
878 static FORCEINLINE_DEBUGGABLE VkResult vkCreateComputePipelines(VkDevice Device, VkPipelineCache PipelineCache, uint32 CreateInfoCount, const VkComputePipelineCreateInfo* CreateInfos, const VkAllocationCallbacks* Allocator, VkPipeline* Pipelines)
879 {
880 FWrapLayer::CreateComputePipelines(VK_RESULT_MAX_ENUM, Device, PipelineCache, CreateInfoCount, CreateInfos, Pipelines);
881 VkResult Result = VULKANAPINAMESPACE::vkCreateComputePipelines(Device, PipelineCache, CreateInfoCount, CreateInfos, Allocator, Pipelines);
882 FWrapLayer::CreateComputePipelines(Result, Device, PipelineCache, CreateInfoCount, CreateInfos, Pipelines);
883 return Result;
884 }
885
886 static FORCEINLINE_DEBUGGABLE void vkDestroyPipeline(VkDevice Device, VkPipeline Pipeline, const VkAllocationCallbacks* Allocator)
887 {
888 FWrapLayer::DestroyPipeline(VK_RESULT_MAX_ENUM, Device, Pipeline);
889 VULKANAPINAMESPACE::vkDestroyPipeline(Device, Pipeline, Allocator);
890 FWrapLayer::DestroyPipeline(VK_SUCCESS, Device, Pipeline);
891 }
892
893 static FORCEINLINE_DEBUGGABLE VkResult vkCreatePipelineLayout(VkDevice Device, const VkPipelineLayoutCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkPipelineLayout* PipelineLayout)
894 {
895 FWrapLayer::CreatePipelineLayout(VK_RESULT_MAX_ENUM, Device, CreateInfo, PipelineLayout);
896 VkResult Result = VULKANAPINAMESPACE::vkCreatePipelineLayout(Device, CreateInfo, Allocator, PipelineLayout);
897 FWrapLayer::CreatePipelineLayout(Result, Device, CreateInfo, PipelineLayout);
898 return Result;
899 }
900
901 static FORCEINLINE_DEBUGGABLE void vkDestroyPipelineLayout(VkDevice Device, VkPipelineLayout PipelineLayout, const VkAllocationCallbacks* Allocator)
902 {
903 FWrapLayer::DestroyPipelineLayout(VK_RESULT_MAX_ENUM, Device, PipelineLayout);
904 VULKANAPINAMESPACE::vkDestroyPipelineLayout(Device, PipelineLayout, Allocator);
905 FWrapLayer::DestroyPipelineLayout(VK_SUCCESS, Device, PipelineLayout);
906 }
907
908 static FORCEINLINE_DEBUGGABLE VkResult vkCreateSampler(VkDevice Device, const VkSamplerCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkSampler* Sampler)
909 {
910 FWrapLayer::CreateSampler(VK_RESULT_MAX_ENUM, Device, CreateInfo, Sampler);
911 VkResult Result = VULKANAPINAMESPACE::vkCreateSampler(Device, CreateInfo, Allocator, Sampler);
912 FWrapLayer::CreateSampler(Result, Device, CreateInfo, Sampler);
913 return Result;
914 }
915
916 static FORCEINLINE_DEBUGGABLE void vkDestroySampler(VkDevice Device, VkSampler Sampler, const VkAllocationCallbacks* Allocator)
917 {
918 FWrapLayer::DestroySampler(VK_RESULT_MAX_ENUM, Device, Sampler);
919 VULKANAPINAMESPACE::vkDestroySampler(Device, Sampler, Allocator);
920 FWrapLayer::DestroySampler(VK_RESULT_MAX_ENUM, Device, Sampler);
921 }
922
923 static FORCEINLINE_DEBUGGABLE VkResult vkCreateDescriptorSetLayout(VkDevice Device, const VkDescriptorSetLayoutCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkDescriptorSetLayout* SetLayout)
924 {
925 FWrapLayer::CreateDescriptorSetLayout(VK_RESULT_MAX_ENUM, Device, CreateInfo, SetLayout);
926 VkResult Result = VULKANAPINAMESPACE::vkCreateDescriptorSetLayout(Device, CreateInfo, Allocator, SetLayout);
927 FWrapLayer::CreateDescriptorSetLayout(Result, Device, CreateInfo, SetLayout);
928 return Result;
929 }
930
931 static FORCEINLINE_DEBUGGABLE void vkDestroyDescriptorSetLayout(VkDevice Device, VkDescriptorSetLayout DescriptorSetLayout, const VkAllocationCallbacks* Allocator)
932 {
933 FWrapLayer::DestroyDescriptorSetLayout(VK_RESULT_MAX_ENUM, Device, DescriptorSetLayout);
934 VULKANAPINAMESPACE::vkDestroyDescriptorSetLayout(Device, DescriptorSetLayout, Allocator);
935 FWrapLayer::DestroyDescriptorSetLayout(VK_SUCCESS, Device, DescriptorSetLayout);
936 }
937
938 static FORCEINLINE_DEBUGGABLE VkResult vkCreateDescriptorPool(VkDevice Device, const VkDescriptorPoolCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkDescriptorPool* DescriptorPool)
939 {
940 FWrapLayer::CreateDescriptorPool(VK_RESULT_MAX_ENUM, Device, CreateInfo, DescriptorPool);
941 VkResult Result = VULKANAPINAMESPACE::vkCreateDescriptorPool(Device, CreateInfo, Allocator, DescriptorPool);
942 FWrapLayer::CreateDescriptorPool(Result, Device, CreateInfo, DescriptorPool);
943 return Result;
944 }
945
946 static FORCEINLINE_DEBUGGABLE void vkDestroyDescriptorPool(VkDevice Device, VkDescriptorPool DescriptorPool, const VkAllocationCallbacks* Allocator)
947 {
948 FWrapLayer::DestroyDescriptorPool(VK_RESULT_MAX_ENUM, Device, DescriptorPool);
949 VULKANAPINAMESPACE::vkDestroyDescriptorPool(Device, DescriptorPool, Allocator);
950 FWrapLayer::DestroyDescriptorPool(VK_SUCCESS, Device, DescriptorPool);
951 }
952
953 static FORCEINLINE_DEBUGGABLE VkResult vkResetDescriptorPool(VkDevice Device, VkDescriptorPool DescriptorPool, VkDescriptorPoolResetFlags Flags)
954 {
955 FWrapLayer::ResetDescriptorPool(VK_RESULT_MAX_ENUM, Device, DescriptorPool, Flags);
956 VkResult Result = VULKANAPINAMESPACE::vkResetDescriptorPool(Device, DescriptorPool, Flags);
957 FWrapLayer::ResetDescriptorPool(Result, Device, DescriptorPool, Flags);
958 return Result;
959 }
960
961 static FORCEINLINE_DEBUGGABLE VkResult vkAllocateDescriptorSets(VkDevice Device, const VkDescriptorSetAllocateInfo* AllocateInfo, VkDescriptorSet* DescriptorSets)
962 {
963 FWrapLayer::AllocateDescriptorSets(VK_RESULT_MAX_ENUM, Device, AllocateInfo, DescriptorSets);
964 VkResult Result = VULKANAPINAMESPACE::vkAllocateDescriptorSets(Device, AllocateInfo, DescriptorSets);
965 FWrapLayer::AllocateDescriptorSets(Result, Device, AllocateInfo, DescriptorSets);
966 return Result;
967 }
968
969 static FORCEINLINE_DEBUGGABLE VkResult vkFreeDescriptorSets(VkDevice Device, VkDescriptorPool DescriptorPool, uint32 DescriptorSetCount, const VkDescriptorSet* DescriptorSets)
970 {
971 FWrapLayer::FreeDescriptorSets(VK_RESULT_MAX_ENUM, Device, DescriptorPool, DescriptorSetCount, DescriptorSets);
972 VkResult Result = VULKANAPINAMESPACE::vkFreeDescriptorSets(Device, DescriptorPool, DescriptorSetCount, DescriptorSets);
973 FWrapLayer::FreeDescriptorSets(Result, Device, DescriptorPool, DescriptorSetCount, DescriptorSets);
974 return Result;
975 }
976
977 static FORCEINLINE_DEBUGGABLE void vkUpdateDescriptorSets(VkDevice Device, uint32 DescriptorWriteCount, const VkWriteDescriptorSet* DescriptorWrites, uint32 DescriptorCopyCount, const VkCopyDescriptorSet* DescriptorCopies)
978 {
979 FWrapLayer::UpdateDescriptorSets(VK_RESULT_MAX_ENUM, Device, DescriptorWriteCount, DescriptorWrites, DescriptorCopyCount, DescriptorCopies);
980 VULKANAPINAMESPACE::vkUpdateDescriptorSets(Device, DescriptorWriteCount, DescriptorWrites, DescriptorCopyCount, DescriptorCopies);
981 FWrapLayer::UpdateDescriptorSets(VK_SUCCESS, Device, DescriptorWriteCount, DescriptorWrites, DescriptorCopyCount, DescriptorCopies);
982 }
983
984 static FORCEINLINE_DEBUGGABLE VkResult vkCreateFramebuffer(VkDevice Device, const VkFramebufferCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkFramebuffer* Framebuffer)
985 {
986 FWrapLayer::CreateFramebuffer(VK_RESULT_MAX_ENUM, Device, CreateInfo, Framebuffer);
987 VkResult Result = VULKANAPINAMESPACE::vkCreateFramebuffer(Device, CreateInfo, Allocator, Framebuffer);
988 FWrapLayer::CreateFramebuffer(Result, Device, CreateInfo, Framebuffer);
989 return Result;
990 }
991
992 static FORCEINLINE_DEBUGGABLE void vkDestroyFramebuffer(VkDevice Device, VkFramebuffer Framebuffer, const VkAllocationCallbacks* Allocator)
993 {
994 FWrapLayer::DestroyFramebuffer(VK_RESULT_MAX_ENUM, Device, Framebuffer);
995 VULKANAPINAMESPACE::vkDestroyFramebuffer(Device, Framebuffer, Allocator);
996 FWrapLayer::DestroyFramebuffer(VK_SUCCESS, Device, Framebuffer);
997 }
998
999 static FORCEINLINE_DEBUGGABLE VkResult vkCreateRenderPass(VkDevice Device, const VkRenderPassCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkRenderPass* RenderPass)
1000 {
1001 FWrapLayer::CreateRenderPass(VK_RESULT_MAX_ENUM, Device, CreateInfo, RenderPass);
1002 VkResult Result = VULKANAPINAMESPACE::vkCreateRenderPass(Device, CreateInfo, Allocator, RenderPass);
1003 FWrapLayer::CreateRenderPass(Result, Device, CreateInfo, RenderPass);
1004 return Result;
1005 }
1006
1007 static FORCEINLINE_DEBUGGABLE VkResult vkCreateRenderPass2KHR(VkDevice Device, const VkRenderPassCreateInfo2* CreateInfo, const VkAllocationCallbacks* Allocator, VkRenderPass* RenderPass)
1008 {
1009 FWrapLayer::CreateRenderPass2KHR(VK_RESULT_MAX_ENUM, Device, CreateInfo, RenderPass);
1010 VkResult Result = VULKANAPINAMESPACE::vkCreateRenderPass2KHR(Device, CreateInfo, Allocator, RenderPass);
1011 FWrapLayer::CreateRenderPass2KHR(Result, Device, CreateInfo, RenderPass);
1012 return Result;
1013 }
1014
1015 static FORCEINLINE_DEBUGGABLE void vkDestroyRenderPass(VkDevice Device, VkRenderPass RenderPass, const VkAllocationCallbacks* Allocator)
1016 {
1017 FWrapLayer::DestroyRenderPass(VK_RESULT_MAX_ENUM, Device, RenderPass);
1018 VULKANAPINAMESPACE::vkDestroyRenderPass(Device, RenderPass, Allocator);
1019 FWrapLayer::DestroyRenderPass(VK_SUCCESS, Device, RenderPass);
1020 }
1021
1022 static FORCEINLINE_DEBUGGABLE void vkGetRenderAreaGranularity(VkDevice Device, VkRenderPass RenderPass, VkExtent2D* pGranularity)
1023 {
1024 FWrapLayer::GetRenderAreaGranularity(VK_RESULT_MAX_ENUM, Device, RenderPass, pGranularity);
1025 VULKANAPINAMESPACE::vkGetRenderAreaGranularity(Device, RenderPass, pGranularity);
1026 FWrapLayer::GetRenderAreaGranularity(VK_SUCCESS, Device, RenderPass, pGranularity);
1027 }
1028
1029 static FORCEINLINE_DEBUGGABLE VkResult vkCreateCommandPool(VkDevice Device, const VkCommandPoolCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkCommandPool* CommandPool)
1030 {
1031 FWrapLayer::CreateCommandPool(VK_RESULT_MAX_ENUM, Device, CreateInfo, CommandPool);
1032 VkResult Result = VULKANAPINAMESPACE::vkCreateCommandPool(Device, CreateInfo, Allocator, CommandPool);
1033 FWrapLayer::CreateCommandPool(Result, Device, CreateInfo, CommandPool);
1034 return Result;
1035 }
1036
1037 static FORCEINLINE_DEBUGGABLE void vkDestroyCommandPool(VkDevice Device, VkCommandPool CommandPool, const VkAllocationCallbacks* Allocator)
1038 {
1039 FWrapLayer::DestroyCommandPool(VK_RESULT_MAX_ENUM, Device, CommandPool);
1040 VULKANAPINAMESPACE::vkDestroyCommandPool(Device, CommandPool, Allocator);
1041 FWrapLayer::DestroyCommandPool(VK_SUCCESS, Device, CommandPool);
1042 }
1043
1044 static FORCEINLINE_DEBUGGABLE VkResult vkResetCommandPool(VkDevice Device, VkCommandPool CommandPool, VkCommandPoolResetFlags Flags)
1045 {
1046 FWrapLayer::ResetCommandPool(VK_RESULT_MAX_ENUM, Device, CommandPool, Flags);
1047 VkResult Result = VULKANAPINAMESPACE::vkResetCommandPool(Device, CommandPool, Flags);
1048 FWrapLayer::ResetCommandPool(Result, Device, CommandPool, Flags);
1049 return Result;
1050 }
1051
1052 static FORCEINLINE_DEBUGGABLE void vkTrimCommandPool(VkDevice Device, VkCommandPool CommandPool, VkCommandPoolTrimFlags Flags)
1053 {
1054 FWrapLayer::TrimCommandPool(VK_RESULT_MAX_ENUM, Device, CommandPool, Flags);
1055 VULKANAPINAMESPACE::vkTrimCommandPool(Device, CommandPool, Flags);
1056 FWrapLayer::TrimCommandPool(VK_SUCCESS, Device, CommandPool, Flags);
1057 }
1058
1059 static FORCEINLINE_DEBUGGABLE VkResult vkAllocateCommandBuffers(VkDevice Device, const VkCommandBufferAllocateInfo* AllocateInfo, VkCommandBuffer* CommandBuffers)
1060 {
1061 FWrapLayer::AllocateCommandBuffers(VK_RESULT_MAX_ENUM, Device, AllocateInfo, CommandBuffers);
1062 VkResult Result = VULKANAPINAMESPACE::vkAllocateCommandBuffers(Device, AllocateInfo, CommandBuffers);
1063 FWrapLayer::AllocateCommandBuffers(Result, Device, AllocateInfo, CommandBuffers);
1064 return Result;
1065 }
1066
1067 static FORCEINLINE_DEBUGGABLE void vkFreeCommandBuffers(VkDevice Device, VkCommandPool CommandPool, uint32 CommandBufferCount, const VkCommandBuffer* CommandBuffers)
1068 {
1069 FWrapLayer::FreeCommandBuffers(VK_RESULT_MAX_ENUM, Device, CommandPool, CommandBufferCount, CommandBuffers);
1070 VULKANAPINAMESPACE::vkFreeCommandBuffers(Device, CommandPool, CommandBufferCount, CommandBuffers);
1071 FWrapLayer::FreeCommandBuffers(VK_SUCCESS, Device, CommandPool, CommandBufferCount, CommandBuffers);
1072 }
1073
1074 static FORCEINLINE_DEBUGGABLE VkResult vkBeginCommandBuffer(VkCommandBuffer CommandBuffer, const VkCommandBufferBeginInfo* BeginInfo)
1075 {
1076 FWrapLayer::BeginCommandBuffer(VK_RESULT_MAX_ENUM, CommandBuffer, BeginInfo);
1077 VkResult Result = VULKANAPINAMESPACE::vkBeginCommandBuffer(CommandBuffer, BeginInfo);
1078 FWrapLayer::BeginCommandBuffer(Result, CommandBuffer, BeginInfo);
1079 return Result;
1080 }
1081
1082 static FORCEINLINE_DEBUGGABLE VkResult vkEndCommandBuffer(VkCommandBuffer CommandBuffer)
1083 {
1084 FWrapLayer::EndCommandBuffer(VK_RESULT_MAX_ENUM, CommandBuffer);
1085 VkResult Result = VULKANAPINAMESPACE::vkEndCommandBuffer(CommandBuffer);
1086 FWrapLayer::EndCommandBuffer(Result, CommandBuffer);
1087 return Result;
1088 }
1089
1090 static FORCEINLINE_DEBUGGABLE VkResult vkResetCommandBuffer(VkCommandBuffer CommandBuffer, VkCommandBufferResetFlags Flags)
1091 {
1092 FWrapLayer::ResetCommandBuffer(VK_RESULT_MAX_ENUM, CommandBuffer, Flags);
1093 VkResult Result = VULKANAPINAMESPACE::vkResetCommandBuffer(CommandBuffer, Flags);
1094 FWrapLayer::ResetCommandBuffer(Result, CommandBuffer, Flags);
1095 return Result;
1096 }
1097
1098 static FORCEINLINE_DEBUGGABLE void vkCmdBindPipeline(VkCommandBuffer CommandBuffer, VkPipelineBindPoint PipelineBindPoint, VkPipeline Pipeline)
1099 {
1100 FWrapLayer::CmdBindPipeline(VK_RESULT_MAX_ENUM, CommandBuffer, PipelineBindPoint, Pipeline);
1101 VULKANAPINAMESPACE::vkCmdBindPipeline(CommandBuffer, PipelineBindPoint, Pipeline);
1102 FWrapLayer::CmdBindPipeline(VK_SUCCESS, CommandBuffer, PipelineBindPoint, Pipeline);
1103 }
1104
1105 static FORCEINLINE_DEBUGGABLE void vkCmdSetViewport(VkCommandBuffer CommandBuffer, uint32 FirstViewport, uint32 ViewportCount, const VkViewport* Viewports)
1106 {
1107 FWrapLayer::CmdSetViewport(VK_RESULT_MAX_ENUM, CommandBuffer, FirstViewport, ViewportCount, Viewports);
1108 VULKANAPINAMESPACE::vkCmdSetViewport(CommandBuffer, FirstViewport, ViewportCount, Viewports);
1109 FWrapLayer::CmdSetViewport(VK_SUCCESS, CommandBuffer, FirstViewport, ViewportCount, Viewports);
1110 }
1111
1112 static FORCEINLINE_DEBUGGABLE void vkCmdSetScissor(VkCommandBuffer CommandBuffer, uint32 FirstScissor, uint32 ScissorCount, const VkRect2D* Scissors)
1113 {
1114 FWrapLayer::CmdSetScissor(VK_RESULT_MAX_ENUM, CommandBuffer, FirstScissor, ScissorCount, Scissors);
1115 VULKANAPINAMESPACE::vkCmdSetScissor(CommandBuffer, FirstScissor, ScissorCount, Scissors);
1116 FWrapLayer::CmdSetScissor(VK_SUCCESS, CommandBuffer, FirstScissor, ScissorCount, Scissors);
1117 }
1118
1119 static FORCEINLINE_DEBUGGABLE void vkCmdSetLineWidth(VkCommandBuffer CommandBuffer, float LineWidth)
1120 {
1121 FWrapLayer::CmdSetLineWidth(VK_RESULT_MAX_ENUM, CommandBuffer, LineWidth);
1122 VULKANAPINAMESPACE::vkCmdSetLineWidth(CommandBuffer, LineWidth);
1123 FWrapLayer::CmdSetLineWidth(VK_SUCCESS, CommandBuffer, LineWidth);
1124 }
1125
1126 static FORCEINLINE_DEBUGGABLE void vkCmdSetDepthBias(VkCommandBuffer CommandBuffer, float DepthBiasConstantFactor, float DepthBiasClamp, float DepthBiasSlopeFactor)
1127 {
1128 FWrapLayer::CmdSetDepthBias(VK_RESULT_MAX_ENUM, CommandBuffer, DepthBiasConstantFactor, DepthBiasClamp, DepthBiasSlopeFactor);
1129 VULKANAPINAMESPACE::vkCmdSetDepthBias(CommandBuffer, DepthBiasConstantFactor, DepthBiasClamp, DepthBiasSlopeFactor);
1130 FWrapLayer::CmdSetDepthBias(VK_SUCCESS, CommandBuffer, DepthBiasConstantFactor, DepthBiasClamp, DepthBiasSlopeFactor);
1131 }
1132
1133 static FORCEINLINE_DEBUGGABLE void vkCmdSetBlendConstants(VkCommandBuffer CommandBuffer, const float BlendConstants[4])
1134 {
1135 FWrapLayer::CmdSetBlendConstants(VK_RESULT_MAX_ENUM, CommandBuffer, BlendConstants);
1136 VULKANAPINAMESPACE::vkCmdSetBlendConstants(CommandBuffer, BlendConstants);
1137 FWrapLayer::CmdSetBlendConstants(VK_SUCCESS, CommandBuffer, BlendConstants);
1138 }
1139
1140 static FORCEINLINE_DEBUGGABLE void vkCmdSetDepthBounds(VkCommandBuffer CommandBuffer, float MinDepthBounds, float MaxDepthBounds)
1141 {
1142 FWrapLayer::CmdSetDepthBounds(VK_RESULT_MAX_ENUM, CommandBuffer, MinDepthBounds, MaxDepthBounds);
1143 VULKANAPINAMESPACE::vkCmdSetDepthBounds(CommandBuffer, MinDepthBounds, MaxDepthBounds);
1144 FWrapLayer::CmdSetDepthBounds(VK_SUCCESS, CommandBuffer, MinDepthBounds, MaxDepthBounds);
1145 }
1146
1147 static FORCEINLINE_DEBUGGABLE void vkCmdSetStencilCompareMask(VkCommandBuffer CommandBuffer, VkStencilFaceFlags FaceMask, uint32 CompareMask)
1148 {
1149 FWrapLayer::CmdSetStencilCompareMask(VK_RESULT_MAX_ENUM, CommandBuffer, FaceMask, CompareMask);
1150 VULKANAPINAMESPACE::vkCmdSetStencilCompareMask(CommandBuffer, FaceMask, CompareMask);
1151 FWrapLayer::CmdSetStencilCompareMask(VK_SUCCESS, CommandBuffer, FaceMask, CompareMask);
1152 }
1153
1154 static FORCEINLINE_DEBUGGABLE void vkCmdSetStencilWriteMask(VkCommandBuffer CommandBuffer, VkStencilFaceFlags FaceMask, uint32 WriteMask)
1155 {
1156 FWrapLayer::CmdSetStencilWriteMask(VK_RESULT_MAX_ENUM, CommandBuffer, FaceMask, WriteMask);
1157 VULKANAPINAMESPACE::vkCmdSetStencilWriteMask(CommandBuffer, FaceMask, WriteMask);
1158 FWrapLayer::CmdSetStencilWriteMask(VK_SUCCESS, CommandBuffer, FaceMask, WriteMask);
1159 }
1160
1161 static FORCEINLINE_DEBUGGABLE void vkCmdSetStencilReference(VkCommandBuffer CommandBuffer, VkStencilFaceFlags FaceMask, uint32 Reference)
1162 {
1163 FWrapLayer::CmdSetStencilReference(VK_RESULT_MAX_ENUM, CommandBuffer, FaceMask, Reference);
1164 VULKANAPINAMESPACE::vkCmdSetStencilReference(CommandBuffer, FaceMask, Reference);
1165 FWrapLayer::CmdSetStencilReference(VK_SUCCESS, CommandBuffer, FaceMask, Reference);
1166 }
1167
1168 static FORCEINLINE_DEBUGGABLE void vkCmdBindDescriptorSets(VkCommandBuffer CommandBuffer, VkPipelineBindPoint PipelineBindPoint, VkPipelineLayout Layout, uint32 FirstSet, uint32 DescriptorSetCount, const VkDescriptorSet* DescriptorSets, uint32 DynamicOffsetCount, const uint32* DynamicOffsets)
1169 {
1170 FWrapLayer::CmdBindDescriptorSets(VK_RESULT_MAX_ENUM, CommandBuffer, PipelineBindPoint, Layout, FirstSet, DescriptorSetCount, DescriptorSets, DynamicOffsetCount, DynamicOffsets);
1171 VULKANAPINAMESPACE::vkCmdBindDescriptorSets(CommandBuffer, PipelineBindPoint, Layout, FirstSet, DescriptorSetCount, DescriptorSets, DynamicOffsetCount, DynamicOffsets);
1172 FWrapLayer::CmdBindDescriptorSets(VK_SUCCESS, CommandBuffer, PipelineBindPoint, Layout, FirstSet, DescriptorSetCount, DescriptorSets, DynamicOffsetCount, DynamicOffsets);
1173 }
1174
1175 static FORCEINLINE_DEBUGGABLE void vkCmdBindIndexBuffer(VkCommandBuffer CommandBuffer, VkBuffer Buffer, VkDeviceSize Offset, VkIndexType IndexType)
1176 {
1177 FWrapLayer::CmdBindIndexBuffer(VK_RESULT_MAX_ENUM, CommandBuffer, Buffer, Offset, IndexType);
1178 VULKANAPINAMESPACE::vkCmdBindIndexBuffer(CommandBuffer, Buffer, Offset, IndexType);
1179 FWrapLayer::CmdBindIndexBuffer(VK_SUCCESS, CommandBuffer, Buffer, Offset, IndexType);
1180 }
1181
1182 static FORCEINLINE_DEBUGGABLE void vkCmdBindVertexBuffers(VkCommandBuffer CommandBuffer, uint32 FirstBinding, uint32 BindingCount, const VkBuffer* Buffers, const VkDeviceSize* Offsets)
1183 {
1184 FWrapLayer::CmdBindVertexBuffers(VK_RESULT_MAX_ENUM, CommandBuffer, FirstBinding, BindingCount, Buffers, Offsets);
1185 VULKANAPINAMESPACE::vkCmdBindVertexBuffers(CommandBuffer, FirstBinding, BindingCount, Buffers, Offsets);
1186 FWrapLayer::CmdBindVertexBuffers(VK_SUCCESS, CommandBuffer, FirstBinding, BindingCount, Buffers, Offsets);
1187 }
1188
1189 static FORCEINLINE_DEBUGGABLE void vkCmdDraw(VkCommandBuffer CommandBuffer, uint32 VertexCount, uint32 InstanceCount, uint32 FirstVertex, uint32 FirstInstance)
1190 {
1191 FWrapLayer::CmdDraw(VK_RESULT_MAX_ENUM, CommandBuffer, VertexCount, InstanceCount, FirstVertex, FirstInstance);
1192 VULKANAPINAMESPACE::vkCmdDraw(CommandBuffer, VertexCount, InstanceCount, FirstVertex, FirstInstance);
1193 FWrapLayer::CmdDraw(VK_SUCCESS, CommandBuffer, VertexCount, InstanceCount, FirstVertex, FirstInstance);
1194 }
1195
1196 static FORCEINLINE_DEBUGGABLE void vkCmdDrawIndexed(VkCommandBuffer CommandBuffer, uint32 IndexCount, uint32 InstanceCount, uint32 FirstIndex, int32_t VertexOffset, uint32 FirstInstance)
1197 {
1198 FWrapLayer::CmdDrawIndexed(VK_RESULT_MAX_ENUM, CommandBuffer, IndexCount, InstanceCount, FirstIndex, VertexOffset, FirstInstance);
1199 VULKANAPINAMESPACE::vkCmdDrawIndexed(CommandBuffer, IndexCount, InstanceCount, FirstIndex, VertexOffset, FirstInstance);
1200 FWrapLayer::CmdDrawIndexed(VK_SUCCESS, CommandBuffer, IndexCount, InstanceCount, FirstIndex, VertexOffset, FirstInstance);
1201 }
1202
1203 static FORCEINLINE_DEBUGGABLE void vkCmdDrawIndirect(VkCommandBuffer CommandBuffer, VkBuffer Buffer, VkDeviceSize Offset, uint32 DrawCount, uint32 Stride)
1204 {
1205 FWrapLayer::CmdDrawIndirect(VK_RESULT_MAX_ENUM, CommandBuffer, Buffer, Offset, DrawCount, Stride);
1206 VULKANAPINAMESPACE::vkCmdDrawIndirect(CommandBuffer, Buffer, Offset, DrawCount, Stride);
1207 FWrapLayer::CmdDrawIndirect(VK_SUCCESS, CommandBuffer, Buffer, Offset, DrawCount, Stride);
1208 }
1209
1210 static FORCEINLINE_DEBUGGABLE void vkCmdDrawIndexedIndirect(VkCommandBuffer CommandBuffer, VkBuffer Buffer, VkDeviceSize Offset, uint32 DrawCount, uint32 Stride)
1211 {
1212 FWrapLayer::CmdDrawIndexedIndirect(VK_RESULT_MAX_ENUM, CommandBuffer, Buffer, Offset, DrawCount, Stride);
1213 VULKANAPINAMESPACE::vkCmdDrawIndexedIndirect(CommandBuffer, Buffer, Offset, DrawCount, Stride);
1214 FWrapLayer::CmdDrawIndexedIndirect(VK_SUCCESS, CommandBuffer, Buffer, Offset, DrawCount, Stride);
1215 }
1216
1217 static FORCEINLINE_DEBUGGABLE void vkCmdDispatch(VkCommandBuffer CommandBuffer, uint32 X, uint32 Y, uint32 Z)
1218 {
1219 FWrapLayer::CmdDispatch(VK_RESULT_MAX_ENUM, CommandBuffer, X, Y, Z);
1220 VULKANAPINAMESPACE::vkCmdDispatch(CommandBuffer, X, Y, Z);
1221 FWrapLayer::CmdDispatch(VK_SUCCESS, CommandBuffer, X, Y, Z);
1222 }
1223
1224 static FORCEINLINE_DEBUGGABLE void vkCmdDispatchIndirect(VkCommandBuffer CommandBuffer, VkBuffer Buffer, VkDeviceSize Offset)
1225 {
1226 FWrapLayer::CmdDispatchIndirect(VK_RESULT_MAX_ENUM, CommandBuffer, Buffer, Offset);
1227 VULKANAPINAMESPACE::vkCmdDispatchIndirect(CommandBuffer, Buffer, Offset);
1228 FWrapLayer::CmdDispatchIndirect(VK_SUCCESS, CommandBuffer, Buffer, Offset);
1229 }
1230
1231 static FORCEINLINE_DEBUGGABLE void vkCmdCopyBuffer(VkCommandBuffer CommandBuffer, VkBuffer SrcBuffer, VkBuffer DstBuffer, uint32 RegionCount, const VkBufferCopy* Regions)
1232 {
1233 FWrapLayer::CmdCopyBuffer(VK_RESULT_MAX_ENUM, CommandBuffer, SrcBuffer, DstBuffer, RegionCount, Regions);
1234 VULKANAPINAMESPACE::vkCmdCopyBuffer(CommandBuffer, SrcBuffer, DstBuffer, RegionCount, Regions);
1235 FWrapLayer::CmdCopyBuffer(VK_SUCCESS, CommandBuffer, SrcBuffer, DstBuffer, RegionCount, Regions);
1236 }
1237
1238 static FORCEINLINE_DEBUGGABLE void vkCmdCopyImage(VkCommandBuffer CommandBuffer, VkImage SrcImage, VkImageLayout SrcImageLayout, VkImage DstImage, VkImageLayout DstImageLayout, uint32 RegionCount, const VkImageCopy* Regions)
1239 {
1240 FWrapLayer::CmdCopyImage(VK_RESULT_MAX_ENUM, CommandBuffer, SrcImage, SrcImageLayout, DstImage, DstImageLayout, RegionCount, Regions);
1241 VULKANAPINAMESPACE::vkCmdCopyImage(CommandBuffer, SrcImage, SrcImageLayout, DstImage, DstImageLayout, RegionCount, Regions);
1242 FWrapLayer::CmdCopyImage(VK_SUCCESS, CommandBuffer, SrcImage, SrcImageLayout, DstImage, DstImageLayout, RegionCount, Regions);
1243 }
1244
1245 static FORCEINLINE_DEBUGGABLE void vkCmdBlitImage(VkCommandBuffer CommandBuffer, VkImage SrcImage, VkImageLayout SrcImageLayout, VkImage DstImage, VkImageLayout DstImageLayout, uint32 RegionCount, const VkImageBlit* Regions, VkFilter Filter)
1246 {
1247 FWrapLayer::CmdBlitImage(VK_RESULT_MAX_ENUM, CommandBuffer, SrcImage, SrcImageLayout, DstImage, DstImageLayout, RegionCount, Regions, Filter);
1248 VULKANAPINAMESPACE::vkCmdBlitImage(CommandBuffer, SrcImage, SrcImageLayout, DstImage, DstImageLayout, RegionCount, Regions, Filter);
1249 FWrapLayer::CmdBlitImage(VK_SUCCESS, CommandBuffer, SrcImage, SrcImageLayout, DstImage, DstImageLayout, RegionCount, Regions, Filter);
1250 }
1251
1252 static FORCEINLINE_DEBUGGABLE void vkCmdCopyBufferToImage(VkCommandBuffer CommandBuffer, VkBuffer SrcBuffer, VkImage DstImage, VkImageLayout DstImageLayout, uint32 RegionCount, const VkBufferImageCopy* Regions)
1253 {
1254 FWrapLayer::CmdCopyBufferToImage(VK_RESULT_MAX_ENUM, CommandBuffer, SrcBuffer, DstImage, DstImageLayout, RegionCount, Regions);
1255 VULKANAPINAMESPACE::vkCmdCopyBufferToImage(CommandBuffer, SrcBuffer, DstImage, DstImageLayout, RegionCount, Regions);
1256 FWrapLayer::CmdCopyBufferToImage(VK_SUCCESS, CommandBuffer, SrcBuffer, DstImage, DstImageLayout, RegionCount, Regions);
1257 }
1258
1259 static FORCEINLINE_DEBUGGABLE void vkCmdCopyImageToBuffer(VkCommandBuffer CommandBuffer, VkImage SrcImage, VkImageLayout SrcImageLayout, VkBuffer DstBuffer, uint32 RegionCount, const VkBufferImageCopy* Regions)
1260 {
1261 FWrapLayer::CmdCopyImageToBuffer(VK_RESULT_MAX_ENUM, CommandBuffer, SrcImage, SrcImageLayout, DstBuffer, RegionCount, Regions);
1262 VULKANAPINAMESPACE::vkCmdCopyImageToBuffer(CommandBuffer, SrcImage, SrcImageLayout, DstBuffer, RegionCount, Regions);
1263 FWrapLayer::CmdCopyImageToBuffer(VK_SUCCESS, CommandBuffer, SrcImage, SrcImageLayout, DstBuffer, RegionCount, Regions);
1264 }
1265
1266 static FORCEINLINE_DEBUGGABLE void vkCmdUpdateBuffer(VkCommandBuffer CommandBuffer, VkBuffer DstBuffer, VkDeviceSize DstOffset, VkDeviceSize DataSize, const void* pData)
1267 {
1268 FWrapLayer::CmdUpdateBuffer(VK_RESULT_MAX_ENUM, CommandBuffer, DstBuffer, DstOffset, DataSize, pData);
1269 VULKANAPINAMESPACE::vkCmdUpdateBuffer(CommandBuffer, DstBuffer, DstOffset, DataSize, pData);
1270 FWrapLayer::CmdUpdateBuffer(VK_SUCCESS, CommandBuffer, DstBuffer, DstOffset, DataSize, pData);
1271 }
1272
1273 static FORCEINLINE_DEBUGGABLE void vkCmdFillBuffer(VkCommandBuffer CommandBuffer, VkBuffer DstBuffer, VkDeviceSize DstOffset, VkDeviceSize Size, uint32 Data)
1274 {
1275 FWrapLayer::CmdFillBuffer(VK_RESULT_MAX_ENUM, CommandBuffer, DstBuffer, DstOffset, Size, Data);
1276 VULKANAPINAMESPACE::vkCmdFillBuffer(CommandBuffer, DstBuffer, DstOffset, Size, Data);
1277 FWrapLayer::CmdFillBuffer(VK_SUCCESS, CommandBuffer, DstBuffer, DstOffset, Size, Data);
1278 }
1279
1280 static FORCEINLINE_DEBUGGABLE void vkCmdClearColorImage(VkCommandBuffer CommandBuffer, VkImage Image, VkImageLayout ImageLayout, const VkClearColorValue* Color, uint32 RangeCount, const VkImageSubresourceRange* Ranges)
1281 {
1282 FWrapLayer::CmdClearColorImage(VK_RESULT_MAX_ENUM, CommandBuffer, Image, ImageLayout, Color, RangeCount, Ranges);
1283 VULKANAPINAMESPACE::vkCmdClearColorImage(CommandBuffer, Image, ImageLayout, Color, RangeCount, Ranges);
1284 FWrapLayer::CmdClearColorImage(VK_SUCCESS, CommandBuffer, Image, ImageLayout, Color, RangeCount, Ranges);
1285 }
1286
1287 static FORCEINLINE_DEBUGGABLE void vkCmdClearDepthStencilImage(VkCommandBuffer CommandBuffer, VkImage Image, VkImageLayout ImageLayout, const VkClearDepthStencilValue* DepthStencil, uint32 RangeCount, const VkImageSubresourceRange* Ranges)
1288 {
1289 FWrapLayer::CmdClearDepthStencilImage(VK_RESULT_MAX_ENUM, CommandBuffer, Image, ImageLayout, DepthStencil, RangeCount, Ranges);
1290 VULKANAPINAMESPACE::vkCmdClearDepthStencilImage(CommandBuffer, Image, ImageLayout, DepthStencil, RangeCount, Ranges);
1291 FWrapLayer::CmdClearDepthStencilImage(VK_SUCCESS, CommandBuffer, Image, ImageLayout, DepthStencil, RangeCount, Ranges);
1292 }
1293
1294 static FORCEINLINE_DEBUGGABLE void vkCmdClearAttachments(VkCommandBuffer CommandBuffer, uint32 AttachmentCount, const VkClearAttachment* Attachments, uint32 RectCount, const VkClearRect* Rects)
1295 {
1296 FWrapLayer::CmdClearAttachments(VK_RESULT_MAX_ENUM, CommandBuffer, AttachmentCount, Attachments, RectCount, Rects);
1297 VULKANAPINAMESPACE::vkCmdClearAttachments(CommandBuffer, AttachmentCount, Attachments, RectCount, Rects);
1298 FWrapLayer::CmdClearAttachments(VK_SUCCESS, CommandBuffer, AttachmentCount, Attachments, RectCount, Rects);
1299 }
1300
1301 static FORCEINLINE_DEBUGGABLE void vkCmdResolveImage(
1302 VkCommandBuffer CommandBuffer,
1303 VkImage SrcImage, VkImageLayout SrcImageLayout,
1304 VkImage DstImage, VkImageLayout DstImageLayout,
1305 uint32 RegionCount, const VkImageResolve* Regions)
1306 {
1307 FWrapLayer::CmdResolveImage(VK_RESULT_MAX_ENUM, CommandBuffer, SrcImage, SrcImageLayout, DstImage, DstImageLayout, RegionCount, Regions);
1308 VULKANAPINAMESPACE::vkCmdResolveImage(CommandBuffer, SrcImage, SrcImageLayout, DstImage, DstImageLayout, RegionCount, Regions);
1309 FWrapLayer::CmdResolveImage(VK_SUCCESS, CommandBuffer, SrcImage, SrcImageLayout, DstImage, DstImageLayout, RegionCount, Regions);
1310 }
1311
1312 static FORCEINLINE_DEBUGGABLE void vkCmdSetEvent(VkCommandBuffer CommandBuffer, VkEvent Event, VkPipelineStageFlags StageMask)
1313 {
1314 FWrapLayer::CmdSetEvent(VK_RESULT_MAX_ENUM, CommandBuffer, Event, StageMask);
1315 VULKANAPINAMESPACE::vkCmdSetEvent(CommandBuffer, Event, StageMask);
1316 FWrapLayer::CmdSetEvent(VK_SUCCESS, CommandBuffer, Event, StageMask);
1317 }
1318
1319 static FORCEINLINE_DEBUGGABLE void vkCmdResetEvent(VkCommandBuffer CommandBuffer, VkEvent Event, VkPipelineStageFlags StageMask)
1320 {
1321 FWrapLayer::CmdResetEvent(VK_RESULT_MAX_ENUM, CommandBuffer, Event, StageMask);
1322 VULKANAPINAMESPACE::vkCmdResetEvent(CommandBuffer, Event, StageMask);
1323 FWrapLayer::CmdResetEvent(VK_SUCCESS, CommandBuffer, Event, StageMask);
1324 }
1325
1326 static FORCEINLINE_DEBUGGABLE void vkCmdWaitEvents(VkCommandBuffer CommandBuffer, uint32 EventCount, const VkEvent* Events,
1327 VkPipelineStageFlags SrcStageMask, VkPipelineStageFlags DstStageMask,
1328 uint32 MemoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
1329 uint32 BufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
1330 uint32 ImageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
1331 {
1332 FWrapLayer::CmdWaitEvents(VK_RESULT_MAX_ENUM, CommandBuffer, EventCount, Events, SrcStageMask, DstStageMask,
1333 MemoryBarrierCount, pMemoryBarriers, BufferMemoryBarrierCount, pBufferMemoryBarriers, ImageMemoryBarrierCount, pImageMemoryBarriers);
1334 VULKANAPINAMESPACE::vkCmdWaitEvents(CommandBuffer, EventCount, Events, SrcStageMask, DstStageMask, MemoryBarrierCount, pMemoryBarriers,
1335 BufferMemoryBarrierCount, pBufferMemoryBarriers, ImageMemoryBarrierCount, pImageMemoryBarriers);
1336 FWrapLayer::CmdWaitEvents(VK_SUCCESS, CommandBuffer, EventCount, Events, SrcStageMask, DstStageMask,
1337 MemoryBarrierCount, pMemoryBarriers, BufferMemoryBarrierCount, pBufferMemoryBarriers, ImageMemoryBarrierCount, pImageMemoryBarriers);
1338 }
1339
1340 static FORCEINLINE_DEBUGGABLE void vkCmdPipelineBarrier(
1341 VkCommandBuffer CommandBuffer, VkPipelineStageFlags SrcStageMask, VkPipelineStageFlags DstStageMask, VkDependencyFlags DependencyFlags,
1342 uint32 MemoryBarrierCount, const VkMemoryBarrier* MemoryBarriers,
1343 uint32 BufferMemoryBarrierCount, const VkBufferMemoryBarrier* BufferMemoryBarriers,
1344 uint32 ImageMemoryBarrierCount, const VkImageMemoryBarrier* ImageMemoryBarriers)
1345 {
1346 FWrapLayer::CmdPipelineBarrier(VK_RESULT_MAX_ENUM, CommandBuffer, SrcStageMask, DstStageMask, DependencyFlags, MemoryBarrierCount, MemoryBarriers, BufferMemoryBarrierCount, BufferMemoryBarriers, ImageMemoryBarrierCount, ImageMemoryBarriers);
1347 VULKANAPINAMESPACE::vkCmdPipelineBarrier(CommandBuffer, SrcStageMask, DstStageMask, DependencyFlags, MemoryBarrierCount, MemoryBarriers, BufferMemoryBarrierCount, BufferMemoryBarriers, ImageMemoryBarrierCount, ImageMemoryBarriers);
1348 FWrapLayer::CmdPipelineBarrier(VK_SUCCESS, CommandBuffer, SrcStageMask, DstStageMask, DependencyFlags, MemoryBarrierCount, MemoryBarriers, BufferMemoryBarrierCount, BufferMemoryBarriers, ImageMemoryBarrierCount, ImageMemoryBarriers);
1349 }
1350
1351 static FORCEINLINE_DEBUGGABLE void vkCmdBeginQuery(VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 Query, VkQueryControlFlags Flags)
1352 {
1353 FWrapLayer::CmdBeginQuery(VK_RESULT_MAX_ENUM, CommandBuffer, QueryPool, Query, Flags);
1354 VULKANAPINAMESPACE::vkCmdBeginQuery(CommandBuffer, QueryPool, Query, Flags);
1355 FWrapLayer::CmdBeginQuery(VK_SUCCESS, CommandBuffer, QueryPool, Query, Flags);
1356 }
1357
1358 static FORCEINLINE_DEBUGGABLE void vkCmdEndQuery(VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 Query)
1359 {
1360 FWrapLayer::CmdEndQuery(VK_RESULT_MAX_ENUM, CommandBuffer, QueryPool, Query);
1361 VULKANAPINAMESPACE::vkCmdEndQuery(CommandBuffer, QueryPool, Query);
1362 FWrapLayer::CmdEndQuery(VK_SUCCESS, CommandBuffer, QueryPool, Query);
1363 }
1364
1365 static FORCEINLINE_DEBUGGABLE void vkCmdResetQueryPool(VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 FirstQuery, uint32 QueryCount)
1366 {
1367 FWrapLayer::CmdResetQueryPool(VK_RESULT_MAX_ENUM, CommandBuffer, QueryPool, FirstQuery, QueryCount);
1368 VULKANAPINAMESPACE::vkCmdResetQueryPool(CommandBuffer, QueryPool, FirstQuery, QueryCount);
1369 FWrapLayer::CmdResetQueryPool(VK_SUCCESS, CommandBuffer, QueryPool, FirstQuery, QueryCount);
1370 }
1371
1372 static FORCEINLINE_DEBUGGABLE void vkCmdWriteTimestamp(VkCommandBuffer CommandBuffer, VkPipelineStageFlagBits PipelineStage, VkQueryPool QueryPool, uint32 Query)
1373 {
1374 FWrapLayer::CmdWriteTimestamp(VK_RESULT_MAX_ENUM, CommandBuffer, PipelineStage, QueryPool, Query);
1375 VULKANAPINAMESPACE::vkCmdWriteTimestamp(CommandBuffer, PipelineStage, QueryPool, Query);
1376 FWrapLayer::CmdWriteTimestamp(VK_SUCCESS, CommandBuffer, PipelineStage, QueryPool, Query);
1377 }
1378
1379 static FORCEINLINE_DEBUGGABLE void vkCmdCopyQueryPoolResults(VkCommandBuffer CommandBuffer, VkQueryPool QueryPool, uint32 FirstQuery, uint32 QueryCount,
1380 VkBuffer DstBuffer, VkDeviceSize DstOffset, VkDeviceSize Stride, VkQueryResultFlags Flags)
1381 {
1382 FWrapLayer::CmdCopyQueryPoolResults(VK_RESULT_MAX_ENUM, CommandBuffer, QueryPool, FirstQuery, QueryCount, DstBuffer, DstOffset, Stride, Flags);
1383 VULKANAPINAMESPACE::vkCmdCopyQueryPoolResults(CommandBuffer, QueryPool, FirstQuery, QueryCount, DstBuffer, DstOffset, Stride, Flags);
1384 FWrapLayer::CmdCopyQueryPoolResults(VK_SUCCESS, CommandBuffer, QueryPool, FirstQuery, QueryCount, DstBuffer, DstOffset, Stride, Flags);
1385 }
1386
1387 static FORCEINLINE_DEBUGGABLE void vkCmdPushConstants(VkCommandBuffer CommandBuffer, VkPipelineLayout Layout, VkShaderStageFlags StageFlags, uint32 Offset, uint32 Size, const void* pValues)
1388 {
1389 FWrapLayer::CmdPushConstants(VK_RESULT_MAX_ENUM, CommandBuffer, Layout, StageFlags, Offset, Size, pValues);
1390 VULKANAPINAMESPACE::vkCmdPushConstants(CommandBuffer, Layout, StageFlags, Offset, Size, pValues);
1391 FWrapLayer::CmdPushConstants(VK_SUCCESS, CommandBuffer, Layout, StageFlags, Offset, Size, pValues);
1392 }
1393
1394 static FORCEINLINE_DEBUGGABLE void vkCmdBeginRenderPass(VkCommandBuffer CommandBuffer, const VkRenderPassBeginInfo* RenderPassBegin, VkSubpassContents Contents)
1395 {
1396 FWrapLayer::CmdBeginRenderPass(VK_RESULT_MAX_ENUM, CommandBuffer, RenderPassBegin, Contents);
1397 VULKANAPINAMESPACE::vkCmdBeginRenderPass(CommandBuffer, RenderPassBegin, Contents);
1398 FWrapLayer::CmdBeginRenderPass(VK_SUCCESS, CommandBuffer, RenderPassBegin, Contents);
1399 }
1400
1401 static FORCEINLINE_DEBUGGABLE void vkCmdBeginRenderPass2KHR(VkCommandBuffer CommandBuffer, const VkRenderPassBeginInfo* RenderPassBegin, const VkSubpassBeginInfo* SubpassBeginInfo)
1402 {
1403 FWrapLayer::CmdBeginRenderPass2KHR(VK_RESULT_MAX_ENUM, CommandBuffer, RenderPassBegin, SubpassBeginInfo);
1404 VULKANAPINAMESPACE::vkCmdBeginRenderPass2KHR(CommandBuffer, RenderPassBegin, SubpassBeginInfo);
1405 FWrapLayer::CmdBeginRenderPass2KHR(VK_SUCCESS, CommandBuffer, RenderPassBegin, SubpassBeginInfo);
1406 }
1407
1408 static FORCEINLINE_DEBUGGABLE void vkCmdNextSubpass(VkCommandBuffer CommandBuffer, VkSubpassContents Contents)
1409 {
1410 FWrapLayer::CmdNextSubpass(VK_RESULT_MAX_ENUM, CommandBuffer, Contents);
1411 VULKANAPINAMESPACE::vkCmdNextSubpass(CommandBuffer, Contents);
1412 FWrapLayer::CmdNextSubpass(VK_SUCCESS, CommandBuffer, Contents);
1413 }
1414
1415 static FORCEINLINE_DEBUGGABLE void vkCmdEndRenderPass(VkCommandBuffer CommandBuffer)
1416 {
1417 FWrapLayer::CmdEndRenderPass(VK_RESULT_MAX_ENUM, CommandBuffer);
1418 VULKANAPINAMESPACE::vkCmdEndRenderPass(CommandBuffer);
1419 FWrapLayer::CmdEndRenderPass(VK_SUCCESS, CommandBuffer);
1420 }
1421
1422 static FORCEINLINE_DEBUGGABLE void vkCmdBeginRenderingKHR(VkCommandBuffer CommandBuffer, const VkRenderingInfo* RenderingInfo)
1423 {
1424 FWrapLayer::CmdBeginRenderingKHR(VK_RESULT_MAX_ENUM, CommandBuffer, RenderingInfo);
1425 VULKANAPINAMESPACE::vkCmdBeginRenderingKHR(CommandBuffer, RenderingInfo);
1426 FWrapLayer::CmdBeginRenderingKHR(VK_SUCCESS, CommandBuffer, RenderingInfo);
1427 }
1428
1429 static FORCEINLINE_DEBUGGABLE void vkCmdEndRenderingKHR(VkCommandBuffer CommandBuffer)
1430 {
1431 FWrapLayer::CmdEndRenderingKHR(VK_RESULT_MAX_ENUM, CommandBuffer);
1432 VULKANAPINAMESPACE::vkCmdEndRenderingKHR(CommandBuffer);
1433 FWrapLayer::CmdEndRenderingKHR(VK_SUCCESS, CommandBuffer);
1434 }
1435
1436 static FORCEINLINE_DEBUGGABLE void vkCmdExecuteCommands(VkCommandBuffer CommandBuffer, uint32 CommandBufferCount, const VkCommandBuffer* pCommandBuffers)
1437 {
1438 FWrapLayer::CmdExecuteCommands(VK_RESULT_MAX_ENUM, CommandBuffer, CommandBufferCount, pCommandBuffers);
1439 VULKANAPINAMESPACE::vkCmdExecuteCommands(CommandBuffer, CommandBufferCount, pCommandBuffers);
1440 FWrapLayer::CmdExecuteCommands(VK_SUCCESS, CommandBuffer, CommandBufferCount, pCommandBuffers);
1441 }
1442
1443 static FORCEINLINE_DEBUGGABLE VkResult vkCreateSwapchainKHR(VkDevice Device, const VkSwapchainCreateInfoKHR* CreateInfo, const VkAllocationCallbacks* Allocator, VkSwapchainKHR* Swapchain)
1444 {
1445 FWrapLayer::CreateSwapchainKHR(VK_RESULT_MAX_ENUM, Device, CreateInfo, Swapchain);
1446 VkResult Result = VULKANAPINAMESPACE::vkCreateSwapchainKHR(Device, CreateInfo, Allocator, Swapchain);
1447 FWrapLayer::CreateSwapchainKHR(Result, Device, CreateInfo, Swapchain);
1448 return Result;
1449 }
1450
1451 static FORCEINLINE_DEBUGGABLE void vkDestroySwapchainKHR(VkDevice Device, VkSwapchainKHR Swapchain, const VkAllocationCallbacks* Allocator)
1452 {
1453 FWrapLayer::DestroySwapchainKHR(VK_RESULT_MAX_ENUM, Device, Swapchain);
1454 VULKANAPINAMESPACE::vkDestroySwapchainKHR(Device, Swapchain, Allocator);
1455 FWrapLayer::DestroySwapchainKHR(VK_SUCCESS, Device, Swapchain);
1456 }
1457
1458 static FORCEINLINE_DEBUGGABLE VkResult vkGetSwapchainImagesKHR(VkDevice Device, VkSwapchainKHR Swapchain, uint32_t* SwapchainImageCount, VkImage* SwapchainImages)
1459 {
1460 FWrapLayer::GetSwapChainImagesKHR(VK_RESULT_MAX_ENUM, Device, Swapchain, SwapchainImageCount, SwapchainImages);
1461 VkResult Result = VULKANAPINAMESPACE::vkGetSwapchainImagesKHR(Device, Swapchain, SwapchainImageCount, SwapchainImages);
1462 FWrapLayer::GetSwapChainImagesKHR(Result, Device, Swapchain, SwapchainImageCount, SwapchainImages);
1463 return Result;
1464 }
1465
1466 static FORCEINLINE_DEBUGGABLE VkResult vkAcquireNextImageKHR(VkDevice Device, VkSwapchainKHR Swapchain, uint64_t Timeout, VkSemaphore Semaphore, VkFence Fence, uint32_t* ImageIndex)
1467 {
1468 FWrapLayer::AcquireNextImageKHR(VK_RESULT_MAX_ENUM, Device, Swapchain, Timeout, Semaphore, Fence, ImageIndex);
1469 VkResult Result = VULKANAPINAMESPACE::vkAcquireNextImageKHR(Device, Swapchain, Timeout, Semaphore, Fence, ImageIndex);
1470 FWrapLayer::AcquireNextImageKHR(Result, Device, Swapchain, Timeout, Semaphore, Fence, ImageIndex);
1471 return Result;
1472 }
1473
1474 static FORCEINLINE_DEBUGGABLE VkResult vkQueuePresentKHR(VkQueue Queue, const VkPresentInfoKHR* PresentInfo)
1475 {
1476 FWrapLayer::QueuePresent(VK_RESULT_MAX_ENUM, Queue, PresentInfo);
1477 VkResult Result = VULKANAPINAMESPACE::vkQueuePresentKHR(Queue, PresentInfo);
1478 FWrapLayer::QueuePresent(Result, Queue, PresentInfo);
1479 return Result;
1480 }
1481
1482 static FORCEINLINE_DEBUGGABLE VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice PhysicalDevice, VkSurfaceKHR Surface, VkSurfaceCapabilitiesKHR* SurfaceCapabilities)
1483 {
1484 FWrapLayer::GetPhysicalDeviceSurfaceCapabilitiesKHR(VK_RESULT_MAX_ENUM, PhysicalDevice, Surface, SurfaceCapabilities);
1485 VkResult Result = VULKANAPINAMESPACE::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(PhysicalDevice, Surface, SurfaceCapabilities);
1486 FWrapLayer::GetPhysicalDeviceSurfaceCapabilitiesKHR(VK_SUCCESS, PhysicalDevice, Surface, SurfaceCapabilities);
1487 return Result;
1488 }
1489
1490 static FORCEINLINE_DEBUGGABLE VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice PhysicalDevice, VkSurfaceKHR Surface, uint32_t* SurfaceFormatCountPtr, VkSurfaceFormatKHR* SurfaceFormats)
1491 {
1492 FWrapLayer::GetPhysicalDeviceSurfaceFormatsKHR(VK_RESULT_MAX_ENUM, PhysicalDevice, Surface, SurfaceFormatCountPtr, SurfaceFormats);
1493 VkResult Result = VULKANAPINAMESPACE::vkGetPhysicalDeviceSurfaceFormatsKHR(PhysicalDevice, Surface, SurfaceFormatCountPtr, SurfaceFormats);
1494 FWrapLayer::GetPhysicalDeviceSurfaceFormatsKHR(VK_SUCCESS, PhysicalDevice, Surface, SurfaceFormatCountPtr, SurfaceFormats);
1495 return Result;
1496 }
1497
1498 static FORCEINLINE_DEBUGGABLE VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice PhysicalDevice, uint32_t QueueFamilyIndex, VkSurfaceKHR Surface, VkBool32* SupportedPtr)
1499 {
1500 FWrapLayer::GetPhysicalDeviceSurfaceSupportKHR(VK_RESULT_MAX_ENUM, PhysicalDevice, QueueFamilyIndex, Surface, SupportedPtr);
1501 VkResult Result = VULKANAPINAMESPACE::vkGetPhysicalDeviceSurfaceSupportKHR(PhysicalDevice, QueueFamilyIndex, Surface, SupportedPtr);
1502 FWrapLayer::GetPhysicalDeviceSurfaceSupportKHR(VK_SUCCESS, PhysicalDevice, QueueFamilyIndex, Surface, SupportedPtr);
1503 return Result;
1504 }
1505
1506 static FORCEINLINE_DEBUGGABLE VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice PhysicalDevice, VkSurfaceKHR Surface, uint32_t* PresentModeCountPtr, VkPresentModeKHR* PresentModesPtr)
1507 {
1508 FWrapLayer::GetPhysicalDeviceSurfacePresentModesKHR(VK_RESULT_MAX_ENUM, PhysicalDevice, Surface, PresentModeCountPtr, PresentModesPtr);
1509 VkResult Result = VULKANAPINAMESPACE::vkGetPhysicalDeviceSurfacePresentModesKHR(PhysicalDevice, Surface, PresentModeCountPtr, PresentModesPtr);
1510 FWrapLayer::GetPhysicalDeviceSurfacePresentModesKHR(VK_SUCCESS, PhysicalDevice, Surface, PresentModeCountPtr, PresentModesPtr);
1511 return Result;
1512 }
1513
1514#if VULKAN_USE_CREATE_WIN32_SURFACE
1515 FORCEINLINE_DEBUGGABLE VkResult vkCreateWin32SurfaceKHR(VkInstance Instance, const VkWin32SurfaceCreateInfoKHR* CreateInfo, const VkAllocationCallbacks* Allocator, VkSurfaceKHR* Surface)
1516 {
1517 FWrapLayer::CreateWin32SurfaceKHR(VK_RESULT_MAX_ENUM, Instance, CreateInfo, Surface);
1518 VkResult Result = VULKANAPINAMESPACE::vkCreateWin32SurfaceKHR(Instance, CreateInfo, Allocator, Surface);
1519 FWrapLayer::CreateWin32SurfaceKHR(Result, Instance, CreateInfo, Surface);
1520 return Result;
1521 }
1522#endif
1523
1524#if VULKAN_USE_CREATE_ANDROID_SURFACE
1525 static FORCEINLINE_DEBUGGABLE VkResult vkCreateAndroidSurfaceKHR(VkInstance Instance, const VkAndroidSurfaceCreateInfoKHR* CreateInfo, const VkAllocationCallbacks* Allocator, VkSurfaceKHR* Surface)
1526 {
1527 FWrapLayer::CreateAndroidSurfaceKHR(VK_RESULT_MAX_ENUM, Instance, CreateInfo, Surface);
1528 VkResult Result = VULKANAPINAMESPACE::vkCreateAndroidSurfaceKHR(Instance, CreateInfo, Allocator, Surface);
1529 FWrapLayer::CreateAndroidSurfaceKHR(Result, Instance, CreateInfo, Surface);
1530 return Result;
1531 }
1532#endif
1533
1534 static FORCEINLINE_DEBUGGABLE void vkDestroySurfaceKHR(VkInstance Instance, VkSurfaceKHR Surface, const VkAllocationCallbacks* pAllocator)
1535 {
1536 FWrapLayer::DestroySurfaceKHR(VK_RESULT_MAX_ENUM, Instance, Surface);
1537 VULKANAPINAMESPACE::vkDestroySurfaceKHR(Instance, Surface, pAllocator);
1538 FWrapLayer::DestroySurfaceKHR(VK_SUCCESS, Instance, Surface);
1539 }
1540
1541 static FORCEINLINE_DEBUGGABLE void vkGetImageMemoryRequirements2(VkDevice Device, const VkImageMemoryRequirementsInfo2* Info, VkMemoryRequirements2* MemoryRequirements)
1542 {
1543 FWrapLayer::GetImageMemoryRequirements2(VK_RESULT_MAX_ENUM, Device, Info, MemoryRequirements);
1544 VULKANAPINAMESPACE::vkGetImageMemoryRequirements2(Device, Info, MemoryRequirements);
1545 FWrapLayer::GetImageMemoryRequirements2(VK_SUCCESS, Device, Info, MemoryRequirements);
1546 }
1547
1548 static FORCEINLINE_DEBUGGABLE void vkGetBufferMemoryRequirements2(VkDevice Device, const VkBufferMemoryRequirementsInfo2* Info, VkMemoryRequirements2* MemoryRequirements)
1549 {
1550 FWrapLayer::GetBufferMemoryRequirements2(VK_RESULT_MAX_ENUM, Device, Info, MemoryRequirements);
1551 VULKANAPINAMESPACE::vkGetBufferMemoryRequirements2(Device, Info, MemoryRequirements);
1552 FWrapLayer::GetBufferMemoryRequirements2(VK_SUCCESS, Device, Info, MemoryRequirements);
1553 }
1554
1555 static FORCEINLINE_DEBUGGABLE VkResult vkCreateAccelerationStructureKHR(VkDevice Device, const VkAccelerationStructureCreateInfoKHR* CreateInfo, const VkAllocationCallbacks* Allocator, VkAccelerationStructureKHR* AccelerationStructure)
1556 {
1557 FWrapLayer::CreateAccelerationStructureKHR(VK_RESULT_MAX_ENUM, Device, CreateInfo, Allocator, AccelerationStructure);
1558 const VkResult Result = VULKANAPINAMESPACE::vkCreateAccelerationStructureKHR(Device, CreateInfo, Allocator, AccelerationStructure);
1559 FWrapLayer::CreateAccelerationStructureKHR(Result, Device, CreateInfo, Allocator, AccelerationStructure);
1560 return Result;
1561 }
1562
1563 static FORCEINLINE_DEBUGGABLE void vkDestroyAccelerationStructureKHR(VkDevice Device, VkAccelerationStructureKHR AccelerationStructure, const VkAllocationCallbacks* Allocator)
1564 {
1565 FWrapLayer::DestroyAccelerationStructureKHR(VK_RESULT_MAX_ENUM, Device, AccelerationStructure, Allocator);
1566 VULKANAPINAMESPACE::vkDestroyAccelerationStructureKHR(Device, AccelerationStructure, Allocator);
1567 FWrapLayer::DestroyAccelerationStructureKHR(VK_SUCCESS, Device, AccelerationStructure, Allocator);
1568 }
1569
1570 static FORCEINLINE_DEBUGGABLE void vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer CommandBuffer, uint32 InfoCount, const VkAccelerationStructureBuildGeometryInfoKHR* Infos, const VkAccelerationStructureBuildRangeInfoKHR* const* BuildRangeInfos)
1571 {
1572 FWrapLayer::CmdBuildAccelerationStructuresKHR(VK_RESULT_MAX_ENUM, CommandBuffer, InfoCount, Infos, BuildRangeInfos);
1573 VULKANAPINAMESPACE::vkCmdBuildAccelerationStructuresKHR(CommandBuffer, InfoCount, Infos, BuildRangeInfos);
1574 FWrapLayer::CmdBuildAccelerationStructuresKHR(VK_SUCCESS, CommandBuffer, InfoCount, Infos, BuildRangeInfos);
1575 }
1576
1577 static FORCEINLINE_DEBUGGABLE void vkGetAccelerationStructureBuildSizesKHR(VkDevice Device, VkAccelerationStructureBuildTypeKHR BuildType, const VkAccelerationStructureBuildGeometryInfoKHR* BuildInfo, const uint32* MaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* SizeInfo)
1578 {
1579 FWrapLayer::GetAccelerationStructureBuildSizesKHR(VK_RESULT_MAX_ENUM, Device, BuildType, BuildInfo, MaxPrimitiveCounts, SizeInfo);
1580 VULKANAPINAMESPACE::vkGetAccelerationStructureBuildSizesKHR(Device, BuildType, BuildInfo, MaxPrimitiveCounts, SizeInfo);
1581 FWrapLayer::GetAccelerationStructureBuildSizesKHR(VK_SUCCESS, Device, BuildType, BuildInfo, MaxPrimitiveCounts, SizeInfo);
1582 }
1583
1584 static FORCEINLINE_DEBUGGABLE VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(VkDevice Device, const VkAccelerationStructureDeviceAddressInfoKHR* Info)
1585 {
1586 FWrapLayer::GetAccelerationStructureDeviceAddressKHR(VK_RESULT_MAX_ENUM, Device, Info);
1587 VkDeviceAddress Result = VULKANAPINAMESPACE::vkGetAccelerationStructureDeviceAddressKHR(Device, Info);
1588 FWrapLayer::GetAccelerationStructureDeviceAddressKHR(VK_SUCCESS, Device, Info);
1589 return Result;
1590 }
1591
1592 static FORCEINLINE_DEBUGGABLE void vkCmdTraceRaysKHR(VkCommandBuffer CommandBuffer, const VkStridedDeviceAddressRegionKHR* RaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* MissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* HitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* CallableShaderBindingTable, uint32 width, uint32 height, uint32 depth)
1593 {
1594 FWrapLayer::CmdTraceRaysKHR(VK_RESULT_MAX_ENUM, CommandBuffer, RaygenShaderBindingTable, MissShaderBindingTable, HitShaderBindingTable, CallableShaderBindingTable, width, height, depth);
1595 VULKANAPINAMESPACE::vkCmdTraceRaysKHR(CommandBuffer, RaygenShaderBindingTable, MissShaderBindingTable, HitShaderBindingTable, CallableShaderBindingTable, width, height, depth);
1596 FWrapLayer::CmdTraceRaysKHR(VK_SUCCESS, CommandBuffer, RaygenShaderBindingTable, MissShaderBindingTable, HitShaderBindingTable, CallableShaderBindingTable, width, height, depth);
1597 }
1598
1599 static FORCEINLINE_DEBUGGABLE void vkCmdTraceRaysIndirectKHR(VkCommandBuffer CommandBuffer, const VkStridedDeviceAddressRegionKHR* RaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* MissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* HitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* CallableShaderBindingTable, VkDeviceAddress IndirectDeviceAddress)
1600 {
1601 FWrapLayer::CmdTraceRaysIndirectKHR(VK_RESULT_MAX_ENUM, CommandBuffer, RaygenShaderBindingTable, MissShaderBindingTable, HitShaderBindingTable, CallableShaderBindingTable, IndirectDeviceAddress);
1602 VULKANAPINAMESPACE::vkCmdTraceRaysIndirectKHR(CommandBuffer, RaygenShaderBindingTable, MissShaderBindingTable, HitShaderBindingTable, CallableShaderBindingTable, IndirectDeviceAddress);
1603 FWrapLayer::CmdTraceRaysIndirectKHR(VK_SUCCESS, CommandBuffer, RaygenShaderBindingTable, MissShaderBindingTable, HitShaderBindingTable, CallableShaderBindingTable, IndirectDeviceAddress);
1604 }
1605
1606 static FORCEINLINE_DEBUGGABLE void vkCmdTraceRaysIndirect2KHR(VkCommandBuffer CommandBuffer, VkDeviceAddress IndirectDeviceAddress)
1607 {
1608 FWrapLayer::CmdTraceRaysIndirect2KHR(VK_RESULT_MAX_ENUM, CommandBuffer, IndirectDeviceAddress);
1609 VULKANAPINAMESPACE::vkCmdTraceRaysIndirect2KHR(CommandBuffer, IndirectDeviceAddress);
1610 FWrapLayer::CmdTraceRaysIndirect2KHR(VK_SUCCESS, CommandBuffer, IndirectDeviceAddress);
1611 }
1612
1613 static FORCEINLINE_DEBUGGABLE VkResult vkCreateRayTracingPipelinesKHR(VkDevice Device, VkDeferredOperationKHR DeferredOperation, VkPipelineCache PipelineCache, uint32_t CreateInfoCount, const VkRayTracingPipelineCreateInfoKHR* CreateInfos, const VkAllocationCallbacks* Allocator, VkPipeline* Pipelines)
1614 {
1615 FWrapLayer::CreateRayTracingPipelinesKHR(VK_RESULT_MAX_ENUM, Device, DeferredOperation, PipelineCache, CreateInfoCount, CreateInfos, Allocator, Pipelines);
1616 const VkResult Result = VULKANAPINAMESPACE::vkCreateRayTracingPipelinesKHR(Device, DeferredOperation, PipelineCache, CreateInfoCount, CreateInfos, Allocator, Pipelines);
1617 FWrapLayer::CreateRayTracingPipelinesKHR(Result, Device, DeferredOperation, PipelineCache, CreateInfoCount, CreateInfos, Allocator, Pipelines);
1618 return Result;
1619 }
1620
1621 static FORCEINLINE_DEBUGGABLE VkResult vkGetRayTracingShaderGroupHandlesKHR(VkDevice Device, VkPipeline Pipeline, uint32_t FirstGroup, uint32_t GroupCount, size_t DataSize, void* Data)
1622 {
1623 FWrapLayer::GetRayTracingShaderGroupHandlesKHR(VK_RESULT_MAX_ENUM, Device, Pipeline, FirstGroup, GroupCount, DataSize, Data);
1624 const VkResult Result = VULKANAPINAMESPACE::vkGetRayTracingShaderGroupHandlesKHR(Device, Pipeline, FirstGroup, GroupCount, DataSize, Data);
1625 FWrapLayer::GetRayTracingShaderGroupHandlesKHR(Result, Device, Pipeline, FirstGroup, GroupCount, DataSize, Data);
1626 return Result;
1627 }
1628
1629 static FORCEINLINE_DEBUGGABLE void vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer CommandBuffer, uint32_t AccelerationStructureCount, const VkAccelerationStructureKHR* AccelerationStructures, VkQueryType QueryType, VkQueryPool QueryPool, uint32_t FirstQuery)
1630 {
1631 FWrapLayer::CmdWriteAccelerationStructuresPropertiesKHR(VK_RESULT_MAX_ENUM, CommandBuffer, AccelerationStructureCount, AccelerationStructures, QueryType, QueryPool, FirstQuery);
1632 VULKANAPINAMESPACE::vkCmdWriteAccelerationStructuresPropertiesKHR(CommandBuffer, AccelerationStructureCount, AccelerationStructures, QueryType, QueryPool, FirstQuery);
1633 FWrapLayer::CmdWriteAccelerationStructuresPropertiesKHR(VK_SUCCESS, CommandBuffer, AccelerationStructureCount, AccelerationStructures, QueryType, QueryPool, FirstQuery);
1634 }
1635
1636 static FORCEINLINE_DEBUGGABLE void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer CommandBuffer, const VkCopyAccelerationStructureInfoKHR* Info)
1637 {
1638 FWrapLayer::CmdCopyAccelerationStructureKHR(VK_RESULT_MAX_ENUM, CommandBuffer, Info);
1639 VULKANAPINAMESPACE::vkCmdCopyAccelerationStructureKHR(CommandBuffer, Info);
1640 FWrapLayer::CmdCopyAccelerationStructureKHR(VK_SUCCESS, CommandBuffer, Info);
1641 }
1642
1643 static FORCEINLINE_DEBUGGABLE VkDeviceAddress vkGetBufferDeviceAddressKHR(VkDevice Device, const VkBufferDeviceAddressInfo* Info)
1644 {
1645 FWrapLayer::GetBufferDeviceAddressKHR(VK_RESULT_MAX_ENUM, Device, Info);
1646 const VkDeviceAddress Result = VULKANAPINAMESPACE::vkGetBufferDeviceAddressKHR(Device, Info);
1647 FWrapLayer::GetBufferDeviceAddressKHR(VK_SUCCESS, Device, Info);
1648 return Result;
1649 }
1650
1651 static FORCEINLINE_DEBUGGABLE void vkGetDeviceImageMemoryRequirementsKHR(VkDevice Device, const VkDeviceImageMemoryRequirements* Info, VkMemoryRequirements2* MemoryRequirements)
1652 {
1653 FWrapLayer::GetDeviceImageMemoryRequirementsKHR(VK_RESULT_MAX_ENUM, Device, Info, MemoryRequirements);
1654 VULKANAPINAMESPACE::vkGetDeviceImageMemoryRequirementsKHR(Device, Info, MemoryRequirements);
1655 FWrapLayer::GetDeviceImageMemoryRequirementsKHR(VK_SUCCESS, Device, Info, MemoryRequirements);
1656 }
1657
1658 static FORCEINLINE_DEBUGGABLE void vkGetDeviceBufferMemoryRequirementsKHR(VkDevice Device, const VkDeviceBufferMemoryRequirements* Info, VkMemoryRequirements2* MemoryRequirements)
1659 {
1660 FWrapLayer::GetDeviceBufferMemoryRequirementsKHR(VK_RESULT_MAX_ENUM, Device, Info, MemoryRequirements);
1661 VULKANAPINAMESPACE::vkGetDeviceBufferMemoryRequirementsKHR(Device, Info, MemoryRequirements);
1662 FWrapLayer::GetDeviceBufferMemoryRequirementsKHR(VK_SUCCESS, Device, Info, MemoryRequirements);
1663 }
1664
1665 static FORCEINLINE_DEBUGGABLE void vkResetQueryPoolEXT(VkDevice Device, VkQueryPool QueryPool, uint32_t FirstQuery, uint32_t QueryCount)
1666 {
1667 FWrapLayer::ResetQueryPoolEXT(VK_RESULT_MAX_ENUM, Device, QueryPool, FirstQuery, QueryCount);
1668 VULKANAPINAMESPACE::vkResetQueryPoolEXT(Device, QueryPool, FirstQuery, QueryCount);
1669 FWrapLayer::ResetQueryPoolEXT(VK_SUCCESS, Device, QueryPool, FirstQuery, QueryCount);
1670 }
1671
1672 static FORCEINLINE_DEBUGGABLE VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice PhysicalDevice, uint32_t* TimeDomainCount, VkTimeDomainEXT* TimeDomains)
1673 {
1674 FWrapLayer::GetPhysicalDeviceCalibrateableTimeDomainsEXT(VK_RESULT_MAX_ENUM, PhysicalDevice, TimeDomainCount, TimeDomains);
1675 const VkResult Result = VULKANAPINAMESPACE::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(PhysicalDevice, TimeDomainCount, TimeDomains);
1676 FWrapLayer::GetPhysicalDeviceCalibrateableTimeDomainsEXT(Result, PhysicalDevice, TimeDomainCount, TimeDomains);
1677 return Result;
1678 }
1679
1680 static FORCEINLINE_DEBUGGABLE VkResult vkGetCalibratedTimestampsEXT(VkDevice Device, uint32_t TimestampCount, const VkCalibratedTimestampInfoEXT* TimestampInfos, uint64_t* Timestamps, uint64_t* MaxDeviation)
1681 {
1682 FWrapLayer::GetCalibratedTimestampsEXT(VK_RESULT_MAX_ENUM, Device, TimestampCount, TimestampInfos, Timestamps, MaxDeviation);
1683 const VkResult Result = VULKANAPINAMESPACE::vkGetCalibratedTimestampsEXT(Device, TimestampCount, TimestampInfos, Timestamps, MaxDeviation);
1684 FWrapLayer::GetCalibratedTimestampsEXT(Result, Device, TimestampCount, TimestampInfos, Timestamps, MaxDeviation);
1685 return Result;
1686 }
1687
1688 static FORCEINLINE_DEBUGGABLE VkResult vkBindBufferMemory2(VkDevice Device, uint32_t BindInfoCount, const VkBindBufferMemoryInfo* BindInfos)
1689 {
1690 FWrapLayer::BindBufferMemory2(VK_RESULT_MAX_ENUM, Device, BindInfoCount, BindInfos);
1691 const VkResult Result = VULKANAPINAMESPACE::vkBindBufferMemory2(Device, BindInfoCount, BindInfos);
1692 FWrapLayer::BindBufferMemory2(Result, Device, BindInfoCount, BindInfos);
1693 return Result;
1694 }
1695
1696 static FORCEINLINE_DEBUGGABLE VkResult vkBindImageMemory2(VkDevice Device, uint32_t BindInfoCount, const VkBindImageMemoryInfo* BindInfos)
1697 {
1698 FWrapLayer::BindImageMemory2(VK_RESULT_MAX_ENUM, Device, BindInfoCount, BindInfos);
1699 const VkResult Result = VULKANAPINAMESPACE::vkBindImageMemory2(Device, BindInfoCount, BindInfos);
1700 FWrapLayer::BindImageMemory2(Result, Device, BindInfoCount, BindInfos);
1701 return Result;
1702 }
1703
1704 static FORCEINLINE_DEBUGGABLE void vkCmdPipelineBarrier2KHR(VkCommandBuffer CommandBuffer, const VkDependencyInfo* DependencyInfo)
1705 {
1706 FWrapLayer::CmdPipelineBarrier2KHR(VK_RESULT_MAX_ENUM, CommandBuffer, DependencyInfo);
1707 VULKANAPINAMESPACE::vkCmdPipelineBarrier2KHR(CommandBuffer, DependencyInfo);
1708 FWrapLayer::CmdPipelineBarrier2KHR(VK_SUCCESS, CommandBuffer, DependencyInfo);
1709 }
1710
1711 static FORCEINLINE_DEBUGGABLE void vkCmdResetEvent2KHR(VkCommandBuffer CommandBuffer, VkEvent Event, VkPipelineStageFlags2 StageMask)
1712 {
1713 FWrapLayer::CmdResetEvent2KHR(VK_RESULT_MAX_ENUM, CommandBuffer, Event, StageMask);
1714 VULKANAPINAMESPACE::vkCmdResetEvent2KHR(CommandBuffer, Event, StageMask);
1715 FWrapLayer::CmdResetEvent2KHR(VK_SUCCESS, CommandBuffer, Event, StageMask);
1716 }
1717
1718 static FORCEINLINE_DEBUGGABLE void vkCmdSetEvent2KHR(VkCommandBuffer CommandBuffer, VkEvent Event, const VkDependencyInfo* DependencyInfo)
1719 {
1720 FWrapLayer::CmdSetEvent2KHR(VK_RESULT_MAX_ENUM, CommandBuffer, Event, DependencyInfo);
1721 VULKANAPINAMESPACE::vkCmdSetEvent2KHR(CommandBuffer, Event, DependencyInfo);
1722 FWrapLayer::CmdSetEvent2KHR(VK_SUCCESS, CommandBuffer, Event, DependencyInfo);
1723 }
1724
1725 static FORCEINLINE_DEBUGGABLE void vkCmdWaitEvents2KHR(VkCommandBuffer CommandBuffer, uint32_t EventCount, const VkEvent* Events, const VkDependencyInfo* DependencyInfos)
1726 {
1727 FWrapLayer::CmdWaitEvents2KHR(VK_RESULT_MAX_ENUM, CommandBuffer, EventCount, Events, DependencyInfos);
1728 VULKANAPINAMESPACE::vkCmdWaitEvents2KHR(CommandBuffer, EventCount, Events, DependencyInfos);
1729 FWrapLayer::CmdWaitEvents2KHR(VK_SUCCESS, CommandBuffer, EventCount, Events, DependencyInfos);
1730 }
1731
1732 static FORCEINLINE_DEBUGGABLE void vkQueueSubmit2KHR(VkQueue Queue, uint32_t SubmitCount, const VkSubmitInfo2* Submits, VkFence Fence)
1733 {
1734 FWrapLayer::QueueSubmit2KHR(VK_RESULT_MAX_ENUM, Queue, SubmitCount, Submits, Fence);
1735 VULKANAPINAMESPACE::vkQueueSubmit2KHR(Queue, SubmitCount, Submits, Fence);
1736 FWrapLayer::QueueSubmit2KHR(VK_SUCCESS, Queue, SubmitCount, Submits, Fence);
1737 }
1738
1739 static FORCEINLINE_DEBUGGABLE void vkGetDescriptorSetLayoutSizeEXT(VkDevice Device, VkDescriptorSetLayout Layout, VkDeviceSize* OutLayoutSizeInBytes)
1740 {
1741 FWrapLayer::GetDescriptorSetLayoutSizeEXT(VK_RESULT_MAX_ENUM, Device, Layout, OutLayoutSizeInBytes);
1742 VULKANAPINAMESPACE::vkGetDescriptorSetLayoutSizeEXT(Device, Layout, OutLayoutSizeInBytes);
1743 FWrapLayer::GetDescriptorSetLayoutSizeEXT(VK_SUCCESS, Device, Layout, OutLayoutSizeInBytes);
1744 }
1745
1746 static FORCEINLINE_DEBUGGABLE void vkGetDescriptorSetLayoutBindingOffsetEXT(VkDevice Device, VkDescriptorSetLayout Layout, uint32_t Binding, VkDeviceSize* Offset)
1747 {
1748 FWrapLayer::GetDescriptorSetLayoutBindingOffsetEXT(VK_RESULT_MAX_ENUM, Device, Layout, Binding, Offset);
1749 VULKANAPINAMESPACE::vkGetDescriptorSetLayoutBindingOffsetEXT(Device, Layout, Binding, Offset);
1750 FWrapLayer::GetDescriptorSetLayoutBindingOffsetEXT(VK_SUCCESS, Device, Layout, Binding, Offset);
1751 }
1752
1753 static FORCEINLINE_DEBUGGABLE void vkCmdBindDescriptorBuffersEXT(VkCommandBuffer CommandBuffer, uint32_t BufferCount, const VkDescriptorBufferBindingInfoEXT* BindingInfos)
1754 {
1755 FWrapLayer::CmdBindDescriptorBuffersEXT(VK_RESULT_MAX_ENUM, CommandBuffer, BufferCount, BindingInfos);
1756 VULKANAPINAMESPACE::vkCmdBindDescriptorBuffersEXT(CommandBuffer, BufferCount, BindingInfos);
1757 FWrapLayer::CmdBindDescriptorBuffersEXT(VK_SUCCESS, CommandBuffer, BufferCount, BindingInfos);
1758 }
1759
1760 static FORCEINLINE_DEBUGGABLE void vkCmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer CommandBuffer, VkPipelineBindPoint PipelineBindPoint, VkPipelineLayout Layout, uint32_t FirstSet, uint32_t SetCount, const uint32_t* BufferIndices, const VkDeviceSize* Offsets)
1761 {
1762 FWrapLayer::CmdSetDescriptorBufferOffsetsEXT(VK_RESULT_MAX_ENUM, CommandBuffer, PipelineBindPoint, Layout, FirstSet, SetCount, BufferIndices, Offsets);
1763 VULKANAPINAMESPACE::vkCmdSetDescriptorBufferOffsetsEXT(CommandBuffer, PipelineBindPoint, Layout, FirstSet, SetCount, BufferIndices, Offsets);
1764 FWrapLayer::CmdSetDescriptorBufferOffsetsEXT(VK_SUCCESS, CommandBuffer, PipelineBindPoint, Layout, FirstSet, SetCount, BufferIndices, Offsets);
1765 }
1766
1767 static FORCEINLINE_DEBUGGABLE void vkGetDescriptorEXT(VkDevice Device, const VkDescriptorGetInfoEXT* DescriptorInfo, size_t DataSize, void* Descriptor)
1768 {
1769 FWrapLayer::GetDescriptorEXT(VK_RESULT_MAX_ENUM, Device, DescriptorInfo, DataSize, Descriptor);
1770 VULKANAPINAMESPACE::vkGetDescriptorEXT(Device, DescriptorInfo, DataSize, Descriptor);
1771 FWrapLayer::GetDescriptorEXT(VK_SUCCESS, Device, DescriptorInfo, DataSize, Descriptor);
1772 }
1773
1774 static FORCEINLINE_DEBUGGABLE VkResult vkCreateDeferredOperationKHR(VkDevice Device, const VkAllocationCallbacks* Allocator, VkDeferredOperationKHR* DeferredOperation)
1775 {
1776 FWrapLayer::CreateDeferredOperationKHR(VK_RESULT_MAX_ENUM, Device, Allocator, DeferredOperation);
1777 VkResult Result = VULKANAPINAMESPACE::vkCreateDeferredOperationKHR(Device, Allocator, DeferredOperation);
1778 FWrapLayer::CreateDeferredOperationKHR(Result, Device, Allocator, DeferredOperation);
1779 return Result;
1780 }
1781
1782 static FORCEINLINE_DEBUGGABLE void vkDestroyDeferredOperationKHR(VkDevice Device, VkDeferredOperationKHR DeferredOperation, const VkAllocationCallbacks* Allocator)
1783 {
1784 FWrapLayer::DestroyDeferredOperationKHR(VK_RESULT_MAX_ENUM, Device, DeferredOperation, Allocator);
1785 VULKANAPINAMESPACE::vkDestroyDeferredOperationKHR(Device, DeferredOperation, Allocator);
1786 FWrapLayer::DestroyDeferredOperationKHR(VK_SUCCESS, Device, DeferredOperation, Allocator);
1787 }
1788
1789 static FORCEINLINE_DEBUGGABLE VkResult vkDeferredOperationJoinKHR(VkDevice Device, VkDeferredOperationKHR DeferredOperation)
1790 {
1791 FWrapLayer::DeferredOperationJoinKHR(VK_RESULT_MAX_ENUM, Device, DeferredOperation);
1792 VkResult Result = VULKANAPINAMESPACE::vkDeferredOperationJoinKHR(Device, DeferredOperation);
1793 FWrapLayer::DeferredOperationJoinKHR(Result, Device, DeferredOperation);
1794 return Result;
1795 }
1796
1797 static FORCEINLINE_DEBUGGABLE uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDevice Device, VkDeferredOperationKHR DeferredOperation)
1798 {
1799 FWrapLayer::GetDeferredOperationMaxConcurrencyKHR(VK_RESULT_MAX_ENUM, Device, DeferredOperation);
1800 uint32_t Result = VULKANAPINAMESPACE::vkGetDeferredOperationMaxConcurrencyKHR(Device, DeferredOperation);
1801 FWrapLayer::GetDeferredOperationMaxConcurrencyKHR(VK_SUCCESS, Device, DeferredOperation);
1802 return Result;
1803 }
1804
1805 static FORCEINLINE_DEBUGGABLE VkResult vkGetDeferredOperationResultKHR(VkDevice Device, VkDeferredOperationKHR DeferredOperation)
1806 {
1807 FWrapLayer::GetDeferredOperationResultKHR(VK_RESULT_MAX_ENUM, Device, DeferredOperation);
1808 VkResult Result = VULKANAPINAMESPACE::vkGetDeferredOperationResultKHR(Device, DeferredOperation);
1809 FWrapLayer::GetDeferredOperationResultKHR(Result, Device, DeferredOperation);
1810 return Result;
1811 }
1812
1813 static FORCEINLINE_DEBUGGABLE VkResult vkGetDeviceFaultInfoEXT(VkDevice Device, VkDeviceFaultCountsEXT* FaultCounts, VkDeviceFaultInfoEXT* FaultInfo)
1814 {
1815 FWrapLayer::GetDeviceFaultInfoEXT(VK_RESULT_MAX_ENUM, Device, FaultCounts, FaultInfo);
1816 VkResult Result = VULKANAPINAMESPACE::vkGetDeviceFaultInfoEXT(Device, FaultCounts, FaultInfo);
1817 FWrapLayer::GetDeviceFaultInfoEXT(Result, Device, FaultCounts, FaultInfo);
1818 return Result;
1819 }
1820
1821 static FORCEINLINE_DEBUGGABLE VkResult vkGetPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice PhysicalDevice, uint32_t* ToolCount, VkPhysicalDeviceToolPropertiesEXT* ToolProperties)
1822 {
1823 FWrapLayer::GetPhysicalDeviceToolPropertiesEXT(VK_RESULT_MAX_ENUM, PhysicalDevice, ToolCount, ToolProperties);
1824 VkResult Result = VULKANAPINAMESPACE::vkGetPhysicalDeviceToolPropertiesEXT(PhysicalDevice, ToolCount, ToolProperties);
1825 FWrapLayer::GetPhysicalDeviceToolPropertiesEXT(Result, PhysicalDevice, ToolCount, ToolProperties);
1826 return Result;
1827 }
1828
1829 static FORCEINLINE_DEBUGGABLE VkResult vkCreateSamplerYcbcrConversion(VkDevice Device, const VkSamplerYcbcrConversionCreateInfo* CreateInfo, const VkAllocationCallbacks* Allocator, VkSamplerYcbcrConversion* YcbcrConversion)
1830 {
1831 FWrapLayer::CreateSamplerYcbcrConversion(VK_RESULT_MAX_ENUM, Device, CreateInfo, Allocator, YcbcrConversion);
1832 VkResult Result = VULKANAPINAMESPACE::vkCreateSamplerYcbcrConversion(Device, CreateInfo, Allocator, YcbcrConversion);
1833 FWrapLayer::CreateSamplerYcbcrConversion(Result, Device, CreateInfo, Allocator, YcbcrConversion);
1834 return Result;
1835 }
1836
1837 static FORCEINLINE_DEBUGGABLE void vkDestroySamplerYcbcrConversion(VkDevice Device, VkSamplerYcbcrConversion YcbcrConversion, const VkAllocationCallbacks* Allocator)
1838 {
1839 FWrapLayer::DestroySamplerYcbcrConversion(VK_RESULT_MAX_ENUM, Device, YcbcrConversion, Allocator);
1840 VULKANAPINAMESPACE::vkDestroySamplerYcbcrConversion(Device, YcbcrConversion, Allocator);
1841 FWrapLayer::DestroySamplerYcbcrConversion(VK_SUCCESS, Device, YcbcrConversion, Allocator);
1842 }
1843
1844#if PLATFORM_ANDROID
1845 static FORCEINLINE_DEBUGGABLE VkResult vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice Device, const struct AHardwareBuffer* Buffer, VkAndroidHardwareBufferPropertiesANDROID* Properties)
1846 {
1847 FWrapLayer::GetAndroidHardwareBufferPropertiesANDROID(VK_RESULT_MAX_ENUM, Device, Buffer, Properties);
1848 VkResult Result = VULKANAPINAMESPACE::vkGetAndroidHardwareBufferPropertiesANDROID(Device, Buffer, Properties);
1849 FWrapLayer::GetAndroidHardwareBufferPropertiesANDROID(Result, Device, Buffer, Properties);
1850 return Result;
1851 }
1852#endif // PLATFORM_ANDROID
1853
1854 static FORCEINLINE_DEBUGGABLE VkResult vkGetSemaphoreCounterValueKHR(VkDevice Device, VkSemaphore Semaphore, uint64_t* Value)
1855 {
1856 FWrapLayer::GetSemaphoreCounterValueKHR(VK_RESULT_MAX_ENUM, Device, Semaphore, Value);
1857 const VkResult Result = VULKANAPINAMESPACE::vkGetSemaphoreCounterValueKHR(Device, Semaphore, Value);
1858 FWrapLayer::GetSemaphoreCounterValueKHR(Result, Device, Semaphore, Value);
1859 return Result;
1860 }
1861
1862 static FORCEINLINE_DEBUGGABLE VkResult vkWaitSemaphoresKHR(VkDevice Device, const VkSemaphoreWaitInfo* WaitInfo, uint64_t Timeout)
1863 {
1864 FWrapLayer::WaitSemaphoresKHR(VK_RESULT_MAX_ENUM, Device, WaitInfo, Timeout);
1865 const VkResult Result = VULKANAPINAMESPACE::vkWaitSemaphoresKHR(Device, WaitInfo, Timeout);
1866 FWrapLayer::WaitSemaphoresKHR(Result, Device, WaitInfo, Timeout);
1867 return Result;
1868 }
1869
1870 static FORCEINLINE_DEBUGGABLE VkResult vkSignalSemaphoreKHR(VkDevice Device, const VkSemaphoreSignalInfo* SignalInfo)
1871 {
1872 FWrapLayer::SignalSemaphoreKHR(VK_RESULT_MAX_ENUM, Device, SignalInfo);
1873 const VkResult Result = VULKANAPINAMESPACE::vkSignalSemaphoreKHR(Device, SignalInfo);
1874 FWrapLayer::SignalSemaphoreKHR(Result, Device, SignalInfo);
1875 return Result;
1876 }
1877
1878 static FORCEINLINE_DEBUGGABLE VkResult vkCreateShadersEXT(VkDevice Device, uint32_t CreateInfoCount, const VkShaderCreateInfoEXT* CreateInfos, const VkAllocationCallbacks* Allocator, VkShaderEXT* Shaders)
1879 {
1880 FWrapLayer::CreateShadersEXT(VK_RESULT_MAX_ENUM, Device, CreateInfoCount, CreateInfos, Allocator, Shaders);
1881 const VkResult Result = VULKANAPINAMESPACE::vkCreateShadersEXT(Device, CreateInfoCount, CreateInfos, Allocator, Shaders);
1882 FWrapLayer::CreateShadersEXT(Result, Device, CreateInfoCount, CreateInfos, Allocator, Shaders);
1883 return Result;
1884 }
1885
1886 static FORCEINLINE_DEBUGGABLE void vkDestroyShaderEXT(VkDevice Device, VkShaderEXT Shader, const VkAllocationCallbacks* Allocator)
1887 {
1888 FWrapLayer::DestroyShaderEXT(VK_RESULT_MAX_ENUM, Device, Shader, Allocator);
1889 VULKANAPINAMESPACE::vkDestroyShaderEXT(Device, Shader, Allocator);
1890 FWrapLayer::DestroyShaderEXT(VK_SUCCESS, Device, Shader, Allocator);
1891 }
1892
1893 static FORCEINLINE_DEBUGGABLE VkResult vkGetShaderBinaryDataEXT(VkDevice Device, VkShaderEXT Shader, size_t* DataSize, void* Data)
1894 {
1895 FWrapLayer::GetShaderBinaryDataEXT(VK_RESULT_MAX_ENUM, Device, Shader, DataSize, Data);
1896 const VkResult Result = VULKANAPINAMESPACE::vkGetShaderBinaryDataEXT(Device, Shader, DataSize, Data);
1897 FWrapLayer::GetShaderBinaryDataEXT(Result, Device, Shader, DataSize, Data);
1898 return Result;
1899 }
1900
1901 static FORCEINLINE_DEBUGGABLE void vkCmdBindShadersEXT(VkCommandBuffer CommandBuffer, uint32_t StageCount, const VkShaderStageFlagBits* Stages, const VkShaderEXT* Shaders)
1902 {
1903 FWrapLayer::CmdBindShadersEXT(VK_RESULT_MAX_ENUM, CommandBuffer, StageCount, Stages, Shaders);
1904 VULKANAPINAMESPACE::vkCmdBindShadersEXT(CommandBuffer, StageCount, Stages, Shaders);
1905 FWrapLayer::CmdBindShadersEXT(VK_SUCCESS, CommandBuffer, StageCount, Stages, Shaders);
1906 }
1907
1908 static FORCEINLINE_DEBUGGABLE void vkCmdBindVertexBuffers2EXT(VkCommandBuffer CommandBuffer, uint32_t FirstBinding, uint32_t BindingCount, const VkBuffer* Buffers, const VkDeviceSize* Offsets, const VkDeviceSize* Sizes, const VkDeviceSize* Strides)
1909 {
1910 FWrapLayer::CmdBindVertexBuffers2EXT(VK_RESULT_MAX_ENUM, CommandBuffer, FirstBinding, BindingCount, Buffers, Offsets, Sizes, Strides);
1911 VULKANAPINAMESPACE::vkCmdBindVertexBuffers2EXT(CommandBuffer, FirstBinding, BindingCount, Buffers, Offsets, Sizes, Strides);
1912 FWrapLayer::CmdBindVertexBuffers2EXT(VK_SUCCESS, CommandBuffer, FirstBinding, BindingCount, Buffers, Offsets, Sizes, Strides);
1913 }
1914
1915 static FORCEINLINE_DEBUGGABLE void vkCmdSetCullModeEXT(VkCommandBuffer CommandBuffer, VkCullModeFlags CullMode)
1916 {
1917 FWrapLayer::CmdSetCullModeEXT(VK_RESULT_MAX_ENUM, CommandBuffer, CullMode);
1918 VULKANAPINAMESPACE::vkCmdSetCullModeEXT(CommandBuffer, CullMode);
1919 FWrapLayer::CmdSetCullModeEXT(VK_SUCCESS, CommandBuffer, CullMode);
1920 }
1921
1922 static FORCEINLINE_DEBUGGABLE void vkCmdSetColorBlendEnableEXT(VkCommandBuffer CommandBuffer, uint32_t FirstAttachment, uint32_t AttachmentCount, const VkBool32* ColorBlendEnables)
1923 {
1924 FWrapLayer::CmdSetColorBlendEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, FirstAttachment, AttachmentCount, ColorBlendEnables);
1925 VULKANAPINAMESPACE::vkCmdSetColorBlendEnableEXT(CommandBuffer, FirstAttachment, AttachmentCount, ColorBlendEnables);
1926 FWrapLayer::CmdSetColorBlendEnableEXT(VK_SUCCESS, CommandBuffer, FirstAttachment, AttachmentCount, ColorBlendEnables);
1927 }
1928
1929 static FORCEINLINE_DEBUGGABLE void vkCmdSetColorBlendEquationEXT(VkCommandBuffer CommandBuffer, uint32_t FirstAttachment, uint32_t AttachmentCount, const VkColorBlendEquationEXT* ColorBlendEquations)
1930 {
1931 FWrapLayer::CmdSetColorBlendEquationEXT(VK_RESULT_MAX_ENUM, CommandBuffer, FirstAttachment, AttachmentCount, ColorBlendEquations);
1932 VULKANAPINAMESPACE::vkCmdSetColorBlendEquationEXT(CommandBuffer, FirstAttachment, AttachmentCount, ColorBlendEquations);
1933 FWrapLayer::CmdSetColorBlendEquationEXT(VK_SUCCESS, CommandBuffer, FirstAttachment, AttachmentCount, ColorBlendEquations);
1934 }
1935
1936 static FORCEINLINE_DEBUGGABLE void vkCmdSetColorWriteMaskEXT(VkCommandBuffer CommandBuffer, uint32_t FirstAttachment, uint32_t AttachmentCount, const VkColorComponentFlags* ColorWriteMasks)
1937 {
1938 FWrapLayer::CmdSetColorWriteMaskEXT(VK_RESULT_MAX_ENUM, CommandBuffer, FirstAttachment, AttachmentCount, ColorWriteMasks);
1939 VULKANAPINAMESPACE::vkCmdSetColorWriteMaskEXT(CommandBuffer, FirstAttachment, AttachmentCount, ColorWriteMasks);
1940 FWrapLayer::CmdSetColorWriteMaskEXT(VK_SUCCESS, CommandBuffer, FirstAttachment, AttachmentCount, ColorWriteMasks);
1941 }
1942
1943 static FORCEINLINE_DEBUGGABLE void vkCmdSetFrontFaceEXT(VkCommandBuffer CommandBuffer, VkFrontFace FrontFace)
1944 {
1945 FWrapLayer::CmdSetFrontFaceEXT(VK_RESULT_MAX_ENUM, CommandBuffer, FrontFace);
1946 VULKANAPINAMESPACE::vkCmdSetFrontFaceEXT(CommandBuffer, FrontFace);
1947 FWrapLayer::CmdSetFrontFaceEXT(VK_SUCCESS, CommandBuffer, FrontFace);
1948 }
1949
1950 static FORCEINLINE_DEBUGGABLE void vkCmdSetPolygonModeEXT(VkCommandBuffer CommandBuffer, VkPolygonMode PolygonMode)
1951 {
1952 FWrapLayer::CmdSetPolygonModeEXT(VK_RESULT_MAX_ENUM, CommandBuffer, PolygonMode);
1953 VULKANAPINAMESPACE::vkCmdSetPolygonModeEXT(CommandBuffer, PolygonMode);
1954 FWrapLayer::CmdSetPolygonModeEXT(VK_SUCCESS, CommandBuffer, PolygonMode);
1955 }
1956
1957 static FORCEINLINE_DEBUGGABLE void vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer CommandBuffer, VkPrimitiveTopology PrimitiveTopology)
1958 {
1959 FWrapLayer::CmdSetPrimitiveTopologyEXT(VK_RESULT_MAX_ENUM, CommandBuffer, PrimitiveTopology);
1960 VULKANAPINAMESPACE::vkCmdSetPrimitiveTopologyEXT(CommandBuffer, PrimitiveTopology);
1961 FWrapLayer::CmdSetPrimitiveTopologyEXT(VK_SUCCESS, CommandBuffer, PrimitiveTopology);
1962 }
1963
1964 static FORCEINLINE_DEBUGGABLE void vkCmdSetRasterizationSamplesEXT(VkCommandBuffer CommandBuffer, VkSampleCountFlagBits RasterizationSamples)
1965 {
1966 FWrapLayer::CmdSetRasterizationSamplesEXT(VK_RESULT_MAX_ENUM, CommandBuffer, RasterizationSamples);
1967 VULKANAPINAMESPACE::vkCmdSetRasterizationSamplesEXT(CommandBuffer, RasterizationSamples);
1968 FWrapLayer::CmdSetRasterizationSamplesEXT(VK_SUCCESS, CommandBuffer, RasterizationSamples);
1969 }
1970
1971 static FORCEINLINE_DEBUGGABLE void vkCmdSetScissorWithCountEXT(VkCommandBuffer CommandBuffer, uint32_t ScissorCount, const VkRect2D* Scissors)
1972 {
1973 FWrapLayer::CmdSetScissorWithCountEXT(VK_RESULT_MAX_ENUM, CommandBuffer, ScissorCount, Scissors);
1974 VULKANAPINAMESPACE::vkCmdSetScissorWithCountEXT(CommandBuffer, ScissorCount, Scissors);
1975 FWrapLayer::CmdSetScissorWithCountEXT(VK_SUCCESS, CommandBuffer, ScissorCount, Scissors);
1976 }
1977
1978 static FORCEINLINE_DEBUGGABLE void vkCmdSetStencilOpEXT(VkCommandBuffer CommandBuffer, VkStencilFaceFlags FaceMask, VkStencilOp FailOp, VkStencilOp PassOp, VkStencilOp DepthFailOp, VkCompareOp CompareOp)
1979 {
1980 FWrapLayer::CmdSetStencilOpEXT(VK_RESULT_MAX_ENUM, CommandBuffer, FaceMask, FailOp, PassOp, DepthFailOp, CompareOp);
1981 VULKANAPINAMESPACE::vkCmdSetStencilOpEXT(CommandBuffer, FaceMask, FailOp, PassOp, DepthFailOp, CompareOp);
1982 FWrapLayer::CmdSetStencilOpEXT(VK_SUCCESS, CommandBuffer, FaceMask, FailOp, PassOp, DepthFailOp, CompareOp);
1983 }
1984
1985 static FORCEINLINE_DEBUGGABLE void vkCmdSetStencilTestEnableEXT(VkCommandBuffer CommandBuffer, VkBool32 StencilTestEnable)
1986 {
1987 FWrapLayer::CmdSetStencilTestEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, StencilTestEnable);
1988 VULKANAPINAMESPACE::vkCmdSetStencilTestEnableEXT(CommandBuffer, StencilTestEnable);
1989 FWrapLayer::CmdSetStencilTestEnableEXT(VK_SUCCESS, CommandBuffer, StencilTestEnable);
1990 }
1991
1992 static FORCEINLINE_DEBUGGABLE void vkCmdSetVertexInputEXT(VkCommandBuffer CommandBuffer, uint32_t VertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* VertexBindingDescriptions, uint32_t VertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* VertexAttributeDescriptions)
1993 {
1994 FWrapLayer::CmdSetVertexInputEXT(VK_RESULT_MAX_ENUM, CommandBuffer, VertexBindingDescriptionCount, VertexBindingDescriptions, VertexAttributeDescriptionCount, VertexAttributeDescriptions);
1995 VULKANAPINAMESPACE::vkCmdSetVertexInputEXT(CommandBuffer, VertexBindingDescriptionCount, VertexBindingDescriptions, VertexAttributeDescriptionCount, VertexAttributeDescriptions);
1996 FWrapLayer::CmdSetVertexInputEXT(VK_SUCCESS, CommandBuffer, VertexBindingDescriptionCount, VertexBindingDescriptions, VertexAttributeDescriptionCount, VertexAttributeDescriptions);
1997 }
1998
1999 static FORCEINLINE_DEBUGGABLE void vkCmdSetViewportWithCountEXT(VkCommandBuffer CommandBuffer, uint32_t ViewportCount, const VkViewport* Viewports)
2000 {
2001 FWrapLayer::CmdSetViewportWithCountEXT(VK_RESULT_MAX_ENUM, CommandBuffer, ViewportCount, Viewports);
2002 VULKANAPINAMESPACE::vkCmdSetViewportWithCountEXT(CommandBuffer, ViewportCount, Viewports);
2003 FWrapLayer::CmdSetViewportWithCountEXT(VK_SUCCESS, CommandBuffer, ViewportCount, Viewports);
2004 }
2005
2006 static FORCEINLINE_DEBUGGABLE void vkCmdSetDepthBiasEnableEXT(VkCommandBuffer CommandBuffer, VkBool32 DepthBiasEnable)
2007 {
2008 FWrapLayer::CmdSetDepthBiasEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, DepthBiasEnable);
2009 VULKANAPINAMESPACE::vkCmdSetDepthBiasEnableEXT(CommandBuffer, DepthBiasEnable);
2010 FWrapLayer::CmdSetDepthBiasEnableEXT(VK_SUCCESS, CommandBuffer, DepthBiasEnable);
2011 }
2012
2013 static FORCEINLINE_DEBUGGABLE void vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer CommandBuffer, VkBool32 DepthBoundsTestEnable)
2014 {
2015 FWrapLayer::CmdSetDepthBoundsTestEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, DepthBoundsTestEnable);
2016 VULKANAPINAMESPACE::vkCmdSetDepthBoundsTestEnableEXT(CommandBuffer, DepthBoundsTestEnable);
2017 FWrapLayer::CmdSetDepthBoundsTestEnableEXT(VK_SUCCESS, CommandBuffer, DepthBoundsTestEnable);
2018 }
2019
2020 static FORCEINLINE_DEBUGGABLE void vkCmdSetDepthClampEnableEXT(VkCommandBuffer CommandBuffer, VkBool32 DepthClampEnable)
2021 {
2022 FWrapLayer::CmdSetDepthClampEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, DepthClampEnable);
2023 VULKANAPINAMESPACE::vkCmdSetDepthClampEnableEXT(CommandBuffer, DepthClampEnable);
2024 FWrapLayer::CmdSetDepthClampEnableEXT(VK_SUCCESS, CommandBuffer, DepthClampEnable);
2025 }
2026
2027 static FORCEINLINE_DEBUGGABLE void vkCmdSetDepthCompareOpEXT(VkCommandBuffer CommandBuffer, VkCompareOp DepthCompareOp)
2028 {
2029 FWrapLayer::CmdSetDepthCompareOpEXT(VK_RESULT_MAX_ENUM, CommandBuffer, DepthCompareOp);
2030 VULKANAPINAMESPACE::vkCmdSetDepthCompareOpEXT(CommandBuffer, DepthCompareOp);
2031 FWrapLayer::CmdSetDepthCompareOpEXT(VK_SUCCESS, CommandBuffer, DepthCompareOp);
2032 }
2033
2034 static FORCEINLINE_DEBUGGABLE void vkCmdSetDepthTestEnableEXT(VkCommandBuffer CommandBuffer, VkBool32 DepthTestEnable)
2035 {
2036 FWrapLayer::CmdSetDepthTestEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, DepthTestEnable);
2037 VULKANAPINAMESPACE::vkCmdSetDepthTestEnableEXT(CommandBuffer, DepthTestEnable);
2038 FWrapLayer::CmdSetDepthTestEnableEXT(VK_SUCCESS, CommandBuffer, DepthTestEnable);
2039 }
2040
2041 static FORCEINLINE_DEBUGGABLE void vkCmdSetDepthWriteEnableEXT(VkCommandBuffer CommandBuffer, VkBool32 DepthWriteEnable)
2042 {
2043 FWrapLayer::CmdSetDepthWriteEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, DepthWriteEnable);
2044 VULKANAPINAMESPACE::vkCmdSetDepthWriteEnableEXT(CommandBuffer, DepthWriteEnable);
2045 FWrapLayer::CmdSetDepthWriteEnableEXT(VK_SUCCESS, CommandBuffer, DepthWriteEnable);
2046 }
2047
2048 static FORCEINLINE_DEBUGGABLE void vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer CommandBuffer, VkBool32 RasterizerDiscardEnable)
2049 {
2050 FWrapLayer::CmdSetRasterizerDiscardEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, RasterizerDiscardEnable);
2051 VULKANAPINAMESPACE::vkCmdSetRasterizerDiscardEnableEXT(CommandBuffer, RasterizerDiscardEnable);
2052 FWrapLayer::CmdSetRasterizerDiscardEnableEXT(VK_SUCCESS, CommandBuffer, RasterizerDiscardEnable);
2053 }
2054
2055 static FORCEINLINE_DEBUGGABLE void vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer CommandBuffer, VkBool32 PrimitiveRestartEnable)
2056 {
2057 FWrapLayer::CmdSetPrimitiveRestartEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, PrimitiveRestartEnable);
2058 VULKANAPINAMESPACE::vkCmdSetPrimitiveRestartEnableEXT(CommandBuffer, PrimitiveRestartEnable);
2059 FWrapLayer::CmdSetPrimitiveRestartEnableEXT(VK_SUCCESS, CommandBuffer, PrimitiveRestartEnable);
2060 }
2061
2062 static FORCEINLINE_DEBUGGABLE void vkCmdSetLogicOpEnableEXT(VkCommandBuffer CommandBuffer, VkBool32 LogicOpEnable)
2063 {
2064 FWrapLayer::CmdSetLogicOpEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, LogicOpEnable);
2065 VULKANAPINAMESPACE::vkCmdSetLogicOpEnableEXT(CommandBuffer, LogicOpEnable);
2066 FWrapLayer::CmdSetLogicOpEnableEXT(VK_SUCCESS, CommandBuffer, LogicOpEnable);
2067 }
2068
2069 static FORCEINLINE_DEBUGGABLE void vkCmdSetAlphaToCoverageEnableEXT(VkCommandBuffer CommandBuffer, VkBool32 AlphaToCoverageEnable)
2070 {
2071 FWrapLayer::CmdSetAlphaToCoverageEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, AlphaToCoverageEnable);
2072 VULKANAPINAMESPACE::vkCmdSetAlphaToCoverageEnableEXT(CommandBuffer, AlphaToCoverageEnable);
2073 FWrapLayer::CmdSetAlphaToCoverageEnableEXT(VK_SUCCESS, CommandBuffer, AlphaToCoverageEnable);
2074 }
2075
2076 static FORCEINLINE_DEBUGGABLE void vkCmdSetAlphaToOneEnableEXT(VkCommandBuffer CommandBuffer, VkBool32 AlphaToOneEnable)
2077 {
2078 FWrapLayer::CmdSetAlphaToOneEnableEXT(VK_RESULT_MAX_ENUM, CommandBuffer, AlphaToOneEnable);
2079 VULKANAPINAMESPACE::vkCmdSetAlphaToOneEnableEXT(CommandBuffer, AlphaToOneEnable);
2080 FWrapLayer::CmdSetAlphaToOneEnableEXT(VK_SUCCESS, CommandBuffer, AlphaToOneEnable);
2081 }
2082
2083 static FORCEINLINE_DEBUGGABLE VkResult vkCopyMemoryToImageEXT(VkDevice Device, const VkCopyMemoryToImageInfo* CopyMemoryToImageInfo)
2084 {
2085 FWrapLayer::CopyMemoryToImageEXT(VK_RESULT_MAX_ENUM, Device, CopyMemoryToImageInfo);
2086 const VkResult Result = VULKANAPINAMESPACE::vkCopyMemoryToImageEXT(Device, CopyMemoryToImageInfo);
2087 FWrapLayer::CopyMemoryToImageEXT(Result, Device, CopyMemoryToImageInfo);
2088 return Result;
2089 }
2090
2091 static FORCEINLINE_DEBUGGABLE VkResult vkTransitionImageLayoutEXT(VkDevice Device, uint32_t TransitionCount, const VkHostImageLayoutTransitionInfo* Transitions)
2092 {
2093 FWrapLayer::TransitionImageLayoutEXT(VK_RESULT_MAX_ENUM, Device, TransitionCount, Transitions);
2094 const VkResult Result = VULKANAPINAMESPACE::vkTransitionImageLayoutEXT(Device, TransitionCount, Transitions);
2095 FWrapLayer::TransitionImageLayoutEXT(Result, Device, TransitionCount, Transitions);
2096 return Result;
2097 }
2098
2099
2100#if VULKAN_ENABLE_IMAGE_TRACKING_LAYER
2101 void BindDebugLabelName(VkImage Image, const TCHAR* Name);
2102#endif
2103
2104#if VULKAN_ENABLE_DUMP_LAYER
2105 void DumpLayerPushMarker(const TCHAR* Name);
2106 void DumpLayerPopMarker();
2107 void PrintfBegin(const FString& String);
2108#endif
2109}
2110
2111#endif // VULKAN_COMMANDWRAPPERS_ENABLE
ESplineBoneAxis::Z
@ Z
ESplineBoneAxis::Y
@ Y
FORCEINLINE_DEBUGGABLE
#define FORCEINLINE_DEBUGGABLE
Definition CoreMiscDefines.h:74
TCHAR
FPlatformTypes::TCHAR TCHAR
Either ANSICHAR or WIDECHAR, depending on whether the platform supports wide characters or the requir...
Definition Platform.h:1135
StaticCastSharedRef
UE_FORCEINLINE_HINT TSharedRef< CastToType, Mode > StaticCastSharedRef(TSharedRef< CastFromType, Mode > const &InSharedRef)
Definition SharedPointer.h:127
X
#define X(Name, Desc)
Definition FormatStringSan.h:47
ENUM_VK_ENTRYPOINTS_ALL
#define ENUM_VK_ENTRYPOINTS_ALL(EnumMacro)
Definition VulkanLoader.h:283
Offset
uint32 Offset
Definition VulkanMemory.cpp:4033
Size
uint32 Size
Definition VulkanMemory.cpp:4034
uint32
uint32_t uint32
Definition binka_ue_file_header.h:6
MemPro::Platform::SetEvent
void SetEvent(void *p_os_event_mem)
MemPro::Platform::DestroyEvent
void DestroyEvent(void *p_os_event_mem)
MemPro::Platform::ResetEvent
void ResetEvent(void *p_os_event_mem)
UE::String::Private::Result
UE_STRING_CLASS Result(Forward< LhsType >(Lhs), RhsLen)
Definition String.cpp.inl:732
VulkanRHI
Definition VulkanCommandBuffer.h:22
VulkanRHI::CreateBuffer
VkBuffer CreateBuffer(FVulkanDevice *InDevice, VkDeviceSize Size, VkBufferUsageFlags BufferUsageFlags, VkMemoryRequirements &OutMemoryRequirements)
Definition VulkanUtil.cpp:725