go-vk/vk.h at master · dominikh/go-vk

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

#pragma once

#define VK_NO_PROTOTYPES 1;

#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uintptr_t object;

#include <vulkan/vulkan_core.h>

VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(VkInstance instance, const char *pName);

PFN_vkVoidFunction domVkGetDeviceProcAddr(PFN_vkGetDeviceProcAddr fp, VkDevice device, const char* pName);

VkBool32 domVkDebugReportCallbackEXT(PFN_vkDebugReportCallbackEXT fp, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData);

VkBool32 domVkDebugUtilsMessengerCallbackEXT(PFN_vkDebugUtilsMessengerCallbackEXT fp, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData);

VkResult domVkAcquireNextImage2KHR(PFN_vkAcquireNextImage2KHR fp, VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);

VkResult domVkAcquireNextImageKHR(PFN_vkAcquireNextImageKHR fp, VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);

VkResult domVkAllocateCommandBuffers(PFN_vkAllocateCommandBuffers fp, VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);

VkResult domVkAllocateDescriptorSets(PFN_vkAllocateDescriptorSets fp, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);

VkResult domVkAllocateMemory(PFN_vkAllocateMemory fp, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);

VkResult domVkBeginCommandBuffer(PFN_vkBeginCommandBuffer fp, VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);

VkResult domVkBindBufferMemory(PFN_vkBindBufferMemory fp, VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);

VkResult domVkBindBufferMemory2(PFN_vkBindBufferMemory2 fp, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);

VkResult domVkBindBufferMemory2KHR(PFN_vkBindBufferMemory2KHR fp, VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);

VkResult domVkBindImageMemory(PFN_vkBindImageMemory fp, VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);

VkResult domVkBindImageMemory2(PFN_vkBindImageMemory2 fp, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);

VkResult domVkBindImageMemory2KHR(PFN_vkBindImageMemory2KHR fp, VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);

VkResult domVkCreateBuffer(PFN_vkCreateBuffer fp, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);

VkResult domVkCreateBufferView(PFN_vkCreateBufferView fp, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);

VkResult domVkCreateCommandPool(PFN_vkCreateCommandPool fp, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);

VkResult domVkCreateComputePipelines(PFN_vkCreateComputePipelines fp, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);

VkResult domVkCreateDebugReportCallbackEXT(PFN_vkCreateDebugReportCallbackEXT fp, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);

VkResult domVkCreateDebugUtilsMessengerEXT(PFN_vkCreateDebugUtilsMessengerEXT fp, VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger);

VkResult domVkCreateDescriptorPool(PFN_vkCreateDescriptorPool fp, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);

VkResult domVkCreateDescriptorSetLayout(PFN_vkCreateDescriptorSetLayout fp, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);

VkResult domVkCreateDescriptorUpdateTemplate(PFN_vkCreateDescriptorUpdateTemplate fp, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);

VkResult domVkCreateDescriptorUpdateTemplateKHR(PFN_vkCreateDescriptorUpdateTemplateKHR fp, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);

VkResult domVkCreateDevice(PFN_vkCreateDevice fp, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);

VkResult domVkCreateDisplayModeKHR(PFN_vkCreateDisplayModeKHR fp, VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);

VkResult domVkCreateDisplayPlaneSurfaceKHR(PFN_vkCreateDisplayPlaneSurfaceKHR fp, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);

VkResult domVkCreateEvent(PFN_vkCreateEvent fp, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);

VkResult domVkCreateFence(PFN_vkCreateFence fp, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);

VkResult domVkCreateFramebuffer(PFN_vkCreateFramebuffer fp, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);

VkResult domVkCreateGraphicsPipelines(PFN_vkCreateGraphicsPipelines fp, VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);

VkResult domVkCreateImage(PFN_vkCreateImage fp, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);

VkResult domVkCreateImageView(PFN_vkCreateImageView fp, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);

VkResult domVkCreateInstance(PFN_vkCreateInstance fp, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);

VkResult domVkCreatePipelineCache(PFN_vkCreatePipelineCache fp, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);

VkResult domVkCreatePipelineLayout(PFN_vkCreatePipelineLayout fp, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);

VkResult domVkCreateQueryPool(PFN_vkCreateQueryPool fp, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);

VkResult domVkCreateRenderPass(PFN_vkCreateRenderPass fp, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);

