1732 lines
61 KiB
C
1732 lines
61 KiB
C
/*
|
|
*
|
|
* Copyright (c) 2015-2016 The Khronos Group Inc.
|
|
* Copyright (c) 2015-2016 Valve Corporation
|
|
* Copyright (c) 2015-2016 LunarG, Inc.
|
|
* Copyright (C) 2015 Google Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and/or associated documentation files (the "Materials"), to
|
|
* deal in the Materials without restriction, including without limitation the
|
|
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
* sell copies of the Materials, and to permit persons to whom the Materials are
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice(s) and this permission notice shall be included in
|
|
* all copies or substantial portions of the Materials.
|
|
*
|
|
* THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
*
|
|
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
|
|
* USE OR OTHER DEALINGS IN THE MATERIALS.
|
|
*
|
|
* Author: Courtney Goeltzenleuchter <courtney@lunarg.com>
|
|
* Author: Jon Ashburn <jon@lunarg.com>
|
|
* Author: Tony Barbour <tony@LunarG.com>
|
|
* Author: Chia-I Wu <olv@lunarg.com>
|
|
*/
|
|
#define _GNU_SOURCE
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "vk_loader_platform.h"
|
|
#include "loader.h"
|
|
#include "debug_report.h"
|
|
#include "wsi.h"
|
|
|
|
/* Trampoline entrypoints */
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkInstance *pInstance) {
|
|
struct loader_instance *ptr_instance = NULL;
|
|
VkInstance created_instance = VK_NULL_HANDLE;
|
|
VkResult res = VK_ERROR_INITIALIZATION_FAILED;
|
|
VkDebugReportCallbackEXT instance_callback = VK_NULL_HANDLE;
|
|
void *pNext = (void *)pCreateInfo->pNext;
|
|
|
|
loader_platform_thread_once(&once_init, loader_initialize);
|
|
|
|
#if 0
|
|
if (pAllocator) {
|
|
ptr_instance = (struct loader_instance *) pAllocator->pfnAllocation(
|
|
pAllocator->pUserData,
|
|
sizeof(struct loader_instance),
|
|
sizeof(int *),
|
|
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
|
|
} else {
|
|
#endif
|
|
ptr_instance =
|
|
(struct loader_instance *)malloc(sizeof(struct loader_instance));
|
|
//}
|
|
if (ptr_instance == NULL) {
|
|
return VK_ERROR_OUT_OF_HOST_MEMORY;
|
|
}
|
|
|
|
tls_instance = ptr_instance;
|
|
loader_platform_thread_lock_mutex(&loader_lock);
|
|
memset(ptr_instance, 0, sizeof(struct loader_instance));
|
|
#if 0
|
|
if (pAllocator) {
|
|
ptr_instance->alloc_callbacks = *pAllocator;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Look for a debug report create info structure
|
|
* and setup a callback if found.
|
|
*/
|
|
while (pNext) {
|
|
if (((VkInstanceCreateInfo *)pNext)->sType ==
|
|
VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) {
|
|
instance_callback = (VkDebugReportCallbackEXT)ptr_instance;
|
|
if (util_CreateDebugReportCallback(ptr_instance, pNext, NULL,
|
|
instance_callback)) {
|
|
loader_heap_free(ptr_instance, ptr_instance);
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
return VK_ERROR_OUT_OF_HOST_MEMORY;
|
|
}
|
|
}
|
|
pNext = (void *)((VkInstanceCreateInfo *)pNext)->pNext;
|
|
}
|
|
|
|
/* Due to implicit layers need to get layer list even if
|
|
* enabledLayerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
|
|
* get layer list (both instance and device) via loader_layer_scan(). */
|
|
memset(&ptr_instance->instance_layer_list, 0,
|
|
sizeof(ptr_instance->instance_layer_list));
|
|
memset(&ptr_instance->device_layer_list, 0,
|
|
sizeof(ptr_instance->device_layer_list));
|
|
loader_layer_scan(ptr_instance, &ptr_instance->instance_layer_list,
|
|
&ptr_instance->device_layer_list);
|
|
|
|
/* validate the app requested layers to be enabled */
|
|
if (pCreateInfo->enabledLayerCount > 0) {
|
|
res =
|
|
loader_validate_layers(ptr_instance, pCreateInfo->enabledLayerCount,
|
|
pCreateInfo->ppEnabledLayerNames,
|
|
&ptr_instance->instance_layer_list);
|
|
if (res != VK_SUCCESS) {
|
|
util_DestroyDebugReportCallback(ptr_instance, instance_callback,
|
|
NULL);
|
|
loader_heap_free(ptr_instance, ptr_instance);
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
return res;
|
|
}
|
|
}
|
|
|
|
/* convert any meta layers to the actual layers makes a copy of layer name*/
|
|
uint32_t saved_layer_count = pCreateInfo->enabledLayerCount;
|
|
char **saved_layer_names;
|
|
char **saved_layer_ptr;
|
|
saved_layer_names =
|
|
loader_stack_alloc(sizeof(char *) * pCreateInfo->enabledLayerCount);
|
|
for (uint32_t i = 0; i < saved_layer_count; i++) {
|
|
saved_layer_names[i] = (char *)pCreateInfo->ppEnabledLayerNames[i];
|
|
}
|
|
saved_layer_ptr = (char **)pCreateInfo->ppEnabledLayerNames;
|
|
|
|
loader_expand_layer_names(
|
|
ptr_instance, std_validation_str,
|
|
sizeof(std_validation_names) / sizeof(std_validation_names[0]),
|
|
std_validation_names, (uint32_t *)&pCreateInfo->enabledLayerCount,
|
|
(char ***)&pCreateInfo->ppEnabledLayerNames);
|
|
|
|
/* Scan/discover all ICD libraries */
|
|
memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs));
|
|
loader_icd_scan(ptr_instance, &ptr_instance->icd_libs);
|
|
|
|
/* get extensions from all ICD's, merge so no duplicates, then validate */
|
|
loader_get_icd_loader_instance_extensions(
|
|
ptr_instance, &ptr_instance->icd_libs, &ptr_instance->ext_list);
|
|
res = loader_validate_instance_extensions(
|
|
ptr_instance, &ptr_instance->ext_list,
|
|
&ptr_instance->instance_layer_list, pCreateInfo);
|
|
if (res != VK_SUCCESS) {
|
|
loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count,
|
|
saved_layer_names, saved_layer_ptr,
|
|
pCreateInfo);
|
|
loader_delete_layer_properties(ptr_instance,
|
|
&ptr_instance->device_layer_list);
|
|
loader_delete_layer_properties(ptr_instance,
|
|
&ptr_instance->instance_layer_list);
|
|
loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
|
|
loader_destroy_generic_list(
|
|
ptr_instance,
|
|
(struct loader_generic_list *)&ptr_instance->ext_list);
|
|
util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
loader_heap_free(ptr_instance, ptr_instance);
|
|
return res;
|
|
}
|
|
|
|
ptr_instance->disp =
|
|
loader_heap_alloc(ptr_instance, sizeof(VkLayerInstanceDispatchTable),
|
|
VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
|
|
if (ptr_instance->disp == NULL) {
|
|
loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count,
|
|
saved_layer_names, saved_layer_ptr,
|
|
pCreateInfo);
|
|
loader_delete_layer_properties(ptr_instance,
|
|
&ptr_instance->device_layer_list);
|
|
loader_delete_layer_properties(ptr_instance,
|
|
&ptr_instance->instance_layer_list);
|
|
loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
|
|
loader_destroy_generic_list(
|
|
ptr_instance,
|
|
(struct loader_generic_list *)&ptr_instance->ext_list);
|
|
util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
loader_heap_free(ptr_instance, ptr_instance);
|
|
return VK_ERROR_OUT_OF_HOST_MEMORY;
|
|
}
|
|
memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp));
|
|
ptr_instance->next = loader.instances;
|
|
loader.instances = ptr_instance;
|
|
|
|
/* activate any layers on instance chain */
|
|
res = loader_enable_instance_layers(ptr_instance, pCreateInfo,
|
|
&ptr_instance->instance_layer_list);
|
|
if (res != VK_SUCCESS) {
|
|
loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count,
|
|
saved_layer_names, saved_layer_ptr,
|
|
pCreateInfo);
|
|
loader_delete_layer_properties(ptr_instance,
|
|
&ptr_instance->device_layer_list);
|
|
loader_delete_layer_properties(ptr_instance,
|
|
&ptr_instance->instance_layer_list);
|
|
loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
|
|
loader_destroy_generic_list(
|
|
ptr_instance,
|
|
(struct loader_generic_list *)&ptr_instance->ext_list);
|
|
loader.instances = ptr_instance->next;
|
|
util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
loader_heap_free(ptr_instance, ptr_instance->disp);
|
|
loader_heap_free(ptr_instance, ptr_instance);
|
|
return res;
|
|
}
|
|
|
|
created_instance = (VkInstance)ptr_instance;
|
|
res = loader_create_instance_chain(pCreateInfo, pAllocator, ptr_instance,
|
|
&created_instance);
|
|
|
|
if (res == VK_SUCCESS) {
|
|
wsi_create_instance(ptr_instance, pCreateInfo);
|
|
debug_report_create_instance(ptr_instance, pCreateInfo);
|
|
|
|
*pInstance = created_instance;
|
|
|
|
/*
|
|
* Finally have the layers in place and everyone has seen
|
|
* the CreateInstance command go by. This allows the layer's
|
|
* GetInstanceProcAddr functions to return valid extension functions
|
|
* if enabled.
|
|
*/
|
|
loader_activate_instance_layer_extensions(ptr_instance, *pInstance);
|
|
} else {
|
|
// TODO: cleanup here.
|
|
}
|
|
|
|
/* Remove temporary debug_report callback */
|
|
util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
|
|
loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count,
|
|
saved_layer_names, saved_layer_ptr,
|
|
pCreateInfo);
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
return res;
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyInstance(VkInstance instance,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerInstanceDispatchTable *disp;
|
|
struct loader_instance *ptr_instance = NULL;
|
|
disp = loader_get_instance_dispatch(instance);
|
|
|
|
loader_platform_thread_lock_mutex(&loader_lock);
|
|
|
|
/* TODO: Do we need a temporary callback here to catch cleanup issues? */
|
|
|
|
ptr_instance = loader_get_instance(instance);
|
|
disp->DestroyInstance(instance, pAllocator);
|
|
|
|
loader_deactivate_instance_layers(ptr_instance);
|
|
loader_heap_free(ptr_instance, ptr_instance->disp);
|
|
loader_heap_free(ptr_instance, ptr_instance);
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
|
|
VkPhysicalDevice *pPhysicalDevices) {
|
|
const VkLayerInstanceDispatchTable *disp;
|
|
VkResult res;
|
|
disp = loader_get_instance_dispatch(instance);
|
|
|
|
loader_platform_thread_lock_mutex(&loader_lock);
|
|
res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount,
|
|
pPhysicalDevices);
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
return res;
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkGetPhysicalDeviceFeatures(VkPhysicalDevice gpu,
|
|
VkPhysicalDeviceFeatures *pFeatures) {
|
|
const VkLayerInstanceDispatchTable *disp;
|
|
|
|
disp = loader_get_instance_dispatch(gpu);
|
|
disp->GetPhysicalDeviceFeatures(gpu, pFeatures);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice gpu, VkFormat format,
|
|
VkFormatProperties *pFormatInfo) {
|
|
const VkLayerInstanceDispatchTable *disp;
|
|
|
|
disp = loader_get_instance_dispatch(gpu);
|
|
disp->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkGetPhysicalDeviceImageFormatProperties(
|
|
VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
|
|
VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
|
|
VkImageFormatProperties *pImageFormatProperties) {
|
|
const VkLayerInstanceDispatchTable *disp;
|
|
|
|
disp = loader_get_instance_dispatch(physicalDevice);
|
|
return disp->GetPhysicalDeviceImageFormatProperties(
|
|
physicalDevice, format, type, tiling, usage, flags,
|
|
pImageFormatProperties);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkGetPhysicalDeviceProperties(VkPhysicalDevice gpu,
|
|
VkPhysicalDeviceProperties *pProperties) {
|
|
const VkLayerInstanceDispatchTable *disp;
|
|
|
|
disp = loader_get_instance_dispatch(gpu);
|
|
disp->GetPhysicalDeviceProperties(gpu, pProperties);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkGetPhysicalDeviceQueueFamilyProperties(
|
|
VkPhysicalDevice gpu, uint32_t *pQueueFamilyPropertyCount,
|
|
VkQueueFamilyProperties *pQueueProperties) {
|
|
const VkLayerInstanceDispatchTable *disp;
|
|
|
|
disp = loader_get_instance_dispatch(gpu);
|
|
disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pQueueFamilyPropertyCount,
|
|
pQueueProperties);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
|
|
VkPhysicalDevice gpu, VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
|
|
const VkLayerInstanceDispatchTable *disp;
|
|
|
|
disp = loader_get_instance_dispatch(gpu);
|
|
disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
|
|
VkResult res;
|
|
|
|
loader_platform_thread_lock_mutex(&loader_lock);
|
|
|
|
res = loader_CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
|
|
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
return res;
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
struct loader_device *dev;
|
|
|
|
loader_platform_thread_lock_mutex(&loader_lock);
|
|
|
|
struct loader_icd *icd = loader_get_icd_and_device(device, &dev);
|
|
const struct loader_instance *inst = icd->this_instance;
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyDevice(device, pAllocator);
|
|
dev->device = NULL;
|
|
loader_remove_logical_device(inst, icd, dev);
|
|
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
|
|
const char *pLayerName,
|
|
uint32_t *pPropertyCount,
|
|
VkExtensionProperties *pProperties) {
|
|
VkResult res;
|
|
|
|
loader_platform_thread_lock_mutex(&loader_lock);
|
|
|
|
/* If pLayerName == NULL, then querying ICD extensions, pass this call
|
|
down the instance chain which will terminate in the ICD. This allows
|
|
layers to filter the extensions coming back up the chain.
|
|
If pLayerName != NULL then get layer extensions from manifest file. */
|
|
if (pLayerName == NULL || strlen(pLayerName) == 0) {
|
|
const VkLayerInstanceDispatchTable *disp;
|
|
|
|
disp = loader_get_instance_dispatch(physicalDevice);
|
|
res = disp->EnumerateDeviceExtensionProperties(
|
|
physicalDevice, NULL, pPropertyCount, pProperties);
|
|
} else {
|
|
res = loader_EnumerateDeviceExtensionProperties(
|
|
physicalDevice, pLayerName, pPropertyCount, pProperties);
|
|
}
|
|
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
return res;
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
|
|
uint32_t *pPropertyCount,
|
|
VkLayerProperties *pProperties) {
|
|
VkResult res;
|
|
|
|
loader_platform_thread_lock_mutex(&loader_lock);
|
|
|
|
/* Don't dispatch this call down the instance chain, want all device layers
|
|
enumerated and instance chain may not contain all device layers */
|
|
res = loader_EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount,
|
|
pProperties);
|
|
loader_platform_thread_unlock_mutex(&loader_lock);
|
|
return res;
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex,
|
|
VkQueue *pQueue) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
|
|
loader_set_dispatch(*pQueue, disp);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits,
|
|
VkFence fence) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(queue);
|
|
|
|
return disp->QueueSubmit(queue, submitCount, pSubmits, fence);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(queue);
|
|
|
|
return disp->QueueWaitIdle(queue);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->DeviceWaitIdle(device);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkDeviceMemory *pMemory) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkFreeMemory(VkDevice device, VkDeviceMemory mem,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->FreeMemory(device, mem, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset,
|
|
VkDeviceSize size, VkFlags flags, void **ppData) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->MapMemory(device, mem, offset, size, flags, ppData);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkUnmapMemory(VkDevice device, VkDeviceMemory mem) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->UnmapMemory(device, mem);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
|
|
const VkMappedMemoryRange *pMemoryRanges) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->FlushMappedMemoryRanges(device, memoryRangeCount,
|
|
pMemoryRanges);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
|
|
const VkMappedMemoryRange *pMemoryRanges) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount,
|
|
pMemoryRanges);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
|
|
VkDeviceSize *pCommittedMemoryInBytes) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem,
|
|
VkDeviceSize offset) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->BindBufferMemory(device, buffer, mem, offset);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem,
|
|
VkDeviceSize offset) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->BindImageMemory(device, image, mem, offset);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
|
|
VkMemoryRequirements *pMemoryRequirements) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkGetImageMemoryRequirements(VkDevice device, VkImage image,
|
|
VkMemoryRequirements *pMemoryRequirements) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
|
|
VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
|
|
VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->GetImageSparseMemoryRequirements(device, image,
|
|
pSparseMemoryRequirementCount,
|
|
pSparseMemoryRequirements);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkGetPhysicalDeviceSparseImageFormatProperties(
|
|
VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
|
|
VkSampleCountFlagBits samples, VkImageUsageFlags usage,
|
|
VkImageTiling tiling, uint32_t *pPropertyCount,
|
|
VkSparseImageFormatProperties *pProperties) {
|
|
const VkLayerInstanceDispatchTable *disp;
|
|
|
|
disp = loader_get_instance_dispatch(physicalDevice);
|
|
|
|
disp->GetPhysicalDeviceSparseImageFormatProperties(
|
|
physicalDevice, format, type, samples, usage, tiling, pPropertyCount,
|
|
pProperties);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
|
|
const VkBindSparseInfo *pBindInfo, VkFence fence) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(queue);
|
|
|
|
return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateFence(device, pCreateInfo, pAllocator, pFence);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyFence(VkDevice device, VkFence fence,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyFence(device, fence, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->ResetFences(device, fenceCount, pFences);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkGetFenceStatus(VkDevice device, VkFence fence) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->GetFenceStatus(device, fence);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences,
|
|
VkBool32 waitAll, uint64_t timeout) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkSemaphore *pSemaphore) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroySemaphore(device, semaphore, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyEvent(VkDevice device, VkEvent event,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyEvent(device, event, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkGetEventStatus(VkDevice device, VkEvent event) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->GetEventStatus(device, event);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkSetEvent(VkDevice device, VkEvent event) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->SetEvent(device, event);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkResetEvent(VkDevice device, VkEvent event) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->ResetEvent(device, event);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkQueryPool *pQueryPool) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyQueryPool(device, queryPool, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
|
|
uint32_t firstQuery, uint32_t queryCount, size_t dataSize,
|
|
void *pData, VkDeviceSize stride,
|
|
VkQueryResultFlags flags) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount,
|
|
dataSize, pData, stride, flags);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyBuffer(VkDevice device, VkBuffer buffer,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyBuffer(device, buffer, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkBufferView *pView) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyBufferView(device, bufferView, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateImage(device, pCreateInfo, pAllocator, pImage);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyImage(VkDevice device, VkImage image,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyImage(device, image, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkGetImageSubresourceLayout(VkDevice device, VkImage image,
|
|
const VkImageSubresource *pSubresource,
|
|
VkSubresourceLayout *pLayout) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateImageView(device, pCreateInfo, pAllocator, pView);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyImageView(VkDevice device, VkImageView imageView,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyImageView(device, imageView, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateShaderModule(VkDevice device,
|
|
const VkShaderModuleCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkShaderModule *pShader) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyShaderModule(device, shaderModule, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreatePipelineCache(VkDevice device,
|
|
const VkPipelineCacheCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkPipelineCache *pPipelineCache) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreatePipelineCache(device, pCreateInfo, pAllocator,
|
|
pPipelineCache);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyPipelineCache(device, pipelineCache, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
|
|
size_t *pDataSize, void *pData) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
|
|
uint32_t srcCacheCount,
|
|
const VkPipelineCache *pSrcCaches) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->MergePipelineCaches(device, dstCache, srcCacheCount,
|
|
pSrcCaches);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkGraphicsPipelineCreateInfo *pCreateInfos,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkPipeline *pPipelines) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount,
|
|
pCreateInfos, pAllocator, pPipelines);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
|
|
uint32_t createInfoCount,
|
|
const VkComputePipelineCreateInfo *pCreateInfos,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkPipeline *pPipelines) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateComputePipelines(device, pipelineCache, createInfoCount,
|
|
pCreateInfos, pAllocator, pPipelines);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyPipeline(device, pipeline, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreatePipelineLayout(VkDevice device,
|
|
const VkPipelineLayoutCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkPipelineLayout *pPipelineLayout) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator,
|
|
pPipelineLayout);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroySampler(VkDevice device, VkSampler sampler,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroySampler(device, sampler, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateDescriptorSetLayout(VkDevice device,
|
|
const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkDescriptorSetLayout *pSetLayout) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator,
|
|
pSetLayout);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyDescriptorSetLayout(VkDevice device,
|
|
VkDescriptorSetLayout descriptorSetLayout,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateDescriptorPool(VkDevice device,
|
|
const VkDescriptorPoolCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkDescriptorPool *pDescriptorPool) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator,
|
|
pDescriptorPool);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyDescriptorPool(device, descriptorPool, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
|
|
VkDescriptorPoolResetFlags flags) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->ResetDescriptorPool(device, descriptorPool, flags);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkAllocateDescriptorSets(VkDevice device,
|
|
const VkDescriptorSetAllocateInfo *pAllocateInfo,
|
|
VkDescriptorSet *pDescriptorSets) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
|
|
uint32_t descriptorSetCount,
|
|
const VkDescriptorSet *pDescriptorSets) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount,
|
|
pDescriptorSets);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
|
|
const VkWriteDescriptorSet *pDescriptorWrites,
|
|
uint32_t descriptorCopyCount,
|
|
const VkCopyDescriptorSet *pDescriptorCopies) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites,
|
|
descriptorCopyCount, pDescriptorCopies);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkFramebuffer *pFramebuffer) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateFramebuffer(device, pCreateInfo, pAllocator,
|
|
pFramebuffer);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyFramebuffer(device, framebuffer, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkRenderPass *pRenderPass) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyRenderPass(device, renderPass, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
|
|
VkExtent2D *pGranularity) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
|
|
const VkAllocationCallbacks *pAllocator,
|
|
VkCommandPool *pCommandPool) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->CreateCommandPool(device, pCreateInfo, pAllocator,
|
|
pCommandPool);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
|
|
const VkAllocationCallbacks *pAllocator) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->DestroyCommandPool(device, commandPool, pAllocator);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
|
|
VkCommandPoolResetFlags flags) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
return disp->ResetCommandPool(device, commandPool, flags);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkAllocateCommandBuffers(VkDevice device,
|
|
const VkCommandBufferAllocateInfo *pAllocateInfo,
|
|
VkCommandBuffer *pCommandBuffers) {
|
|
const VkLayerDispatchTable *disp;
|
|
VkResult res;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
|
|
if (res == VK_SUCCESS) {
|
|
for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) {
|
|
if (pCommandBuffers[i]) {
|
|
loader_init_dispatch(pCommandBuffers[i], disp);
|
|
}
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
|
|
uint32_t commandBufferCount,
|
|
const VkCommandBuffer *pCommandBuffers) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(device);
|
|
|
|
disp->FreeCommandBuffers(device, commandPool, commandBufferCount,
|
|
pCommandBuffers);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
|
|
const VkCommandBufferBeginInfo *pBeginInfo) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
return disp->BeginCommandBuffer(commandBuffer, pBeginInfo);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
return disp->EndCommandBuffer(commandBuffer);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
|
|
vkResetCommandBuffer(VkCommandBuffer commandBuffer,
|
|
VkCommandBufferResetFlags flags) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
return disp->ResetCommandBuffer(commandBuffer, flags);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdBindPipeline(VkCommandBuffer commandBuffer,
|
|
VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
|
|
uint32_t viewportCount, const VkViewport *pViewports) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdSetViewport(commandBuffer, firstViewport, viewportCount,
|
|
pViewports);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
|
|
uint32_t scissorCount, const VkRect2D *pScissors) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdSetLineWidth(commandBuffer, lineWidth);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
|
|
float depthBiasClamp, float depthBiasSlopeFactor) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor,
|
|
depthBiasClamp, depthBiasSlopeFactor);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
|
|
const float blendConstants[4]) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdSetBlendConstants(commandBuffer, blendConstants);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
|
|
float maxDepthBounds) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
|
|
VkStencilFaceFlags faceMask, uint32_t compareMask) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
|
|
VkStencilFaceFlags faceMask, uint32_t writeMask) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
|
|
VkStencilFaceFlags faceMask, uint32_t reference) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdSetStencilReference(commandBuffer, faceMask, reference);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
|
|
VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
|
|
VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount,
|
|
const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount,
|
|
const uint32_t *pDynamicOffsets) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout,
|
|
firstSet, descriptorSetCount, pDescriptorSets,
|
|
dynamicOffsetCount, pDynamicOffsets);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
|
|
VkDeviceSize offset, VkIndexType indexType) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
|
|
uint32_t bindingCount, const VkBuffer *pBuffers,
|
|
const VkDeviceSize *pOffsets) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount,
|
|
pBuffers, pOffsets);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
|
|
uint32_t instanceCount, uint32_t firstVertex,
|
|
uint32_t firstInstance) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex,
|
|
firstInstance);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
|
|
uint32_t instanceCount, uint32_t firstIndex,
|
|
int32_t vertexOffset, uint32_t firstInstance) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex,
|
|
vertexOffset, firstInstance);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
|
|
VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
|
|
VkDeviceSize offset, uint32_t drawCount,
|
|
uint32_t stride) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount,
|
|
stride);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y,
|
|
uint32_t z) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdDispatch(commandBuffer, x, y, z);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
|
|
VkDeviceSize offset) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdDispatchIndirect(commandBuffer, buffer, offset);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
|
|
VkBuffer dstBuffer, uint32_t regionCount,
|
|
const VkBufferCopy *pRegions) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount,
|
|
pRegions);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
|
|
VkImageLayout srcImageLayout, VkImage dstImage,
|
|
VkImageLayout dstImageLayout, uint32_t regionCount,
|
|
const VkImageCopy *pRegions) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage,
|
|
dstImageLayout, regionCount, pRegions);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
|
|
VkImageLayout srcImageLayout, VkImage dstImage,
|
|
VkImageLayout dstImageLayout, uint32_t regionCount,
|
|
const VkImageBlit *pRegions, VkFilter filter) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage,
|
|
dstImageLayout, regionCount, pRegions, filter);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
|
|
VkImage dstImage, VkImageLayout dstImageLayout,
|
|
uint32_t regionCount,
|
|
const VkBufferImageCopy *pRegions) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage,
|
|
dstImageLayout, regionCount, pRegions);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
|
|
VkImageLayout srcImageLayout, VkBuffer dstBuffer,
|
|
uint32_t regionCount,
|
|
const VkBufferImageCopy *pRegions) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout,
|
|
dstBuffer, regionCount, pRegions);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
|
|
VkDeviceSize dstOffset, VkDeviceSize dataSize,
|
|
const uint32_t *pData) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
|
|
VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
|
|
VkImageLayout imageLayout, const VkClearColorValue *pColor,
|
|
uint32_t rangeCount,
|
|
const VkImageSubresourceRange *pRanges) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor,
|
|
rangeCount, pRanges);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
|
|
VkImageLayout imageLayout,
|
|
const VkClearDepthStencilValue *pDepthStencil,
|
|
uint32_t rangeCount,
|
|
const VkImageSubresourceRange *pRanges) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout,
|
|
pDepthStencil, rangeCount, pRanges);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
|
|
const VkClearAttachment *pAttachments, uint32_t rectCount,
|
|
const VkClearRect *pRects) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments,
|
|
rectCount, pRects);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
|
|
VkImageLayout srcImageLayout, VkImage dstImage,
|
|
VkImageLayout dstImageLayout, uint32_t regionCount,
|
|
const VkImageResolve *pRegions) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage,
|
|
dstImageLayout, regionCount, pRegions);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
|
|
VkPipelineStageFlags stageMask) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdSetEvent(commandBuffer, event, stageMask);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
|
|
VkPipelineStageFlags stageMask) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdResetEvent(commandBuffer, event, stageMask);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
|
|
const VkEvent *pEvents, VkPipelineStageFlags sourceStageMask,
|
|
VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount,
|
|
const VkMemoryBarrier *pMemoryBarriers,
|
|
uint32_t bufferMemoryBarrierCount,
|
|
const VkBufferMemoryBarrier *pBufferMemoryBarriers,
|
|
uint32_t imageMemoryBarrierCount,
|
|
const VkImageMemoryBarrier *pImageMemoryBarriers) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask,
|
|
dstStageMask, memoryBarrierCount, pMemoryBarriers,
|
|
bufferMemoryBarrierCount, pBufferMemoryBarriers,
|
|
imageMemoryBarrierCount, pImageMemoryBarriers);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
|
|
VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
|
|
VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
|
|
uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
|
|
uint32_t bufferMemoryBarrierCount,
|
|
const VkBufferMemoryBarrier *pBufferMemoryBarriers,
|
|
uint32_t imageMemoryBarrierCount,
|
|
const VkImageMemoryBarrier *pImageMemoryBarriers) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdPipelineBarrier(
|
|
commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
|
|
memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
|
|
pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
|
|
uint32_t slot, VkFlags flags) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
|
|
uint32_t slot) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdEndQuery(commandBuffer, queryPool, slot);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
|
|
uint32_t firstQuery, uint32_t queryCount) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
|
|
VkPipelineStageFlagBits pipelineStage,
|
|
VkQueryPool queryPool, uint32_t slot) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
|
|
uint32_t firstQuery, uint32_t queryCount,
|
|
VkBuffer dstBuffer, VkDeviceSize dstOffset,
|
|
VkDeviceSize stride, VkFlags flags) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery,
|
|
queryCount, dstBuffer, dstOffset, stride,
|
|
flags);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
|
|
VkShaderStageFlags stageFlags, uint32_t offset,
|
|
uint32_t size, const void *pValues) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size,
|
|
pValues);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
|
|
const VkRenderPassBeginInfo *pRenderPassBegin,
|
|
VkSubpassContents contents) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdNextSubpass(commandBuffer, contents);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdEndRenderPass(commandBuffer);
|
|
}
|
|
|
|
LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
|
|
vkCmdExecuteCommands(VkCommandBuffer commandBuffer,
|
|
uint32_t commandBuffersCount,
|
|
const VkCommandBuffer *pCommandBuffers) {
|
|
const VkLayerDispatchTable *disp;
|
|
|
|
disp = loader_get_dispatch(commandBuffer);
|
|
|
|
disp->CmdExecuteCommands(commandBuffer, commandBuffersCount,
|
|
pCommandBuffers);
|
|
}
|