VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
instance_layer_data *my_instance_data = GetLayerDataPtr(get_dispatch_key(gpu), instance_layer_data_map);
VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
assert(chain_info->u.pLayerInfo);
PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(my_instance_data->instance, "vkCreateDevice");
if (fpCreateDevice == NULL) {
return VK_ERROR_INITIALIZATION_FAILED;
}
// Advance the link info for the next element on the chain
chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
if (result != VK_SUCCESS) {
return result;
}
layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);
my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
// Setup layer's device dispatch table
layer_init_device_dispatch_table(*pDevice, &my_device_data->dispatch_table, fpGetDeviceProcAddr);
DeviceExtensionWhitelist(pCreateInfo, *pDevice);
// Set gpu for this device in order to get at any objects mapped at instance level
my_device_data->instance_data = my_instance_data;
return result;
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
assert(chain_info->u.pLayerInfo);
PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(NULL, "vkCreateDevice");
if (fpCreateDevice == NULL) {
return VK_ERROR_INITIALIZATION_FAILED;
}
// Advance the link info for the next element on the chain
chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
VkResult result = fpCreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
if (result != VK_SUCCESS) {
return result;
}
layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);
// Setup device dispatch table
my_device_data->device_dispatch_table = new VkLayerDispatchTable;
layer_init_device_dispatch_table(*pDevice, my_device_data->device_dispatch_table, fpGetDeviceProcAddr);
// store the loader callback for initializing created dispatchable objects
chain_info = get_chain_info(pCreateInfo, VK_LOADER_DATA_CALLBACK);
if (chain_info) {
my_device_data->pfn_dev_init = chain_info->u.pfnSetDeviceLoaderData;
} else {
my_device_data->pfn_dev_init = NULL;
}
uint32_t queue_family_count;
layer_data *my_data = GetLayerDataPtr(get_dispatch_key(gpu), layer_data_map);
my_data->instance_dispatch_table->GetPhysicalDeviceQueueFamilyProperties(gpu, &queue_family_count, NULL);
VkQueueFamilyProperties *queue_props = (VkQueueFamilyProperties *)malloc(queue_family_count * sizeof(VkQueueFamilyProperties));
if (queue_props == NULL) {
return VK_ERROR_INITIALIZATION_FAILED;
}
my_data->instance_dispatch_table->GetPhysicalDeviceQueueFamilyProperties(gpu, &queue_family_count, queue_props);
my_device_data->graphicsQueueFamilyIndex = 0;
for (uint32_t i = 0; i < pCreateInfo->queueCreateInfoCount; i++) {
if (queue_props[pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
my_device_data->graphicsQueueFamilyIndex = pCreateInfo->pQueueCreateInfos[i].queueFamilyIndex;
break;
}
}
free(queue_props);
after_device_create(gpu, *pDevice, my_device_data);
return result;
}
VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
const VkSwapchainCreateInfoKHR *pCreateInfos,
const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) {
layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
safe_VkSwapchainCreateInfoKHR *local_pCreateInfos = NULL;
{
std::lock_guard<std::mutex> lock(global_lock);
if (pCreateInfos) {
local_pCreateInfos = new safe_VkSwapchainCreateInfoKHR[swapchainCount];
for (uint32_t i = 0; i < swapchainCount; ++i) {
local_pCreateInfos[i].initialize(&pCreateInfos[i]);
if (pCreateInfos[i].surface) {
// Surface is instance-level object
local_pCreateInfos[i].surface = Unwrap(dev_data->instance_data, pCreateInfos[i].surface);
}
if (pCreateInfos[i].oldSwapchain) {
local_pCreateInfos[i].oldSwapchain = Unwrap(dev_data, pCreateInfos[i].oldSwapchain);
}
}
}
}
VkResult result = dev_data->dispatch_table.CreateSharedSwapchainsKHR(
device, swapchainCount, local_pCreateInfos->ptr(), pAllocator, pSwapchains);
if (local_pCreateInfos) delete[] local_pCreateInfos;
if (VK_SUCCESS == result) {
std::lock_guard<std::mutex> lock(global_lock);
for (uint32_t i = 0; i < swapchainCount; i++) {
pSwapchains[i] = WrapNew(dev_data, pSwapchains[i]);
}
}
return result;
}
VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device,
const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate) {
layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
safe_VkDescriptorUpdateTemplateCreateInfoKHR *local_create_info = NULL;
{
std::lock_guard<std::mutex> lock(global_lock);
if (pCreateInfo) {
local_create_info = new safe_VkDescriptorUpdateTemplateCreateInfoKHR(pCreateInfo);
if (pCreateInfo->descriptorSetLayout) {
local_create_info->descriptorSetLayout = Unwrap(dev_data, pCreateInfo->descriptorSetLayout);
}
if (pCreateInfo->pipelineLayout) {
local_create_info->pipelineLayout = Unwrap(dev_data, pCreateInfo->pipelineLayout);
}
}
}
VkResult result = dev_data->dispatch_table.CreateDescriptorUpdateTemplateKHR(
device, local_create_info->ptr(), pAllocator, pDescriptorUpdateTemplate);
if (VK_SUCCESS == result) {
std::lock_guard<std::mutex> lock(global_lock);
*pDescriptorUpdateTemplate = WrapNew(dev_data, *pDescriptorUpdateTemplate);
// Shadow template createInfo for later updates
std::unique_ptr<TEMPLATE_STATE> template_state(new TEMPLATE_STATE(*pDescriptorUpdateTemplate, local_create_info));
dev_data->desc_template_map[(uint64_t)*pDescriptorUpdateTemplate] = std::move(template_state);
}
return result;
}
static bool compile_shader(VkDevice device, char const *filename, VkShaderModule *module) {
layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::vector<unsigned char> bytecode;
if (!get_file_contents(filename, bytecode)) {
return false;
}
VkResult U_ASSERT_ONLY res;
VkShaderModuleCreateInfo smci;
smci.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
smci.pNext = nullptr;
smci.codeSize = bytecode.size();
smci.pCode = (uint32_t const *)&bytecode[0];
smci.flags = 0;
res = my_data->device_dispatch_table->CreateShaderModule(device, &smci, nullptr, module);
assert(!res);
#ifdef OVERLAY_DEBUG
printf("Compiled shader for overlay: `%s`\n", filename);
#endif
return true;
}
VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
safe_VkPresentInfoKHR *local_pPresentInfo = NULL;
{
std::lock_guard<std::mutex> lock(global_lock);
if (pPresentInfo) {
local_pPresentInfo = new safe_VkPresentInfoKHR(pPresentInfo);
if (local_pPresentInfo->pWaitSemaphores) {
for (uint32_t index1 = 0; index1 < local_pPresentInfo->waitSemaphoreCount; ++index1) {
local_pPresentInfo->pWaitSemaphores[index1] = Unwrap(dev_data, pPresentInfo->pWaitSemaphores[index1]);
}
}
if (local_pPresentInfo->pSwapchains) {
for (uint32_t index1 = 0; index1 < local_pPresentInfo->swapchainCount; ++index1) {
local_pPresentInfo->pSwapchains[index1] = Unwrap(dev_data, pPresentInfo->pSwapchains[index1]);
}
}
}
}
VkResult result = dev_data->dispatch_table.QueuePresentKHR(queue, local_pPresentInfo->ptr());
// pResults is an output array embedded in a structure. The code generator neglects to copy back from the safe_* version,
// so handle it as a special case here:
if (pPresentInfo && pPresentInfo->pResults) {
for (uint32_t i = 0; i < pPresentInfo->swapchainCount; i++) {
pPresentInfo->pResults[i] = local_pPresentInfo->pResults[i];
}
}
if (local_pPresentInfo) delete local_pPresentInfo;
return result;
}
VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(instance);
layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
pTable->DestroyInstance(instance, pAllocator);
delete pTable;
layer_data_map.erase(key);
}
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
VkLayerInstanceDispatchTable *disp_table = &instance_data->dispatch_table;
if (disp_table->GetPhysicalDeviceProcAddr == NULL) {
return NULL;
}
return disp_table->GetPhysicalDeviceProcAddr(instance, funcName);
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits,
VkFence fence) {
layer_data *my_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
my_data->cmdBuffersThisFrame += submitCount; // XXX WRONG
return pTable->QueueSubmit(queue, submitCount, pSubmits, fence);
}
VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(device);
layer_data *dev_data = GetLayerDataPtr(key, layer_data_map);
layer_debug_report_destroy_device(device);
dev_data->dispatch_table.DestroyDevice(device, pAllocator);
FreeLayerDataPtr(key, layer_data_map);
}
VKAPI_ATTR void VKAPI_CALL GetOriginalPhysicalDeviceFormatPropertiesEXT(VkPhysicalDevice physicalDevice, VkFormat format,
VkFormatProperties *properties) {
std::lock_guard<std::mutex> lock(global_lock);
auto device_profile_api_data_it = device_profile_api_dev_data_map.find(physicalDevice);
if (device_profile_api_data_it != device_profile_api_dev_data_map.end()) {
layer_data *device_profile_data =
GetLayerDataPtr(get_dispatch_key(device_profile_api_dev_data_map[physicalDevice].instance), layer_data_map);
device_profile_data->instance_dispatch_table->GetPhysicalDeviceFormatProperties(physicalDevice, format, properties);
}
}
VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(device);
layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
my_data->Cleanup();
VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
pTable->DeviceWaitIdle(device);
pTable->DestroyDevice(device, pAllocator);
delete pTable;
layer_data_map.erase(key);
}
VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName,
uint32_t *pCount, VkExtensionProperties *pProperties) {
if (pLayerName && !strcmp(pLayerName, globalLayerProps.layerName))
return util_GetExtensionProperties(0, nullptr, pCount, pProperties);
assert(physicalDevice);
dispatch_key key = get_dispatch_key(physicalDevice);
instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map);
return instance_data->dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
}
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(VkInstance instance, const char *funcName) {
const auto item = name_to_funcptr_map.find(funcName);
if (item != name_to_funcptr_map.end()) {
return reinterpret_cast<PFN_vkVoidFunction>(item->second);
}
instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
const auto &table = instance_data->dispatch_table;
if (!table.GetInstanceProcAddr) return nullptr;
return table.GetInstanceProcAddr(instance, funcName);
}
VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
{
std::lock_guard<std::mutex> lock(global_lock);
mode = Unwrap(dev_data, mode);
}
VkResult result =
dev_data->dispatch_table.GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
return result;
}
void WsiImageData::Cleanup(VkDevice dev) {
layer_data *my_data = GetLayerDataPtr(get_dispatch_key(dev), layer_data_map);
VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
pTable->DeviceWaitIdle(dev);
// XXX: needs device data
// pTable->FreeCommandBuffers(dev, cmd, nullptr);
pTable->DestroyFramebuffer(dev, framebuffer, nullptr);
pTable->DestroyImageView(dev, view, nullptr);
pTable->DestroyBuffer(dev, vertexBuffer, nullptr);
pTable->FreeMemory(dev, vertexBufferMemory, nullptr);
}
VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
const VkAllocationCallbacks *pAllocator) {
layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
uint64_t descriptor_update_template_id = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
dev_data->desc_template_map.erase(descriptor_update_template_id);
descriptorUpdateTemplate = (VkDescriptorUpdateTemplateKHR)dev_data->unique_id_mapping[descriptor_update_template_id];
dev_data->unique_id_mapping.erase(descriptor_update_template_id);
lock.unlock();
dev_data->dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
}
VKAPI_ATTR void VKAPI_CALL GetOriginalPhysicalDeviceLimitsEXT(VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits *orgLimits) {
std::lock_guard<std::mutex> lock(global_lock);
auto device_profile_api_data_it = device_profile_api_dev_data_map.find(physicalDevice);
if (device_profile_api_data_it != device_profile_api_dev_data_map.end()) {
layer_data *device_profile_data = GetLayerDataPtr(get_dispatch_key(device_profile_api_dev_data_map[physicalDevice].instance), layer_data_map);
VkPhysicalDeviceProperties props;
device_profile_data->instance_dispatch_table
->GetPhysicalDeviceProperties(physicalDevice, &props);
memcpy(orgLimits, &props.limits, sizeof(VkPhysicalDeviceLimits));
}
}
VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
VkInstance *pInstance) {
VkLayerInstanceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
assert(chain_info->u.pLayerInfo);
PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
PFN_vkCreateInstance fpCreateInstance = (PFN_vkCreateInstance)fpGetInstanceProcAddr(NULL, "vkCreateInstance");
if (fpCreateInstance == NULL) {
return VK_ERROR_INITIALIZATION_FAILED;
}
// Advance the link info for the next element on the chain
chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
if (result != VK_SUCCESS) {
return result;
}
instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), instance_layer_data_map);
instance_data->instance = *pInstance;
layer_init_instance_dispatch_table(*pInstance, &instance_data->dispatch_table, fpGetInstanceProcAddr);
instance_data->instance = *pInstance;
instance_data->report_data =
debug_report_create_instance(&instance_data->dispatch_table, *pInstance, pCreateInfo->enabledExtensionCount,
pCreateInfo->ppEnabledExtensionNames);
// Set up temporary debug callbacks to output messages at CreateInstance-time
if (!layer_copy_tmp_callbacks(pCreateInfo->pNext, &instance_data->num_tmp_callbacks, &instance_data->tmp_dbg_create_infos,
&instance_data->tmp_callbacks)) {
if (instance_data->num_tmp_callbacks > 0) {
if (layer_enable_tmp_callbacks(instance_data->report_data, instance_data->num_tmp_callbacks,
instance_data->tmp_dbg_create_infos, instance_data->tmp_callbacks)) {
layer_free_tmp_callbacks(instance_data->tmp_dbg_create_infos, instance_data->tmp_callbacks);
instance_data->num_tmp_callbacks = 0;
}
}
}
initUniqueObjects(instance_data, pAllocator);
InstanceExtensionWhitelist(pCreateInfo, *pInstance);
// Disable and free tmp callbacks, no longer necessary
if (instance_data->num_tmp_callbacks > 0) {
layer_disable_tmp_callbacks(instance_data->report_data, instance_data->num_tmp_callbacks, instance_data->tmp_callbacks);
layer_free_tmp_callbacks(instance_data->tmp_dbg_create_infos, instance_data->tmp_callbacks);
instance_data->num_tmp_callbacks = 0;
}
return result;
}
VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
layer_data *my_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
for (uint32_t i = 0; i < pPresentInfo->swapchainCount; i++) {
auto data = my_data->swapChains->find(pPresentInfo->pSwapchains[i]);
assert(data != my_data->swapChains->end());
before_present(queue, my_data, data->second, pPresentInfo->pImageIndices[i]);
}
VkResult result = my_data->pfnQueuePresentKHR(queue, pPresentInfo);
return result;
}
// Check enabled device extensions against supported device extension whitelist
static void DeviceExtensionWhitelist(const VkDeviceCreateInfo *pCreateInfo, VkDevice device) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
// Check for recognized device extensions
if (!white_list(pCreateInfo->ppEnabledExtensionNames[i], kUniqueObjectsSupportedDeviceExtensions)) {
log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
VALIDATION_ERROR_UNDEFINED, "UniqueObjects",
"Device Extension %s is not supported by this layer. Using this extension may adversely affect "
"validation results and/or produce undefined behavior.",
pCreateInfo->ppEnabledExtensionNames[i]);
}
}
}
void SwapChainData::Cleanup(VkDevice dev) {
layer_data *my_data = GetLayerDataPtr(get_dispatch_key(dev), layer_data_map);
VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
for (uint32_t i = 0; i < presentableImages.size(); i++) {
presentableImages[i]->Cleanup(dev);
delete presentableImages[i];
}
presentableImages.clear();
pTable->DestroyPipeline(dev, pipeline, nullptr);
pTable->DestroyRenderPass(dev, render_pass, nullptr);
}
VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
auto local_name_info = new safe_VkDebugMarkerObjectNameInfoEXT(pNameInfo);
{
std::lock_guard<std::mutex> lock(global_lock);
auto it = device_data->unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_name_info->object));
if (it != device_data->unique_id_mapping.end()) {
local_name_info->object = it->second;
}
}
VkResult result = device_data->dispatch_table.DebugMarkerSetObjectNameEXT(
device, reinterpret_cast<VkDebugMarkerObjectNameInfoEXT *>(local_name_info));
return result;
}
VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
const VkAllocationCallbacks *pAllocator) {
layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
/* Clean up our resources associated with this swapchain */
auto it = my_data->swapChains->find(swapchain);
assert(it != my_data->swapChains->end());
it->second->Cleanup(device);
delete it->second;
my_data->swapChains->erase(it->first);
my_data->pfnDestroySwapchainKHR(device, swapchain, pAllocator);
}
VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
VkDisplayPropertiesKHR *pProperties) {
instance_layer_data *my_map_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
VkResult result = my_map_data->dispatch_table.GetPhysicalDeviceDisplayPropertiesKHR(
physicalDevice, pPropertyCount, pProperties);
if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
std::lock_guard<std::mutex> lock(global_lock);
for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
pProperties[idx0].display = WrapNew(my_map_data, pProperties[idx0].display);
}
}
return result;
}
VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
VkPipelineLayout layout, uint32_t set, const void *pData) {
layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
uint64_t template_handle = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
{
std::lock_guard<std::mutex> lock(global_lock);
descriptorUpdateTemplate = Unwrap(dev_data, descriptorUpdateTemplate);
layout = Unwrap(dev_data, layout);
}
void *unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(dev_data, template_handle, pData);
dev_data->dispatch_table.CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set,
unwrapped_buffer);
free(unwrapped_buffer);
}
VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet descriptorSet,
VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
const void *pData) {
layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
uint64_t template_handle = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
{
std::lock_guard<std::mutex> lock(global_lock);
descriptorSet = Unwrap(dev_data, descriptorSet);
descriptorUpdateTemplate = (VkDescriptorUpdateTemplateKHR)dev_data->unique_id_mapping[template_handle];
}
void *unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(dev_data, template_handle, pData);
dev_data->dispatch_table.UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate,
unwrapped_buffer);
free(unwrapped_buffer);
}
static uint32_t choose_memory_type(VkPhysicalDevice gpu, uint32_t typeBits, VkMemoryPropertyFlags properties) {
layer_data *my_data = GetLayerDataPtr(get_dispatch_key(gpu), layer_data_map);
VkPhysicalDeviceMemoryProperties props;
my_data->instance_dispatch_table->GetPhysicalDeviceMemoryProperties(gpu, &props);
for (auto i = 0u; i < props.memoryTypeCount; i++) {
if ((1 << i) & typeBits) {
if ((props.memoryTypes[i].propertyFlags & properties) == properties) return i;
}
}
assert(!"Failed to choose memory type");
return 0;
}
VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(instance);
instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map);
VkLayerInstanceDispatchTable *disp_table = &instance_data->dispatch_table;
disp_table->DestroyInstance(instance, pAllocator);
// Clean up logging callback, if any
while (instance_data->logging_callback.size() > 0) {
VkDebugReportCallbackEXT callback = instance_data->logging_callback.back();
layer_destroy_msg_callback(instance_data->report_data, callback, pAllocator);
instance_data->logging_callback.pop_back();
}
layer_debug_report_destroy_instance(instance_data->report_data);
FreeLayerDataPtr(key, instance_layer_data_map);
}
VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo *pCreateInfos,
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
safe_VkGraphicsPipelineCreateInfo *local_pCreateInfos = nullptr;
if (pCreateInfos) {
local_pCreateInfos = new safe_VkGraphicsPipelineCreateInfo[createInfoCount];
std::lock_guard<std::mutex> lock(global_lock);
for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
local_pCreateInfos[idx0].initialize(&pCreateInfos[idx0]);
if (pCreateInfos[idx0].basePipelineHandle) {
local_pCreateInfos[idx0].basePipelineHandle = Unwrap(device_data, pCreateInfos[idx0].basePipelineHandle);
}
if (pCreateInfos[idx0].layout) {
local_pCreateInfos[idx0].layout = Unwrap(device_data, pCreateInfos[idx0].layout);
}
if (pCreateInfos[idx0].pStages) {
for (uint32_t idx1 = 0; idx1 < pCreateInfos[idx0].stageCount; ++idx1) {
if (pCreateInfos[idx0].pStages[idx1].module) {
local_pCreateInfos[idx0].pStages[idx1].module = Unwrap(device_data, pCreateInfos[idx0].pStages[idx1].module);
}
}
}
if (pCreateInfos[idx0].renderPass) {
local_pCreateInfos[idx0].renderPass = Unwrap(device_data, pCreateInfos[idx0].renderPass);
}
}
}
if (pipelineCache) {
std::lock_guard<std::mutex> lock(global_lock);
pipelineCache = Unwrap(device_data, pipelineCache);
}
VkResult result = device_data->dispatch_table.CreateGraphicsPipelines(
device, pipelineCache, createInfoCount, local_pCreateInfos->ptr(), pAllocator, pPipelines);
delete[] local_pCreateInfos;
{
std::lock_guard<std::mutex> lock(global_lock);
for (uint32_t i = 0; i < createInfoCount; ++i) {
if (pPipelines[i] != VK_NULL_HANDLE) {
pPipelines[i] = WrapNew(device_data, pPipelines[i]);
}
}
}
return result;
}