VkResult domVkCreateRenderPass2KHR(PFN_vkCreateRenderPass2KHR fp, VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);

VkResult domVkCreateSampler(PFN_vkCreateSampler fp, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);

VkResult domVkCreateSamplerYcbcrConversion(PFN_vkCreateSamplerYcbcrConversion fp, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);

VkResult domVkCreateSamplerYcbcrConversionKHR(PFN_vkCreateSamplerYcbcrConversionKHR fp, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);

VkResult domVkCreateSemaphore(PFN_vkCreateSemaphore fp, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);

VkResult domVkCreateShaderModule(PFN_vkCreateShaderModule fp, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);

VkResult domVkCreateSharedSwapchainsKHR(PFN_vkCreateSharedSwapchainsKHR fp, VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);

VkResult domVkCreateSwapchainKHR(PFN_vkCreateSwapchainKHR fp, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);

VkResult domVkCreateValidationCacheEXT(PFN_vkCreateValidationCacheEXT fp, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache);

VkResult domVkDebugMarkerSetObjectNameEXT(PFN_vkDebugMarkerSetObjectNameEXT fp, VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);

VkResult domVkDebugMarkerSetObjectTagEXT(PFN_vkDebugMarkerSetObjectTagEXT fp, VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);

VkResult domVkDeviceWaitIdle(PFN_vkDeviceWaitIdle fp, VkDevice device);

VkResult domVkDisplayPowerControlEXT(PFN_vkDisplayPowerControlEXT fp, VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);

VkResult domVkEndCommandBuffer(PFN_vkEndCommandBuffer fp, VkCommandBuffer commandBuffer);

VkResult domVkEnumerateDeviceExtensionProperties(PFN_vkEnumerateDeviceExtensionProperties fp, VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);

VkResult domVkEnumerateDeviceLayerProperties(PFN_vkEnumerateDeviceLayerProperties fp, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);

VkResult domVkEnumerateInstanceExtensionProperties(PFN_vkEnumerateInstanceExtensionProperties fp, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);

VkResult domVkEnumerateInstanceLayerProperties(PFN_vkEnumerateInstanceLayerProperties fp, uint32_t* pPropertyCount, VkLayerProperties* pProperties);

VkResult domVkEnumerateInstanceVersion(PFN_vkEnumerateInstanceVersion fp, uint32_t* pApiVersion);

VkResult domVkEnumeratePhysicalDeviceGroups(PFN_vkEnumeratePhysicalDeviceGroups fp, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);

VkResult domVkEnumeratePhysicalDeviceGroupsKHR(PFN_vkEnumeratePhysicalDeviceGroupsKHR fp, VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);

VkResult domVkEnumeratePhysicalDevices(PFN_vkEnumeratePhysicalDevices fp, VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);

VkResult domVkFlushMappedMemoryRanges(PFN_vkFlushMappedMemoryRanges fp, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);

VkResult domVkFreeDescriptorSets(PFN_vkFreeDescriptorSets fp, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);

VkResult domVkGetCalibratedTimestampsEXT(PFN_vkGetCalibratedTimestampsEXT fp, VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);

VkResult domVkGetDeviceGroupPresentCapabilitiesKHR(PFN_vkGetDeviceGroupPresentCapabilitiesKHR fp, VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);

VkResult domVkGetDeviceGroupSurfacePresentModesKHR(PFN_vkGetDeviceGroupSurfacePresentModesKHR fp, VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes);

VkResult domVkGetDisplayModeProperties2KHR(PFN_vkGetDisplayModeProperties2KHR fp, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties);

VkResult domVkGetDisplayModePropertiesKHR(PFN_vkGetDisplayModePropertiesKHR fp, VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);

VkResult domVkGetDisplayPlaneCapabilities2KHR(PFN_vkGetDisplayPlaneCapabilities2KHR fp, VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities);

VkResult domVkGetDisplayPlaneCapabilitiesKHR(PFN_vkGetDisplayPlaneCapabilitiesKHR fp, VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);

VkResult domVkGetDisplayPlaneSupportedDisplaysKHR(PFN_vkGetDisplayPlaneSupportedDisplaysKHR fp, VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);

VkResult domVkGetEventStatus(PFN_vkGetEventStatus fp, VkDevice device, VkEvent event);

VkResult domVkGetFenceFdKHR(PFN_vkGetFenceFdKHR fp, VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);

