// Ordinarily we'd check these before calling down the chain, but none of the layer
// support is in place until now, if we survive we can report the issue now.
- parameter_validation_vkCreateInstance(my_instance_data->report_data, pCreateInfo, pAllocator, pInstance);
+ parameter_validation_vkCreateInstance(my_instance_data, pCreateInfo, pAllocator, pInstance);
if (pCreateInfo->pApplicationInfo) {
if (pCreateInfo->pApplicationInfo->pApplicationName) {
}
}
- skip |= parameter_validation_vkDestroyInstance(my_data->report_data, pAllocator);
+ skip |= parameter_validation_vkDestroyInstance(my_data, pAllocator);
// Disable and cleanup the temporary callback(s):
if (callback_setup) {
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);
+ skip |= parameter_validation_vkEnumeratePhysicalDevices(my_data, pPhysicalDeviceCount, pPhysicalDevices);
if (!skip) {
result = my_data->dispatch_table.EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices);
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);
+ skip |= parameter_validation_vkGetPhysicalDeviceFeatures(my_data, pFeatures);
if (!skip) {
my_data->dispatch_table.GetPhysicalDeviceFeatures(physicalDevice, pFeatures);
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);
+ skip |= parameter_validation_vkGetPhysicalDeviceFormatProperties(my_data, format, pFormatProperties);
if (!skip) {
my_data->dispatch_table.GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
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,
+ skip |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties(my_data, format, type, tiling, usage, flags,
pImageFormatProperties);
if (!skip) {
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);
+ skip |= parameter_validation_vkGetPhysicalDeviceProperties(my_data, pProperties);
if (!skip) {
my_data->dispatch_table.GetPhysicalDeviceProperties(physicalDevice, pProperties);
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,
+ skip |= parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties(my_data, pQueueFamilyPropertyCount,
pQueueFamilyProperties);
if (!skip) {
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);
+ skip |= parameter_validation_vkGetPhysicalDeviceMemoryProperties(my_data, pMemoryProperties);
if (!skip) {
my_data->dispatch_table.GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
assert(my_instance_data != nullptr);
std::unique_lock<std::mutex> lock(global_lock);
- skip |= parameter_validation_vkCreateDevice(my_instance_data->report_data, pCreateInfo, pAllocator, pDevice);
+ skip |= parameter_validation_vkCreateDevice(my_instance_data, pCreateInfo, pAllocator, pDevice);
if (pCreateInfo != NULL) skip |= ValidateDeviceCreateInfo(my_instance_data, physicalDevice, pCreateInfo);
layer_data *my_data = GetLayerDataPtr(key, layer_data_map);
assert(my_data != NULL);
- skip |= parameter_validation_vkDestroyDevice(my_data->report_data, pAllocator);
+ skip |= parameter_validation_vkDestroyDevice(my_data, pAllocator);
if (!skip) {
layer_debug_report_destroy_device(device);
assert(my_data != NULL);
std::unique_lock<std::mutex> lock(global_lock);
- skip |= parameter_validation_vkGetDeviceQueue(my_data->report_data, queueFamilyIndex, queueIndex, pQueue);
+ skip |= parameter_validation_vkGetDeviceQueue(my_data, queueFamilyIndex, queueIndex, pQueue);
if (!skip) {
PreGetDeviceQueue(device, queueFamilyIndex, queueIndex);
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);
+ skip |= parameter_validation_vkQueueSubmit(my_data, submitCount, pSubmits, fence);
if (!skip) {
result = my_data->dispatch_table.QueueSubmit(queue, submitCount, pSubmits, fence);
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);
+ skip |= parameter_validation_vkAllocateMemory(my_data, pAllocateInfo, pAllocator, pMemory);
if (!skip) {
result = my_data->dispatch_table.AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
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);
+ skip |= parameter_validation_vkFreeMemory(my_data, memory, pAllocator);
if (!skip) {
my_data->dispatch_table.FreeMemory(device, memory, pAllocator);
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);
+ skip |= parameter_validation_vkMapMemory(my_data, memory, offset, size, flags, ppData);
if (!skip) {
result = my_data->dispatch_table.MapMemory(device, memory, offset, size, flags, ppData);
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);
+ skip |= parameter_validation_vkUnmapMemory(my_data, memory);
if (!skip) {
my_data->dispatch_table.UnmapMemory(device, memory);
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);
+ skip |= parameter_validation_vkFlushMappedMemoryRanges(my_data, memoryRangeCount, pMemoryRanges);
if (!skip) {
result = my_data->dispatch_table.FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
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);
+ skip |= parameter_validation_vkInvalidateMappedMemoryRanges(my_data, memoryRangeCount, pMemoryRanges);
if (!skip) {
result = my_data->dispatch_table.InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
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);
+ skip |= parameter_validation_vkGetDeviceMemoryCommitment(my_data, memory, pCommittedMemoryInBytes);
if (!skip) {
my_data->dispatch_table.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
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);
+ skip |= parameter_validation_vkBindBufferMemory(my_data, buffer, memory, memoryOffset);
if (!skip) {
result = my_data->dispatch_table.BindBufferMemory(device, buffer, memory, memoryOffset);
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);
+ skip |= parameter_validation_vkBindImageMemory(my_data, image, memory, memoryOffset);
if (!skip) {
result = my_data->dispatch_table.BindImageMemory(device, image, memory, memoryOffset);
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);
+ skip |= parameter_validation_vkGetBufferMemoryRequirements(my_data, buffer, pMemoryRequirements);
if (!skip) {
my_data->dispatch_table.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
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);
+ skip |= parameter_validation_vkGetImageMemoryRequirements(my_data, image, pMemoryRequirements);
if (!skip) {
my_data->dispatch_table.GetImageMemoryRequirements(device, image, pMemoryRequirements);
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,
+ skip |= parameter_validation_vkGetImageSparseMemoryRequirements(my_data, image, pSparseMemoryRequirementCount,
pSparseMemoryRequirements);
if (!skip) {
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,
+ skip |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties(my_data, format, type, samples, usage,
tiling, pPropertyCount, pProperties);
if (!skip) {
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);
+ skip |= parameter_validation_vkQueueBindSparse(my_data, bindInfoCount, pBindInfo, fence);
if (!skip) {
result = my_data->dispatch_table.QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
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);
+ skip |= parameter_validation_vkCreateFence(my_data, pCreateInfo, pAllocator, pFence);
if (!skip) {
result = my_data->dispatch_table.CreateFence(device, pCreateInfo, pAllocator, pFence);
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);
+ skip |= parameter_validation_vkDestroyFence(my_data, fence, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyFence(device, fence, pAllocator);
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);
+ skip |= parameter_validation_vkResetFences(my_data, fenceCount, pFences);
if (!skip) {
result = my_data->dispatch_table.ResetFences(device, fenceCount, pFences);
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);
+ skip |= parameter_validation_vkGetFenceStatus(my_data, fence);
if (!skip) {
result = my_data->dispatch_table.GetFenceStatus(device, fence);
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);
+ skip |= parameter_validation_vkWaitForFences(my_data, fenceCount, pFences, waitAll, timeout);
if (!skip) {
result = my_data->dispatch_table.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
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);
+ skip |= parameter_validation_vkCreateSemaphore(my_data, pCreateInfo, pAllocator, pSemaphore);
if (!skip) {
result = my_data->dispatch_table.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
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);
+ skip |= parameter_validation_vkDestroySemaphore(my_data, semaphore, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroySemaphore(device, semaphore, pAllocator);
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);
+ skip |= parameter_validation_vkCreateEvent(my_data, pCreateInfo, pAllocator, pEvent);
if (!skip) {
result = my_data->dispatch_table.CreateEvent(device, pCreateInfo, pAllocator, pEvent);
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);
+ skip |= parameter_validation_vkDestroyEvent(my_data, event, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyEvent(device, event, pAllocator);
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);
+ skip |= parameter_validation_vkGetEventStatus(my_data, event);
if (!skip) {
result = my_data->dispatch_table.GetEventStatus(device, event);
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);
+ skip |= parameter_validation_vkSetEvent(my_data, event);
if (!skip) {
result = my_data->dispatch_table.SetEvent(device, event);
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);
+ skip |= parameter_validation_vkResetEvent(my_data, event);
if (!skip) {
result = my_data->dispatch_table.ResetEvent(device, event);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
- skip |= parameter_validation_vkCreateQueryPool(device_data->report_data, pCreateInfo, pAllocator, pQueryPool);
+ skip |= parameter_validation_vkCreateQueryPool(device_data, pCreateInfo, pAllocator, pQueryPool);
// Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
if (pCreateInfo != nullptr) {
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);
+ skip |= parameter_validation_vkDestroyQueryPool(my_data, queryPool, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyQueryPool(device, queryPool, pAllocator);
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,
+ skip |= parameter_validation_vkGetQueryPoolResults(my_data, queryPool, firstQuery, queryCount, dataSize, pData,
stride, flags);
if (!skip) {
std::unique_lock<std::mutex> lock(global_lock);
debug_report_data *report_data = device_data->report_data;
- skip |= parameter_validation_vkCreateBuffer(report_data, pCreateInfo, pAllocator, pBuffer);
+ skip |= parameter_validation_vkCreateBuffer(device_data, pCreateInfo, pAllocator, pBuffer);
if (pCreateInfo != nullptr) {
// Buffer size must be greater than 0 (error 00663)
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);
+ skip |= parameter_validation_vkDestroyBuffer(my_data, buffer, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyBuffer(device, buffer, pAllocator);
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);
+ skip |= parameter_validation_vkCreateBufferView(my_data, pCreateInfo, pAllocator, pView);
if (!skip) {
result = my_data->dispatch_table.CreateBufferView(device, pCreateInfo, pAllocator, pView);
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);
+ skip |= parameter_validation_vkDestroyBufferView(my_data, bufferView, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyBufferView(device, bufferView, pAllocator);
std::unique_lock<std::mutex> lock(global_lock);
debug_report_data *report_data = device_data->report_data;
- skip |= parameter_validation_vkCreateImage(report_data, pCreateInfo, pAllocator, pImage);
+ skip |= parameter_validation_vkCreateImage(device_data, pCreateInfo, pAllocator, pImage);
if (pCreateInfo != nullptr) {
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);
+ skip |= parameter_validation_vkDestroyImage(my_data, image, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyImage(device, image, pAllocator);
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);
+ skip |= parameter_validation_vkGetImageSubresourceLayout(my_data, image, pSubresource, pLayout);
if (!skip) {
PreGetImageSubresourceLayout(device, pSubresource);
assert(my_data != NULL);
debug_report_data *report_data = my_data->report_data;
- skip |= parameter_validation_vkCreateImageView(report_data, pCreateInfo, pAllocator, pView);
+ skip |= parameter_validation_vkCreateImageView(my_data, pCreateInfo, pAllocator, pView);
if (pCreateInfo != nullptr) {
if ((pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_1D) || (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_2D)) {
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);
+ skip |= parameter_validation_vkDestroyImageView(my_data, imageView, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyImageView(device, imageView, pAllocator);
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);
+ skip |= parameter_validation_vkCreateShaderModule(my_data, pCreateInfo, pAllocator, pShaderModule);
if (!skip) {
result = my_data->dispatch_table.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
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);
+ skip |= parameter_validation_vkDestroyShaderModule(my_data, shaderModule, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyShaderModule(device, shaderModule, pAllocator);
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);
+ skip |= parameter_validation_vkCreatePipelineCache(my_data, pCreateInfo, pAllocator, pPipelineCache);
if (!skip) {
result = my_data->dispatch_table.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
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);
+ skip |= parameter_validation_vkDestroyPipelineCache(my_data, pipelineCache, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyPipelineCache(device, pipelineCache, pAllocator);
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);
+ skip |= parameter_validation_vkGetPipelineCacheData(my_data, pipelineCache, pDataSize, pData);
if (!skip) {
result = my_data->dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
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);
+ skip |= parameter_validation_vkMergePipelineCaches(my_data, dstCache, srcCacheCount, pSrcCaches);
if (!skip) {
result = my_data->dispatch_table.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
- skip |= parameter_validation_vkCreateGraphicsPipelines(report_data, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
+ skip |= parameter_validation_vkCreateGraphicsPipelines(device_data, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
pPipelines);
if (pCreateInfos != nullptr) {
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,
+ skip |= parameter_validation_vkCreateComputePipelines(my_data, pipelineCache, createInfoCount, pCreateInfos,
pAllocator, pPipelines);
skip |= PreCreateComputePipelines(device, pCreateInfos);
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);
+ skip |= parameter_validation_vkDestroyPipeline(my_data, pipeline, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyPipeline(device, pipeline, pAllocator);
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);
+ skip |= parameter_validation_vkCreatePipelineLayout(my_data, pCreateInfo, pAllocator, pPipelineLayout);
if (!skip) {
result = my_data->dispatch_table.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
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);
+ skip |= parameter_validation_vkDestroyPipelineLayout(my_data, pipelineLayout, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyPipelineLayout(device, pipelineLayout, pAllocator);
assert(device_data != NULL);
debug_report_data *report_data = device_data->report_data;
- skip |= parameter_validation_vkCreateSampler(report_data, pCreateInfo, pAllocator, pSampler);
+ skip |= parameter_validation_vkCreateSampler(device_data, pCreateInfo, pAllocator, pSampler);
if (pCreateInfo != nullptr) {
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);
+ skip |= parameter_validation_vkDestroySampler(my_data, sampler, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroySampler(device, sampler, pAllocator);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
- skip |= parameter_validation_vkCreateDescriptorSetLayout(report_data, pCreateInfo, pAllocator, pSetLayout);
+ skip |= parameter_validation_vkCreateDescriptorSetLayout(device_data, pCreateInfo, pAllocator, pSetLayout);
// Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
if ((pCreateInfo != nullptr) && (pCreateInfo->pBindings != nullptr)) {
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);
+ skip |= parameter_validation_vkDestroyDescriptorSetLayout(my_data, descriptorSetLayout, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
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);
+ skip |= parameter_validation_vkCreateDescriptorPool(my_data, pCreateInfo, pAllocator, pDescriptorPool);
/* TODOVV: How do we validate maxSets? Probably belongs in the limits layer? */
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);
+ skip |= parameter_validation_vkDestroyDescriptorPool(my_data, descriptorPool, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyDescriptorPool(device, descriptorPool, pAllocator);
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);
+ skip |= parameter_validation_vkResetDescriptorPool(my_data, descriptorPool, flags);
if (!skip) {
result = my_data->dispatch_table.ResetDescriptorPool(device, descriptorPool, flags);
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);
+ skip |= parameter_validation_vkAllocateDescriptorSets(my_data, pAllocateInfo, pDescriptorSets);
if (!skip) {
result = my_data->dispatch_table.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
- skip |= parameter_validation_vkFreeDescriptorSets(report_data, descriptorPool, descriptorSetCount, pDescriptorSets);
+ skip |= parameter_validation_vkFreeDescriptorSets(device_data, descriptorPool, descriptorSetCount, pDescriptorSets);
// Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
// This is an array of handles, where the elements are allowed to be VK_NULL_HANDLE, and does not require any validation beyond
assert(device_data != NULL);
debug_report_data *report_data = device_data->report_data;
- skip |= parameter_validation_vkUpdateDescriptorSets(report_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
+ skip |= parameter_validation_vkUpdateDescriptorSets(device_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
pDescriptorCopies);
// Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
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);
+ skip |= parameter_validation_vkCreateFramebuffer(my_data, pCreateInfo, pAllocator, pFramebuffer);
if (!skip) {
result = my_data->dispatch_table.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
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);
+ skip |= parameter_validation_vkDestroyFramebuffer(my_data, framebuffer, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyFramebuffer(device, framebuffer, pAllocator);
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);
+ skip |= parameter_validation_vkCreateRenderPass(my_data, pCreateInfo, pAllocator, pRenderPass);
skip |= PreCreateRenderPass(my_data, pCreateInfo);
if (!skip) {
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);
+ skip |= parameter_validation_vkDestroyRenderPass(my_data, renderPass, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyRenderPass(device, renderPass, pAllocator);
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);
+ skip |= parameter_validation_vkGetRenderAreaGranularity(my_data, renderPass, pGranularity);
if (!skip) {
my_data->dispatch_table.GetRenderAreaGranularity(device, renderPass, pGranularity);
skip |= ValidateDeviceQueueFamily(my_data, pCreateInfo->queueFamilyIndex, "vkCreateCommandPool",
"pCreateInfo->queueFamilyIndex", VALIDATION_ERROR_02c0004e);
- skip |= parameter_validation_vkCreateCommandPool(my_data->report_data, pCreateInfo, pAllocator, pCommandPool);
+ skip |= parameter_validation_vkCreateCommandPool(my_data, pCreateInfo, pAllocator, pCommandPool);
if (!skip) {
result = my_data->dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
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);
+ skip |= parameter_validation_vkDestroyCommandPool(my_data, commandPool, pAllocator);
if (!skip) {
my_data->dispatch_table.DestroyCommandPool(device, commandPool, pAllocator);
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);
+ skip |= parameter_validation_vkResetCommandPool(my_data, commandPool, flags);
if (!skip) {
result = my_data->dispatch_table.ResetCommandPool(device, commandPool, flags);
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);
+ skip |= parameter_validation_vkAllocateCommandBuffers(my_data, pAllocateInfo, pCommandBuffers);
if (!skip) {
result = my_data->dispatch_table.AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
- skip |= parameter_validation_vkFreeCommandBuffers(report_data, commandPool, commandBufferCount, pCommandBuffers);
+ skip |= parameter_validation_vkFreeCommandBuffers(device_data, commandPool, commandBufferCount, pCommandBuffers);
// Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
// This is an array of handles, where the elements are allowed to be VK_NULL_HANDLE, and does not require any validation beyond
assert(device_data != nullptr);
debug_report_data *report_data = device_data->report_data;
- skip |= parameter_validation_vkBeginCommandBuffer(report_data, pBeginInfo);
+ skip |= parameter_validation_vkBeginCommandBuffer(device_data, pBeginInfo);
// Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
// TODO: pBeginInfo->pInheritanceInfo must not be NULL if commandBuffer is a secondary command buffer
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);
+ bool skip = parameter_validation_vkResetCommandBuffer(my_data, flags);
if (!skip) {
result = my_data->dispatch_table.ResetCommandBuffer(commandBuffer, flags);
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);
+ skip |= parameter_validation_vkCmdBindPipeline(my_data, pipelineBindPoint, pipeline);
if (!skip) {
my_data->dispatch_table.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
assert(my_data != NULL);
debug_report_data *report_data = my_data->report_data;
- skip |= parameter_validation_vkCmdSetScissor(my_data->report_data, firstScissor, scissorCount, pScissors);
+ skip |= parameter_validation_vkCmdSetScissor(my_data, firstScissor, scissorCount, pScissors);
if (my_data->physical_device_features.multiViewport == false) {
if (scissorCount != 1) {
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);
+ skip |= parameter_validation_vkCmdSetBlendConstants(my_data, blendConstants);
if (!skip) {
my_data->dispatch_table.CmdSetBlendConstants(commandBuffer, blendConstants);
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);
+ skip |= parameter_validation_vkCmdSetStencilCompareMask(my_data, faceMask, compareMask);
if (!skip) {
my_data->dispatch_table.CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
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);
+ skip |= parameter_validation_vkCmdSetStencilWriteMask(my_data, faceMask, writeMask);
if (!skip) {
my_data->dispatch_table.CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
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);
+ skip |= parameter_validation_vkCmdSetStencilReference(my_data, faceMask, reference);
if (!skip) {
my_data->dispatch_table.CmdSetStencilReference(commandBuffer, faceMask, reference);
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,
+ skip |= parameter_validation_vkCmdBindDescriptorSets(my_data, pipelineBindPoint, layout, firstSet,
descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
if (!skip) {
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);
+ skip |= parameter_validation_vkCmdBindIndexBuffer(my_data, buffer, offset, indexType);
if (!skip) {
my_data->dispatch_table.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
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);
+ skip |= parameter_validation_vkCmdBindVertexBuffers(my_data, firstBinding, bindingCount, pBuffers, pOffsets);
if (!skip) {
my_data->dispatch_table.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
DEVICE_FEATURE, LayerName,
"CmdDrawIndirect(): Device feature multiDrawIndirect disabled: count must be 0 or 1 but is %d", count);
}
- skip |= parameter_validation_vkCmdDrawIndirect(my_data->report_data, buffer, offset, count, stride);
+ skip |= parameter_validation_vkCmdDrawIndirect(my_data, buffer, offset, count, stride);
if (!skip) {
my_data->dispatch_table.CmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
DEVICE_FEATURE, LayerName,
"CmdDrawIndexedIndirect(): Device feature multiDrawIndirect disabled: count must be 0 or 1 but is %d", count);
}
- skip |= parameter_validation_vkCmdDrawIndexedIndirect(my_data->report_data, buffer, offset, count, stride);
+ skip |= parameter_validation_vkCmdDrawIndexedIndirect(my_data, buffer, offset, count, stride);
if (!skip) {
my_data->dispatch_table.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
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);
+ skip |= parameter_validation_vkCmdDispatchIndirect(my_data, buffer, offset);
if (!skip) {
my_data->dispatch_table.CmdDispatchIndirect(commandBuffer, buffer, offset);
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);
+ skip |= parameter_validation_vkCmdCopyBuffer(my_data, srcBuffer, dstBuffer, regionCount, pRegions);
if (!skip) {
my_data->dispatch_table.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
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,
+ skip |= parameter_validation_vkCmdCopyImage(my_data, srcImage, srcImageLayout, dstImage, dstImageLayout,
regionCount, pRegions);
if (!skip) {
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,
+ skip |= parameter_validation_vkCmdBlitImage(my_data, srcImage, srcImageLayout, dstImage, dstImageLayout,
regionCount, pRegions, filter);
if (!skip) {
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,
+ skip |= parameter_validation_vkCmdCopyBufferToImage(my_data, srcBuffer, dstImage, dstImageLayout, regionCount,
pRegions);
if (!skip) {
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,
+ skip |= parameter_validation_vkCmdCopyImageToBuffer(my_data, srcImage, srcImageLayout, dstBuffer, regionCount,
pRegions);
if (!skip) {
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);
+ skip |= parameter_validation_vkCmdUpdateBuffer(my_data, dstBuffer, dstOffset, dataSize, pData);
if (dstOffset & 3) {
skip |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
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);
+ skip |= parameter_validation_vkCmdFillBuffer(my_data, dstBuffer, dstOffset, size, data);
if (dstOffset & 3) {
skip |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__,
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);
+ skip |= parameter_validation_vkCmdClearColorImage(my_data, image, imageLayout, pColor, rangeCount, pRanges);
if (!skip) {
my_data->dispatch_table.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
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,
+ skip |= parameter_validation_vkCmdClearDepthStencilImage(my_data, image, imageLayout, pDepthStencil, rangeCount,
pRanges);
if (!skip) {
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);
+ skip |= parameter_validation_vkCmdClearAttachments(my_data, attachmentCount, pAttachments, rectCount, pRects);
if (!skip) {
my_data->dispatch_table.CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
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,
+ skip |= parameter_validation_vkCmdResolveImage(my_data, srcImage, srcImageLayout, dstImage, dstImageLayout,
regionCount, pRegions);
if (!skip) {
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);
+ skip |= parameter_validation_vkCmdSetEvent(my_data, event, stageMask);
if (!skip) {
my_data->dispatch_table.CmdSetEvent(commandBuffer, event, stageMask);
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);
+ skip |= parameter_validation_vkCmdResetEvent(my_data, event, stageMask);
if (!skip) {
my_data->dispatch_table.CmdResetEvent(commandBuffer, event, stageMask);
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,
+ skip |= parameter_validation_vkCmdWaitEvents(my_data, eventCount, pEvents, srcStageMask, dstStageMask,
memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
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,
+ skip |= parameter_validation_vkCmdPipelineBarrier(my_data, srcStageMask, dstStageMask, dependencyFlags,
memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
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);
+ skip |= parameter_validation_vkCmdBeginQuery(my_data, queryPool, slot, flags);
if (!skip) {
my_data->dispatch_table.CmdBeginQuery(commandBuffer, queryPool, slot, flags);
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);
+ skip |= parameter_validation_vkCmdEndQuery(my_data, queryPool, slot);
if (!skip) {
my_data->dispatch_table.CmdEndQuery(commandBuffer, queryPool, slot);
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);
+ skip |= parameter_validation_vkCmdResetQueryPool(my_data, queryPool, firstQuery, queryCount);
if (!skip) {
my_data->dispatch_table.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
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);
+ skip |= parameter_validation_vkCmdWriteTimestamp(my_data, pipelineStage, queryPool, query);
if (!skip) {
my_data->dispatch_table.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
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,
+ skip |= parameter_validation_vkCmdCopyQueryPoolResults(my_data, queryPool, firstQuery, queryCount, dstBuffer,
dstOffset, stride, flags);
if (!skip) {
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);
+ skip |= parameter_validation_vkCmdPushConstants(my_data, layout, stageFlags, offset, size, pValues);
if (!skip) {
my_data->dispatch_table.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
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);
+ skip |= parameter_validation_vkCmdBeginRenderPass(my_data, pRenderPassBegin, contents);
if (!skip) {
my_data->dispatch_table.CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
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);
+ skip |= parameter_validation_vkCmdNextSubpass(my_data, contents);
if (!skip) {
my_data->dispatch_table.CmdNextSubpass(commandBuffer, contents);
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);
+ skip |= parameter_validation_vkCmdExecuteCommands(my_data, commandBufferCount, pCommandBuffers);
if (!skip) {
my_data->dispatch_table.CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
skip |= require_device_extension(device_data, device_data->enables.khr_swapchain, "vkCreateSwapchainKHR",
VK_KHR_SWAPCHAIN_EXTENSION_NAME);
- skip |= parameter_validation_vkCreateSwapchainKHR(device_data->report_data, pCreateInfo, pAllocator, pSwapchain);
+ skip |= parameter_validation_vkCreateSwapchainKHR(device_data, pCreateInfo, pAllocator, pSwapchain);
if (pCreateInfo != nullptr) {
if ((device_data->physical_device_features.textureCompressionETC2 == false) &&
skip |= require_device_extension(my_data, my_data->enables.khr_swapchain, "vkGetSwapchainImagesKHR",
VK_KHR_SWAPCHAIN_EXTENSION_NAME);
- skip |= parameter_validation_vkGetSwapchainImagesKHR(my_data->report_data, swapchain, pSwapchainImageCount, pSwapchainImages);
+ skip |= parameter_validation_vkGetSwapchainImagesKHR(my_data, swapchain, pSwapchainImageCount, pSwapchainImages);
if (!skip) {
result = my_data->dispatch_table.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
skip |= require_device_extension(my_data, my_data->enables.khr_swapchain, "vkAcquireNextImageKHR",
VK_KHR_SWAPCHAIN_EXTENSION_NAME);
- skip |= parameter_validation_vkAcquireNextImageKHR(my_data->report_data, swapchain, timeout, semaphore, fence, pImageIndex);
+ skip |= parameter_validation_vkAcquireNextImageKHR(my_data, swapchain, timeout, semaphore, fence, pImageIndex);
if (!skip) {
result = my_data->dispatch_table.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
skip |= require_device_extension(my_data, my_data->enables.khr_swapchain, "vkQueuePresentKHR",
VK_KHR_SWAPCHAIN_EXTENSION_NAME);
- skip |= parameter_validation_vkQueuePresentKHR(my_data->report_data, pPresentInfo);
+ skip |= parameter_validation_vkQueuePresentKHR(my_data, pPresentInfo);
if (pPresentInfo && pPresentInfo->pNext) {
// Verify ext struct
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_surface,
"vkGetPhysicalDeviceSurfaceSupportKHR", VK_KHR_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceSurfaceSupportKHR(my_data->report_data, queueFamilyIndex, surface, pSupported);
+ skip |= parameter_validation_vkGetPhysicalDeviceSurfaceSupportKHR(my_data, queueFamilyIndex, surface, pSupported);
if (!skip) {
result = my_data->dispatch_table.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_surface,
"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", VK_KHR_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(my_data->report_data, surface, pSurfaceCapabilities);
+ skip |= parameter_validation_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(my_data, surface, pSurfaceCapabilities);
if (!skip) {
result = my_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_surface,
"vkGetPhysicalDeviceSurfaceFormatsKHR", VK_KHR_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceSurfaceFormatsKHR(my_data->report_data, surface, pSurfaceFormatCount,
+ skip |= parameter_validation_vkGetPhysicalDeviceSurfaceFormatsKHR(my_data, surface, pSurfaceFormatCount,
pSurfaceFormats);
if (!skip) {
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_surface,
"vkGetPhysicalDeviceSurfacePresentModesKHR", VK_KHR_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceSurfacePresentModesKHR(my_data->report_data, surface, pPresentModeCount,
+ skip |= parameter_validation_vkGetPhysicalDeviceSurfacePresentModesKHR(my_data, surface, pPresentModeCount,
pPresentModes);
if (!skip) {
validation_error_map[VALIDATION_ERROR_15a00a38]);
}
- skip |= parameter_validation_vkCreateWin32SurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface);
+ skip |= parameter_validation_vkCreateWin32SurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface);
if (!skip) {
result = my_data->dispatch_table.CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
skip |= require_instance_extension(instance, &InstanceExtensions::khr_xcb_surface, "vkCreateXcbSurfaceKHR",
VK_KHR_XCB_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkCreateXcbSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface);
+ skip |= parameter_validation_vkCreateXcbSurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface);
if (!skip) {
result = my_data->dispatch_table.CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_xcb_surface,
"vkGetPhysicalDeviceXcbPresentationSupportKHR", VK_KHR_XCB_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceXcbPresentationSupportKHR(my_data->report_data, queueFamilyIndex, connection,
+ skip |= parameter_validation_vkGetPhysicalDeviceXcbPresentationSupportKHR(my_data, queueFamilyIndex, connection,
visual_id);
if (!skip) {
skip |= require_instance_extension(instance, &InstanceExtensions::khr_xlib_surface, "vkCreateXlibSurfaceKHR",
VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkCreateXlibSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface);
+ skip |= parameter_validation_vkCreateXlibSurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface);
if (!skip) {
result = my_data->dispatch_table.CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
"vkGetPhysicalDeviceXlibPresentationSupportKHR", VK_KHR_XLIB_SURFACE_EXTENSION_NAME);
skip |=
- parameter_validation_vkGetPhysicalDeviceXlibPresentationSupportKHR(my_data->report_data, queueFamilyIndex, dpy, visualID);
+ parameter_validation_vkGetPhysicalDeviceXlibPresentationSupportKHR(my_data, queueFamilyIndex, dpy, visualID);
if (!skip) {
result =
skip |= require_instance_extension(instance, &InstanceExtensions::khr_mir_surface, "vkCreateMirSurfaceKHR",
VK_KHR_MIR_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkCreateMirSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface);
+ skip |= parameter_validation_vkCreateMirSurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface);
if (!skip) {
result = my_data->dispatch_table.CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_mir_surface,
"vkGetPhysicalDeviceMirPresentationSupportKHR", VK_KHR_MIR_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceMirPresentationSupportKHR(my_data->report_data, queueFamilyIndex, connection);
+ skip |= parameter_validation_vkGetPhysicalDeviceMirPresentationSupportKHR(my_data, queueFamilyIndex, connection);
if (!skip) {
result = my_data->dispatch_table.GetPhysicalDeviceMirPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection);
skip |= require_instance_extension(instance, &InstanceExtensions::khr_wayland_surface, "vkCreateWaylandSurfaceKHR",
VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkCreateWaylandSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface);
+ skip |= parameter_validation_vkCreateWaylandSurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface);
if (!skip) {
result = my_data->dispatch_table.CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_wayland_surface,
"vkGetPhysicalDeviceWaylandPresentationSupportKHR", VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceWaylandPresentationSupportKHR(my_data->report_data, queueFamilyIndex, display);
+ skip |= parameter_validation_vkGetPhysicalDeviceWaylandPresentationSupportKHR(my_data, queueFamilyIndex, display);
if (!skip) {
result = my_data->dispatch_table.GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display);
skip |= require_instance_extension(instance, &InstanceExtensions::khr_android_surface, "vkCreateAndroidSurfaceKHR",
VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
- skip |= parameter_validation_vkCreateAndroidSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface);
+ skip |= parameter_validation_vkCreateAndroidSurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface);
if (!skip) {
result = my_data->dispatch_table.CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
skip |= require_device_extension(my_data, my_data->enables.khr_display_swapchain, "vkCreateSharedSwapchainsKHR",
VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME);
- skip |= parameter_validation_vkCreateSharedSwapchainsKHR(my_data->report_data, swapchainCount, pCreateInfos, pAllocator,
+ skip |= parameter_validation_vkCreateSharedSwapchainsKHR(my_data, swapchainCount, pCreateInfos, pAllocator,
pSwapchains);
if (!skip) {
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_get_physical_device_properties2,
"vkGetPhysicalDeviceFeatures2KHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceFeatures2KHR(my_data->report_data, pFeatures);
+ skip |= parameter_validation_vkGetPhysicalDeviceFeatures2KHR(my_data, pFeatures);
if (!skip) {
my_data->dispatch_table.GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures);
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_get_physical_device_properties2,
"vkGetPhysicalDeviceProperties2KHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceProperties2KHR(my_data->report_data, pProperties);
+ skip |= parameter_validation_vkGetPhysicalDeviceProperties2KHR(my_data, pProperties);
if (!skip) {
my_data->dispatch_table.GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties);
"vkGetPhysicalDeviceFormatProperties2KHR",
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceFormatProperties2KHR(my_data->report_data, format, pFormatProperties);
+ skip |= parameter_validation_vkGetPhysicalDeviceFormatProperties2KHR(my_data, format, pFormatProperties);
if (!skip) {
my_data->dispatch_table.GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties);
"vkGetPhysicalDeviceImageFormatProperties2KHR",
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties2KHR(my_data->report_data, pImageFormatInfo,
+ skip |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties2KHR(my_data, pImageFormatInfo,
pImageFormatProperties);
if (!skip) {
"vkGetPhysicalDeviceQueueFamilyProperties2KHR",
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties2KHR(my_data->report_data, pQueueFamilyPropertyCount,
+ skip |= parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties2KHR(my_data, pQueueFamilyPropertyCount,
pQueueFamilyProperties);
if (!skip) {
"vkGetPhysicalDeviceMemoryProperties2KHR",
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceMemoryProperties2KHR(my_data->report_data, pMemoryProperties);
+ skip |= parameter_validation_vkGetPhysicalDeviceMemoryProperties2KHR(my_data, pMemoryProperties);
if (!skip) {
my_data->dispatch_table.GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties);
"vkGetPhysicalDeviceSparseImageFormatProperties2KHR",
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(my_data->report_data, pFormatInfo,
+ skip |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(my_data, pFormatInfo,
pPropertyCount, pProperties);
if (!skip) {
skip |= require_device_extension(my_data, my_data->enables.khr_maintenance1, "vkTrimCommandPoolKHR",
VK_KHR_MAINTENANCE1_EXTENSION_NAME);
- skip |= parameter_validation_vkTrimCommandPoolKHR(my_data->report_data, commandPool, flags);
+ skip |= parameter_validation_vkTrimCommandPoolKHR(my_data, commandPool, flags);
if (!skip) {
my_data->dispatch_table.TrimCommandPoolKHR(device, commandPool, flags);
skip |= require_device_extension(my_data, my_data->enables.khr_push_descriptor, "vkCmdPushDescriptorSetKHR",
VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
- skip |= parameter_validation_vkCmdPushDescriptorSetKHR(my_data->report_data, pipelineBindPoint, layout, set,
+ skip |= parameter_validation_vkCmdPushDescriptorSetKHR(my_data, pipelineBindPoint, layout, set,
descriptorWriteCount, pDescriptorWrites);
if (!skip) {
skip |= require_device_extension(my_data, my_data->enables.khr_descriptor_update_template,
"vkCreateDescriptorUpdateTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME);
- skip |= parameter_validation_vkCreateDescriptorUpdateTemplateKHR(my_data->report_data, pCreateInfo, pAllocator,
+ skip |= parameter_validation_vkCreateDescriptorUpdateTemplateKHR(my_data, pCreateInfo, pAllocator,
pDescriptorUpdateTemplate);
if (!skip) {
"vkDestroyDescriptorUpdateTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME);
#if 0 // Validation not automatically generated
- skip |= parameter_validation_vkDestroyDescriptorUpdateTemplateKHR(my_data->report_data, descriptorUpdateTemplate,
+ skip |= parameter_validation_vkDestroyDescriptorUpdateTemplateKHR(my_data, descriptorUpdateTemplate,
pAllocator);
#endif
skip |= require_device_extension(my_data, my_data->enables.khr_descriptor_update_template,
"vkUpdateDescriptorSetWithTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME);
- skip |= parameter_validation_vkUpdateDescriptorSetWithTemplateKHR(my_data->report_data, descriptorSet, descriptorUpdateTemplate,
+ skip |= parameter_validation_vkUpdateDescriptorSetWithTemplateKHR(my_data, descriptorSet, descriptorUpdateTemplate,
pData);
if (!skip) {
skip |= require_device_extension(my_data, my_data->enables.khr_descriptor_update_template,
"vkCmdPushDescriptorSetWithTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME);
- skip |= parameter_validation_vkCmdPushDescriptorSetWithTemplateKHR(my_data->report_data, descriptorUpdateTemplate, layout, set,
+ skip |= parameter_validation_vkCmdPushDescriptorSetWithTemplateKHR(my_data, descriptorUpdateTemplate, layout, set,
pData);
if (!skip) {
layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- skip = parameter_validation_vkGetSwapchainStatusKHR(dev_data->report_data, swapchain);
+ skip = parameter_validation_vkGetSwapchainStatusKHR(dev_data, swapchain);
if (!skip) {
result = dev_data->dispatch_table.GetSwapchainStatusKHR(device, swapchain);
instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- skip = parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2KHR(instance_data->report_data, pSurfaceInfo,
+ skip = parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2KHR(instance_data, pSurfaceInfo,
pSurfaceCapabilities);
if (!skip) {
bool skip = false;
instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
- skip = parameter_validation_vkGetPhysicalDeviceSurfaceFormats2KHR(instance_data->report_data, pSurfaceInfo, pSurfaceFormatCount,
+ skip = parameter_validation_vkGetPhysicalDeviceSurfaceFormats2KHR(instance_data, pSurfaceInfo, pSurfaceFormatCount,
pSurfaceFormats);
if (!skip) {
result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo,
skip |= require_instance_extension(instance, &InstanceExtensions::khx_device_group_creation,
"vkEnumeratePhysicalDeviceGroupsKHX", VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME);
- skip |= parameter_validation_vkEnumeratePhysicalDeviceGroupsKHX(my_data->report_data, pPhysicalDeviceGroupCount,
+ skip |= parameter_validation_vkEnumeratePhysicalDeviceGroupsKHX(my_data, pPhysicalDeviceGroupCount,
pPhysicalDeviceGroupProperties);
if (!skip) {
skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkGetDeviceGroupPeerMemoryFeaturesKHX",
VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
- skip |= parameter_validation_vkGetDeviceGroupPeerMemoryFeaturesKHX(my_data->report_data, heapIndex, localDeviceIndex,
+ skip |= parameter_validation_vkGetDeviceGroupPeerMemoryFeaturesKHX(my_data, heapIndex, localDeviceIndex,
remoteDeviceIndex, pPeerMemoryFeatures);
if (!skip) {
skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkBindBufferMemory2KHX",
VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
- skip |= parameter_validation_vkBindBufferMemory2KHX(my_data->report_data, bindInfoCount, pBindInfos);
+ skip |= parameter_validation_vkBindBufferMemory2KHX(my_data, bindInfoCount, pBindInfos);
if (!skip) {
result = my_data->dispatch_table.BindBufferMemory2KHX(device, bindInfoCount, pBindInfos);
skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkBindImageMemory2KHX",
VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
- skip |= parameter_validation_vkBindImageMemory2KHX(my_data->report_data, bindInfoCount, pBindInfos);
+ skip |= parameter_validation_vkBindImageMemory2KHX(my_data, bindInfoCount, pBindInfos);
if (!skip) {
result = my_data->dispatch_table.BindImageMemory2KHX(device, bindInfoCount, pBindInfos);
VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
#if 0 // Validation not automatically generated
- skip |= parameter_validation_vkCmdSetDeviceMaskKHX(my_data->report_data, deviceMask);
+ skip |= parameter_validation_vkCmdSetDeviceMaskKHX(my_data, deviceMask);
#endif
if (!skip) {
skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkGetDeviceGroupPresentCapabilitiesKHX",
VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
- skip |= parameter_validation_vkGetDeviceGroupPresentCapabilitiesKHX(my_data->report_data, pDeviceGroupPresentCapabilities);
+ skip |= parameter_validation_vkGetDeviceGroupPresentCapabilitiesKHX(my_data, pDeviceGroupPresentCapabilities);
if (!skip) {
result = my_data->dispatch_table.GetDeviceGroupPresentCapabilitiesKHX(device, pDeviceGroupPresentCapabilities);
skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkGetDeviceGroupSurfacePresentModesKHX",
VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
- skip |= parameter_validation_vkGetDeviceGroupSurfacePresentModesKHX(my_data->report_data, surface, pModes);
+ skip |= parameter_validation_vkGetDeviceGroupSurfacePresentModesKHX(my_data, surface, pModes);
if (!skip) {
result = my_data->dispatch_table.GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes);
skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkAcquireNextImage2KHX",
VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
- skip |= parameter_validation_vkAcquireNextImage2KHX(my_data->report_data, pAcquireInfo, pImageIndex);
+ skip |= parameter_validation_vkAcquireNextImage2KHX(my_data, pAcquireInfo, pImageIndex);
if (!skip) {
result = my_data->dispatch_table.AcquireNextImage2KHX(device, pAcquireInfo, pImageIndex);
VK_KHX_DEVICE_GROUP_EXTENSION_NAME);
#if 0 // Validation not automatically generated
- skip |= parameter_validation_vkCmdDispatchBaseKHX(my_data->report_data, baseGroupX, baseGroupY, baseGroupZ,
+ skip |= parameter_validation_vkCmdDispatchBaseKHX(my_data, baseGroupX, baseGroupY, baseGroupZ,
groupCountX, groupCountY, groupCountZ);
#endif
auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
assert(my_data != NULL);
- skip |= parameter_validation_vkGetPhysicalDevicePresentRectanglesKHX(my_data->report_data, surface, pRectCount, pRects);
+ skip |= parameter_validation_vkGetPhysicalDevicePresentRectanglesKHX(my_data, surface, pRectCount, pRects);
if (!skip) {
result = my_data->dispatch_table.GetPhysicalDevicePresentRectanglesKHX(physicalDevice, surface, pRectCount, pRects);
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khx_external_memory_capabilities,
"vkGetPhysicalDeviceExternalBufferPropertiesKHX",
VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceExternalBufferPropertiesKHX(my_data->report_data, pExternalBufferInfo,
+ skip |= parameter_validation_vkGetPhysicalDeviceExternalBufferPropertiesKHX(my_data, pExternalBufferInfo,
pExternalBufferProperties);
if (!skip) {
my_data->dispatch_table.GetPhysicalDeviceExternalBufferPropertiesKHX(physicalDevice, pExternalBufferInfo,
skip |= require_device_extension(my_data, my_data->enables.khx_external_memory_fd, "vkGetMemoryFdKHX",
VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
- skip |= parameter_validation_vkGetMemoryFdKHX(my_data->report_data, memory, handleType, pFd);
+ skip |= parameter_validation_vkGetMemoryFdKHX(my_data, memory, handleType, pFd);
if (!skip) {
result = my_data->dispatch_table.GetMemoryFdKHX(device, memory, handleType, pFd);
skip |= require_device_extension(my_data, my_data->enables.khx_external_memory_fd, "vkGetMemoryFdPropertiesKHX",
VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
- skip |= parameter_validation_vkGetMemoryFdPropertiesKHX(my_data->report_data, handleType, fd, pMemoryFdProperties);
+ skip |= parameter_validation_vkGetMemoryFdPropertiesKHX(my_data, handleType, fd, pMemoryFdProperties);
if (!skip) {
result = my_data->dispatch_table.GetMemoryFdPropertiesKHX(device, handleType, fd, pMemoryFdProperties);
skip |= require_device_extension(my_data, my_data->enables.khx_external_memory_win32, "vkGetMemoryWin32HandleKHX",
VK_KHX_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
- skip |= parameter_validation_vkGetMemoryWin32HandleKHX(my_data->report_data, memory, handleType, pHandle);
+ skip |= parameter_validation_vkGetMemoryWin32HandleKHX(my_data, memory, handleType, pHandle);
if (!skip) {
result = my_data->dispatch_table.GetMemoryWin32HandleKHX(device, memory, handleType, pHandle);
skip |= require_device_extension(my_data, my_data->enables.khx_external_memory_win32, "vkGetMemoryWin32HandlePropertiesKHX",
VK_KHX_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
- skip |= parameter_validation_vkGetMemoryWin32HandlePropertiesKHX(my_data->report_data, handleType, handle,
+ skip |= parameter_validation_vkGetMemoryWin32HandlePropertiesKHX(my_data, handleType, handle,
pMemoryWin32HandleProperties);
if (!skip) {
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khx_external_memory_capabilities,
"vkGetPhysicalDeviceExternalSemaphorePropertiesKHX",
VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX(my_data->report_data, pExternalSemaphoreInfo,
+ skip |= parameter_validation_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX(my_data, pExternalSemaphoreInfo,
pExternalSemaphoreProperties);
if (!skip) {
my_data->dispatch_table.GetPhysicalDeviceExternalSemaphorePropertiesKHX(physicalDevice, pExternalSemaphoreInfo,
skip |= require_device_extension(my_data, my_data->enables.khx_external_semaphore_fd, "vkImportSemaphoreFdKHX",
VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME);
- skip |= parameter_validation_vkImportSemaphoreFdKHX(my_data->report_data, pImportSemaphoreFdInfo);
+ skip |= parameter_validation_vkImportSemaphoreFdKHX(my_data, pImportSemaphoreFdInfo);
if (!skip) {
result = my_data->dispatch_table.ImportSemaphoreFdKHX(device, pImportSemaphoreFdInfo);
skip |= require_device_extension(my_data, my_data->enables.khx_external_semaphore_fd, "vkGetSemaphoreFdKHX",
VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME);
- skip |= parameter_validation_vkGetSemaphoreFdKHX(my_data->report_data, semaphore, handleType, pFd);
+ skip |= parameter_validation_vkGetSemaphoreFdKHX(my_data, semaphore, handleType, pFd);
if (!skip) {
result = my_data->dispatch_table.GetSemaphoreFdKHX(device, semaphore, handleType, pFd);
skip |= require_device_extension(my_data, my_data->enables.khx_external_semaphore_win32, "vkImportSemaphoreWin32HandleKHX",
VK_KHX_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME);
- skip |= parameter_validation_vkImportSemaphoreWin32HandleKHX(my_data->report_data, pImportSemaphoreWin32HandleInfo);
+ skip |= parameter_validation_vkImportSemaphoreWin32HandleKHX(my_data, pImportSemaphoreWin32HandleInfo);
if (!skip) {
result = my_data->dispatch_table.ImportSemaphoreWin32HandleKHX(device, pImportSemaphoreWin32HandleInfo);
validate_result(my_data->report_data, "vkImportSemaphoreWin32HandleKHX", {}, result);
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.khx_external_semaphore_win32, "vkGetSemaphoreWin32HandleKHX",
VK_KHX_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME);
- skip |= parameter_validation_vkGetSemaphoreWin32HandleKHX(my_data->report_data, semaphore, handleType, pHandle);
+ skip |= parameter_validation_vkGetSemaphoreWin32HandleKHX(my_data, semaphore, handleType, pHandle);
if (!skip) {
result = my_data->dispatch_table.GetSemaphoreWin32HandleKHX(device, semaphore, handleType, pHandle);
validate_result(my_data->report_data, "vkGetSemaphoreWin32HandleKHX", {}, result);
bool skip = false;
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::ext_acquire_xlib_display,
"vkAcquireXlibDisplayEXT", VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME);
- skip |= parameter_validation_vkAcquireXlibDisplayEXT(my_data->report_data, dpy, display);
+ skip |= parameter_validation_vkAcquireXlibDisplayEXT(my_data, dpy, display);
if (!skip) {
result = my_data->dispatch_table.AcquireXlibDisplayEXT(physicalDevice, dpy, display);
validate_result(my_data->report_data, "vkAcquireXlibDisplayEXT", {}, result);
bool skip = false;
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::ext_acquire_xlib_display,
"vkGetRandROutputDisplayEXT", VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME);
- skip |= parameter_validation_vkGetRandROutputDisplayEXT(my_data->report_data, dpy, rrOutput, pDisplay);
+ skip |= parameter_validation_vkGetRandROutputDisplayEXT(my_data, dpy, rrOutput, pDisplay);
if (!skip) {
result = my_data->dispatch_table.GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
validate_result(my_data->report_data, "vkGetRandROutputDisplayEXT", {}, result);
skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkDebugMarkerSetObjectTagEXT",
VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
- skip |= parameter_validation_vkDebugMarkerSetObjectTagEXT(my_data->report_data, pTagInfo);
+ skip |= parameter_validation_vkDebugMarkerSetObjectTagEXT(my_data, pTagInfo);
if (!skip) {
if (my_data->dispatch_table.DebugMarkerSetObjectTagEXT) {
skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkDebugMarkerSetObjectNameEXT",
VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
- skip |= parameter_validation_vkDebugMarkerSetObjectNameEXT(my_data->report_data, pNameInfo);
+ skip |= parameter_validation_vkDebugMarkerSetObjectNameEXT(my_data, pNameInfo);
if (!skip) {
if (my_data->dispatch_table.DebugMarkerSetObjectNameEXT) {
skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkCmdDebugMarkerBeginEXT",
VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
- skip |= parameter_validation_vkCmdDebugMarkerBeginEXT(my_data->report_data, pMarkerInfo);
+ skip |= parameter_validation_vkCmdDebugMarkerBeginEXT(my_data, pMarkerInfo);
if (!skip && my_data->dispatch_table.CmdDebugMarkerBeginEXT) {
my_data->dispatch_table.CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkCmdDebugMarkerInsertEXT",
VK_EXT_DEBUG_MARKER_EXTENSION_NAME);
- skip |= parameter_validation_vkCmdDebugMarkerInsertEXT(my_data->report_data, pMarkerInfo);
+ skip |= parameter_validation_vkCmdDebugMarkerInsertEXT(my_data, pMarkerInfo);
if (!skip && my_data->dispatch_table.CmdDebugMarkerInsertEXT) {
my_data->dispatch_table.CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::ext_direct_mode_display,
"vkReleaseDisplayEXT", VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME);
#if 0 // Validation not automatically generated
- skip |= parameter_validation_vkReleaseDisplayEXT(my_data->report_data, display);
+ skip |= parameter_validation_vkReleaseDisplayEXT(my_data, display);
#endif
if (!skip) {
result = my_data->dispatch_table.ReleaseDisplayEXT(physicalDevice, display);
skip |= require_device_extension(my_data, my_data->enables.ext_discard_rectangles, "vkCmdSetDiscardRectangleEXT",
VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME);
- skip |= parameter_validation_vkCmdSetDiscardRectangleEXT(my_data->report_data, firstDiscardRectangle,
+ skip |= parameter_validation_vkCmdSetDiscardRectangleEXT(my_data, firstDiscardRectangle,
discardRectangleCount, pDiscardRectangles);
if (!skip && my_data->dispatch_table.CmdSetDiscardRectangleEXT) {
skip |= require_device_extension(my_data, my_data->enables.ext_display_control, "vkDisplayPowerControlEXT",
VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME);
- skip |= parameter_validation_vkDisplayPowerControlEXT(my_data->report_data, display, pDisplayPowerInfo);
+ skip |= parameter_validation_vkDisplayPowerControlEXT(my_data, display, pDisplayPowerInfo);
if (!skip) {
if (my_data->dispatch_table.DisplayPowerControlEXT) {
skip |= require_device_extension(my_data, my_data->enables.ext_display_control, "vkRegisterDeviceEventEXT",
VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME);
- skip |= parameter_validation_vkRegisterDeviceEventEXT(my_data->report_data, pDeviceEventInfo, pAllocator, pFence);
+ skip |= parameter_validation_vkRegisterDeviceEventEXT(my_data, pDeviceEventInfo, pAllocator, pFence);
if (!skip) {
if (my_data->dispatch_table.RegisterDeviceEventEXT) {
skip |= require_device_extension(my_data, my_data->enables.ext_display_control, "vkRegisterDisplayEventEXT",
VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME);
- skip |= parameter_validation_vkRegisterDisplayEventEXT(my_data->report_data, display, pDisplayEventInfo, pAllocator, pFence);
+ skip |= parameter_validation_vkRegisterDisplayEventEXT(my_data, display, pDisplayEventInfo, pAllocator, pFence);
if (!skip) {
if (my_data->dispatch_table.RegisterDisplayEventEXT) {
skip |= require_device_extension(my_data, my_data->enables.ext_display_control, "vkGetSwapchainCounterEXT",
VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME);
- skip |= parameter_validation_vkGetSwapchainCounterEXT(my_data->report_data, swapchain, counter, pCounterValue);
+ skip |= parameter_validation_vkGetSwapchainCounterEXT(my_data, swapchain, counter, pCounterValue);
if (!skip) {
if (my_data->dispatch_table.GetSwapchainCounterEXT) {
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.amd_draw_indirect_count, "vkCmdDrawIndirectCountAMD",
VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME);
- skip |= parameter_validation_vkCmdDrawIndirectCountAMD(my_data->report_data, buffer, offset, countBuffer, countBufferOffset,
+ skip |= parameter_validation_vkCmdDrawIndirectCountAMD(my_data, buffer, offset, countBuffer, countBufferOffset,
maxDrawCount, stride);
if (!skip) {
my_data->dispatch_table.CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount,
assert(my_data != NULL);
skip |= require_device_extension(my_data, my_data->enables.amd_draw_indirect_count, "vkCmdDrawIndexedIndirectCountAMD",
VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME);
- skip |= parameter_validation_vkCmdDrawIndexedIndirectCountAMD(my_data->report_data, buffer, offset, countBuffer,
+ skip |= parameter_validation_vkCmdDrawIndexedIndirectCountAMD(my_data, buffer, offset, countBuffer,
countBufferOffset, maxDrawCount, stride);
if (!skip) {
my_data->dispatch_table.CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset,
bool skip = false;
skip |= require_instance_extension(physicalDevice, &InstanceExtensions::ext_display_surface_counter,
"vkGetPhysicalDeviceSurfaceCapabilities2EXT", VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
- skip |= parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2EXT(my_data->report_data, surface, pSurfaceCapabilities);
+ skip |= parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2EXT(my_data, surface, pSurfaceCapabilities);
if (!skip) {
result = my_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
validate_result(my_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilities2EXT", {}, result);
skip |= require_device_extension(my_data, my_data->enables.amd_draw_indirect_count, "vkCmdSetViewportWScalingNV",
VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME);
#if 0 // Validation not automatically generated
- skip |= parameter_validation_vkCmdSetViewportWScalingNV(my_data->report_data, firstViewport, viewportCount, pViewportWScalings);
+ skip |= parameter_validation_vkCmdSetViewportWScalingNV(my_data, firstViewport, viewportCount, pViewportWScalings);
#endif
if (!skip) {
my_data->dispatch_table.CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
skip |= parameter_validation_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
- my_data->report_data, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
+ my_data, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
if (!skip) {
result = my_data->dispatch_table.GetPhysicalDeviceExternalImageFormatPropertiesNV(
skip |= require_device_extension(my_data, my_data->enables.nv_external_memory_win32, "vkGetMemoryWin32HandleNV",
VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
- skip |= parameter_validation_vkGetMemoryWin32HandleNV(my_data->report_data, memory, handleType, pHandle);
+ skip |= parameter_validation_vkGetMemoryWin32HandleNV(my_data, memory, handleType, pHandle);
if (!skip) {
result = my_data->dispatch_table.GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
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);
- skip |= parameter_validation_vkCmdProcessCommandsNVX(my_data->report_data, pProcessCommandsInfo);
+ skip |= parameter_validation_vkCmdProcessCommandsNVX(my_data, pProcessCommandsInfo);
if (!skip) {
my_data->dispatch_table.CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
}
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);
- skip |= parameter_validation_vkCmdReserveSpaceForCommandsNVX(my_data->report_data, pReserveSpaceInfo);
+ skip |= parameter_validation_vkCmdReserveSpaceForCommandsNVX(my_data, pReserveSpaceInfo);
if (!skip) {
my_data->dispatch_table.CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
}
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);
- skip |= parameter_validation_vkCreateIndirectCommandsLayoutNVX(my_data->report_data, pCreateInfo, pAllocator,
+ skip |= parameter_validation_vkCreateIndirectCommandsLayoutNVX(my_data, pCreateInfo, pAllocator,
pIndirectCommandsLayout);
if (!skip) {
result = my_data->dispatch_table.CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkDestroyIndirectCommandsLayoutNVX",
VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
#if 0 // Validation not automatically generated
- skip |= parameter_validation_vkDestroyIndirectCommandsLayoutNVX(my_data->report_data, indirectCommandsLayout, pAllocator);
+ skip |= parameter_validation_vkDestroyIndirectCommandsLayoutNVX(my_data, indirectCommandsLayout, pAllocator);
#endif
if (!skip) {
my_data->dispatch_table.DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
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);
- skip |= parameter_validation_vkCreateObjectTableNVX(my_data->report_data, pCreateInfo, pAllocator, pObjectTable);
+ skip |= parameter_validation_vkCreateObjectTableNVX(my_data, pCreateInfo, pAllocator, pObjectTable);
if (!skip) {
result = my_data->dispatch_table.CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
validate_result(my_data->report_data, "vkCreateObjectTableNVX", {}, result);
skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkDestroyObjectTableNVX",
VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME);
#if 0 // Validation not automatically generated
- skip |= parameter_validation_vkDestroyObjectTableNVX(my_data->report_data, objectTable, pAllocator);
+ skip |= parameter_validation_vkDestroyObjectTableNVX(my_data, objectTable, pAllocator);
#endif
if (!skip) {
my_data->dispatch_table.DestroyObjectTableNVX(device, objectTable, pAllocator);
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);
- skip |= parameter_validation_vkRegisterObjectsNVX(my_data->report_data, objectTable, objectCount, ppObjectTableEntries,
+ skip |= parameter_validation_vkRegisterObjectsNVX(my_data, objectTable, objectCount, ppObjectTableEntries,
pObjectIndices);
if (!skip) {
result = my_data->dispatch_table.RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
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);
- skip |= parameter_validation_vkUnregisterObjectsNVX(my_data->report_data, objectTable, objectCount, pObjectEntryTypes,
+ skip |= parameter_validation_vkUnregisterObjectsNVX(my_data, objectTable, objectCount, pObjectEntryTypes,
pObjectIndices);
if (!skip) {
result = my_data->dispatch_table.UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
bool skip = false;
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);
+ skip |= parameter_validation_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(my_data, pFeatures, pLimits);
if (!skip) {
my_data->dispatch_table.GetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits);
}
bool skip = false;
auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
- skip |= parameter_validation_vkGetPastPresentationTimingGOOGLE(my_data->report_data, swapchain, pPresentationTimingCount,
+ skip |= parameter_validation_vkGetPastPresentationTimingGOOGLE(my_data, swapchain, pPresentationTimingCount,
pPresentationTimings);
if (!skip) {
result = my_data->dispatch_table.GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount,
bool skip = false;
auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
- skip |= parameter_validation_vkGetRefreshCycleDurationGOOGLE(my_data->report_data, swapchain, pDisplayTimingProperties);
+ skip |= parameter_validation_vkGetRefreshCycleDurationGOOGLE(my_data, swapchain, pDisplayTimingProperties);
if (!skip) {
result = my_data->dispatch_table.GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
}
bool skip = false;
auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
assert(my_data != NULL);
- skip |= parameter_validation_vkSetHdrMetadataEXT(my_data->report_data, swapchainCount, pSwapchains, pMetadata);
+ skip |= parameter_validation_vkSetHdrMetadataEXT(my_data, swapchainCount, pSwapchains, pMetadata);
if (!skip) {
my_data->dispatch_table.SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
}
projects / platform / upstream / Vulkan-Tools.git / commitdiff