VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
if (result != VK_SUCCESS) return result;
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(*pInstance), instance_layer_data_map);
+ 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->report_data = debug_report_create_instance(
dispatch_key key = get_dispatch_key(instance);
// TBD: Need any locking this early, in case this function is called at the
// same time by more than one thread?
- instance_layer_data *instance_data = get_my_data_ptr(key, instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(key, instance_layer_data_map);
instance_data->dispatch_table.DestroyInstance(instance, pAllocator);
std::lock_guard<std::mutex> lock(global_lock);
static void checkDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, VkDevice device) {
uint32_t i;
// TBD: Need any locking, in case this function is called at the same time by more than one thread?
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
dev_data->device_extensions.wsi_enabled = false;
dev_data->device_extensions.wsi_display_swapchain_enabled = false;
dev_data->device_extensions.nv_glsl_shader_enabled = false;
VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
- instance_layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(gpu), instance_layer_data_map);
bool skip_call = false;
// Check that any requested features are available
if (pCreateInfo->pEnabledFeatures) {
- skip_call |= ValidateRequestedFeatures(my_instance_data, gpu, pCreateInfo->pEnabledFeatures);
+ skip_call |= ValidateRequestedFeatures(instance_data, gpu, pCreateInfo->pEnabledFeatures);
}
- skip_call |= ValidateRequestedQueueFamilyProperties(my_instance_data, gpu, pCreateInfo);
+ skip_call |= ValidateRequestedQueueFamilyProperties(instance_data, gpu, pCreateInfo);
if (skip_call) {
return VK_ERROR_VALIDATION_FAILED_EXT;
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");
+ PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(instance_data->instance, "vkCreateDevice");
if (fpCreateDevice == NULL) {
return VK_ERROR_INITIALIZATION_FAILED;
}
}
std::unique_lock<std::mutex> lock(global_lock);
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);
- my_device_data->instance_data = my_instance_data;
+ device_data->instance_data = instance_data;
// Setup device dispatch table
- layer_init_device_dispatch_table(*pDevice, &my_device_data->dispatch_table, fpGetDeviceProcAddr);
- my_device_data->device = *pDevice;
+ layer_init_device_dispatch_table(*pDevice, &device_data->dispatch_table, fpGetDeviceProcAddr);
+ device_data->device = *pDevice;
// Save PhysicalDevice handle
- my_device_data->physical_device = gpu;
+ device_data->physical_device = gpu;
- my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
+ device_data->report_data = layer_debug_report_create_device(instance_data->report_data, *pDevice);
checkDeviceRegisterExtensions(pCreateInfo, *pDevice);
// Get physical device limits for this device
- my_instance_data->dispatch_table.GetPhysicalDeviceProperties(gpu, &(my_device_data->phys_dev_properties.properties));
+ instance_data->dispatch_table.GetPhysicalDeviceProperties(gpu, &(device_data->phys_dev_properties.properties));
uint32_t count;
- my_instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties(gpu, &count, nullptr);
- my_device_data->phys_dev_properties.queue_family_properties.resize(count);
- my_instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties(
- gpu, &count, &my_device_data->phys_dev_properties.queue_family_properties[0]);
+ instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties(gpu, &count, nullptr);
+ device_data->phys_dev_properties.queue_family_properties.resize(count);
+ instance_data->dispatch_table.GetPhysicalDeviceQueueFamilyProperties(
+ gpu, &count, &device_data->phys_dev_properties.queue_family_properties[0]);
// TODO: device limits should make sure these are compatible
if (pCreateInfo->pEnabledFeatures) {
- my_device_data->enabled_features = *pCreateInfo->pEnabledFeatures;
+ device_data->enabled_features = *pCreateInfo->pEnabledFeatures;
} else {
- memset(&my_device_data->enabled_features, 0, sizeof(VkPhysicalDeviceFeatures));
+ memset(&device_data->enabled_features, 0, sizeof(VkPhysicalDeviceFeatures));
}
// Store physical device properties and physical device mem limits into device layer_data structs
- my_instance_data->dispatch_table.GetPhysicalDeviceMemoryProperties(gpu, &my_device_data->phys_dev_mem_props);
- my_instance_data->dispatch_table.GetPhysicalDeviceProperties(gpu, &my_device_data->phys_dev_props);
+ instance_data->dispatch_table.GetPhysicalDeviceMemoryProperties(gpu, &device_data->phys_dev_mem_props);
+ instance_data->dispatch_table.GetPhysicalDeviceProperties(gpu, &device_data->phys_dev_props);
lock.unlock();
ValidateLayerOrdering(*pCreateInfo);
// TODOSC : Shouldn't need any customization here
bool skip = false;
dispatch_key key = get_dispatch_key(device);
- layer_data *dev_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(key, layer_data_map);
// Free all the memory
std::unique_lock<std::mutex> lock(global_lock);
deletePipelines(dev_data);
VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateAllocateMemory(dev_data);
if (!skip) {
}
VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
DEVICE_MEM_INFO *mem_info = nullptr;
VK_OBJECT obj_struct;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, VkBool32 waitAll,
uint64_t timeout) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
// Verify fence status of submitted fences
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateWaitForFences(dev_data, fenceCount, pFences);
static void PostCallRecordGetFenceStatus(layer_data *dev_data, VkFence fence) { RetireFence(dev_data, fence); }
VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateGetFenceStatus(dev_data, fence);
lock.unlock();
}
VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
dev_data->dispatch_table.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
std::lock_guard<std::mutex> lock(global_lock);
}
VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
QUEUE_STATE *queue_state = nullptr;
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateQueueWaitIdle(dev_data, queue, &queue_state);
}
VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateDeviceWaitIdle(dev_data);
lock.unlock();
static void PostCallRecordDestroyFence(layer_data *dev_data, VkFence fence) { dev_data->fenceMap.erase(fence); }
VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
// Common data objects used pre & post call
FENCE_NODE *fence_node = nullptr;
VK_OBJECT obj_struct;
static void PostCallRecordDestroySemaphore(layer_data *dev_data, VkSemaphore sema) { dev_data->semaphoreMap.erase(sema); }
VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
SEMAPHORE_NODE *sema_node;
VK_OBJECT obj_struct;
std::unique_lock<std::mutex> lock(global_lock);
}
VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
EVENT_STATE *event_state = nullptr;
VK_OBJECT obj_struct;
std::unique_lock<std::mutex> lock(global_lock);
}
VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
QUERY_POOL_NODE *qp_state = nullptr;
VK_OBJECT obj_struct;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount,
size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
unordered_map<QueryObject, vector<VkCommandBuffer>> queries_in_flight;
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateGetQueryPoolResults(dev_data, queryPool, firstQuery, queryCount, flags, &queries_in_flight);
}
VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
BUFFER_STATE *buffer_state = nullptr;
VK_OBJECT obj_struct;
std::unique_lock<std::mutex> lock(global_lock);
}
VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
// Common data objects used pre & post call
BUFFER_VIEW_STATE *buffer_view_state = nullptr;
VK_OBJECT obj_struct;
}
VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
IMAGE_STATE *image_state = nullptr;
VK_OBJECT obj_struct;
std::unique_lock<std::mutex> lock(global_lock);
}
VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
std::unique_lock<std::mutex> lock(global_lock);
// Track objects tied to memory
VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
VkMemoryRequirements *pMemoryRequirements) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
dev_data->dispatch_table.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
auto buffer_state = getBufferState(dev_data, buffer);
if (buffer_state) {
}
VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
dev_data->dispatch_table.GetImageMemoryRequirements(device, image, pMemoryRequirements);
auto image_state = getImageState(dev_data, image);
if (image_state) {
}
VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
// Common data objects used pre & post call
IMAGE_VIEW_STATE *image_view_state = nullptr;
VK_OBJECT obj_struct;
VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
dev_data->shaderModuleMap.erase(shaderModule);
}
VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
PIPELINE_STATE *pipeline_state = nullptr;
VK_OBJECT obj_struct;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
dev_data->pipelineLayoutMap.erase(pipelineLayout);
lock.unlock();
}
VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
SAMPLER_STATE *sampler_state = nullptr;
VK_OBJECT obj_struct;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
dev_data->dispatch_table.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
std::unique_lock<std::mutex> lock(global_lock);
PostCallRecordDestroyDescriptorSetLayout(dev_data, descriptorSetLayout);
VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
DESCRIPTOR_POOL_STATE *desc_pool_state = nullptr;
VK_OBJECT obj_struct;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
const VkCommandBuffer *pCommandBuffers) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip_call = false;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = false;
if (pCreateInfo && pCreateInfo->queryType == VK_QUERY_TYPE_PIPELINE_STATISTICS) {
if (!dev_data->enabled_features.pipelineStatisticsQuery) {
// Destroy commandPool along with all of the commandBuffers allocated from that pool
VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
COMMAND_POOL_NODE *cp_state = nullptr;
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateDestroyCommandPool(dev_data, commandPool, &cp_state);
}
VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip_call = false;
std::unique_lock<std::mutex> lock(global_lock);
}
VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip_call = false;
std::unique_lock<std::mutex> lock(global_lock);
for (uint32_t i = 0; i < fenceCount; ++i) {
}
VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
FRAMEBUFFER_STATE *framebuffer_state = nullptr;
VK_OBJECT obj_struct;
std::unique_lock<std::mutex> lock(global_lock);
}
VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
RENDER_PASS_STATE *rp_state = nullptr;
VK_OBJECT obj_struct;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
// TODO: Add check for VALIDATION_ERROR_00658
// TODO: Add check for VALIDATION_ERROR_00666
// TODO: Add check for VALIDATION_ERROR_00667
VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkBufferView *pView) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
bool skip_call = PreCallValidateCreateBufferView(dev_data, pCreateInfo);
lock.unlock();
VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip = PreCallValidateCreateImage(dev_data, pCreateInfo, pAllocator, pImage);
if (!skip) {
result = dev_data->dispatch_table.CreateImage(device, pCreateInfo, pAllocator, pImage);
VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateCreateImageView(dev_data, pCreateInfo);
lock.unlock();
VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.CreateFence(device, pCreateInfo, pAllocator, pFence);
if (VK_SUCCESS == result) {
std::lock_guard<std::mutex> lock(global_lock);
// TODO handle pipeline caches
VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
return result;
}
VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
dev_data->dispatch_table.DestroyPipelineCache(device, pipelineCache, pAllocator);
}
VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t *pDataSize,
void *pData) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
return result;
}
VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount,
const VkPipelineCache *pSrcCaches) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
return result;
}
const VkGraphicsPipelineCreateInfo *create_infos, vector<PIPELINE_STATE *> &pipe_state) {
bool skip = false;
instance_layer_data *instance_data =
- get_my_data_ptr(get_dispatch_key(device_data->instance_data->instance), instance_layer_data_map);
+ GetLayerDataPtr(get_dispatch_key(device_data->instance_data->instance), instance_layer_data_map);
for (uint32_t i = 0; i < count; i++) {
skip |= verifyPipelineCreateState(device_data, pipe_state, i);
bool skip = false;
// TODO : Improve this data struct w/ unique_ptrs so cleanup below is automatic
vector<PIPELINE_STATE *> pipe_state(count);
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
uint32_t i = 0;
std::unique_lock<std::mutex> lock(global_lock);
// TODO : Improve this data struct w/ unique_ptrs so cleanup below is automatic
vector<PIPELINE_STATE *> pPipeState(count);
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
uint32_t i = 0;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.CreateSampler(device, pCreateInfo, pAllocator, pSampler);
if (VK_SUCCESS == result) {
std::lock_guard<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDescriptorSetLayout *pSetLayout) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateCreateDescriptorSetLayout(dev_data, pCreateInfo);
VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
// TODO : Add checks for VALIDATION_ERRORS 865-871
// Push Constant Range checks
uint32_t i, j;
VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
if (VK_SUCCESS == result) {
if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags) {
// TODO : Add checks for VALIDATION_ERROR_00928
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.ResetDescriptorPool(device, descriptorPool, flags);
if (VK_SUCCESS == result) {
std::lock_guard<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo,
VkDescriptorSet *pDescriptorSets) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
cvdescriptorset::AllocateDescriptorSetsData common_data(pAllocateInfo->descriptorSetCount);
bool skip_call = PreCallValidateAllocateDescriptorSets(dev_data, pAllocateInfo, &common_data);
VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count,
const VkDescriptorSet *pDescriptorSets) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
// Make sure that no sets being destroyed are in-flight
std::unique_lock<std::mutex> lock(global_lock);
bool skip_call = PreCallValidateFreeDescriptorSets(dev_data, descriptorPool, count, pDescriptorSets);
const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount,
const VkCopyDescriptorSet *pDescriptorCopies) {
// Only map look-up at top level is for device-level layer_data
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
bool skip_call = PreCallValidateUpdateDescriptorSets(dev_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
pDescriptorCopies);
VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pCreateInfo,
VkCommandBuffer *pCommandBuffer) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
if (VK_SUCCESS == result) {
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
// Validate command buffer level
GLOBAL_CB_NODE *cb_node = getCBNode(dev_data, commandBuffer);
VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) {
bool skip_call = false;
VkResult result = VK_SUCCESS;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
VkCommandPool cmdPool = pCB->createInfo.commandPool;
VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline) {
bool skip = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *cb_state = getCBNode(dev_data, commandBuffer);
if (cb_state) {
VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount,
const VkViewport *pViewports) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount,
const VkRect2D *pScissors) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp,
float depthBiasSlopeFactor) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
uint32_t compareMask) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount,
const uint32_t *pDynamicOffsets) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
VkIndexType indexType) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
// TODO : Somewhere need to verify that IBs have correct usage state flagged
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
// TODO : Somewhere need to verify that VBs have correct usage state flagged
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
uint32_t firstVertex, uint32_t firstInstance) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
GLOBAL_CB_NODE *cb_state = nullptr;
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateCmdDraw(dev_data, commandBuffer, false, VK_PIPELINE_BIND_POINT_GRAPHICS, &cb_state, "vkCmdDraw()");
VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
GLOBAL_CB_NODE *cb_state = nullptr;
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateCmdDrawIndexed(dev_data, commandBuffer, true, VK_PIPELINE_BIND_POINT_GRAPHICS, &cb_state,
VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
uint32_t stride) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
GLOBAL_CB_NODE *cb_state = nullptr;
BUFFER_STATE *buffer_state = nullptr;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
uint32_t count, uint32_t stride) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
GLOBAL_CB_NODE *cb_state = nullptr;
BUFFER_STATE *buffer_state = nullptr;
std::unique_lock<std::mutex> lock(global_lock);
}
VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
GLOBAL_CB_NODE *cb_state = nullptr;
std::unique_lock<std::mutex> lock(global_lock);
bool skip =
}
VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
GLOBAL_CB_NODE *cb_state = nullptr;
BUFFER_STATE *buffer_state = nullptr;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
uint32_t regionCount, const VkBufferCopy *pRegions) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto cb_node = getCBNode(dev_data, commandBuffer);
VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageCopy *pRegions) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto cb_node = getCBNode(dev_data, commandBuffer);
VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageBlit *pRegions, VkFilter filter) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto cb_node = getCBNode(dev_data, commandBuffer);
VkImageLayout dstImageLayout, uint32_t regionCount,
const VkBufferImageCopy *pRegions) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto cb_node = getCBNode(dev_data, commandBuffer);
VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto cb_node = getCBNode(dev_data, commandBuffer);
VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
VkDeviceSize dataSize, const uint32_t *pData) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto cb_node = getCBNode(dev_data, commandBuffer);
VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
VkDeviceSize size, uint32_t data) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto cb_node = getCBNode(dev_data, commandBuffer);
const VkClearAttachment *pAttachments, uint32_t rectCount,
const VkClearRect *pRects) {
bool skip = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
{
std::lock_guard<std::mutex> lock(global_lock);
skip = PreCallValidateCmdClearAttachments(dev_data, commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
const VkClearColorValue *pColor, uint32_t rangeCount,
const VkImageSubresourceRange *pRanges) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateCmdClearColorImage(dev_data, commandBuffer, image, imageLayout, rangeCount, pRanges);
VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
const VkImageSubresourceRange *pRanges) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
bool skip = PreCallValidateCmdClearDepthStencilImage(dev_data, commandBuffer, image, imageLayout, rangeCount, pRanges);
VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageResolve *pRegions) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto cb_node = getCBNode(dev_data, commandBuffer);
VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource,
VkSubresourceLayout *pLayout) {
bool skipCall = false;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkFormat format;
auto imageEntry = getImageState(device_data, image);
}
bool setEventStageMask(VkQueue queue, VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
pCB->eventToStageMap[event] = stageMask;
VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
const VkBufferMemoryBarrier *pBufferMemBarriers, uint32_t imageMemBarrierCount,
const VkImageMemoryBarrier *pImageMemBarriers) {
bool skip = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(cmdBuffer), layer_data_map);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, cmdBuffer);
if (pCB->activeRenderPass && memBarrierCount) {
if (!pCB->activeRenderPass->hasSelfDependency[pCB->activeSubpass]) {
VkPipelineStageFlags sourceStageMask) {
bool skip_call = false;
VkPipelineStageFlags stageMask = 0;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
for (uint32_t i = 0; i < eventCount; ++i) {
auto event = pCB->events[firstEventIndex + i];
auto queue_data = dev_data->queueMap.find(queue);
const char *function, UNIQUE_VALIDATION_ERROR_CODE error_code) {
bool skip = false;
uint32_t queue_family_index = dev_data->commandPoolMap[cb_state->createInfo.commandPool].queueFamilyIndex;
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(dev_data->physical_device), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(dev_data->physical_device), instance_layer_data_map);
auto physical_device_state = getPhysicalDeviceState(instance_data, dev_data->physical_device);
// Any pipeline stage included in srcStageMask or dstStageMask must be supported by the capabilities of the queue family
uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) {
bool skip = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *cb_state = getCBNode(dev_data, commandBuffer);
if (cb_state) {
uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) {
bool skip = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *cb_state = getCBNode(dev_data, commandBuffer);
if (cb_state) {
}
bool setQueryState(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject object, bool value) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
pCB->queryToStateMap[object] = value;
VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
uint32_t queryCount) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
bool validateQuery(VkQueue queue, GLOBAL_CB_NODE *pCB, VkQueryPool queryPool, uint32_t queryCount, uint32_t firstQuery) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(pCB->commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(pCB->commandBuffer), layer_data_map);
auto queue_data = dev_data->queueMap.find(queue);
if (queue_data == dev_data->queueMap.end()) return false;
for (uint32_t i = 0; i < queryCount; i++) {
uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
VkDeviceSize stride, VkQueryResultFlags flags) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto cb_node = getCBNode(dev_data, commandBuffer);
VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags,
uint32_t offset, uint32_t size, const void *pValues) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool, uint32_t slot) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
bool skip_call = PreCallValidateCreateFramebuffer(dev_data, pCreateInfo);
lock.unlock();
VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip_call = false;
spv_result_t spv_valid = SPV_SUCCESS;
VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
// TODO: As part of wrapping up the mem_tracker/core_validation merge the following routine should be consolidated with
VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
VkSubpassContents contents) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *cb_node = getCBNode(dev_data, commandBuffer);
auto render_pass_state = pRenderPassBegin ? getRenderPassState(dev_data, pRenderPassBegin->renderPass) : nullptr;
VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto pCB = getCBNode(dev_data, commandBuffer);
FRAMEBUFFER_STATE *framebuffer = NULL;
VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount,
const VkCommandBuffer *pCommandBuffers) {
bool skip_call = false;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
if (pCB) {
VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags,
void **ppData) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip_call = false;
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
}
VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory mem) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip_call = false;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount,
const VkMappedMemoryRange *pMemRanges) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (!PreCallValidateFlushMappedMemoryRanges(dev_data, memRangeCount, pMemRanges)) {
result = dev_data->dispatch_table.FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount,
const VkMappedMemoryRange *pMemRanges) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (!PreCallValidateInvalidateMappedMemoryRanges(dev_data, memRangeCount, pMemRanges)) {
result = dev_data->dispatch_table.InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
}
VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip_call = false;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event) {
bool skip_call = false;
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto event_state = getEventNode(dev_data, event);
if (event_state) {
VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo,
VkFence fence) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip_call = false;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
if (result == VK_SUCCESS) {
std::lock_guard<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.CreateEvent(device, pCreateInfo, pAllocator, pEvent);
if (result == VK_SUCCESS) {
std::lock_guard<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
auto surface_state = getSurfaceState(dev_data->instance_data, pCreateInfo->surface);
auto old_swapchain_state = getSwapchainNode(dev_data, pCreateInfo->oldSwapchain);
}
VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip_call = false;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pCount,
VkImage *pSwapchainImages) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = dev_data->dispatch_table.GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages);
if (result == VK_SUCCESS && pSwapchainImages != NULL) {
}
VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
bool skip_call = false;
std::lock_guard<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
const VkSwapchainCreateInfoKHR *pCreateInfos,
const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::vector<SURFACE_STATE *> surface_state;
std::vector<SWAPCHAIN_NODE *> old_swapchain_state;
VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip_call = false;
std::unique_lock<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
VkPhysicalDevice *pPhysicalDevices) {
bool skip_call = false;
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
assert(instance_data);
// For this instance, flag when vkEnumeratePhysicalDevices goes to QUERY_COUNT and then QUERY_DETAILS
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pCount,
VkQueueFamilyProperties *pQueueFamilyProperties) {
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice);
assert(physical_device_state);
bool skip =
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice);
assert(physical_device_state);
bool skip = PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR(instance_data, physical_device_state,
template <typename TCreateInfo, typename FPtr>
static VkResult CreateSurface(VkInstance instance, TCreateInfo const *pCreateInfo, VkAllocationCallbacks const *pAllocator,
VkSurfaceKHR *pSurface, FPtr fptr) {
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
// Call down the call chain:
VkResult result = (instance_data->dispatch_table.*fptr)(instance, pCreateInfo, pAllocator, pSurface);
VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) {
bool skip_call = false;
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto surface_state = getSurfaceState(instance_data, surface);
VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
- auto instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice);
VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
VkSurfaceKHR surface, VkBool32 *pSupported) {
- auto instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto surface_state = getSurfaceState(instance_data, surface);
lock.unlock();
uint32_t *pPresentModeCount,
VkPresentModeKHR *pPresentModes) {
bool skip_call = false;
- auto instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
// TODO: this isn't quite right. available modes may differ by surface AND physical device.
auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice);
uint32_t *pSurfaceFormatCount,
VkSurfaceFormatKHR *pSurfaceFormats) {
bool skip_call = false;
- auto instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
auto physical_device_state = getPhysicalDeviceState(instance_data, physicalDevice);
auto &call_state = physical_device_state->vkGetPhysicalDeviceSurfaceFormatsKHRState;
const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackEXT *pMsgCallback) {
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
VkResult res = instance_data->dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
if (VK_SUCCESS == res) {
std::lock_guard<std::mutex> lock(global_lock);
VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
const VkAllocationCallbacks *pAllocator) {
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
instance_data->dispatch_table.DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
std::lock_guard<std::mutex> lock(global_lock);
layer_destroy_msg_callback(instance_data->report_data, msgCallback, pAllocator);
VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
instance_data->dispatch_table.DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
}
assert(physicalDevice);
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
return instance_data->dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
}
proc = intercept_khr_swapchain_command(funcName, dev);
if (proc) return proc;
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(dev), layer_data_map);
auto &table = dev_data->dispatch_table;
if (!table.GetDeviceProcAddr) return nullptr;
assert(instance);
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
proc = debug_report_get_instance_proc_addr(instance_data->report_data, funcName);
if (proc) return proc;
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
assert(instance);
- instance_layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
auto &table = instance_data->dispatch_table;
if (!table.GetPhysicalDeviceProcAddr) return nullptr;
layer_data *dev_data = nullptr;
if (dev) {
- dev_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map);
+ dev_data = GetLayerDataPtr(get_dispatch_key(dev), layer_data_map);
if (!dev_data->device_extensions.wsi_enabled) return nullptr;
}
instance_layer_data *instance_data = nullptr;
if (instance) {
- instance_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ instance_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
}
for (size_t i = 0; i < ARRAY_SIZE(khr_surface_commands); i++) {
const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackEXT *pMsgCallback) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
VkResult res = my_data->instance_dispatch_table->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
if (res == VK_SUCCESS) {
res = layer_create_msg_callback(my_data->report_data, false, pCreateInfo, pAllocator, pMsgCallback);
VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
const VkAllocationCallbacks *pAllocator) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
my_data->instance_dispatch_table->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
}
VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
my_data->instance_dispatch_table->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix,
pMsg);
}
VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
if (result != VK_SUCCESS) return result;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map);
my_data->instance = *pInstance;
my_data->instance_dispatch_table = new VkLayerInstanceDispatchTable;
layer_init_instance_dispatch_table(*pInstance, my_data->instance_dispatch_table, fpGetInstanceProcAddr);
VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
// Grab the key before the instance is destroyed.
dispatch_key key = get_dispatch_key(instance);
- layer_data *my_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
pTable->DestroyInstance(instance, pAllocator);
VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
- layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
assert(chain_info->u.pLayerInfo);
return result;
}
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
+ 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;
VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(device);
- layer_data *my_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
my_data->device_dispatch_table->DestroyDevice(device, pAllocator);
delete my_data->device_dispatch_table;
layer_data_map.erase(key);
VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
result = device_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
}
VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
device_data->imageMap.erase(image);
lock.unlock();
VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (!PreCallValidateCmdCopyImageToBuffer(device_data, srcImage, regionCount, pRegions, "vkCmdCopyImageToBuffer()")) {
device_data->device_dispatch_table->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount,
VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
VkImageLayout dstImageLayout, uint32_t regionCount,
const VkBufferImageCopy *pRegions) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (!PreCallValidateCmdCopyBufferToImage(device_data, dstImage, regionCount, pRegions, "vkCmdCopyBufferToImage()")) {
device_data->device_dispatch_table->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount,
}
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) {
- layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *phy_dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
phy_dev_data->instance_dispatch_table->GetPhysicalDeviceProperties(physicalDevice, pProperties);
}
assert(physicalDevice);
dispatch_key key = get_dispatch_key(physicalDevice);
- layer_data *my_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
return pTable->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
}
assert(device);
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
{
if (proc) return proc;
assert(instance);
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
proc = debug_report_get_instance_proc_addr(my_data->report_data, funcName);
if (proc) return proc;
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
assert(instance);
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
if (pTable->GetPhysicalDeviceProcAddr == NULL) return NULL;
// Add new queue to head of global queue list
static void AddQueueInfo(VkDevice device, uint32_t queue_node_index, VkQueue queue) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
auto queueItem = device_data->queue_info_map.find(queue);
if (queueItem == device_data->queue_info_map.end()) {
OT_QUEUE_INFO *p_queue_info = new OT_QUEUE_INFO;
// Destroy memRef lists and free all memory
static void DestroyQueueDataStructures(VkDevice device) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
for (auto queue_item : device_data->queue_info_map) {
delete queue_item.second;
// Check Queue type flags for selected queue operations
static void ValidateQueueFlags(VkQueue queue, const char *function) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
auto queue_item = device_data->queue_info_map.find(queue);
if (queue_item != device_data->queue_info_map.end()) {
OT_QUEUE_INFO *pQueueInfo = queue_item->second;
if (pQueueInfo != NULL) {
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(device_data->physical_device), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(device_data->physical_device), layer_data_map);
if ((instance_data->queue_family_properties[pQueueInfo->queue_node_index].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) ==
0) {
log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
static void AllocateCommandBuffer(VkDevice device, const VkCommandPool command_pool, const VkCommandBuffer command_buffer,
VkDebugReportObjectTypeEXT object_type, VkCommandBufferLevel level) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, object_type,
reinterpret_cast<const uint64_t>(command_buffer), __LINE__, OBJTRACK_NONE, LayerName,
}
static bool ValidateCommandBuffer(VkDevice device, VkCommandPool command_pool, VkCommandBuffer command_buffer) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip_call = false;
uint64_t object_handle = reinterpret_cast<uint64_t>(command_buffer);
if (device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT].find(object_handle) !=
static void AllocateDescriptorSet(VkDevice device, VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set,
VkDebugReportObjectTypeEXT object_type) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, object_type,
reinterpret_cast<uint64_t &>(descriptor_set), __LINE__, OBJTRACK_NONE, LayerName,
}
static bool ValidateDescriptorSet(VkDevice device, VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip_call = false;
uint64_t object_handle = reinterpret_cast<uint64_t &>(descriptor_set);
auto dsItem = device_data->object_map[VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT].find(object_handle);
}
static void CreateQueue(VkDevice device, VkQueue vkObj, VkDebugReportObjectTypeEXT object_type) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, object_type, reinterpret_cast<uint64_t>(vkObj), __LINE__,
OBJTRACK_NONE, LayerName, "OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++,
}
static void CreateSwapchainImageObject(VkDevice dispatchable_object, VkImage swapchain_image, VkSwapchainKHR swapchain) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(dispatchable_object), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
log_msg(device_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
reinterpret_cast<uint64_t &>(swapchain_image), __LINE__, OBJTRACK_NONE, LayerName,
"OBJ[0x%" PRIxLEAST64 "] : CREATE %s object 0x%" PRIxLEAST64, object_track_index++, "SwapchainImage",
template <typename T1, typename T2>
static void CreateObject(T1 dispatchable_object, T2 object, VkDebugReportObjectTypeEXT object_type,
const VkAllocationCallbacks *pAllocator) {
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(dispatchable_object), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
auto object_handle = handle_value(object);
bool custom_allocator = pAllocator != nullptr;
static void DestroyObject(T1 dispatchable_object, T2 object, VkDebugReportObjectTypeEXT object_type,
const VkAllocationCallbacks *pAllocator, enum UNIQUE_VALIDATION_ERROR_CODE expected_custom_allocator_code,
enum UNIQUE_VALIDATION_ERROR_CODE expected_default_allocator_code) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(dispatchable_object), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
auto object_handle = handle_value(object);
bool custom_allocator = pAllocator != nullptr;
}
auto object_handle = handle_value(object);
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(dispatchable_object), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(dispatchable_object), layer_data_map);
if (device_data->object_map[object_type].find(object_handle) == device_data->object_map[object_type].end()) {
// If object is an image, also look for it in the swapchain image map
if ((object_type != VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT) ||
static void DeviceReportUndestroyedObjects(VkDevice device, VkDebugReportObjectTypeEXT object_type,
enum UNIQUE_VALIDATION_ERROR_CODE error_code) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
for (auto item = device_data->object_map[object_type].begin(); item != device_data->object_map[object_type].end();) {
OBJTRACK_NODE *object_info = item->second;
log_msg(device_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_info->object_type, object_info->handle, __LINE__,
std::unique_lock<std::mutex> lock(global_lock);
dispatch_key key = get_dispatch_key(instance);
- layer_data *instance_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(key, layer_data_map);
// Enable the temporary callback(s) here to catch cleanup issues:
bool callback_setup = false;
VkDescriptorPoolResetFlags flags) {
bool skip_call = false;
std::unique_lock<std::mutex> lock(global_lock);
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
skip_call |=
ValidateObject(device, descriptorPool, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, false, VALIDATION_ERROR_00930);
skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00929);
}
VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer command_buffer, const VkCommandBufferBeginInfo *begin_info) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(command_buffer), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(command_buffer), layer_data_map);
bool skip_call = false;
{
std::lock_guard<std::mutex> lock(global_lock);
if (pCreateInfo) {
skip_call |= ValidateObject(device, pCreateInfo->oldSwapchain, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, true,
VALIDATION_ERROR_01935);
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
skip_call |= ValidateObject(device_data->physical_device, pCreateInfo->surface,
VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false, VALIDATION_ERROR_01926);
}
for (i = 0; i < swapchainCount; i++) {
skip_call |= ValidateObject(device, pCreateInfos[i].oldSwapchain, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
true, VALIDATION_ERROR_01935);
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
skip_call |= ValidateObject(device_data->physical_device, pCreateInfos[i].surface,
VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, false, VALIDATION_ERROR_01926);
}
VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance);
VkResult result = pInstanceTable->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
if (VK_SUCCESS == result) {
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
result = layer_create_msg_callback(instance_data->report_data, false, pCreateInfo, pAllocator, pCallback);
CreateObject(instance, *pCallback, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, pAllocator);
}
const VkAllocationCallbacks *pAllocator) {
VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, instance);
pInstanceTable->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
layer_destroy_msg_callback(instance_data->report_data, msgCallback, pAllocator);
DestroyObject(instance, msgCallback, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, pAllocator, VALIDATION_ERROR_02049,
VALIDATION_ERROR_02050);
}
static inline PFN_vkVoidFunction InterceptMsgCallbackGetProcAddrCommand(const char *name, VkInstance instance) {
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
return debug_report_get_instance_proc_addr(instance_data->report_data, name);
}
}
static void CheckDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, VkDevice device) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
device_data->wsi_enabled = false;
device_data->wsi_display_swapchain_enabled = false;
device_data->wsi_display_extension_enabled = false;
VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
std::lock_guard<std::mutex> lock(global_lock);
- layer_data *phy_dev_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *phy_dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
assert(chain_info->u.pLayerInfo);
return result;
}
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);
device_data->report_data = layer_debug_report_create_device(phy_dev_data->report_data, *pDevice);
layer_init_device_dispatch_table(*pDevice, &device_data->dispatch_table, fpGetDeviceProcAddr);
->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
std::lock_guard<std::mutex> lock(global_lock);
if (pQueueFamilyProperties != NULL) {
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
if (instance_data->queue_family_properties.size() < *pQueueFamilyPropertyCount) {
instance_data->queue_family_properties.resize(*pQueueFamilyPropertyCount);
}
return result;
}
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map);
instance_data->instance = *pInstance;
initInstanceTable(*pInstance, fpGetInstanceProcAddr, ot_instance_table_map);
VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ot_instance_table_map, *pInstance);
}
}
VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
// A swapchain's images are implicitly deleted when the swapchain is deleted.
// Remove this swapchain's images from our map of such images.
VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
const VkAllocationCallbacks *pAllocator) {
bool skip_call = VK_FALSE;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00904);
skip_call |=
}
VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
bool skip_call = false;
std::unique_lock<std::mutex> lock(global_lock);
skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_00080);
if (skip_call) {
return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_SUCCESS;
if (dev_data->dispatch_table.DebugMarkerSetObjectTagEXT) {
result = dev_data->dispatch_table.DebugMarkerSetObjectTagEXT(device, pTagInfo);
if (skip_call) {
return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_SUCCESS;
if (dev_data->dispatch_table.DebugMarkerSetObjectNameEXT) {
result = dev_data->dispatch_table.DebugMarkerSetObjectNameEXT(device, pNameInfo);
skip_call |=
ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false, VALIDATION_ERROR_02014);
lock.unlock();
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (!skip_call && dev_data->dispatch_table.CmdDebugMarkerBeginEXT) {
dev_data->dispatch_table.CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
}
skip_call |=
ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false, VALIDATION_ERROR_02022);
lock.unlock();
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (!skip_call && dev_data->dispatch_table.CmdDebugMarkerEndEXT) {
dev_data->dispatch_table.CmdDebugMarkerEndEXT(commandBuffer);
}
skip_call |=
ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false, VALIDATION_ERROR_02025);
lock.unlock();
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (!skip_call && dev_data->dispatch_table.CmdDebugMarkerInsertEXT) {
dev_data->dispatch_table.CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
}
->GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
std::lock_guard<std::mutex> lock(global_lock);
if (pQueueFamilyProperties != NULL) {
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
if (instance_data->queue_family_properties.size() < *pQueueFamilyPropertyCount) {
instance_data->queue_family_properties.resize(*pQueueFamilyPropertyCount);
}
skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
VALIDATION_ERROR_UNDEFINED);
lock.unlock();
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (!skip_call && dev_data->dispatch_table.CmdProcessCommandsNVX) {
dev_data->dispatch_table.CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
}
skip_call |= ValidateObject(commandBuffer, commandBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, false,
VALIDATION_ERROR_UNDEFINED);
lock.unlock();
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (!skip_call && dev_data->dispatch_table.CmdReserveSpaceForCommandsNVX) {
dev_data->dispatch_table.CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
}
if (skip_call) {
return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_SUCCESS;
if (dev_data->dispatch_table.CreateIndirectCommandsLayoutNVX) {
result = dev_data->dispatch_table.CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED);
lock.unlock();
if (!skip_call) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (dev_data->dispatch_table.DestroyIndirectCommandsLayoutNVX) {
dev_data->dispatch_table.DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
}
if (skip_call) {
return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_SUCCESS;
if (dev_data->dispatch_table.CreateObjectTableNVX) {
result = dev_data->dispatch_table.CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
skip_call |= ValidateObject(device, device, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, false, VALIDATION_ERROR_UNDEFINED);
lock.unlock();
if (!skip_call) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (dev_data->dispatch_table.DestroyObjectTableNVX) {
dev_data->dispatch_table.DestroyObjectTableNVX(device, objectTable, pAllocator);
}
if (skip_call) {
return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_SUCCESS;
if (dev_data->dispatch_table.RegisterObjectsNVX) {
result =
if (skip_call) {
return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_SUCCESS;
if (dev_data->dispatch_table.UnregisterObjectsNVX) {
result = dev_data->dispatch_table.UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
if (skip_call) {
return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_SUCCESS;
if (dev_data->dispatch_table.DisplayPowerControlEXT) {
result = dev_data->dispatch_table.DisplayPowerControlEXT(device, display, pDisplayPowerInfo);
if (skip_call) {
return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_SUCCESS;
if (dev_data->dispatch_table.RegisterDeviceEventEXT) {
result = dev_data->dispatch_table.RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
if (skip_call) {
return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_SUCCESS;
if (dev_data->dispatch_table.RegisterDisplayEventEXT) {
result = dev_data->dispatch_table.RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
if (skip_call) {
return VK_ERROR_VALIDATION_FAILED_EXT;
}
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_SUCCESS;
if (dev_data->dispatch_table.GetSwapchainCounterEXT) {
result = dev_data->dispatch_table.GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
static inline PFN_vkVoidFunction InterceptDeviceExtensionCommand(const char *name, VkDevice device) {
if (device) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (!name || name[0] != 'v' || name[1] != 'k') return NULL;
static inline PFN_vkVoidFunction InterceptWsiEnabledCommand(const char *name, VkDevice device) {
if (device) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (device_data->wsi_enabled) {
if (!strcmp("vkCreateSwapchainKHR", name)) return reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR);
const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackEXT *pMsgCallback) {
- auto data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
VkResult result = data->dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
if (result == VK_SUCCESS) {
VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
const VkAllocationCallbacks *pAllocator) {
- auto data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
data->dispatch_table.DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
layer_destroy_msg_callback(data->report_data, msgCallback, pAllocator);
VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
- auto data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
data->dispatch_table.DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix, pMsg);
}
result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
if (result == VK_SUCCESS) {
- auto my_instance_data = get_my_data_ptr(get_dispatch_key(*pInstance), instance_layer_data_map);
+ auto my_instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), instance_layer_data_map);
assert(my_instance_data != nullptr);
layer_init_instance_dispatch_table(*pInstance, &my_instance_data->dispatch_table, fpGetInstanceProcAddr);
// Grab the key before the instance is destroyed.
dispatch_key key = get_dispatch_key(instance);
bool skip = false;
- auto my_data = get_my_data_ptr(key, instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(key, instance_layer_data_map);
assert(my_data != NULL);
// Enable the temporary callback(s) here to catch vkDestroyInstance issues:
VkPhysicalDevice *pPhysicalDevices) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkEnumeratePhysicalDevices(my_data->report_data, pPhysicalDeviceCount, pPhysicalDevices);
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetPhysicalDeviceFeatures(my_data->report_data, pFeatures);
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format,
VkFormatProperties *pFormatProperties) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetPhysicalDeviceFormatProperties(my_data->report_data, format, pFormatProperties);
VkImageFormatProperties *pImageFormatProperties) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties(my_data->report_data, format, type, tiling, usage, flags,
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetPhysicalDeviceProperties(my_data->report_data, pProperties);
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties *pQueueFamilyProperties) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties(my_data->report_data, pQueueFamilyPropertyCount,
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetPhysicalDeviceMemoryProperties(my_data->report_data, pMemoryProperties);
const std::vector<VkQueueFamilyProperties> properties) {
std::unordered_set<uint32_t> set;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
if ((pCreateInfo != nullptr) && (pCreateInfo->pQueueCreateInfos != nullptr)) {
for (uint32_t i = 0; i < pCreateInfo->queueCreateInfoCount; ++i) {
}
static void CheckDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, VkDevice device) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
device_data->enables.khr_swapchain_enabled = true;
}
void storeCreateDeviceData(VkDevice device, const VkDeviceCreateInfo *pCreateInfo) {
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if ((pCreateInfo != nullptr) && (pCreateInfo->pQueueCreateInfos != nullptr)) {
for (uint32_t i = 0; i < pCreateInfo->queueCreateInfoCount; ++i) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_instance_data != nullptr);
skip |= parameter_validation_vkCreateDevice(my_instance_data->report_data, pCreateInfo, pAllocator, pDevice);
validate_result(my_instance_data->report_data, "vkCreateDevice", result);
if (result == VK_SUCCESS) {
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
+ layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);
assert(my_device_data != nullptr);
my_device_data->report_data = layer_debug_report_create_device(my_instance_data->report_data, *pDevice);
VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(device);
bool skip = false;
- layer_data *my_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyDevice(my_data->report_data, pAllocator);
}
static bool PreGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex) {
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_device_data != nullptr);
validate_queue_family_index(my_device_data, "vkGetDeviceQueue", "queueFamilyIndex", queueFamilyIndex);
VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetDeviceQueue(my_data->report_data, queueFamilyIndex, queueIndex, pQueue);
VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkQueueSubmit(my_data->report_data, submitCount, pSubmits, fence);
}
VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(VkQueue queue) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
assert(my_data != NULL);
VkResult result = my_data->dispatch_table.QueueWaitIdle(queue);
}
VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(VkDevice device) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
VkResult result = my_data->dispatch_table.DeviceWaitIdle(device);
const VkAllocationCallbacks *pAllocator, VkDeviceMemory *pMemory) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkAllocateMemory(my_data->report_data, pAllocateInfo, pAllocator, pMemory);
VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkFreeMemory(my_data->report_data, memory, pAllocator);
VkMemoryMapFlags flags, void **ppData) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkMapMemory(my_data->report_data, memory, offset, size, flags, ppData);
VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory memory) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkUnmapMemory(my_data->report_data, memory);
const VkMappedMemoryRange *pMemoryRanges) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkFlushMappedMemoryRanges(my_data->report_data, memoryRangeCount, pMemoryRanges);
const VkMappedMemoryRange *pMemoryRanges) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkInvalidateMappedMemoryRanges(my_data->report_data, memoryRangeCount, pMemoryRanges);
VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
VkDeviceSize *pCommittedMemoryInBytes) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetDeviceMemoryCommitment(my_data->report_data, memory, pCommittedMemoryInBytes);
VkDeviceSize memoryOffset) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkBindBufferMemory(my_data->report_data, buffer, memory, memoryOffset);
VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkBindImageMemory(my_data->report_data, image, memory, memoryOffset);
VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
VkMemoryRequirements *pMemoryRequirements) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetBufferMemoryRequirements(my_data->report_data, buffer, pMemoryRequirements);
VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements *pMemoryRequirements) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetImageMemoryRequirements(my_data->report_data, image, pMemoryRequirements);
static bool PostGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pNumRequirements,
VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (pSparseMemoryRequirements != nullptr) {
if ((pSparseMemoryRequirements->formatProperties.aspectMask &
(VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT |
VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetImageSparseMemoryRequirements(my_data->report_data, image, pSparseMemoryRequirementCount,
VkSampleCountFlagBits samples, VkImageUsageFlags usage,
VkImageTiling tiling, uint32_t *pNumProperties,
VkSparseImageFormatProperties *pProperties) {
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
if (pProperties != nullptr) {
if ((pProperties->aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT |
VK_IMAGE_ASPECT_METADATA_BIT)) == 0) {
uint32_t *pPropertyCount,
VkSparseImageFormatProperties *pProperties) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties(my_data->report_data, format, type, samples, usage,
VkFence fence) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkQueueBindSparse(my_data->report_data, bindInfoCount, pBindInfo, fence);
const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCreateFence(my_data->report_data, pCreateInfo, pAllocator, pFence);
VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyFence(my_data->report_data, fence, pAllocator);
VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkResetFences(my_data->report_data, fenceCount, pFences);
VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetFenceStatus(my_data->report_data, fence);
uint64_t timeout) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkWaitForFences(my_data->report_data, fenceCount, pFences, waitAll, timeout);
const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCreateSemaphore(my_data->report_data, pCreateInfo, pAllocator, pSemaphore);
VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroySemaphore(my_data->report_data, semaphore, pAllocator);
const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCreateEvent(my_data->report_data, pCreateInfo, pAllocator, pEvent);
VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyEvent(my_data->report_data, event, pAllocator);
VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(VkDevice device, VkEvent event) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetEventStatus(my_data->report_data, event);
VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkSetEvent(my_data->report_data, event);
VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(VkDevice device, VkEvent event) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkResetEvent(my_data->report_data, event);
const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyQueryPool(my_data->report_data, queryPool, pAllocator);
size_t dataSize, void *pData, VkDeviceSize stride, VkQueryResultFlags flags) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetQueryPoolResults(my_data->report_data, queryPool, firstQuery, queryCount, dataSize, pData,
const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyBuffer(my_data->report_data, buffer, pAllocator);
const VkAllocationCallbacks *pAllocator, VkBufferView *pView) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCreateBufferView(my_data->report_data, pCreateInfo, pAllocator, pView);
VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyBufferView(my_data->report_data, bufferView, pAllocator);
const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyImage(my_data->report_data, image, pAllocator);
}
static bool PreGetImageSubresourceLayout(VkDevice device, const VkImageSubresource *pSubresource) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (pSubresource != nullptr) {
if ((pSubresource->aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT |
VK_IMAGE_ASPECT_METADATA_BIT)) == 0) {
VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource *pSubresource,
VkSubresourceLayout *pLayout) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetImageSubresourceLayout(my_data->report_data, image, pSubresource, pLayout);
const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
debug_report_data *report_data = my_data->report_data;
VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyImageView(my_data->report_data, imageView, pAllocator);
const VkAllocationCallbacks *pAllocator, VkShaderModule *pShaderModule) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCreateShaderModule(my_data->report_data, pCreateInfo, pAllocator, pShaderModule);
VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyShaderModule(my_data->report_data, shaderModule, pAllocator);
const VkAllocationCallbacks *pAllocator, VkPipelineCache *pPipelineCache) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCreatePipelineCache(my_data->report_data, pCreateInfo, pAllocator, pPipelineCache);
VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyPipelineCache(my_data->report_data, pipelineCache, pAllocator);
void *pData) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetPipelineCacheData(my_data->report_data, pipelineCache, pDataSize, pData);
const VkPipelineCache *pSrcCaches) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkMergePipelineCaches(my_data->report_data, dstCache, srcCacheCount, pSrcCaches);
}
static bool PreCreateGraphicsPipelines(VkDevice device, const VkGraphicsPipelineCreateInfo *pCreateInfos) {
- layer_data *data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
// TODO: Handle count
if (pCreateInfos != nullptr) {
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
}
bool PreCreateComputePipelines(VkDevice device, const VkComputePipelineCreateInfo *pCreateInfos) {
- layer_data *data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (pCreateInfos != nullptr) {
// TODO: Handle count!
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCreateComputePipelines(my_data->report_data, pipelineCache, createInfoCount, pCreateInfos,
VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyPipeline(my_data->report_data, pipeline, pAllocator);
const VkAllocationCallbacks *pAllocator, VkPipelineLayout *pPipelineLayout) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCreatePipelineLayout(my_data->report_data, pCreateInfo, pAllocator, pPipelineLayout);
VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyPipelineLayout(my_data->report_data, pipelineLayout, pAllocator);
const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(device_data != NULL);
debug_report_data *report_data = device_data->report_data;
VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroySampler(my_data->report_data, sampler, pAllocator);
VkDescriptorSetLayout *pSetLayout) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyDescriptorSetLayout(my_data->report_data, descriptorSetLayout, pAllocator);
const VkAllocationCallbacks *pAllocator, VkDescriptorPool *pDescriptorPool) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCreateDescriptorPool(my_data->report_data, pCreateInfo, pAllocator, pDescriptorPool);
VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyDescriptorPool(my_data->report_data, descriptorPool, pAllocator);
VkDescriptorPoolResetFlags flags) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkResetDescriptorPool(my_data->report_data, descriptorPool, flags);
VkDescriptorSet *pDescriptorSets) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkAllocateDescriptorSets(my_data->report_data, pAllocateInfo, pDescriptorSets);
const VkDescriptorSet *pDescriptorSets) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
const VkWriteDescriptorSet *pDescriptorWrites, uint32_t descriptorCopyCount,
const VkCopyDescriptorSet *pDescriptorCopies) {
bool skip = false;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(device_data != NULL);
debug_report_data *report_data = device_data->report_data;
const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCreateFramebuffer(my_data->report_data, pCreateInfo, pAllocator, pFramebuffer);
VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyFramebuffer(my_data->report_data, framebuffer, pAllocator);
const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCreateRenderPass(my_data->report_data, pCreateInfo, pAllocator, pRenderPass);
VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyRenderPass(my_data->report_data, renderPass, pAllocator);
VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D *pGranularity) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetRenderAreaGranularity(my_data->report_data, renderPass, pGranularity);
const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |=
VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkDestroyCommandPool(my_data->report_data, commandPool, pAllocator);
VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkResetCommandPool(my_data->report_data, commandPool, flags);
VkCommandBuffer *pCommandBuffers) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkAllocateCommandBuffers(my_data->report_data, pAllocateInfo, pCommandBuffers);
VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
const VkCommandBuffer *pCommandBuffers) {
bool skip = false;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo *pBeginInfo) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
}
VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(VkCommandBuffer commandBuffer) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
VkResult result = my_data->dispatch_table.EndCommandBuffer(commandBuffer);
VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
bool skip = parameter_validation_vkResetCommandBuffer(my_data->report_data, flags);
VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdBindPipeline(my_data->report_data, pipelineBindPoint, pipeline);
VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount,
const VkViewport *pViewports) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= preCmdSetViewport(my_data, viewportCount, pViewports);
VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount,
const VkRect2D *pScissors) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
debug_report_data *report_data = my_data->report_data;
}
VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
my_data->dispatch_table.CmdSetLineWidth(commandBuffer, lineWidth);
}
VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp,
float depthBiasSlopeFactor) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
my_data->dispatch_table.CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdSetBlendConstants(my_data->report_data, blendConstants);
}
VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
my_data->dispatch_table.CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
}
VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
uint32_t compareMask) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdSetStencilCompareMask(my_data->report_data, faceMask, compareMask);
VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdSetStencilWriteMask(my_data->report_data, faceMask, writeMask);
VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdSetStencilReference(my_data->report_data, faceMask, reference);
const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount,
const uint32_t *pDynamicOffsets) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdBindDescriptorSets(my_data->report_data, pipelineBindPoint, layout, firstSet,
VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
VkIndexType indexType) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdBindIndexBuffer(my_data->report_data, buffer, offset, indexType);
VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdBindVertexBuffers(my_data->report_data, firstBinding, bindingCount, pBuffers, pOffsets);
static bool PreCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
uint32_t firstInstance) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (vertexCount == 0) {
// TODO: Verify against Valid Usage section. I don't see a non-zero vertexCount listed, may need to add that and make
// this an error or leave as is.
VKAPI_ATTR void VKAPI_CALL CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
uint32_t firstVertex, uint32_t firstInstance) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
PreCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
my_data->dispatch_table.CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
my_data->dispatch_table.CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
uint32_t stride) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdDrawIndirect(my_data->report_data, buffer, offset, count, stride);
VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
uint32_t count, uint32_t stride) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdDrawIndexedIndirect(my_data->report_data, buffer, offset, count, stride);
}
VKAPI_ATTR void VKAPI_CALL CmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
my_data->dispatch_table.CmdDispatch(commandBuffer, x, y, z);
}
VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdDispatchIndirect(my_data->report_data, buffer, offset);
VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
uint32_t regionCount, const VkBufferCopy *pRegions) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdCopyBuffer(my_data->report_data, srcBuffer, dstBuffer, regionCount, pRegions);
}
static bool PreCmdCopyImage(VkCommandBuffer commandBuffer, const VkImageCopy *pRegions) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (pRegions != nullptr) {
if ((pRegions->srcSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) {
VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageCopy *pRegions) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdCopyImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout,
}
static bool PreCmdBlitImage(VkCommandBuffer commandBuffer, const VkImageBlit *pRegions) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (pRegions != nullptr) {
if ((pRegions->srcSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) {
VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageBlit *pRegions, VkFilter filter) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdBlitImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout,
}
static bool PreCmdCopyBufferToImage(VkCommandBuffer commandBuffer, const VkBufferImageCopy *pRegions) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (pRegions != nullptr) {
if ((pRegions->imageSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) {
VkImageLayout dstImageLayout, uint32_t regionCount,
const VkBufferImageCopy *pRegions) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdCopyBufferToImage(my_data->report_data, srcBuffer, dstImage, dstImageLayout, regionCount,
}
static bool PreCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, const VkBufferImageCopy *pRegions) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (pRegions != nullptr) {
if ((pRegions->imageSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) {
VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdCopyImageToBuffer(my_data->report_data, srcImage, srcImageLayout, dstBuffer, regionCount,
VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
VkDeviceSize dataSize, const uint32_t *pData) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdUpdateBuffer(my_data->report_data, dstBuffer, dstOffset, dataSize, pData);
VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
VkDeviceSize size, uint32_t data) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdFillBuffer(my_data->report_data, dstBuffer, dstOffset, size, data);
const VkClearColorValue *pColor, uint32_t rangeCount,
const VkImageSubresourceRange *pRanges) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdClearColorImage(my_data->report_data, image, imageLayout, pColor, rangeCount, pRanges);
const VkClearDepthStencilValue *pDepthStencil, uint32_t rangeCount,
const VkImageSubresourceRange *pRanges) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdClearDepthStencilImage(my_data->report_data, image, imageLayout, pDepthStencil, rangeCount,
const VkClearAttachment *pAttachments, uint32_t rectCount,
const VkClearRect *pRects) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdClearAttachments(my_data->report_data, attachmentCount, pAttachments, rectCount, pRects);
}
static bool PreCmdResolveImage(VkCommandBuffer commandBuffer, const VkImageResolve *pRegions) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
if (pRegions != nullptr) {
if ((pRegions->srcSubresource.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT)) == 0) {
VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
const VkImageResolve *pRegions) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdResolveImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout,
VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdSetEvent(my_data->report_data, event, stageMask);
VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdResetEvent(my_data->report_data, event, stageMask);
uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdWaitEvents(my_data->report_data, eventCount, pEvents, srcStageMask, dstStageMask,
uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier *pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier *pImageMemoryBarriers) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdPipelineBarrier(my_data->report_data, srcStageMask, dstStageMask, dependencyFlags,
VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot,
VkQueryControlFlags flags) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdBeginQuery(my_data->report_data, queryPool, slot, flags);
VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdEndQuery(my_data->report_data, queryPool, slot);
VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
uint32_t queryCount) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdResetQueryPool(my_data->report_data, queryPool, firstQuery, queryCount);
VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool, uint32_t query) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdWriteTimestamp(my_data->report_data, pipelineStage, queryPool, query);
uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
VkDeviceSize stride, VkQueryResultFlags flags) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdCopyQueryPoolResults(my_data->report_data, queryPool, firstQuery, queryCount, dstBuffer,
VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags,
uint32_t offset, uint32_t size, const void *pValues) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdPushConstants(my_data->report_data, layout, stageFlags, offset, size, pValues);
VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
VkSubpassContents contents) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdBeginRenderPass(my_data->report_data, pRenderPassBegin, contents);
VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdNextSubpass(my_data->report_data, contents);
}
VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(VkCommandBuffer commandBuffer) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
my_data->dispatch_table.CmdEndRenderPass(commandBuffer);
}
VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
const VkCommandBuffer *pCommandBuffers) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkCmdExecuteCommands(my_data->report_data, commandBufferCount, pCommandBuffers);
assert(physicalDevice);
- return get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map)
+ return GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map)
->dispatch_table.EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
}
const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkCreateSwapchainKHR",
VkImage *pSwapchainImages) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkGetSwapchainImagesKHR",
VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkAcquireNextImageKHR",
VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkQueuePresentKHR",
VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.khr_swapchain_enabled, "vkDestroySwapchainKHR",
static bool require_instance_extension(void *instance, bool instance_extension_enables::*flag, char const *function_name,
char const *extension_name) {
- auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
if (!(my_data->extensions.*flag)) {
return log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
reinterpret_cast<uint64_t>(instance), __LINE__, EXTENSION_NOT_ENABLED, LayerName,
VkSurfaceKHR surface, VkBool32 *pSupported) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::surface_enabled,
VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::surface_enabled,
VkSurfaceFormatKHR *pSurfaceFormats) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::surface_enabled,
VkPresentModeKHR *pPresentModes) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::surface_enabled,
VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
skip |= require_instance_extension(instance, &instance_extension_enables::surface_enabled, "vkDestroySurfaceKHR",
VK_KHR_SURFACE_EXTENSION_NAME);
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
uint32_t queueFamilyIndex) {
VkBool32 result = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
xcb_visualid_t visual_id) {
VkBool32 result = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
VisualID visualID) {
VkBool32 result = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
uint32_t queueFamilyIndex, MirConnection *connection) {
VkBool32 result = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
struct wl_display *display) {
VkBool32 result = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.khr_display_swapchain_enabled, "vkCreateSharedSwapchainsKHR",
VkDisplayPropertiesKHR *pProperties) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::display_enabled,
VkDisplayPlanePropertiesKHR *pProperties) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::display_enabled,
uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::display_enabled,
uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::display_enabled,
const VkAllocationCallbacks *pAllocator, VkDisplayModeKHR *pMode) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::display_enabled, "vkCreateDisplayModeKHR",
uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::display_enabled,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(instance, &instance_extension_enables::display_enabled, "vkCreateDisplayPlaneSurfaceKHR",
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR *pFeatures) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled,
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties2KHR *pProperties) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled,
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format,
VkFormatProperties2KHR *pFormatProperties) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled,
VkImageFormatProperties2KHR *pImageFormatProperties) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled,
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled,
const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo,
uint32_t *pPropertyCount,
VkSparseImageFormatProperties2KHR *pProperties) {
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
if (pProperties != nullptr) {
for (uint32_t i = 0; i < *pPropertyCount; ++i) {
if ((pProperties[i].properties.aspectMask & (VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT |
VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount,
VkSparseImageFormatProperties2KHR *pProperties) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::khr_get_phys_dev_properties2_enabled,
VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) {
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip_call |= require_device_extension(my_data, my_data->enables.khr_maintenance1, "vkTrimCommandPoolKHR",
#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::ext_acquire_xlib_display_enabled,
VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput,
VkDisplayKHR *pDisplay) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::ext_acquire_xlib_display_enabled,
VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkDebugMarkerSetObjectTagEXT",
VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkDebugMarkerSetObjectNameEXT",
VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT *pMarkerInfo) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkCmdDebugMarkerBeginEXT",
VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT *pMarkerInfo) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkCmdDebugMarkerInsertEXT",
VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::ext_direct_mode_display_enabled,
VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
VkSurfaceCapabilities2EXT *pSurfaceCapabilities) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
bool skip = false;
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::ext_display_surface_counter_enabled,
VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= require_instance_extension(physicalDevice, &instance_extension_enables::nv_external_memory_capabilities_enabled,
VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.nv_external_memory_win32, "vkGetMemoryWin32HandleNV",
VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX(VkCommandBuffer commandBuffer,
const VkCmdProcessCommandsInfoNVX *pProcessCommandsInfo) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCmdProcessCommandsNVX",
VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer,
const VkCmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCmdReserveSpaceForCommandsNVX",
VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
VkIndirectCommandsLayoutNVX *pIndirectCommandsLayout) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCreateIndirectCommandsLayoutNVX",
VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout,
const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkDestroyIndirectCommandsLayoutNVX",
VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
const VkAllocationCallbacks *pAllocator, VkObjectTableNVX *pObjectTable) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCreateObjectTableNVX",
VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable,
const VkAllocationCallbacks *pAllocator) {
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkDestroyObjectTableNVX",
VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
const uint32_t *pObjectIndices) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkRegisterObjectsNVX",
VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
const VkObjectEntryTypeNVX *pObjectEntryTypes, const uint32_t *pObjectIndices) {
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
bool skip = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkUnregisterObjectsNVX",
VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
VkDeviceGeneratedCommandsFeaturesNVX *pFeatures,
VkDeviceGeneratedCommandsLimitsNVX *pLimits) {
bool skip = false;
- auto my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), instance_layer_data_map);
+ auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
skip |= parameter_validation_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(my_data->report_data, pFeatures, pLimits);
if (!skip) {
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(VkDevice device, const char *funcName) {
assert(device);
- layer_data *data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (validate_string(data->report_data, "vkGetDeviceProcAddr", "funcName", funcName)) {
return NULL;
assert(instance);
- auto data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
proc = debug_report_get_instance_proc_addr(data->report_data, funcName);
if (!proc) proc = InterceptWsiEnabledCommand(funcName, instance);
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
assert(instance);
- auto data = get_my_data_ptr(get_dispatch_key(instance), instance_layer_data_map);
+ auto data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map);
if (!data->dispatch_table.GetPhysicalDeviceProcAddr) return nullptr;
return data->dispatch_table.GetPhysicalDeviceProcAddr(instance, funcName);
};
static void checkDeviceRegisterExtensions(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, VkDevice device) {
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
- layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
SwpPhysicalDevice *pPhysicalDevice = NULL;
{
static void checkInstanceRegisterExtensions(const VkInstanceCreateInfo *pCreateInfo, VkInstance instance) {
uint32_t i;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
// Remember this instance, and whether the VK_KHR_surface extension
// was enabled for it:
return result;
}
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map);
my_data->instance = *pInstance;
my_data->instance_dispatch_table = new VkLayerInstanceDispatchTable;
layer_init_instance_dispatch_table(*pInstance, my_data->instance_dispatch_table, fpGetInstanceProcAddr);
VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(instance);
- layer_data *my_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
SwpInstance *pInstance = NULL;
{
auto it = my_data->instanceMap.find(instance);
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
uint32_t *pQueueFamilyPropertyCount,
VkQueueFamilyProperties *pQueueFamilyProperties) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
// Call down the call chain:
my_data->instance_dispatch_table->GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount,
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpInstance *pInstance = NULL;
{
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpInstance *pInstance = NULL;
{
uint32_t queueFamilyIndex, MirConnection *connection) {
VkBool32 result = VK_FALSE;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpPhysicalDevice *pPhysicalDevice = NULL;
{
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpInstance *pInstance = NULL;
{
struct wl_display *display) {
VkBool32 result = VK_FALSE;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpPhysicalDevice *pPhysicalDevice = NULL;
{
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpInstance *pInstance = NULL;
{
uint32_t queueFamilyIndex) {
VkBool32 result = VK_FALSE;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpPhysicalDevice *pPhysicalDevice = NULL;
{
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpInstance *pInstance = NULL;
{
xcb_visualid_t visual_id) {
VkBool32 result = VK_FALSE;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpPhysicalDevice *pPhysicalDevice = NULL;
{
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpInstance *pInstance = NULL;
{
VisualID visualID) {
VkBool32 result = VK_FALSE;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpPhysicalDevice *pPhysicalDevice = NULL;
{
VkDisplayPlanePropertiesKHR *pProperties) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpPhysicalDevice *pPhysicalDevice = NULL;
{
uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpPhysicalDevice *pPhysicalDevice = NULL;
{
uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpPhysicalDevice *pPhysicalDevice = NULL;
{
const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpInstance *pInstance = &(my_data->instanceMap[instance]);
VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) {
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpSurface *pSurface = NULL;
{
VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
VkPhysicalDevice *pPhysicalDevices) {
VkResult result = VK_SUCCESS;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
// Call down the call chain:
result = my_data->instance_dispatch_table->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
- layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
assert(chain_info->u.pLayerInfo);
}
std::lock_guard<std::mutex> lock(global_lock);
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
+ 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;
VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(device);
- layer_data *my_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
// Call down the call chain:
my_data->device_dispatch_table->DestroyDevice(device, pAllocator);
VkSurfaceKHR surface, VkBool32 *pSupported) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpPhysicalDevice *pPhysicalDevice = NULL;
{
// TODO: Validate cases of re-creating a swapchain (the current code
// assumes a new swapchain is being created).
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
SwpDevice *pDevice = NULL;
{
auto it = my_data->deviceMap.find(device);
VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
VkResult result = VK_SUCCESS;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
bool skip_call = validateCreateSwapchainKHR(device, pCreateInfo, pSwapchain);
lock.unlock();
SwpPhysicalDevice *pPhysicalDevice = pDevice->pPhysicalDevice;
SwpInstance *pInstance = (pPhysicalDevice) ? pPhysicalDevice->pInstance : NULL;
layer_data *my_instance_data =
- ((pInstance) ? get_my_data_ptr(get_dispatch_key(pInstance->instance), layer_data_map) : NULL);
+ ((pInstance) ? GetLayerDataPtr(get_dispatch_key(pInstance->instance), layer_data_map) : NULL);
SwpSurface *pSurface = ((my_data && pCreateInfo) ? &my_instance_data->surfaceMap[pCreateInfo->surface] : NULL);
my_data->swapchainMap[*pSwapchain].pSurface = pSurface;
if (pSurface) {
// presentable images acquired from pname:swapchain must: have completed
// execution
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
// Regardless of skip_call value, do some internal cleanup:
VkImage *pSwapchainImages) {
VkResult result = VK_SUCCESS;
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
SwpSwapchain *pSwapchain = NULL;
VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
bool skip_call = false;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (!skip_call) {
// Call down the call chain:
const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackEXT *pMsgCallback) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
VkResult result =
my_data->instance_dispatch_table->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
if (VK_SUCCESS == result) {
VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT msgCallback,
const VkAllocationCallbacks *pAllocator) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
my_data->instance_dispatch_table->DestroyDebugReportCallbackEXT(instance, msgCallback, pAllocator);
std::lock_guard<std::mutex> lock(global_lock);
layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
my_data->instance_dispatch_table->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix,
pMsg);
}
assert(physicalDevice);
dispatch_key key = get_dispatch_key(physicalDevice);
- layer_data *my_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
return my_data->instance_dispatch_table->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
}
layer_data *my_data;
- my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkLayerDispatchTable *pDisp = my_data->device_dispatch_table;
proc = intercept_khr_swapchain_command(funcName, device);
assert(instance);
layer_data *my_data;
- my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
proc = debug_report_get_instance_proc_addr(my_data->report_data, funcName);
assert(instance);
layer_data *my_data;
- my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
if (pTable->GetPhysicalDeviceProcAddr == NULL) return NULL;
VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
if (result != VK_SUCCESS) return result;
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map);
my_data->instance = *pInstance;
my_data->instance_dispatch_table = new VkLayerInstanceDispatchTable;
layer_init_instance_dispatch_table(*pInstance, my_data->instance_dispatch_table, fpGetInstanceProcAddr);
VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(instance);
- layer_data *my_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
// Enable the temporary callback(s) here to catch cleanup issues:
VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
- layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
+ layer_data *my_instance_data = GetLayerDataPtr(get_dispatch_key(gpu), layer_data_map);
VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
assert(chain_info->u.pLayerInfo);
return result;
}
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
+ 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;
VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(device);
- layer_data *dev_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(key, layer_data_map);
bool threadChecks = startMultiThread();
if (threadChecks) {
startWriteObject(dev_data, device);
assert(physicalDevice);
dispatch_key key = get_dispatch_key(physicalDevice);
- layer_data *my_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
return my_data->instance_dispatch_table->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
}
addr = layer_intercept_proc(funcName);
if (addr) return addr;
- dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkLayerDispatchTable *pTable = dev_data->device_dispatch_table;
if (pTable->GetDeviceProcAddr == NULL) return NULL;
assert(instance);
- my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
addr = debug_report_get_instance_proc_addr(my_data->report_data, funcName);
if (addr) {
return addr;
assert(instance);
layer_data *my_data;
- my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
if (pTable->GetPhysicalDeviceProcAddr == NULL) return NULL;
const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackEXT *pMsgCallback) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
bool threadChecks = startMultiThread();
if (threadChecks) {
startReadObject(my_data, instance);
VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks *pAllocator) {
- layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
bool threadChecks = startMultiThread();
if (threadChecks) {
startReadObject(my_data, instance);
VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo,
VkCommandBuffer *pCommandBuffers) {
dispatch_key key = get_dispatch_key(device);
- layer_data *my_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
VkResult result;
bool threadChecks = startMultiThread();
VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
const VkCommandBuffer *pCommandBuffers) {
dispatch_key key = get_dispatch_key(device);
- layer_data *my_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
VkLayerDispatchTable *pTable = my_data->device_dispatch_table;
const bool lockCommandPool = false; // pool is already directly locked
bool threadChecks = startMultiThread();
// Handle CreateInstance Extensions
static void checkInstanceRegisterExtensions(const VkInstanceCreateInfo *pCreateInfo, VkInstance instance) {
uint32_t i;
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
VkLayerInstanceDispatchTable *disp_table = instance_data->instance_dispatch_table;
instance_ext_map[disp_table] = {};
// Handle CreateDevice Extensions
static void createDeviceRegisterExtensions(const VkDeviceCreateInfo *pCreateInfo, VkDevice device) {
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkLayerDispatchTable *disp_table = device_data->device_dispatch_table;
PFN_vkGetDeviceProcAddr gpa = disp_table->GetDeviceProcAddr;
return result;
}
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(*pInstance), layer_data_map);
instance_data->instance = *pInstance;
instance_data->instance_dispatch_table = new VkLayerInstanceDispatchTable;
layer_init_instance_dispatch_table(*pInstance, instance_data->instance_dispatch_table, fpGetInstanceProcAddr);
VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(instance);
- layer_data *instance_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(key, layer_data_map);
VkLayerInstanceDispatchTable *disp_table = instance_data->instance_dispatch_table;
instance_ext_map.erase(disp_table);
disp_table->DestroyInstance(instance, pAllocator);
VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
- layer_data *my_instance_data = get_my_data_ptr(get_dispatch_key(gpu), layer_data_map);
+ layer_data *my_instance_data = GetLayerDataPtr(get_dispatch_key(gpu), layer_data_map);
VkLayerDeviceCreateInfo *chain_info = get_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
assert(chain_info->u.pLayerInfo);
return result;
}
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(*pDevice), layer_data_map);
+ 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
VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
dispatch_key key = get_dispatch_key(device);
- layer_data *dev_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(key, layer_data_map);
layer_debug_report_destroy_device(device);
dev_data->device_dispatch_table->DestroyDevice(device, pAllocator);
assert(physicalDevice);
dispatch_key key = get_dispatch_key(physicalDevice);
- layer_data *instance_data = get_my_data_ptr(key, layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(key, layer_data_map);
return instance_data->instance_dispatch_table->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pCount, pProperties);
}
return addr;
}
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkLayerDispatchTable *disp_table = dev_data->device_dispatch_table;
if (disp_table->GetDeviceProcAddr == NULL) {
return NULL;
}
assert(instance);
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
addr = debug_report_get_instance_proc_addr(instance_data->report_data, funcName);
if (addr) {
return addr;
VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) {
assert(instance);
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
VkLayerInstanceDispatchTable *disp_table = instance_data->instance_dispatch_table;
if (disp_table->GetPhysicalDeviceProcAddr == NULL) {
return NULL;
const VkMemoryAllocateInfo *input_allocate_info = pAllocateInfo;
std::unique_ptr<safe_VkMemoryAllocateInfo> safe_allocate_info;
std::unique_ptr<safe_VkDedicatedAllocationMemoryAllocateInfoNV> safe_dedicated_allocate_info;
- layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if ((pAllocateInfo != nullptr) &&
ContainsExtStruct(pAllocateInfo, VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV)) {
VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
const VkComputePipelineCreateInfo *pCreateInfos,
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
safe_VkComputePipelineCreateInfo *local_pCreateInfos = NULL;
if (pCreateInfos) {
std::lock_guard<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo *pCreateInfos,
const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
safe_VkGraphicsPipelineCreateInfo *local_pCreateInfos = NULL;
if (pCreateInfos) {
local_pCreateInfos = new safe_VkGraphicsPipelineCreateInfo[createInfoCount];
const VkDebugReportCallbackCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugReportCallbackEXT *pMsgCallback) {
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
VkResult result =
instance_data->instance_dispatch_table->CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pMsgCallback);
VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks *pAllocator) {
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
instance_data->instance_dispatch_table->DestroyDebugReportCallbackEXT(instance, callback, pAllocator);
layer_destroy_msg_callback(instance_data->report_data, callback, pAllocator);
}
VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(VkInstance instance, VkDebugReportFlagsEXT flags,
VkDebugReportObjectTypeEXT objType, uint64_t object, size_t location,
int32_t msgCode, const char *pLayerPrefix, const char *pMsg) {
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
instance_data->instance_dispatch_table->DebugReportMessageEXT(instance, flags, objType, object, location, msgCode, pLayerPrefix,
pMsg);
}
VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
- layer_data *my_map_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_map_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
safe_VkSwapchainCreateInfoKHR *local_pCreateInfo = NULL;
if (pCreateInfo) {
std::lock_guard<std::mutex> lock(global_lock);
local_pCreateInfo->oldSwapchain =
(VkSwapchainKHR)my_map_data->unique_id_mapping[reinterpret_cast<const uint64_t &>(pCreateInfo->oldSwapchain)];
// Need to pull surface mapping from the instance-level map
- layer_data *instance_data = get_my_data_ptr(get_dispatch_key(my_map_data->gpu), layer_data_map);
+ layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(my_map_data->gpu), layer_data_map);
local_pCreateInfo->surface =
(VkSurfaceKHR)instance_data->unique_id_mapping[reinterpret_cast<const uint64_t &>(pCreateInfo->surface)];
}
VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount,
VkImage *pSwapchainImages) {
- layer_data *my_device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+ layer_data *my_device_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
if (VK_NULL_HANDLE != swapchain) {
std::lock_guard<std::mutex> lock(global_lock);
swapchain = (VkSwapchainKHR)my_device_data->unique_id_mapping[reinterpret_cast<uint64_t &>(swapchain)];
#ifndef __ANDROID__
VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
VkDisplayPropertiesKHR *pProperties) {
- layer_data *my_map_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_map_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
safe_VkDisplayPropertiesKHR *local_pProperties = NULL;
{
std::lock_guard<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
uint32_t *pDisplayCount, VkDisplayKHR *pDisplays) {
- layer_data *my_map_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_map_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
VkResult result = my_map_data->instance_dispatch_table->GetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex,
pDisplayCount, pDisplays);
if (VK_SUCCESS == result) {
VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display,
uint32_t *pPropertyCount, VkDisplayModePropertiesKHR *pProperties) {
- layer_data *my_map_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *my_map_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
VkDisplayModePropertiesKHR *local_pProperties = NULL;
{
std::lock_guard<std::mutex> lock(global_lock);
VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode,
uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR *pCapabilities) {
- layer_data *dev_data = get_my_data_ptr(get_dispatch_key(physicalDevice), layer_data_map);
+ layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
{
std::lock_guard<std::mutex> lock(global_lock);
auto it = dev_data->unique_id_mapping.find(reinterpret_cast<uint64_t &>(mode));
-/* Copyright (c) 2015-2016 The Khronos Group Inc.
- * Copyright (c) 2015-2016 Valve Corporation
- * Copyright (c) 2015-2016 LunarG, Inc.
+/* Copyright (c) 2015-2017 The Khronos Group Inc.
+ * Copyright (c) 2015-2017 Valve Corporation
+ * Copyright (c) 2015-2017 LunarG, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* See the License for the specific language governing permissions and
* limitations under the License.
*
- * Author: Tobin Ehlis <tobin@lunarg.com>
+ * Author: Tobin Ehlis <tobine@google.com>
*/
#ifndef LAYER_DATA_H
#include <unordered_map>
#include "vk_layer_table.h"
+// For the given data key, look up the layer_data instance from given layer_data_map
template <typename DATA_T>
-DATA_T *get_my_data_ptr(void *data_key, std::unordered_map<void *, DATA_T *> &layer_data_map) {
+DATA_T *GetLayerDataPtr(void *data_key, std::unordered_map<void *, DATA_T *> &layer_data_map) {
DATA_T *debug_data;
typename std::unordered_map<void *, DATA_T *>::const_iterator got;
bool g_DEBUG_REPORT;
} debug_report_data;
-template debug_report_data *get_my_data_ptr<debug_report_data>(void *data_key,
+template debug_report_data *GetLayerDataPtr<debug_report_data>(void *data_key,
std::unordered_map<void *, debug_report_data *> &data_map);
// Forward Declarations
dispatchable_type = cmdinfo.elem.find('param/type').text
dispatchable_name = cmdinfo.elem.find('param/name').text
self.appendSection('command', ' dispatch_key key = get_dispatch_key('+dispatchable_name+');')
- self.appendSection('command', ' layer_data *my_data = get_my_data_ptr(key, layer_data_map);')
+ self.appendSection('command', ' layer_data *my_data = GetLayerDataPtr(key, layer_data_map);')
if dispatchable_type in ["VkPhysicalDevice", "VkInstance"]:
self.appendSection('command', ' VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;')
else:
dispatchable_type = cmdinfo.elem.find('param/type').text
dispatchable_name = cmdinfo.elem.find('param/name').text
# Generate local instance/pdev/device data lookup
- self.appendSection('command', ' layer_data *dev_data = get_my_data_ptr(get_dispatch_key('+dispatchable_name+'), layer_data_map);')
+ self.appendSection('command', ' layer_data *dev_data = GetLayerDataPtr(get_dispatch_key('+dispatchable_name+'), layer_data_map);')
# Handle return values, if any
resulttype = cmdinfo.elem.find('proto/type')
if (resulttype != None and resulttype.text == 'void'):
projects / platform / upstream / Vulkan-Tools.git / commitdiff