VkResult domVkGetFenceStatus(PFN_vkGetFenceStatus fp, VkDevice device, VkFence fence);

VkResult domVkGetImageDrmFormatModifierPropertiesEXT(PFN_vkGetImageDrmFormatModifierPropertiesEXT fp, VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties);

VkResult domVkGetMemoryFdKHR(PFN_vkGetMemoryFdKHR fp, VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);

VkResult domVkGetMemoryFdPropertiesKHR(PFN_vkGetMemoryFdPropertiesKHR fp, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);

VkResult domVkGetMemoryHostPointerPropertiesEXT(PFN_vkGetMemoryHostPointerPropertiesEXT fp, VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);

VkResult domVkGetPastPresentationTimingGOOGLE(PFN_vkGetPastPresentationTimingGOOGLE fp, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);

VkResult domVkGetPhysicalDeviceCalibrateableTimeDomainsEXT(PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT fp, VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains);

VkResult domVkGetPhysicalDeviceDisplayPlaneProperties2KHR(PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR fp, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties);

VkResult domVkGetPhysicalDeviceDisplayPlanePropertiesKHR(PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR fp, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);

VkResult domVkGetPhysicalDeviceDisplayProperties2KHR(PFN_vkGetPhysicalDeviceDisplayProperties2KHR fp, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties);

VkResult domVkGetPhysicalDeviceDisplayPropertiesKHR(PFN_vkGetPhysicalDeviceDisplayPropertiesKHR fp, VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);

VkResult domVkGetPhysicalDeviceExternalImageFormatPropertiesNV(PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV fp, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);

VkResult domVkGetPhysicalDeviceImageFormatProperties(PFN_vkGetPhysicalDeviceImageFormatProperties fp, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);

VkResult domVkGetPhysicalDeviceImageFormatProperties2(PFN_vkGetPhysicalDeviceImageFormatProperties2 fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);

VkResult domVkGetPhysicalDeviceImageFormatProperties2KHR(PFN_vkGetPhysicalDeviceImageFormatProperties2KHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);

VkResult domVkGetPhysicalDevicePresentRectanglesKHR(PFN_vkGetPhysicalDevicePresentRectanglesKHR fp, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);

VkResult domVkGetPhysicalDeviceSurfaceCapabilities2EXT(PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT fp, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);

VkResult domVkGetPhysicalDeviceSurfaceCapabilities2KHR(PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);

VkResult domVkGetPhysicalDeviceSurfaceCapabilitiesKHR(PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fp, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);

VkResult domVkGetPhysicalDeviceSurfaceFormats2KHR(PFN_vkGetPhysicalDeviceSurfaceFormats2KHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);

VkResult domVkGetPhysicalDeviceSurfaceFormatsKHR(PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fp, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);

VkResult domVkGetPhysicalDeviceSurfacePresentModesKHR(PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fp, VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);

VkResult domVkGetPhysicalDeviceSurfaceSupportKHR(PFN_vkGetPhysicalDeviceSurfaceSupportKHR fp, VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);

VkResult domVkGetPipelineCacheData(PFN_vkGetPipelineCacheData fp, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);

VkResult domVkGetQueryPoolResults(PFN_vkGetQueryPoolResults fp, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);

VkResult domVkGetRefreshCycleDurationGOOGLE(PFN_vkGetRefreshCycleDurationGOOGLE fp, VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);

VkResult domVkGetSemaphoreFdKHR(PFN_vkGetSemaphoreFdKHR fp, VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);

VkResult domVkGetShaderInfoAMD(PFN_vkGetShaderInfoAMD fp, VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo);

VkResult domVkGetSwapchainCounterEXT(PFN_vkGetSwapchainCounterEXT fp, VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);

VkResult domVkGetSwapchainImagesKHR(PFN_vkGetSwapchainImagesKHR fp, VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);

VkResult domVkGetSwapchainStatusKHR(PFN_vkGetSwapchainStatusKHR fp, VkDevice device, VkSwapchainKHR swapchain);

VkResult domVkGetValidationCacheDataEXT(PFN_vkGetValidationCacheDataEXT fp, VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData);

VkResult domVkImportFenceFdKHR(PFN_vkImportFenceFdKHR fp, VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);

VkResult domVkImportSemaphoreFdKHR(PFN_vkImportSemaphoreFdKHR fp, VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);

VkResult domVkInvalidateMappedMemoryRanges(PFN_vkInvalidateMappedMemoryRanges fp, VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);

VkResult domVkMapMemory(PFN_vkMapMemory fp, VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);

VkResult domVkMergePipelineCaches(PFN_vkMergePipelineCaches fp, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);

VkResult domVkMergeValidationCachesEXT(PFN_vkMergeValidationCachesEXT fp, VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches);

VkResult domVkQueueBindSparse(PFN_vkQueueBindSparse fp, VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);

VkResult domVkQueuePresentKHR(PFN_vkQueuePresentKHR fp, VkQueue queue, const VkPresentInfoKHR* pPresentInfo);

VkResult domVkQueueSubmit(PFN_vkQueueSubmit fp, VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);

VkResult domVkQueueWaitIdle(PFN_vkQueueWaitIdle fp, VkQueue queue);

VkResult domVkRegisterDeviceEventEXT(PFN_vkRegisterDeviceEventEXT fp, VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);

VkResult domVkRegisterDisplayEventEXT(PFN_vkRegisterDisplayEventEXT fp, VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);

VkResult domVkReleaseDisplayEXT(PFN_vkReleaseDisplayEXT fp, VkPhysicalDevice physicalDevice, VkDisplayKHR display);

VkResult domVkResetCommandBuffer(PFN_vkResetCommandBuffer fp, VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);

VkResult domVkResetCommandPool(PFN_vkResetCommandPool fp, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);

VkResult domVkResetDescriptorPool(PFN_vkResetDescriptorPool fp, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);

VkResult domVkResetEvent(PFN_vkResetEvent fp, VkDevice device, VkEvent event);

VkResult domVkResetFences(PFN_vkResetFences fp, VkDevice device, uint32_t fenceCount, const VkFence* pFences);

VkResult domVkSetDebugUtilsObjectNameEXT(PFN_vkSetDebugUtilsObjectNameEXT fp, VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo);

VkResult domVkSetDebugUtilsObjectTagEXT(PFN_vkSetDebugUtilsObjectTagEXT fp, VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);

VkResult domVkSetEvent(PFN_vkSetEvent fp, VkDevice device, VkEvent event);

VkResult domVkWaitForFences(PFN_vkWaitForFences fp, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);

void domVkCmdBeginConditionalRenderingEXT(PFN_vkCmdBeginConditionalRenderingEXT fp, VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);

void domVkCmdBeginDebugUtilsLabelEXT(PFN_vkCmdBeginDebugUtilsLabelEXT fp, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);

void domVkCmdBeginQuery(PFN_vkCmdBeginQuery fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);

void domVkCmdBeginQueryIndexedEXT(PFN_vkCmdBeginQueryIndexedEXT fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index);

void domVkCmdBeginRenderPass(PFN_vkCmdBeginRenderPass fp, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);

void domVkCmdBeginRenderPass2KHR(PFN_vkCmdBeginRenderPass2KHR fp, VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo);

void domVkCmdBeginTransformFeedbackEXT(PFN_vkCmdBeginTransformFeedbackEXT fp, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);

void domVkCmdBindDescriptorSets(PFN_vkCmdBindDescriptorSets fp, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);

void domVkCmdBindIndexBuffer(PFN_vkCmdBindIndexBuffer fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);

void domVkCmdBindPipeline(PFN_vkCmdBindPipeline fp, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);

void domVkCmdBindShadingRateImageNV(PFN_vkCmdBindShadingRateImageNV fp, VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);

void domVkCmdBindTransformFeedbackBuffersEXT(PFN_vkCmdBindTransformFeedbackBuffersEXT fp, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes);

void domVkCmdBindVertexBuffers(PFN_vkCmdBindVertexBuffers fp, VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);

void domVkCmdBlitImage(PFN_vkCmdBlitImage fp, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);

void domVkCmdClearAttachments(PFN_vkCmdClearAttachments fp, VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);

void domVkCmdClearColorImage(PFN_vkCmdClearColorImage fp, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);

void domVkCmdClearDepthStencilImage(PFN_vkCmdClearDepthStencilImage fp, VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);

void domVkCmdCopyBuffer(PFN_vkCmdCopyBuffer fp, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);

void domVkCmdCopyBufferToImage(PFN_vkCmdCopyBufferToImage fp, VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);

void domVkCmdCopyImage(PFN_vkCmdCopyImage fp, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);

void domVkCmdCopyImageToBuffer(PFN_vkCmdCopyImageToBuffer fp, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);

void domVkCmdCopyQueryPoolResults(PFN_vkCmdCopyQueryPoolResults fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);

void domVkCmdDebugMarkerBeginEXT(PFN_vkCmdDebugMarkerBeginEXT fp, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);

void domVkCmdDebugMarkerEndEXT(PFN_vkCmdDebugMarkerEndEXT fp, VkCommandBuffer commandBuffer);

void domVkCmdDebugMarkerInsertEXT(PFN_vkCmdDebugMarkerInsertEXT fp, VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);

void domVkCmdDispatch(PFN_vkCmdDispatch fp, VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);

void domVkCmdDispatchBase(PFN_vkCmdDispatchBase fp, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);

void domVkCmdDispatchBaseKHR(PFN_vkCmdDispatchBaseKHR fp, VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);

void domVkCmdDispatchIndirect(PFN_vkCmdDispatchIndirect fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);

void domVkCmdDraw(PFN_vkCmdDraw fp, VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);

void domVkCmdDrawIndexed(PFN_vkCmdDrawIndexed fp, VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);

void domVkCmdDrawIndexedIndirect(PFN_vkCmdDrawIndexedIndirect fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);

void domVkCmdDrawIndexedIndirectCountAMD(PFN_vkCmdDrawIndexedIndirectCountAMD fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

void domVkCmdDrawIndexedIndirectCountKHR(PFN_vkCmdDrawIndexedIndirectCountKHR fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

void domVkCmdDrawIndirect(PFN_vkCmdDrawIndirect fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);

void domVkCmdDrawIndirectByteCountEXT(PFN_vkCmdDrawIndirectByteCountEXT fp, VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride);

void domVkCmdDrawIndirectCountAMD(PFN_vkCmdDrawIndirectCountAMD fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

void domVkCmdDrawIndirectCountKHR(PFN_vkCmdDrawIndirectCountKHR fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

void domVkCmdDrawMeshTasksIndirectCountNV(PFN_vkCmdDrawMeshTasksIndirectCountNV fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

void domVkCmdDrawMeshTasksIndirectNV(PFN_vkCmdDrawMeshTasksIndirectNV fp, VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);

void domVkCmdDrawMeshTasksNV(PFN_vkCmdDrawMeshTasksNV fp, VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);

void domVkCmdEndConditionalRenderingEXT(PFN_vkCmdEndConditionalRenderingEXT fp, VkCommandBuffer commandBuffer);

void domVkCmdEndDebugUtilsLabelEXT(PFN_vkCmdEndDebugUtilsLabelEXT fp, VkCommandBuffer commandBuffer);

void domVkCmdEndQuery(PFN_vkCmdEndQuery fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);

void domVkCmdEndQueryIndexedEXT(PFN_vkCmdEndQueryIndexedEXT fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);

void domVkCmdEndRenderPass(PFN_vkCmdEndRenderPass fp, VkCommandBuffer commandBuffer);

void domVkCmdEndRenderPass2KHR(PFN_vkCmdEndRenderPass2KHR fp, VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo);

void domVkCmdEndTransformFeedbackEXT(PFN_vkCmdEndTransformFeedbackEXT fp, VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);

void domVkCmdExecuteCommands(PFN_vkCmdExecuteCommands fp, VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);

void domVkCmdFillBuffer(PFN_vkCmdFillBuffer fp, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);

void domVkCmdInsertDebugUtilsLabelEXT(PFN_vkCmdInsertDebugUtilsLabelEXT fp, VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);

void domVkCmdNextSubpass(PFN_vkCmdNextSubpass fp, VkCommandBuffer commandBuffer, VkSubpassContents contents);

void domVkCmdNextSubpass2KHR(PFN_vkCmdNextSubpass2KHR fp, VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo);

void domVkCmdPipelineBarrier(PFN_vkCmdPipelineBarrier fp, VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);

void domVkCmdPushConstants(PFN_vkCmdPushConstants fp, VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);

void domVkCmdPushDescriptorSetKHR(PFN_vkCmdPushDescriptorSetKHR fp, VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);

void domVkCmdPushDescriptorSetWithTemplateKHR(PFN_vkCmdPushDescriptorSetWithTemplateKHR fp, VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);

void domVkCmdResetEvent(PFN_vkCmdResetEvent fp, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);

void domVkCmdResetQueryPool(PFN_vkCmdResetQueryPool fp, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);

void domVkCmdResolveImage(PFN_vkCmdResolveImage fp, VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);

void domVkCmdSetBlendConstants(PFN_vkCmdSetBlendConstants fp, VkCommandBuffer commandBuffer, const float blendConstants[4]);

void domVkCmdSetCheckpointNV(PFN_vkCmdSetCheckpointNV fp, VkCommandBuffer commandBuffer, const void* pCheckpointMarker);

void domVkCmdSetCoarseSampleOrderNV(PFN_vkCmdSetCoarseSampleOrderNV fp, VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);

void domVkCmdSetDepthBias(PFN_vkCmdSetDepthBias fp, VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);

void domVkCmdSetDepthBounds(PFN_vkCmdSetDepthBounds fp, VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);

void domVkCmdSetDeviceMask(PFN_vkCmdSetDeviceMask fp, VkCommandBuffer commandBuffer, uint32_t deviceMask);

void domVkCmdSetDeviceMaskKHR(PFN_vkCmdSetDeviceMaskKHR fp, VkCommandBuffer commandBuffer, uint32_t deviceMask);

void domVkCmdSetDiscardRectangleEXT(PFN_vkCmdSetDiscardRectangleEXT fp, VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);

void domVkCmdSetEvent(PFN_vkCmdSetEvent fp, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);

void domVkCmdSetExclusiveScissorNV(PFN_vkCmdSetExclusiveScissorNV fp, VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);

void domVkCmdSetLineWidth(PFN_vkCmdSetLineWidth fp, VkCommandBuffer commandBuffer, float lineWidth);

void domVkCmdSetSampleLocationsEXT(PFN_vkCmdSetSampleLocationsEXT fp, VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo);

void domVkCmdSetScissor(PFN_vkCmdSetScissor fp, VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);

void domVkCmdSetStencilCompareMask(PFN_vkCmdSetStencilCompareMask fp, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);

void domVkCmdSetStencilReference(PFN_vkCmdSetStencilReference fp, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);

void domVkCmdSetStencilWriteMask(PFN_vkCmdSetStencilWriteMask fp, VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);

void domVkCmdSetViewport(PFN_vkCmdSetViewport fp, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);

void domVkCmdSetViewportShadingRatePaletteNV(PFN_vkCmdSetViewportShadingRatePaletteNV fp, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes);

void domVkCmdSetViewportWScalingNV(PFN_vkCmdSetViewportWScalingNV fp, VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);

void domVkCmdUpdateBuffer(PFN_vkCmdUpdateBuffer fp, VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);

void domVkCmdWaitEvents(PFN_vkCmdWaitEvents fp, VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);

void domVkCmdWriteBufferMarkerAMD(PFN_vkCmdWriteBufferMarkerAMD fp, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);

void domVkCmdWriteTimestamp(PFN_vkCmdWriteTimestamp fp, VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);

void domVkDebugReportMessageEXT(PFN_vkDebugReportMessageEXT fp, VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);

void domVkDestroyBuffer(PFN_vkDestroyBuffer fp, VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);

void domVkDestroyBufferView(PFN_vkDestroyBufferView fp, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);

void domVkDestroyCommandPool(PFN_vkDestroyCommandPool fp, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);

void domVkDestroyDebugReportCallbackEXT(PFN_vkDestroyDebugReportCallbackEXT fp, VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);

void domVkDestroyDebugUtilsMessengerEXT(PFN_vkDestroyDebugUtilsMessengerEXT fp, VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);

void domVkDestroyDescriptorPool(PFN_vkDestroyDescriptorPool fp, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);

void domVkDestroyDescriptorSetLayout(PFN_vkDestroyDescriptorSetLayout fp, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);

void domVkDestroyDescriptorUpdateTemplate(PFN_vkDestroyDescriptorUpdateTemplate fp, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);

void domVkDestroyDescriptorUpdateTemplateKHR(PFN_vkDestroyDescriptorUpdateTemplateKHR fp, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);

void domVkDestroyDevice(PFN_vkDestroyDevice fp, VkDevice device, const VkAllocationCallbacks* pAllocator);

void domVkDestroyEvent(PFN_vkDestroyEvent fp, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);

void domVkDestroyFence(PFN_vkDestroyFence fp, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);

void domVkDestroyFramebuffer(PFN_vkDestroyFramebuffer fp, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);

void domVkDestroyImage(PFN_vkDestroyImage fp, VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);

void domVkDestroyImageView(PFN_vkDestroyImageView fp, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);

void domVkDestroyInstance(PFN_vkDestroyInstance fp, VkInstance instance, const VkAllocationCallbacks* pAllocator);

void domVkDestroyPipeline(PFN_vkDestroyPipeline fp, VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);

void domVkDestroyPipelineCache(PFN_vkDestroyPipelineCache fp, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);

void domVkDestroyPipelineLayout(PFN_vkDestroyPipelineLayout fp, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);

void domVkDestroyQueryPool(PFN_vkDestroyQueryPool fp, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);

void domVkDestroyRenderPass(PFN_vkDestroyRenderPass fp, VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);

void domVkDestroySampler(PFN_vkDestroySampler fp, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);

void domVkDestroySamplerYcbcrConversion(PFN_vkDestroySamplerYcbcrConversion fp, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);

void domVkDestroySamplerYcbcrConversionKHR(PFN_vkDestroySamplerYcbcrConversionKHR fp, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);

void domVkDestroySemaphore(PFN_vkDestroySemaphore fp, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);

void domVkDestroyShaderModule(PFN_vkDestroyShaderModule fp, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);

void domVkDestroySurfaceKHR(PFN_vkDestroySurfaceKHR fp, VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);

void domVkDestroySwapchainKHR(PFN_vkDestroySwapchainKHR fp, VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);

void domVkDestroyValidationCacheEXT(PFN_vkDestroyValidationCacheEXT fp, VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator);

void domVkFreeCommandBuffers(PFN_vkFreeCommandBuffers fp, VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);

void domVkFreeMemory(PFN_vkFreeMemory fp, VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);

void domVkGetBufferMemoryRequirements(PFN_vkGetBufferMemoryRequirements fp, VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);

void domVkGetBufferMemoryRequirements2(PFN_vkGetBufferMemoryRequirements2 fp, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);

void domVkGetBufferMemoryRequirements2KHR(PFN_vkGetBufferMemoryRequirements2KHR fp, VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);

void domVkGetDescriptorSetLayoutSupport(PFN_vkGetDescriptorSetLayoutSupport fp, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);

void domVkGetDescriptorSetLayoutSupportKHR(PFN_vkGetDescriptorSetLayoutSupportKHR fp, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);

void domVkGetDeviceGroupPeerMemoryFeatures(PFN_vkGetDeviceGroupPeerMemoryFeatures fp, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);

void domVkGetDeviceGroupPeerMemoryFeaturesKHR(PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR fp, VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);

void domVkGetDeviceMemoryCommitment(PFN_vkGetDeviceMemoryCommitment fp, VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);

void domVkGetDeviceQueue(PFN_vkGetDeviceQueue fp, VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);

void domVkGetDeviceQueue2(PFN_vkGetDeviceQueue2 fp, VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);

void domVkGetImageMemoryRequirements(PFN_vkGetImageMemoryRequirements fp, VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);

void domVkGetImageMemoryRequirements2(PFN_vkGetImageMemoryRequirements2 fp, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);

void domVkGetImageMemoryRequirements2KHR(PFN_vkGetImageMemoryRequirements2KHR fp, VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);

void domVkGetImageSparseMemoryRequirements(PFN_vkGetImageSparseMemoryRequirements fp, VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);

void domVkGetImageSparseMemoryRequirements2(PFN_vkGetImageSparseMemoryRequirements2 fp, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);

void domVkGetImageSparseMemoryRequirements2KHR(PFN_vkGetImageSparseMemoryRequirements2KHR fp, VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);

void domVkGetImageSubresourceLayout(PFN_vkGetImageSubresourceLayout fp, VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);

void domVkGetPhysicalDeviceExternalBufferProperties(PFN_vkGetPhysicalDeviceExternalBufferProperties fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);

void domVkGetPhysicalDeviceExternalBufferPropertiesKHR(PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);

void domVkGetPhysicalDeviceExternalFenceProperties(PFN_vkGetPhysicalDeviceExternalFenceProperties fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);

void domVkGetPhysicalDeviceExternalFencePropertiesKHR(PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);

void domVkGetPhysicalDeviceExternalSemaphoreProperties(PFN_vkGetPhysicalDeviceExternalSemaphoreProperties fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);

void domVkGetPhysicalDeviceExternalSemaphorePropertiesKHR(PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);

void domVkGetPhysicalDeviceFeatures(PFN_vkGetPhysicalDeviceFeatures fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);

void domVkGetPhysicalDeviceFeatures2(PFN_vkGetPhysicalDeviceFeatures2 fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);

void domVkGetPhysicalDeviceFeatures2KHR(PFN_vkGetPhysicalDeviceFeatures2KHR fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);

void domVkGetPhysicalDeviceFormatProperties(PFN_vkGetPhysicalDeviceFormatProperties fp, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);

void domVkGetPhysicalDeviceFormatProperties2(PFN_vkGetPhysicalDeviceFormatProperties2 fp, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);

void domVkGetPhysicalDeviceFormatProperties2KHR(PFN_vkGetPhysicalDeviceFormatProperties2KHR fp, VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);

void domVkGetPhysicalDeviceMemoryProperties(PFN_vkGetPhysicalDeviceMemoryProperties fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);

void domVkGetPhysicalDeviceMemoryProperties2(PFN_vkGetPhysicalDeviceMemoryProperties2 fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);

void domVkGetPhysicalDeviceMemoryProperties2KHR(PFN_vkGetPhysicalDeviceMemoryProperties2KHR fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);

void domVkGetPhysicalDeviceMultisamplePropertiesEXT(PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT fp, VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties);

void domVkGetPhysicalDeviceProperties(PFN_vkGetPhysicalDeviceProperties fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);

void 4EDF domVkGetPhysicalDeviceProperties2(PFN_vkGetPhysicalDeviceProperties2 fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);

void domVkGetPhysicalDeviceProperties2KHR(PFN_vkGetPhysicalDeviceProperties2KHR fp, VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);

void domVkGetPhysicalDeviceQueueFamilyProperties(PFN_vkGetPhysicalDeviceQueueFamilyProperties fp, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);

void domVkGetPhysicalDeviceQueueFamilyProperties2(PFN_vkGetPhysicalDeviceQueueFamilyProperties2 fp, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);

void domVkGetPhysicalDeviceQueueFamilyProperties2KHR(PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR fp, VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);

void domVkGetPhysicalDeviceSparseImageFormatProperties(PFN_vkGetPhysicalDeviceSparseImageFormatProperties fp, VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);

void domVkGetPhysicalDeviceSparseImageFormatProperties2(PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);

void domVkGetPhysicalDeviceSparseImageFormatProperties2KHR(PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR fp, VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);

void domVkGetQueueCheckpointDataNV(PFN_vkGetQueueCheckpointDataNV fp, VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData);

void domVkGetRenderAreaGranularity(PFN_vkGetRenderAreaGranularity fp, VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);

void domVkQueueBeginDebugUtilsLabelEXT(PFN_vkQueueBeginDebugUtilsLabelEXT fp, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);

void domVkQueueEndDebugUtilsLabelEXT(PFN_vkQueueEndDebugUtilsLabelEXT fp, VkQueue queue);

void domVkQueueInsertDebugUtilsLabelEXT(PFN_vkQueueInsertDebugUtilsLabelEXT fp, VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);

void domVkSetHdrMetadataEXT(PFN_vkSetHdrMetadataEXT fp, VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);

void domVkSubmitDebugUtilsMessageEXT(PFN_vkSubmitDebugUtilsMessageEXT fp, VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);

void domVkTrimCommandPool(PFN_vkTrimCommandPool fp, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);

void domVkTrimCommandPoolKHR(PFN_vkTrimCommandPoolKHR fp, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);

void domVkUnmapMemory(PFN_vkUnmapMemory fp, VkDevice device, VkDeviceMemory memory);

void domVkUpdateDescriptorSetWithTemplate(PFN_vkUpdateDescriptorSetWithTemplate fp, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);

void domVkUpdateDescriptorSetWithTemplateKHR(PFN_vkUpdateDescriptorSetWithTemplateKHR fp, VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);

void domVkUpdateDescriptorSets(PFN_vkUpdateDescriptorSets fp, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);

FilesExpand file tree

vk.h

Latest commit

History

vk.h

File metadata and controls