Google Git
Sign in
android / toolchain / prebuilts / ndk / r13 / refs/heads/main / . / sources / third_party / vulkan / src / build-android / generated / include / parameter_validation.h
blob: 4af83da62cd996ef6ce72e662258d879e9475817 [file] [log] [blame]
/*
** Copyright (c) 2015-2016 The Khronos Group Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
/*
** This header is generated from the Khronos Vulkan XML API Registry.
**
*/
#ifndef PARAMETER_VALIDATION_H
#define PARAMETER_VALIDATION_H 1
#include <string>
#include "vulkan/vulkan.h"
#include "vk_layer_extension_utils.h"
#include "parameter_validation_utils.h"
#ifndef UNUSED_PARAMETER
#define UNUSED_PARAMETER(x) (void)(x)
#endif // UNUSED_PARAMETER
namespace parameter_validation {
const uint32_t GeneratedHeaderVersion = 26;
const VkAccessFlags AllVkAccessFlagBits = VK_ACCESS_INDIRECT_COMMAND_READ_BIT|VK_ACCESS_INDEX_READ_BIT|VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT|VK_ACCESS_UNIFORM_READ_BIT|VK_ACCESS_INPUT_ATTACHMENT_READ_BIT|VK_ACCESS_SHADER_READ_BIT|VK_ACCESS_SHADER_WRITE_BIT|VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT|VK_ACCESS_TRANSFER_READ_BIT|VK_ACCESS_TRANSFER_WRITE_BIT|VK_ACCESS_HOST_READ_BIT|VK_ACCESS_HOST_WRITE_BIT|VK_ACCESS_MEMORY_READ_BIT|VK_ACCESS_MEMORY_WRITE_BIT;
const VkAttachmentDescriptionFlags AllVkAttachmentDescriptionFlagBits = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT;
const VkBufferCreateFlags AllVkBufferCreateFlagBits = VK_BUFFER_CREATE_SPARSE_BINDING_BIT|VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT|VK_BUFFER_CREATE_SPARSE_ALIASED_BIT;
const VkBufferUsageFlags AllVkBufferUsageFlagBits = VK_BUFFER_USAGE_TRANSFER_SRC_BIT|VK_BUFFER_USAGE_TRANSFER_DST_BIT|VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT|VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT|VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT|VK_BUFFER_USAGE_STORAGE_BUFFER_BIT|VK_BUFFER_USAGE_INDEX_BUFFER_BIT|VK_BUFFER_USAGE_VERTEX_BUFFER_BIT|VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
const VkColorComponentFlags AllVkColorComponentFlagBits = VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT;
const VkCommandBufferResetFlags AllVkCommandBufferResetFlagBits = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT;
const VkCommandBufferUsageFlags AllVkCommandBufferUsageFlagBits = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT|VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT|VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
const VkCommandPoolCreateFlags AllVkCommandPoolCreateFlagBits = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT|VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
const VkCommandPoolResetFlags AllVkCommandPoolResetFlagBits = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT;
const VkCullModeFlags AllVkCullModeFlagBits = VK_CULL_MODE_NONE|VK_CULL_MODE_FRONT_BIT|VK_CULL_MODE_BACK_BIT|VK_CULL_MODE_FRONT_AND_BACK;
const VkDependencyFlags AllVkDependencyFlagBits = VK_DEPENDENCY_BY_REGION_BIT;
const VkDescriptorPoolCreateFlags AllVkDescriptorPoolCreateFlagBits = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
const VkFenceCreateFlags AllVkFenceCreateFlagBits = VK_FENCE_CREATE_SIGNALED_BIT;
const VkFormatFeatureFlags AllVkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT|VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT|VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT|VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT|VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT|VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT|VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT|VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT|VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT|VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_FORMAT_FEATURE_BLIT_SRC_BIT|VK_FORMAT_FEATURE_BLIT_DST_BIT|VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT|VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG;
const VkImageAspectFlags AllVkImageAspectFlagBits = VK_IMAGE_ASPECT_COLOR_BIT|VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT|VK_IMAGE_ASPECT_METADATA_BIT;
const VkImageCreateFlags AllVkImageCreateFlagBits = VK_IMAGE_CREATE_SPARSE_BINDING_BIT|VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT|VK_IMAGE_CREATE_SPARSE_ALIASED_BIT|VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT|VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
const VkImageUsageFlags AllVkImageUsageFlagBits = VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_STORAGE_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT|VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
const VkMemoryHeapFlags AllVkMemoryHeapFlagBits = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT;
const VkMemoryPropertyFlags AllVkMemoryPropertyFlagBits = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT|VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
const VkPipelineCreateFlags AllVkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT|VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT|VK_PIPELINE_CREATE_DERIVATIVE_BIT;
const VkPipelineStageFlags AllVkPipelineStageFlagBits = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT|VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT|VK_PIPELINE_STAGE_VERTEX_INPUT_BIT|VK_PIPELINE_STAGE_VERTEX_SHADER_BIT|VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT|VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT|VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT|VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT|VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT|VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT|VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT|VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT|VK_PIPELINE_STAGE_TRANSFER_BIT|VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT|VK_PIPELINE_STAGE_HOST_BIT|VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT|VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
const VkQueryControlFlags AllVkQueryControlFlagBits = VK_QUERY_CONTROL_PRECISE_BIT;
const VkQueryPipelineStatisticFlags AllVkQueryPipelineStatisticFlagBits = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT|VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT|VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT;
const VkQueryResultFlags AllVkQueryResultFlagBits = VK_QUERY_RESULT_64_BIT|VK_QUERY_RESULT_WAIT_BIT|VK_QUERY_RESULT_WITH_AVAILABILITY_BIT|VK_QUERY_RESULT_PARTIAL_BIT;
const VkQueueFlags AllVkQueueFlagBits = VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT|VK_QUEUE_TRANSFER_BIT|VK_QUEUE_SPARSE_BINDING_BIT;
const VkSampleCountFlags AllVkSampleCountFlagBits = VK_SAMPLE_COUNT_1_BIT|VK_SAMPLE_COUNT_2_BIT|VK_SAMPLE_COUNT_4_BIT|VK_SAMPLE_COUNT_8_BIT|VK_SAMPLE_COUNT_16_BIT|VK_SAMPLE_COUNT_32_BIT|VK_SAMPLE_COUNT_64_BIT;
const VkShaderStageFlags AllVkShaderStageFlagBits = VK_SHADER_STAGE_VERTEX_BIT|VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT|VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT|VK_SHADER_STAGE_GEOMETRY_BIT|VK_SHADER_STAGE_FRAGMENT_BIT|VK_SHADER_STAGE_COMPUTE_BIT|VK_SHADER_STAGE_ALL_GRAPHICS|VK_SHADER_STAGE_ALL;
const VkSparseImageFormatFlags AllVkSparseImageFormatFlagBits = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT|VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT|VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT;
const VkSparseMemoryBindFlags AllVkSparseMemoryBindFlagBits = VK_SPARSE_MEMORY_BIND_METADATA_BIT;
const VkStencilFaceFlags AllVkStencilFaceFlagBits = VK_STENCIL_FACE_FRONT_BIT|VK_STENCIL_FACE_BACK_BIT|VK_STENCIL_FRONT_AND_BACK;
static bool parameter_validation_vkCreateInstance(
debug_report_data* report_data,
const VkInstanceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateInstance", "pCreateInfo", "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_reserved_flags(report_data, "vkCreateInstance", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_struct_type(report_data, "vkCreateInstance", "pCreateInfo->pApplicationInfo", "VK_STRUCTURE_TYPE_APPLICATION_INFO", pCreateInfo->pApplicationInfo, VK_STRUCTURE_TYPE_APPLICATION_INFO, false);
if (pCreateInfo->pApplicationInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateInstance", "pCreateInfo->pApplicationInfo->pNext", NULL, pCreateInfo->pApplicationInfo->pNext, 0, NULL, GeneratedHeaderVersion);
}
skipCall |= validate_string_array(report_data, "vkCreateInstance", "pCreateInfo->enabledLayerCount", "pCreateInfo->ppEnabledLayerNames", pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames, false, true);
skipCall |= validate_string_array(report_data, "vkCreateInstance", "pCreateInfo->enabledExtensionCount", "pCreateInfo->ppEnabledExtensionNames", pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames, false, true);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateInstance", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateInstance", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateInstance", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateInstance", "pInstance", pInstance);
return skipCall;
}
static bool parameter_validation_vkDestroyInstance(
debug_report_data* report_data,
const VkAllocationCallbacks* pAllocator)
{
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyInstance", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyInstance", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyInstance", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkEnumeratePhysicalDevices(
debug_report_data* report_data,
uint32_t* pPhysicalDeviceCount,
VkPhysicalDevice* pPhysicalDevices)
{
bool skipCall = false;
skipCall |= validate_array(report_data, "vkEnumeratePhysicalDevices", "pPhysicalDeviceCount", "pPhysicalDevices", pPhysicalDeviceCount, pPhysicalDevices, true, false, false);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceFeatures(
debug_report_data* report_data,
VkPhysicalDeviceFeatures* pFeatures)
{
bool skipCall = false;
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceFeatures", "pFeatures", pFeatures);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceFormatProperties(
debug_report_data* report_data,
VkFormat format,
VkFormatProperties* pFormatProperties)
{
bool skipCall = false;
skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceFormatProperties", "format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, format);
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceFormatProperties", "pFormatProperties", pFormatProperties);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceImageFormatProperties(
debug_report_data* report_data,
VkFormat format,
VkImageType type,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
VkImageFormatProperties* pImageFormatProperties)
{
bool skipCall = false;
skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceImageFormatProperties", "format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, format);
skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceImageFormatProperties", "type", "VkImageType", VK_IMAGE_TYPE_BEGIN_RANGE, VK_IMAGE_TYPE_END_RANGE, type);
skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceImageFormatProperties", "tiling", "VkImageTiling", VK_IMAGE_TILING_BEGIN_RANGE, VK_IMAGE_TILING_END_RANGE, tiling);
skipCall |= validate_flags(report_data, "vkGetPhysicalDeviceImageFormatProperties", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, true);
skipCall |= validate_flags(report_data, "vkGetPhysicalDeviceImageFormatProperties", "flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, flags, false);
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceImageFormatProperties", "pImageFormatProperties", pImageFormatProperties);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceProperties(
debug_report_data* report_data,
VkPhysicalDeviceProperties* pProperties)
{
bool skipCall = false;
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceProperties", "pProperties", pProperties);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties(
debug_report_data* report_data,
uint32_t* pQueueFamilyPropertyCount,
VkQueueFamilyProperties* pQueueFamilyProperties)
{
bool skipCall = false;
skipCall |= validate_array(report_data, "vkGetPhysicalDeviceQueueFamilyProperties", "pQueueFamilyPropertyCount", "pQueueFamilyProperties", pQueueFamilyPropertyCount, pQueueFamilyProperties, true, false, false);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceMemoryProperties(
debug_report_data* report_data,
VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
bool skipCall = false;
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceMemoryProperties", "pMemoryProperties", pMemoryProperties);
return skipCall;
}
static bool parameter_validation_vkCreateDevice(
debug_report_data* report_data,
const VkDeviceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDevice* pDevice)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateDevice", "pCreateInfo", "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_reserved_flags(report_data, "vkCreateDevice", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_struct_type_array(report_data, "vkCreateDevice", "pCreateInfo->queueCreateInfoCount", "pCreateInfo->pQueueCreateInfos", "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO", pCreateInfo->queueCreateInfoCount, pCreateInfo->pQueueCreateInfos, VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, true, true);
if (pCreateInfo->pQueueCreateInfos != NULL)
{
for (uint32_t queueCreateInfoIndex = 0; queueCreateInfoIndex < pCreateInfo->queueCreateInfoCount; ++queueCreateInfoIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].pNext", ParameterName::IndexVector{ queueCreateInfoIndex }), NULL, pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].flags", ParameterName::IndexVector{ queueCreateInfoIndex }), pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].flags);
skipCall |= validate_array(report_data, "vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].queueCount", ParameterName::IndexVector{ queueCreateInfoIndex }), ParameterName("pCreateInfo->pQueueCreateInfos[%i].pQueuePriorities", ParameterName::IndexVector{ queueCreateInfoIndex }), pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].queueCount, pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].pQueuePriorities, true, true);
}
}
skipCall |= validate_string_array(report_data, "vkCreateDevice", "pCreateInfo->enabledLayerCount", "pCreateInfo->ppEnabledLayerNames", pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames, false, true);
skipCall |= validate_string_array(report_data, "vkCreateDevice", "pCreateInfo->enabledExtensionCount", "pCreateInfo->ppEnabledExtensionNames", pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames, false, true);
if (pCreateInfo->pEnabledFeatures != NULL)
{
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->robustBufferAccess", pCreateInfo->pEnabledFeatures->robustBufferAccess);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->fullDrawIndexUint32", pCreateInfo->pEnabledFeatures->fullDrawIndexUint32);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->imageCubeArray", pCreateInfo->pEnabledFeatures->imageCubeArray);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->independentBlend", pCreateInfo->pEnabledFeatures->independentBlend);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->geometryShader", pCreateInfo->pEnabledFeatures->geometryShader);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->tessellationShader", pCreateInfo->pEnabledFeatures->tessellationShader);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sampleRateShading", pCreateInfo->pEnabledFeatures->sampleRateShading);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->dualSrcBlend", pCreateInfo->pEnabledFeatures->dualSrcBlend);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->logicOp", pCreateInfo->pEnabledFeatures->logicOp);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->multiDrawIndirect", pCreateInfo->pEnabledFeatures->multiDrawIndirect);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->drawIndirectFirstInstance", pCreateInfo->pEnabledFeatures->drawIndirectFirstInstance);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->depthClamp", pCreateInfo->pEnabledFeatures->depthClamp);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->depthBiasClamp", pCreateInfo->pEnabledFeatures->depthBiasClamp);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->fillModeNonSolid", pCreateInfo->pEnabledFeatures->fillModeNonSolid);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->depthBounds", pCreateInfo->pEnabledFeatures->depthBounds);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->wideLines", pCreateInfo->pEnabledFeatures->wideLines);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->largePoints", pCreateInfo->pEnabledFeatures->largePoints);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->alphaToOne", pCreateInfo->pEnabledFeatures->alphaToOne);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->multiViewport", pCreateInfo->pEnabledFeatures->multiViewport);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->samplerAnisotropy", pCreateInfo->pEnabledFeatures->samplerAnisotropy);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->textureCompressionETC2", pCreateInfo->pEnabledFeatures->textureCompressionETC2);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->textureCompressionASTC_LDR", pCreateInfo->pEnabledFeatures->textureCompressionASTC_LDR);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->textureCompressionBC", pCreateInfo->pEnabledFeatures->textureCompressionBC);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->occlusionQueryPrecise", pCreateInfo->pEnabledFeatures->occlusionQueryPrecise);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->pipelineStatisticsQuery", pCreateInfo->pEnabledFeatures->pipelineStatisticsQuery);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->vertexPipelineStoresAndAtomics", pCreateInfo->pEnabledFeatures->vertexPipelineStoresAndAtomics);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->fragmentStoresAndAtomics", pCreateInfo->pEnabledFeatures->fragmentStoresAndAtomics);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderTessellationAndGeometryPointSize", pCreateInfo->pEnabledFeatures->shaderTessellationAndGeometryPointSize);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderImageGatherExtended", pCreateInfo->pEnabledFeatures->shaderImageGatherExtended);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageExtendedFormats", pCreateInfo->pEnabledFeatures->shaderStorageImageExtendedFormats);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageMultisample", pCreateInfo->pEnabledFeatures->shaderStorageImageMultisample);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageReadWithoutFormat", pCreateInfo->pEnabledFeatures->shaderStorageImageReadWithoutFormat);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageWriteWithoutFormat", pCreateInfo->pEnabledFeatures->shaderStorageImageWriteWithoutFormat);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderUniformBufferArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderUniformBufferArrayDynamicIndexing);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderSampledImageArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderSampledImageArrayDynamicIndexing);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageBufferArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderStorageBufferArrayDynamicIndexing);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderStorageImageArrayDynamicIndexing);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderClipDistance", pCreateInfo->pEnabledFeatures->shaderClipDistance);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderCullDistance", pCreateInfo->pEnabledFeatures->shaderCullDistance);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderFloat64", pCreateInfo->pEnabledFeatures->shaderFloat64);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderInt64", pCreateInfo->pEnabledFeatures->shaderInt64);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderInt16", pCreateInfo->pEnabledFeatures->shaderInt16);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderResourceResidency", pCreateInfo->pEnabledFeatures->shaderResourceResidency);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderResourceMinLod", pCreateInfo->pEnabledFeatures->shaderResourceMinLod);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseBinding", pCreateInfo->pEnabledFeatures->sparseBinding);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyBuffer", pCreateInfo->pEnabledFeatures->sparseResidencyBuffer);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyImage2D", pCreateInfo->pEnabledFeatures->sparseResidencyImage2D);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyImage3D", pCreateInfo->pEnabledFeatures->sparseResidencyImage3D);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency2Samples", pCreateInfo->pEnabledFeatures->sparseResidency2Samples);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency4Samples", pCreateInfo->pEnabledFeatures->sparseResidency4Samples);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency8Samples", pCreateInfo->pEnabledFeatures->sparseResidency8Samples);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency16Samples", pCreateInfo->pEnabledFeatures->sparseResidency16Samples);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyAliased", pCreateInfo->pEnabledFeatures->sparseResidencyAliased);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->variableMultisampleRate", pCreateInfo->pEnabledFeatures->variableMultisampleRate);
skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->inheritedQueries", pCreateInfo->pEnabledFeatures->inheritedQueries);
}
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateDevice", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateDevice", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateDevice", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateDevice", "pDevice", pDevice);
return skipCall;
}
static bool parameter_validation_vkDestroyDevice(
debug_report_data* report_data,
const VkAllocationCallbacks* pAllocator)
{
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyDevice", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyDevice", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyDevice", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkEnumerateInstanceExtensionProperties(
debug_report_data* report_data,
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties)
{
bool skipCall = false;
skipCall |= validate_array(report_data, "vkEnumerateInstanceExtensionProperties", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false);
return skipCall;
}
static bool parameter_validation_vkEnumerateDeviceExtensionProperties(
debug_report_data* report_data,
const char* pLayerName,
uint32_t* pPropertyCount,
VkExtensionProperties* pProperties)
{
UNUSED_PARAMETER(pLayerName);
bool skipCall = false;
skipCall |= validate_array(report_data, "vkEnumerateDeviceExtensionProperties", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false);
return skipCall;
}
static bool parameter_validation_vkGetDeviceQueue(
debug_report_data* report_data,
uint32_t queueFamilyIndex,
uint32_t queueIndex,
VkQueue* pQueue)
{
UNUSED_PARAMETER(queueFamilyIndex);
UNUSED_PARAMETER(queueIndex);
bool skipCall = false;
skipCall |= validate_required_pointer(report_data, "vkGetDeviceQueue", "pQueue", pQueue);
return skipCall;
}
static bool parameter_validation_vkQueueSubmit(
debug_report_data* report_data,
uint32_t submitCount,
const VkSubmitInfo* pSubmits,
VkFence fence)
{
UNUSED_PARAMETER(fence);
bool skipCall = false;
skipCall |= validate_struct_type_array(report_data, "vkQueueSubmit", "submitCount", "pSubmits", "VK_STRUCTURE_TYPE_SUBMIT_INFO", submitCount, pSubmits, VK_STRUCTURE_TYPE_SUBMIT_INFO, false, true);
if (pSubmits != NULL)
{
for (uint32_t submitIndex = 0; submitIndex < submitCount; ++submitIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkQueueSubmit", ParameterName("pSubmits[%i].pNext", ParameterName::IndexVector{ submitIndex }), NULL, pSubmits[submitIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_array(report_data, "vkQueueSubmit", ParameterName("pSubmits[%i].waitSemaphoreCount", ParameterName::IndexVector{ submitIndex }), ParameterName("pSubmits[%i].pWaitSemaphores", ParameterName::IndexVector{ submitIndex }), pSubmits[submitIndex].waitSemaphoreCount, pSubmits[submitIndex].pWaitSemaphores, false, true);
skipCall |= validate_flags_array(report_data, "vkQueueSubmit", ParameterName("pSubmits[%i].waitSemaphoreCount", ParameterName::IndexVector{ submitIndex }), ParameterName("pSubmits[%i].pWaitDstStageMask", ParameterName::IndexVector{ submitIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pSubmits[submitIndex].waitSemaphoreCount, pSubmits[submitIndex].pWaitDstStageMask, false, true);
skipCall |= validate_array(report_data, "vkQueueSubmit", ParameterName("pSubmits[%i].commandBufferCount", ParameterName::IndexVector{ submitIndex }), ParameterName("pSubmits[%i].pCommandBuffers", ParameterName::IndexVector{ submitIndex }), pSubmits[submitIndex].commandBufferCount, pSubmits[submitIndex].pCommandBuffers, false, true);
skipCall |= validate_array(report_data, "vkQueueSubmit", ParameterName("pSubmits[%i].signalSemaphoreCount", ParameterName::IndexVector{ submitIndex }), ParameterName("pSubmits[%i].pSignalSemaphores", ParameterName::IndexVector{ submitIndex }), pSubmits[submitIndex].signalSemaphoreCount, pSubmits[submitIndex].pSignalSemaphores, false, true);
}
}
return skipCall;
}
static bool parameter_validation_vkAllocateMemory(
debug_report_data* report_data,
const VkMemoryAllocateInfo* pAllocateInfo,
const VkAllocationCallbacks* pAllocator,
VkDeviceMemory* pMemory)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkAllocateMemory", "pAllocateInfo", "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, true);
if (pAllocateInfo != NULL)
{
const VkStructureType allowedStructs[] = {VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV};
skipCall |= validate_struct_pnext(report_data, "vkAllocateMemory", "pAllocateInfo->pNext", "VkDedicatedAllocationMemoryAllocateInfoNV", pAllocateInfo->pNext, ARRAY_SIZE(allowedStructs), allowedStructs, GeneratedHeaderVersion);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkAllocateMemory", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkAllocateMemory", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkAllocateMemory", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkAllocateMemory", "pMemory", pMemory);
return skipCall;
}
static bool parameter_validation_vkFreeMemory(
debug_report_data* report_data,
VkDeviceMemory memory,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(memory);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkFreeMemory", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkFreeMemory", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkFreeMemory", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkMapMemory(
debug_report_data* report_data,
VkDeviceMemory memory,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags,
void** ppData)
{
UNUSED_PARAMETER(offset);
UNUSED_PARAMETER(size);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkMapMemory", "memory", memory);
skipCall |= validate_reserved_flags(report_data, "vkMapMemory", "flags", flags);
skipCall |= validate_required_pointer(report_data, "vkMapMemory", "ppData", ppData);
return skipCall;
}
static bool parameter_validation_vkUnmapMemory(
debug_report_data* report_data,
VkDeviceMemory memory)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkUnmapMemory", "memory", memory);
return skipCall;
}
static bool parameter_validation_vkFlushMappedMemoryRanges(
debug_report_data* report_data,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges)
{
bool skipCall = false;
skipCall |= validate_struct_type_array(report_data, "vkFlushMappedMemoryRanges", "memoryRangeCount", "pMemoryRanges", "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE", memoryRangeCount, pMemoryRanges, VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, true, true);
if (pMemoryRanges != NULL)
{
for (uint32_t memoryRangeIndex = 0; memoryRangeIndex < memoryRangeCount; ++memoryRangeIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkFlushMappedMemoryRanges", ParameterName("pMemoryRanges[%i].pNext", ParameterName::IndexVector{ memoryRangeIndex }), NULL, pMemoryRanges[memoryRangeIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_required_handle(report_data, "vkFlushMappedMemoryRanges", ParameterName("pMemoryRanges[%i].memory", ParameterName::IndexVector{ memoryRangeIndex }), pMemoryRanges[memoryRangeIndex].memory);
}
}
return skipCall;
}
static bool parameter_validation_vkInvalidateMappedMemoryRanges(
debug_report_data* report_data,
uint32_t memoryRangeCount,
const VkMappedMemoryRange* pMemoryRanges)
{
bool skipCall = false;
skipCall |= validate_struct_type_array(report_data, "vkInvalidateMappedMemoryRanges", "memoryRangeCount", "pMemoryRanges", "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE", memoryRangeCount, pMemoryRanges, VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, true, true);
if (pMemoryRanges != NULL)
{
for (uint32_t memoryRangeIndex = 0; memoryRangeIndex < memoryRangeCount; ++memoryRangeIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkInvalidateMappedMemoryRanges", ParameterName("pMemoryRanges[%i].pNext", ParameterName::IndexVector{ memoryRangeIndex }), NULL, pMemoryRanges[memoryRangeIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_required_handle(report_data, "vkInvalidateMappedMemoryRanges", ParameterName("pMemoryRanges[%i].memory", ParameterName::IndexVector{ memoryRangeIndex }), pMemoryRanges[memoryRangeIndex].memory);
}
}
return skipCall;
}
static bool parameter_validation_vkGetDeviceMemoryCommitment(
debug_report_data* report_data,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetDeviceMemoryCommitment", "memory", memory);
skipCall |= validate_required_pointer(report_data, "vkGetDeviceMemoryCommitment", "pCommittedMemoryInBytes", pCommittedMemoryInBytes);
return skipCall;
}
static bool parameter_validation_vkBindBufferMemory(
debug_report_data* report_data,
VkBuffer buffer,
VkDeviceMemory memory,
VkDeviceSize memoryOffset)
{
UNUSED_PARAMETER(memoryOffset);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkBindBufferMemory", "buffer", buffer);
skipCall |= validate_required_handle(report_data, "vkBindBufferMemory", "memory", memory);
return skipCall;
}
static bool parameter_validation_vkBindImageMemory(
debug_report_data* report_data,
VkImage image,
VkDeviceMemory memory,
VkDeviceSize memoryOffset)
{
UNUSED_PARAMETER(memoryOffset);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkBindImageMemory", "image", image);
skipCall |= validate_required_handle(report_data, "vkBindImageMemory", "memory", memory);
return skipCall;
}
static bool parameter_validation_vkGetBufferMemoryRequirements(
debug_report_data* report_data,
VkBuffer buffer,
VkMemoryRequirements* pMemoryRequirements)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetBufferMemoryRequirements", "buffer", buffer);
skipCall |= validate_required_pointer(report_data, "vkGetBufferMemoryRequirements", "pMemoryRequirements", pMemoryRequirements);
return skipCall;
}
static bool parameter_validation_vkGetImageMemoryRequirements(
debug_report_data* report_data,
VkImage image,
VkMemoryRequirements* pMemoryRequirements)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetImageMemoryRequirements", "image", image);
skipCall |= validate_required_pointer(report_data, "vkGetImageMemoryRequirements", "pMemoryRequirements", pMemoryRequirements);
return skipCall;
}
static bool parameter_validation_vkGetImageSparseMemoryRequirements(
debug_report_data* report_data,
VkImage image,
uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetImageSparseMemoryRequirements", "image", image);
skipCall |= validate_array(report_data, "vkGetImageSparseMemoryRequirements", "pSparseMemoryRequirementCount", "pSparseMemoryRequirements", pSparseMemoryRequirementCount, pSparseMemoryRequirements, true, false, false);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties(
debug_report_data* report_data,
VkFormat format,
VkImageType type,
VkSampleCountFlagBits samples,
VkImageUsageFlags usage,
VkImageTiling tiling,
uint32_t* pPropertyCount,
VkSparseImageFormatProperties* pProperties)
{
UNUSED_PARAMETER(samples);
bool skipCall = false;
skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, format);
skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "type", "VkImageType", VK_IMAGE_TYPE_BEGIN_RANGE, VK_IMAGE_TYPE_END_RANGE, type);
skipCall |= validate_flags(report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, true);
skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "tiling", "VkImageTiling", VK_IMAGE_TILING_BEGIN_RANGE, VK_IMAGE_TILING_END_RANGE, tiling);
skipCall |= validate_array(report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false);
return skipCall;
}
static bool parameter_validation_vkQueueBindSparse(
debug_report_data* report_data,
uint32_t bindInfoCount,
const VkBindSparseInfo* pBindInfo,
VkFence fence)
{
UNUSED_PARAMETER(fence);
bool skipCall = false;
skipCall |= validate_struct_type_array(report_data, "vkQueueBindSparse", "bindInfoCount", "pBindInfo", "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO", bindInfoCount, pBindInfo, VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, false, true);
if (pBindInfo != NULL)
{
for (uint32_t bindInfoIndex = 0; bindInfoIndex < bindInfoCount; ++bindInfoIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pNext", ParameterName::IndexVector{ bindInfoIndex }), NULL, pBindInfo[bindInfoIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_array(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].waitSemaphoreCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfo[%i].pWaitSemaphores", ParameterName::IndexVector{ bindInfoIndex }), pBindInfo[bindInfoIndex].waitSemaphoreCount, pBindInfo[bindInfoIndex].pWaitSemaphores, false, true);
skipCall |= validate_array(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].bufferBindCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfo[%i].pBufferBinds", ParameterName::IndexVector{ bindInfoIndex }), pBindInfo[bindInfoIndex].bufferBindCount, pBindInfo[bindInfoIndex].pBufferBinds, false, true);
if (pBindInfo[bindInfoIndex].pBufferBinds != NULL)
{
for (uint32_t bufferBindIndex = 0; bufferBindIndex < pBindInfo[bindInfoIndex].bufferBindCount; ++bufferBindIndex)
{
skipCall |= validate_required_handle(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pBufferBinds[%i].buffer", ParameterName::IndexVector{ bindInfoIndex, bufferBindIndex }), pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].buffer);
skipCall |= validate_array(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pBufferBinds[%i].bindCount", ParameterName::IndexVector{ bindInfoIndex, bufferBindIndex }), ParameterName("pBindInfo[%i].pBufferBinds[%i].pBinds", ParameterName::IndexVector{ bindInfoIndex, bufferBindIndex }), pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].bindCount, pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].pBinds, true, true);
if (pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].pBinds != NULL)
{
for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].bindCount; ++bindIndex)
{
skipCall |= validate_flags(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pBufferBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, bufferBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].pBinds[bindIndex].flags, false);
}
}
}
}
skipCall |= validate_array(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].imageOpaqueBindCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfo[%i].pImageOpaqueBinds", ParameterName::IndexVector{ bindInfoIndex }), pBindInfo[bindInfoIndex].imageOpaqueBindCount, pBindInfo[bindInfoIndex].pImageOpaqueBinds, false, true);
if (pBindInfo[bindInfoIndex].pImageOpaqueBinds != NULL)
{
for (uint32_t imageOpaqueBindIndex = 0; imageOpaqueBindIndex < pBindInfo[bindInfoIndex].imageOpaqueBindCount; ++imageOpaqueBindIndex)
{
skipCall |= validate_required_handle(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageOpaqueBinds[%i].image", ParameterName::IndexVector{ bindInfoIndex, imageOpaqueBindIndex }), pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].image);
skipCall |= validate_array(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageOpaqueBinds[%i].bindCount", ParameterName::IndexVector{ bindInfoIndex, imageOpaqueBindIndex }), ParameterName("pBindInfo[%i].pImageOpaqueBinds[%i].pBinds", ParameterName::IndexVector{ bindInfoIndex, imageOpaqueBindIndex }), pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].bindCount, pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].pBinds, true, true);
if (pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].pBinds != NULL)
{
for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].bindCount; ++bindIndex)
{
skipCall |= validate_flags(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageOpaqueBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, imageOpaqueBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].pBinds[bindIndex].flags, false);
}
}
}
}
skipCall |= validate_array(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].imageBindCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfo[%i].pImageBinds", ParameterName::IndexVector{ bindInfoIndex }), pBindInfo[bindInfoIndex].imageBindCount, pBindInfo[bindInfoIndex].pImageBinds, false, true);
if (pBindInfo[bindInfoIndex].pImageBinds != NULL)
{
for (uint32_t imageBindIndex = 0; imageBindIndex < pBindInfo[bindInfoIndex].imageBindCount; ++imageBindIndex)
{
skipCall |= validate_required_handle(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].image", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex }), pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].image);
skipCall |= validate_array(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].bindCount", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex }), ParameterName("pBindInfo[%i].pImageBinds[%i].pBinds", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex }), pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].bindCount, pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds, true, true);
if (pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds != NULL)
{
for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].bindCount; ++bindIndex)
{
skipCall |= validate_flags(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].pBinds[%i].subresource.aspectMask", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex, bindIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds[bindIndex].subresource.aspectMask, true);
skipCall |= validate_flags(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds[bindIndex].flags, false);
}
}
}
}
skipCall |= validate_array(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].signalSemaphoreCount", ParameterName::IndexVector{ bindInfoIndex }), ParameterName("pBindInfo[%i].pSignalSemaphores", ParameterName::IndexVector{ bindInfoIndex }), pBindInfo[bindInfoIndex].signalSemaphoreCount, pBindInfo[bindInfoIndex].pSignalSemaphores, false, true);
}
}
return skipCall;
}
static bool parameter_validation_vkCreateFence(
debug_report_data* report_data,
const VkFenceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkFence* pFence)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateFence", "pCreateInfo", "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateFence", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCreateFence", "pCreateInfo->flags", "VkFenceCreateFlagBits", AllVkFenceCreateFlagBits, pCreateInfo->flags, false);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateFence", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateFence", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateFence", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateFence", "pFence", pFence);
return skipCall;
}
static bool parameter_validation_vkDestroyFence(
debug_report_data* report_data,
VkFence fence,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(fence);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyFence", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyFence", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyFence", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkResetFences(
debug_report_data* report_data,
uint32_t fenceCount,
const VkFence* pFences)
{
bool skipCall = false;
skipCall |= validate_handle_array(report_data, "vkResetFences", "fenceCount", "pFences", fenceCount, pFences, true, true);
return skipCall;
}
static bool parameter_validation_vkGetFenceStatus(
debug_report_data* report_data,
VkFence fence)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetFenceStatus", "fence", fence);
return skipCall;
}
static bool parameter_validation_vkWaitForFences(
debug_report_data* report_data,
uint32_t fenceCount,
const VkFence* pFences,
VkBool32 waitAll,
uint64_t timeout)
{
UNUSED_PARAMETER(timeout);
bool skipCall = false;
skipCall |= validate_handle_array(report_data, "vkWaitForFences", "fenceCount", "pFences", fenceCount, pFences, true, true);
skipCall |= validate_bool32(report_data, "vkWaitForFences", "waitAll", waitAll);
return skipCall;
}
static bool parameter_validation_vkCreateSemaphore(
debug_report_data* report_data,
const VkSemaphoreCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateSemaphore", "pCreateInfo", "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateSemaphore", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateSemaphore", "pCreateInfo->flags", pCreateInfo->flags);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateSemaphore", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateSemaphore", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateSemaphore", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateSemaphore", "pSemaphore", pSemaphore);
return skipCall;
}
static bool parameter_validation_vkDestroySemaphore(
debug_report_data* report_data,
VkSemaphore semaphore,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(semaphore);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroySemaphore", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroySemaphore", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroySemaphore", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkCreateEvent(
debug_report_data* report_data,
const VkEventCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkEvent* pEvent)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateEvent", "pCreateInfo", "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateEvent", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateEvent", "pCreateInfo->flags", pCreateInfo->flags);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateEvent", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateEvent", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateEvent", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateEvent", "pEvent", pEvent);
return skipCall;
}
static bool parameter_validation_vkDestroyEvent(
debug_report_data* report_data,
VkEvent event,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(event);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyEvent", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyEvent", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyEvent", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkGetEventStatus(
debug_report_data* report_data,
VkEvent event)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetEventStatus", "event", event);
return skipCall;
}
static bool parameter_validation_vkSetEvent(
debug_report_data* report_data,
VkEvent event)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkSetEvent", "event", event);
return skipCall;
}
static bool parameter_validation_vkResetEvent(
debug_report_data* report_data,
VkEvent event)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkResetEvent", "event", event);
return skipCall;
}
static bool parameter_validation_vkCreateQueryPool(
debug_report_data* report_data,
const VkQueryPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkQueryPool* pQueryPool)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateQueryPool", "pCreateInfo", "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateQueryPool", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateQueryPool", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_ranged_enum(report_data, "vkCreateQueryPool", "pCreateInfo->queryType", "VkQueryType", VK_QUERY_TYPE_BEGIN_RANGE, VK_QUERY_TYPE_END_RANGE, pCreateInfo->queryType);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateQueryPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateQueryPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateQueryPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateQueryPool", "pQueryPool", pQueryPool);
return skipCall;
}
static bool parameter_validation_vkDestroyQueryPool(
debug_report_data* report_data,
VkQueryPool queryPool,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(queryPool);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyQueryPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyQueryPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyQueryPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkGetQueryPoolResults(
debug_report_data* report_data,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
size_t dataSize,
void* pData,
VkDeviceSize stride,
VkQueryResultFlags flags)
{
UNUSED_PARAMETER(firstQuery);
UNUSED_PARAMETER(queryCount);
UNUSED_PARAMETER(stride);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetQueryPoolResults", "queryPool", queryPool);
skipCall |= validate_array(report_data, "vkGetQueryPoolResults", "dataSize", "pData", dataSize, pData, true, true);
skipCall |= validate_flags(report_data, "vkGetQueryPoolResults", "flags", "VkQueryResultFlagBits", AllVkQueryResultFlagBits, flags, false);
return skipCall;
}
static bool parameter_validation_vkCreateBuffer(
debug_report_data* report_data,
const VkBufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateBuffer", "pCreateInfo", "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
const VkStructureType allowedStructs[] = {VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV};
skipCall |= validate_struct_pnext(report_data, "vkCreateBuffer", "pCreateInfo->pNext", "VkDedicatedAllocationBufferCreateInfoNV", pCreateInfo->pNext, ARRAY_SIZE(allowedStructs), allowedStructs, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCreateBuffer", "pCreateInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pCreateInfo->flags, false);
skipCall |= validate_flags(report_data, "vkCreateBuffer", "pCreateInfo->usage", "VkBufferUsageFlagBits", AllVkBufferUsageFlagBits, pCreateInfo->usage, true);
skipCall |= validate_ranged_enum(report_data, "vkCreateBuffer", "pCreateInfo->sharingMode", "VkSharingMode", VK_SHARING_MODE_BEGIN_RANGE, VK_SHARING_MODE_END_RANGE, pCreateInfo->sharingMode);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateBuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateBuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateBuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateBuffer", "pBuffer", pBuffer);
return skipCall;
}
static bool parameter_validation_vkDestroyBuffer(
debug_report_data* report_data,
VkBuffer buffer,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(buffer);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyBuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyBuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyBuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkCreateBufferView(
debug_report_data* report_data,
const VkBufferViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkBufferView* pView)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateBufferView", "pCreateInfo", "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateBufferView", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateBufferView", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_required_handle(report_data, "vkCreateBufferView", "pCreateInfo->buffer", pCreateInfo->buffer);
skipCall |= validate_ranged_enum(report_data, "vkCreateBufferView", "pCreateInfo->format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, pCreateInfo->format);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateBufferView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateBufferView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateBufferView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateBufferView", "pView", pView);
return skipCall;
}
static bool parameter_validation_vkDestroyBufferView(
debug_report_data* report_data,
VkBufferView bufferView,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(bufferView);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyBufferView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyBufferView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyBufferView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkCreateImage(
debug_report_data* report_data,
const VkImageCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImage* pImage)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateImage", "pCreateInfo", "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
const VkStructureType allowedStructs[] = {VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV};
skipCall |= validate_struct_pnext(report_data, "vkCreateImage", "pCreateInfo->pNext", "VkDedicatedAllocationImageCreateInfoNV", pCreateInfo->pNext, ARRAY_SIZE(allowedStructs), allowedStructs, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCreateImage", "pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pCreateInfo->flags, false);
skipCall |= validate_ranged_enum(report_data, "vkCreateImage", "pCreateInfo->imageType", "VkImageType", VK_IMAGE_TYPE_BEGIN_RANGE, VK_IMAGE_TYPE_END_RANGE, pCreateInfo->imageType);
skipCall |= validate_ranged_enum(report_data, "vkCreateImage", "pCreateInfo->format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, pCreateInfo->format);
skipCall |= validate_ranged_enum(report_data, "vkCreateImage", "pCreateInfo->tiling", "VkImageTiling", VK_IMAGE_TILING_BEGIN_RANGE, VK_IMAGE_TILING_END_RANGE, pCreateInfo->tiling);
skipCall |= validate_flags(report_data, "vkCreateImage", "pCreateInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pCreateInfo->usage, true);
skipCall |= validate_ranged_enum(report_data, "vkCreateImage", "pCreateInfo->sharingMode", "VkSharingMode", VK_SHARING_MODE_BEGIN_RANGE, VK_SHARING_MODE_END_RANGE, pCreateInfo->sharingMode);
skipCall |= validate_ranged_enum(report_data, "vkCreateImage", "pCreateInfo->initialLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pCreateInfo->initialLayout);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateImage", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateImage", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateImage", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateImage", "pImage", pImage);
return skipCall;
}
static bool parameter_validation_vkDestroyImage(
debug_report_data* report_data,
VkImage image,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(image);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyImage", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyImage", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyImage", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkGetImageSubresourceLayout(
debug_report_data* report_data,
VkImage image,
const VkImageSubresource* pSubresource,
VkSubresourceLayout* pLayout)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetImageSubresourceLayout", "image", image);
skipCall |= validate_required_pointer(report_data, "vkGetImageSubresourceLayout", "pSubresource", pSubresource);
if (pSubresource != NULL)
{
skipCall |= validate_flags(report_data, "vkGetImageSubresourceLayout", "pSubresource->aspectMask", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pSubresource->aspectMask, true);
}
skipCall |= validate_required_pointer(report_data, "vkGetImageSubresourceLayout", "pLayout", pLayout);
return skipCall;
}
static bool parameter_validation_vkCreateImageView(
debug_report_data* report_data,
const VkImageViewCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkImageView* pView)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateImageView", "pCreateInfo", "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateImageView", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateImageView", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_required_handle(report_data, "vkCreateImageView", "pCreateInfo->image", pCreateInfo->image);
skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->viewType", "VkImageViewType", VK_IMAGE_VIEW_TYPE_BEGIN_RANGE, VK_IMAGE_VIEW_TYPE_END_RANGE, pCreateInfo->viewType);
skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, pCreateInfo->format);
skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->components.r", "VkComponentSwizzle", VK_COMPONENT_SWIZZLE_BEGIN_RANGE, VK_COMPONENT_SWIZZLE_END_RANGE, pCreateInfo->components.r);
skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->components.g", "VkComponentSwizzle", VK_COMPONENT_SWIZZLE_BEGIN_RANGE, VK_COMPONENT_SWIZZLE_END_RANGE, pCreateInfo->components.g);
skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->components.b", "VkComponentSwizzle", VK_COMPONENT_SWIZZLE_BEGIN_RANGE, VK_COMPONENT_SWIZZLE_END_RANGE, pCreateInfo->components.b);
skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->components.a", "VkComponentSwizzle", VK_COMPONENT_SWIZZLE_BEGIN_RANGE, VK_COMPONENT_SWIZZLE_END_RANGE, pCreateInfo->components.a);
skipCall |= validate_flags(report_data, "vkCreateImageView", "pCreateInfo->subresourceRange.aspectMask", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pCreateInfo->subresourceRange.aspectMask, true);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateImageView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateImageView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateImageView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateImageView", "pView", pView);
return skipCall;
}
static bool parameter_validation_vkDestroyImageView(
debug_report_data* report_data,
VkImageView imageView,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(imageView);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyImageView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyImageView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyImageView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkCreateShaderModule(
debug_report_data* report_data,
const VkShaderModuleCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateShaderModule", "pCreateInfo", "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateShaderModule", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateShaderModule", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_array(report_data, "vkCreateShaderModule", "pCreateInfo->codeSize", "pCreateInfo->pCode", pCreateInfo->codeSize, pCreateInfo->pCode, true, true);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateShaderModule", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateShaderModule", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateShaderModule", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateShaderModule", "pShaderModule", pShaderModule);
return skipCall;
}
static bool parameter_validation_vkDestroyShaderModule(
debug_report_data* report_data,
VkShaderModule shaderModule,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(shaderModule);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyShaderModule", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyShaderModule", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyShaderModule", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkCreatePipelineCache(
debug_report_data* report_data,
const VkPipelineCacheCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreatePipelineCache", "pCreateInfo", "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreatePipelineCache", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreatePipelineCache", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_array(report_data, "vkCreatePipelineCache", "pCreateInfo->initialDataSize", "pCreateInfo->pInitialData", pCreateInfo->initialDataSize, pCreateInfo->pInitialData, false, true);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreatePipelineCache", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreatePipelineCache", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreatePipelineCache", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreatePipelineCache", "pPipelineCache", pPipelineCache);
return skipCall;
}
static bool parameter_validation_vkDestroyPipelineCache(
debug_report_data* report_data,
VkPipelineCache pipelineCache,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(pipelineCache);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineCache", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineCache", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineCache", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkGetPipelineCacheData(
debug_report_data* report_data,
VkPipelineCache pipelineCache,
size_t* pDataSize,
void* pData)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetPipelineCacheData", "pipelineCache", pipelineCache);
skipCall |= validate_array(report_data, "vkGetPipelineCacheData", "pDataSize", "pData", pDataSize, pData, true, false, false);
return skipCall;
}
static bool parameter_validation_vkMergePipelineCaches(
debug_report_data* report_data,
VkPipelineCache dstCache,
uint32_t srcCacheCount,
const VkPipelineCache* pSrcCaches)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkMergePipelineCaches", "dstCache", dstCache);
skipCall |= validate_handle_array(report_data, "vkMergePipelineCaches", "srcCacheCount", "pSrcCaches", srcCacheCount, pSrcCaches, true, true);
return skipCall;
}
static bool parameter_validation_vkCreateGraphicsPipelines(
debug_report_data* report_data,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines)
{
UNUSED_PARAMETER(pipelineCache);
bool skipCall = false;
skipCall |= validate_struct_type_array(report_data, "vkCreateGraphicsPipelines", "createInfoCount", "pCreateInfos", "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO", createInfoCount, pCreateInfos, VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, true, true);
if (pCreateInfos != NULL)
{
for (uint32_t createInfoIndex = 0; createInfoIndex < createInfoCount; ++createInfoIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, false);
skipCall |= validate_struct_type_array(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].stageCount", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].pStages", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", pCreateInfos[createInfoIndex].stageCount, pCreateInfos[createInfoIndex].pStages, VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, true, true);
if (pCreateInfos[createInfoIndex].pStages != NULL)
{
for (uint32_t stageIndex = 0; stageIndex < pCreateInfos[createInfoIndex].stageCount; ++stageIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].pNext", ParameterName::IndexVector{ createInfoIndex, stageIndex }), NULL, pCreateInfos[createInfoIndex].pStages[stageIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].flags", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].flags);
skipCall |= validate_required_handle(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].module", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].module);
skipCall |= validate_required_pointer(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].pName", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].pName);
if (pCreateInfos[createInfoIndex].pStages[stageIndex].pSpecializationInfo != NULL)
{
skipCall |= validate_array(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].pSpecializationInfo->mapEntryCount", ParameterName::IndexVector{ createInfoIndex, stageIndex }), ParameterName("pCreateInfos[%i].pStages[%i].pSpecializationInfo->pMapEntries", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].pSpecializationInfo->mapEntryCount, pCreateInfos[createInfoIndex].pStages[stageIndex].pSpecializationInfo->pMapEntries, false, true);
skipCall |= validate_array(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].pSpecializationInfo->dataSize", ParameterName::IndexVector{ createInfoIndex, stageIndex }), ParameterName("pCreateInfos[%i].pStages[%i].pSpecializationInfo->pData", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].pSpecializationInfo->dataSize, pCreateInfos[createInfoIndex].pStages[stageIndex].pSpecializationInfo->pData, false, true);
}
}
}
skipCall |= validate_struct_type(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO", pCreateInfos[createInfoIndex].pVertexInputState, VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, true);
if (pCreateInfos[createInfoIndex].pVertexInputState != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pVertexInputState->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pVertexInputState->flags);
skipCall |= validate_array(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->vertexBindingDescriptionCount", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].pVertexInputState->pVertexBindingDescriptions", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pVertexInputState->vertexBindingDescriptionCount, pCreateInfos[createInfoIndex].pVertexInputState->pVertexBindingDescriptions, false, true);
if (pCreateInfos[createInfoIndex].pVertexInputState->pVertexBindingDescriptions != NULL)
{
for (uint32_t vertexBindingDescriptionIndex = 0; vertexBindingDescriptionIndex < pCreateInfos[createInfoIndex].pVertexInputState->vertexBindingDescriptionCount; ++vertexBindingDescriptionIndex)
{
skipCall |= validate_ranged_enum(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->pVertexBindingDescriptions[%i].inputRate", ParameterName::IndexVector{ createInfoIndex, vertexBindingDescriptionIndex }), "VkVertexInputRate", VK_VERTEX_INPUT_RATE_BEGIN_RANGE, VK_VERTEX_INPUT_RATE_END_RANGE, pCreateInfos[createInfoIndex].pVertexInputState->pVertexBindingDescriptions[vertexBindingDescriptionIndex].inputRate);
}
}
skipCall |= validate_array(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->vertexAttributeDescriptionCount", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].pVertexInputState->pVertexAttributeDescriptions", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pVertexInputState->vertexAttributeDescriptionCount, pCreateInfos[createInfoIndex].pVertexInputState->pVertexAttributeDescriptions, false, true);
if (pCreateInfos[createInfoIndex].pVertexInputState->pVertexAttributeDescriptions != NULL)
{
for (uint32_t vertexAttributeDescriptionIndex = 0; vertexAttributeDescriptionIndex < pCreateInfos[createInfoIndex].pVertexInputState->vertexAttributeDescriptionCount; ++vertexAttributeDescriptionIndex)
{
skipCall |= validate_ranged_enum(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->pVertexAttributeDescriptions[%i].format", ParameterName::IndexVector{ createInfoIndex, vertexAttributeDescriptionIndex }), "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, pCreateInfos[createInfoIndex].pVertexInputState->pVertexAttributeDescriptions[vertexAttributeDescriptionIndex].format);
}
}
}
skipCall |= validate_struct_type(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO", pCreateInfos[createInfoIndex].pInputAssemblyState, VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, true);
if (pCreateInfos[createInfoIndex].pInputAssemblyState != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState->pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pInputAssemblyState->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pInputAssemblyState->flags);
skipCall |= validate_ranged_enum(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState->topology", ParameterName::IndexVector{ createInfoIndex }), "VkPrimitiveTopology", VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE, VK_PRIMITIVE_TOPOLOGY_END_RANGE, pCreateInfos[createInfoIndex].pInputAssemblyState->topology);
skipCall |= validate_bool32(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState->primitiveRestartEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pInputAssemblyState->primitiveRestartEnable);
}
skipCall |= validate_struct_type(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO", pCreateInfos[createInfoIndex].pRasterizationState, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, true);
if (pCreateInfos[createInfoIndex].pRasterizationState != NULL)
{
const VkStructureType allowedStructs[] = {VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD};
skipCall |= validate_struct_pnext(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->pNext", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineRasterizationStateRasterizationOrderAMD", pCreateInfos[createInfoIndex].pRasterizationState->pNext, ARRAY_SIZE(allowedStructs), allowedStructs, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->flags);
skipCall |= validate_bool32(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->depthClampEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->depthClampEnable);
skipCall |= validate_bool32(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->rasterizerDiscardEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->rasterizerDiscardEnable);
skipCall |= validate_ranged_enum(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->polygonMode", ParameterName::IndexVector{ createInfoIndex }), "VkPolygonMode", VK_POLYGON_MODE_BEGIN_RANGE, VK_POLYGON_MODE_END_RANGE, pCreateInfos[createInfoIndex].pRasterizationState->polygonMode);
skipCall |= validate_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->cullMode", ParameterName::IndexVector{ createInfoIndex }), "VkCullModeFlagBits", AllVkCullModeFlagBits, pCreateInfos[createInfoIndex].pRasterizationState->cullMode, false);
skipCall |= validate_ranged_enum(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->frontFace", ParameterName::IndexVector{ createInfoIndex }), "VkFrontFace", VK_FRONT_FACE_BEGIN_RANGE, VK_FRONT_FACE_END_RANGE, pCreateInfos[createInfoIndex].pRasterizationState->frontFace);
skipCall |= validate_bool32(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->depthBiasEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->depthBiasEnable);
}
skipCall |= validate_struct_type(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pDynamicState", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO", pCreateInfos[createInfoIndex].pDynamicState, VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, false);
if (pCreateInfos[createInfoIndex].pDynamicState != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pDynamicState->pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pDynamicState->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pDynamicState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pDynamicState->flags);
skipCall |= validate_ranged_enum_array(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pDynamicState->dynamicStateCount", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].pDynamicState->pDynamicStates", ParameterName::IndexVector{ createInfoIndex }), "VkDynamicState", VK_DYNAMIC_STATE_BEGIN_RANGE, VK_DYNAMIC_STATE_END_RANGE, pCreateInfos[createInfoIndex].pDynamicState->dynamicStateCount, pCreateInfos[createInfoIndex].pDynamicState->pDynamicStates, true, true);
}
skipCall |= validate_required_handle(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].layout", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].layout);
skipCall |= validate_required_handle(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].renderPass", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].renderPass);
}
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateGraphicsPipelines", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateGraphicsPipelines", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateGraphicsPipelines", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_array(report_data, "vkCreateGraphicsPipelines", "createInfoCount", "pPipelines", createInfoCount, pPipelines, true, true);
return skipCall;
}
static bool parameter_validation_vkCreateComputePipelines(
debug_report_data* report_data,
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines)
{
UNUSED_PARAMETER(pipelineCache);
bool skipCall = false;
skipCall |= validate_struct_type_array(report_data, "vkCreateComputePipelines", "createInfoCount", "pCreateInfos", "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO", createInfoCount, pCreateInfos, VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, true, true);
if (pCreateInfos != NULL)
{
for (uint32_t createInfoIndex = 0; createInfoIndex < createInfoCount; ++createInfoIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, false);
skipCall |= validate_struct_type(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", &(pCreateInfos[createInfoIndex].stage), VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, false);
skipCall |= validate_struct_pnext(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].stage.pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.flags);
skipCall |= validate_required_handle(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.module", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.module);
skipCall |= validate_required_pointer(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.pName", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.pName);
if (pCreateInfos[createInfoIndex].stage.pSpecializationInfo != NULL)
{
skipCall |= validate_array(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.pSpecializationInfo->mapEntryCount", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].stage.pSpecializationInfo->pMapEntries", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.pSpecializationInfo->mapEntryCount, pCreateInfos[createInfoIndex].stage.pSpecializationInfo->pMapEntries, false, true);
skipCall |= validate_array(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.pSpecializationInfo->dataSize", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].stage.pSpecializationInfo->pData", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.pSpecializationInfo->dataSize, pCreateInfos[createInfoIndex].stage.pSpecializationInfo->pData, false, true);
}
skipCall |= validate_required_handle(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].layout", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].layout);
}
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateComputePipelines", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateComputePipelines", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateComputePipelines", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_array(report_data, "vkCreateComputePipelines", "createInfoCount", "pPipelines", createInfoCount, pPipelines, true, true);
return skipCall;
}
static bool parameter_validation_vkDestroyPipeline(
debug_report_data* report_data,
VkPipeline pipeline,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(pipeline);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyPipeline", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyPipeline", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyPipeline", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkCreatePipelineLayout(
debug_report_data* report_data,
const VkPipelineLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreatePipelineLayout", "pCreateInfo", "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreatePipelineLayout", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreatePipelineLayout", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_array(report_data, "vkCreatePipelineLayout", "pCreateInfo->setLayoutCount", "pCreateInfo->pSetLayouts", pCreateInfo->setLayoutCount, pCreateInfo->pSetLayouts, false, true);
skipCall |= validate_array(report_data, "vkCreatePipelineLayout", "pCreateInfo->pushConstantRangeCount", "pCreateInfo->pPushConstantRanges", pCreateInfo->pushConstantRangeCount, pCreateInfo->pPushConstantRanges, false, true);
if (pCreateInfo->pPushConstantRanges != NULL)
{
for (uint32_t pushConstantRangeIndex = 0; pushConstantRangeIndex < pCreateInfo->pushConstantRangeCount; ++pushConstantRangeIndex)
{
skipCall |= validate_flags(report_data, "vkCreatePipelineLayout", ParameterName("pCreateInfo->pPushConstantRanges[%i].stageFlags", ParameterName::IndexVector{ pushConstantRangeIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfo->pPushConstantRanges[pushConstantRangeIndex].stageFlags, true);
}
}
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreatePipelineLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreatePipelineLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreatePipelineLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreatePipelineLayout", "pPipelineLayout", pPipelineLayout);
return skipCall;
}
static bool parameter_validation_vkDestroyPipelineLayout(
debug_report_data* report_data,
VkPipelineLayout pipelineLayout,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(pipelineLayout);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkCreateSampler(
debug_report_data* report_data,
const VkSamplerCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSampler* pSampler)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateSampler", "pCreateInfo", "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateSampler", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateSampler", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->magFilter", "VkFilter", VK_FILTER_BEGIN_RANGE, VK_FILTER_END_RANGE, pCreateInfo->magFilter);
skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->minFilter", "VkFilter", VK_FILTER_BEGIN_RANGE, VK_FILTER_END_RANGE, pCreateInfo->minFilter);
skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->mipmapMode", "VkSamplerMipmapMode", VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE, VK_SAMPLER_MIPMAP_MODE_END_RANGE, pCreateInfo->mipmapMode);
skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->addressModeU", "VkSamplerAddressMode", VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE, VK_SAMPLER_ADDRESS_MODE_END_RANGE, pCreateInfo->addressModeU);
skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->addressModeV", "VkSamplerAddressMode", VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE, VK_SAMPLER_ADDRESS_MODE_END_RANGE, pCreateInfo->addressModeV);
skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->addressModeW", "VkSamplerAddressMode", VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE, VK_SAMPLER_ADDRESS_MODE_END_RANGE, pCreateInfo->addressModeW);
skipCall |= validate_bool32(report_data, "vkCreateSampler", "pCreateInfo->anisotropyEnable", pCreateInfo->anisotropyEnable);
skipCall |= validate_bool32(report_data, "vkCreateSampler", "pCreateInfo->compareEnable", pCreateInfo->compareEnable);
skipCall |= validate_bool32(report_data, "vkCreateSampler", "pCreateInfo->unnormalizedCoordinates", pCreateInfo->unnormalizedCoordinates);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateSampler", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateSampler", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateSampler", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateSampler", "pSampler", pSampler);
return skipCall;
}
static bool parameter_validation_vkDestroySampler(
debug_report_data* report_data,
VkSampler sampler,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(sampler);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroySampler", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroySampler", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroySampler", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkCreateDescriptorSetLayout(
debug_report_data* report_data,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateDescriptorSetLayout", "pCreateInfo", "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateDescriptorSetLayout", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateDescriptorSetLayout", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_array(report_data, "vkCreateDescriptorSetLayout", "pCreateInfo->bindingCount", "pCreateInfo->pBindings", pCreateInfo->bindingCount, pCreateInfo->pBindings, false, true);
if (pCreateInfo->pBindings != NULL)
{
for (uint32_t bindingIndex = 0; bindingIndex < pCreateInfo->bindingCount; ++bindingIndex)
{
skipCall |= validate_ranged_enum(report_data, "vkCreateDescriptorSetLayout", ParameterName("pCreateInfo->pBindings[%i].descriptorType", ParameterName::IndexVector{ bindingIndex }), "VkDescriptorType", VK_DESCRIPTOR_TYPE_BEGIN_RANGE, VK_DESCRIPTOR_TYPE_END_RANGE, pCreateInfo->pBindings[bindingIndex].descriptorType);
}
}
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorSetLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorSetLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorSetLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorSetLayout", "pSetLayout", pSetLayout);
return skipCall;
}
static bool parameter_validation_vkDestroyDescriptorSetLayout(
debug_report_data* report_data,
VkDescriptorSetLayout descriptorSetLayout,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(descriptorSetLayout);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorSetLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorSetLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorSetLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkCreateDescriptorPool(
debug_report_data* report_data,
const VkDescriptorPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateDescriptorPool", "pCreateInfo", "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateDescriptorPool", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCreateDescriptorPool", "pCreateInfo->flags", "VkDescriptorPoolCreateFlagBits", AllVkDescriptorPoolCreateFlagBits, pCreateInfo->flags, false);
skipCall |= validate_array(report_data, "vkCreateDescriptorPool", "pCreateInfo->poolSizeCount", "pCreateInfo->pPoolSizes", pCreateInfo->poolSizeCount, pCreateInfo->pPoolSizes, true, true);
if (pCreateInfo->pPoolSizes != NULL)
{
for (uint32_t poolSizeIndex = 0; poolSizeIndex < pCreateInfo->poolSizeCount; ++poolSizeIndex)
{
skipCall |= validate_ranged_enum(report_data, "vkCreateDescriptorPool", ParameterName("pCreateInfo->pPoolSizes[%i].type", ParameterName::IndexVector{ poolSizeIndex }), "VkDescriptorType", VK_DESCRIPTOR_TYPE_BEGIN_RANGE, VK_DESCRIPTOR_TYPE_END_RANGE, pCreateInfo->pPoolSizes[poolSizeIndex].type);
}
}
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorPool", "pDescriptorPool", pDescriptorPool);
return skipCall;
}
static bool parameter_validation_vkDestroyDescriptorPool(
debug_report_data* report_data,
VkDescriptorPool descriptorPool,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(descriptorPool);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkResetDescriptorPool(
debug_report_data* report_data,
VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkResetDescriptorPool", "descriptorPool", descriptorPool);
skipCall |= validate_reserved_flags(report_data, "vkResetDescriptorPool", "flags", flags);
return skipCall;
}
static bool parameter_validation_vkAllocateDescriptorSets(
debug_report_data* report_data,
const VkDescriptorSetAllocateInfo* pAllocateInfo,
VkDescriptorSet* pDescriptorSets)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkAllocateDescriptorSets", "pAllocateInfo", "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, true);
if (pAllocateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkAllocateDescriptorSets", "pAllocateInfo->pNext", NULL, pAllocateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_required_handle(report_data, "vkAllocateDescriptorSets", "pAllocateInfo->descriptorPool", pAllocateInfo->descriptorPool);
skipCall |= validate_handle_array(report_data, "vkAllocateDescriptorSets", "pAllocateInfo->descriptorSetCount", "pAllocateInfo->pSetLayouts", pAllocateInfo->descriptorSetCount, pAllocateInfo->pSetLayouts, true, true);
}
if (pAllocateInfo != NULL) {
skipCall |= validate_array(report_data, "vkAllocateDescriptorSets", "pAllocateInfo->descriptorSetCount", "pDescriptorSets", pAllocateInfo->descriptorSetCount, pDescriptorSets, true, true);
}
return skipCall;
}
static bool parameter_validation_vkFreeDescriptorSets(
debug_report_data* report_data,
VkDescriptorPool descriptorPool,
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets)
{
UNUSED_PARAMETER(pDescriptorSets);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkFreeDescriptorSets", "descriptorPool", descriptorPool);
return skipCall;
}
static bool parameter_validation_vkUpdateDescriptorSets(
debug_report_data* report_data,
uint32_t descriptorWriteCount,
const VkWriteDescriptorSet* pDescriptorWrites,
uint32_t descriptorCopyCount,
const VkCopyDescriptorSet* pDescriptorCopies)
{
bool skipCall = false;
skipCall |= validate_struct_type_array(report_data, "vkUpdateDescriptorSets", "descriptorWriteCount", "pDescriptorWrites", "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET", descriptorWriteCount, pDescriptorWrites, VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, false, true);
if (pDescriptorWrites != NULL)
{
for (uint32_t descriptorWriteIndex = 0; descriptorWriteIndex < descriptorWriteCount; ++descriptorWriteIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorWrites[%i].pNext", ParameterName::IndexVector{ descriptorWriteIndex }), NULL, pDescriptorWrites[descriptorWriteIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_required_handle(report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorWrites[%i].dstSet", ParameterName::IndexVector{ descriptorWriteIndex }), pDescriptorWrites[descriptorWriteIndex].dstSet);
skipCall |= validate_ranged_enum(report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorWrites[%i].descriptorType", ParameterName::IndexVector{ descriptorWriteIndex }), "VkDescriptorType", VK_DESCRIPTOR_TYPE_BEGIN_RANGE, VK_DESCRIPTOR_TYPE_END_RANGE, pDescriptorWrites[descriptorWriteIndex].descriptorType);
}
}
skipCall |= validate_struct_type_array(report_data, "vkUpdateDescriptorSets", "descriptorCopyCount", "pDescriptorCopies", "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET", descriptorCopyCount, pDescriptorCopies, VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, false, true);
if (pDescriptorCopies != NULL)
{
for (uint32_t descriptorCopyIndex = 0; descriptorCopyIndex < descriptorCopyCount; ++descriptorCopyIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorCopies[%i].pNext", ParameterName::IndexVector{ descriptorCopyIndex }), NULL, pDescriptorCopies[descriptorCopyIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_required_handle(report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorCopies[%i].srcSet", ParameterName::IndexVector{ descriptorCopyIndex }), pDescriptorCopies[descriptorCopyIndex].srcSet);
skipCall |= validate_required_handle(report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorCopies[%i].dstSet", ParameterName::IndexVector{ descriptorCopyIndex }), pDescriptorCopies[descriptorCopyIndex].dstSet);
}
}
return skipCall;
}
static bool parameter_validation_vkCreateFramebuffer(
debug_report_data* report_data,
const VkFramebufferCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkFramebuffer* pFramebuffer)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateFramebuffer", "pCreateInfo", "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateFramebuffer", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateFramebuffer", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_required_handle(report_data, "vkCreateFramebuffer", "pCreateInfo->renderPass", pCreateInfo->renderPass);
skipCall |= validate_array(report_data, "vkCreateFramebuffer", "pCreateInfo->attachmentCount", "pCreateInfo->pAttachments", pCreateInfo->attachmentCount, pCreateInfo->pAttachments, false, true);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateFramebuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateFramebuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateFramebuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateFramebuffer", "pFramebuffer", pFramebuffer);
return skipCall;
}
static bool parameter_validation_vkDestroyFramebuffer(
debug_report_data* report_data,
VkFramebuffer framebuffer,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(framebuffer);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyFramebuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyFramebuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyFramebuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkCreateRenderPass(
debug_report_data* report_data,
const VkRenderPassCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateRenderPass", "pCreateInfo", "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateRenderPass", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateRenderPass", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_array(report_data, "vkCreateRenderPass", "pCreateInfo->attachmentCount", "pCreateInfo->pAttachments", pCreateInfo->attachmentCount, pCreateInfo->pAttachments, false, true);
if (pCreateInfo->pAttachments != NULL)
{
for (uint32_t attachmentIndex = 0; attachmentIndex < pCreateInfo->attachmentCount; ++attachmentIndex)
{
skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].flags", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentDescriptionFlagBits", AllVkAttachmentDescriptionFlagBits, pCreateInfo->pAttachments[attachmentIndex].flags, false);
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].format", ParameterName::IndexVector{ attachmentIndex }), "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, pCreateInfo->pAttachments[attachmentIndex].format);
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].loadOp", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentLoadOp", VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE, VK_ATTACHMENT_LOAD_OP_END_RANGE, pCreateInfo->pAttachments[attachmentIndex].loadOp);
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].storeOp", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentStoreOp", VK_ATTACHMENT_STORE_OP_BEGIN_RANGE, VK_ATTACHMENT_STORE_OP_END_RANGE, pCreateInfo->pAttachments[attachmentIndex].storeOp);
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].stencilLoadOp", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentLoadOp", VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE, VK_ATTACHMENT_LOAD_OP_END_RANGE, pCreateInfo->pAttachments[attachmentIndex].stencilLoadOp);
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].stencilStoreOp", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentStoreOp", VK_ATTACHMENT_STORE_OP_BEGIN_RANGE, VK_ATTACHMENT_STORE_OP_END_RANGE, pCreateInfo->pAttachments[attachmentIndex].stencilStoreOp);
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].initialLayout", ParameterName::IndexVector{ attachmentIndex }), "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pCreateInfo->pAttachments[attachmentIndex].initialLayout);
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].finalLayout", ParameterName::IndexVector{ attachmentIndex }), "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pCreateInfo->pAttachments[attachmentIndex].finalLayout);
}
}
skipCall |= validate_array(report_data, "vkCreateRenderPass", "pCreateInfo->subpassCount", "pCreateInfo->pSubpasses", pCreateInfo->subpassCount, pCreateInfo->pSubpasses, true, true);
if (pCreateInfo->pSubpasses != NULL)
{
for (uint32_t subpassIndex = 0; subpassIndex < pCreateInfo->subpassCount; ++subpassIndex)
{
skipCall |= validate_reserved_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].flags", ParameterName::IndexVector{ subpassIndex }), pCreateInfo->pSubpasses[subpassIndex].flags);
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].pipelineBindPoint", ParameterName::IndexVector{ subpassIndex }), "VkPipelineBindPoint", VK_PIPELINE_BIND_POINT_BEGIN_RANGE, VK_PIPELINE_BIND_POINT_END_RANGE, pCreateInfo->pSubpasses[subpassIndex].pipelineBindPoint);
skipCall |= validate_array(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].inputAttachmentCount", ParameterName::IndexVector{ subpassIndex }), ParameterName("pCreateInfo->pSubpasses[%i].pInputAttachments", ParameterName::IndexVector{ subpassIndex }), pCreateInfo->pSubpasses[subpassIndex].inputAttachmentCount, pCreateInfo->pSubpasses[subpassIndex].pInputAttachments, false, true);
if (pCreateInfo->pSubpasses[subpassIndex].pInputAttachments != NULL)
{
for (uint32_t inputAttachmentIndex = 0; inputAttachmentIndex < pCreateInfo->pSubpasses[subpassIndex].inputAttachmentCount; ++inputAttachmentIndex)
{
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].pInputAttachments[%i].layout", ParameterName::IndexVector{ subpassIndex, inputAttachmentIndex }), "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pCreateInfo->pSubpasses[subpassIndex].pInputAttachments[inputAttachmentIndex].layout);
}
}
skipCall |= validate_array(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].colorAttachmentCount", ParameterName::IndexVector{ subpassIndex }), ParameterName("pCreateInfo->pSubpasses[%i].pColorAttachments", ParameterName::IndexVector{ subpassIndex }), pCreateInfo->pSubpasses[subpassIndex].colorAttachmentCount, pCreateInfo->pSubpasses[subpassIndex].pColorAttachments, false, true);
if (pCreateInfo->pSubpasses[subpassIndex].pColorAttachments != NULL)
{
for (uint32_t colorAttachmentIndex = 0; colorAttachmentIndex < pCreateInfo->pSubpasses[subpassIndex].colorAttachmentCount; ++colorAttachmentIndex)
{
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].pColorAttachments[%i].layout", ParameterName::IndexVector{ subpassIndex, colorAttachmentIndex }), "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pCreateInfo->pSubpasses[subpassIndex].pColorAttachments[colorAttachmentIndex].layout);
}
}
if (pCreateInfo->pSubpasses[subpassIndex].pResolveAttachments != NULL)
{
for (uint32_t colorAttachmentIndex = 0; colorAttachmentIndex < pCreateInfo->pSubpasses[subpassIndex].colorAttachmentCount; ++colorAttachmentIndex)
{
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].pResolveAttachments[%i].layout", ParameterName::IndexVector{ subpassIndex, colorAttachmentIndex }), "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pCreateInfo->pSubpasses[subpassIndex].pResolveAttachments[colorAttachmentIndex].layout);
}
}
if (pCreateInfo->pSubpasses[subpassIndex].pDepthStencilAttachment != NULL)
{
skipCall |= validate_ranged_enum(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].pDepthStencilAttachment->layout", ParameterName::IndexVector{ subpassIndex }), "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pCreateInfo->pSubpasses[subpassIndex].pDepthStencilAttachment->layout);
}
skipCall |= validate_array(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].preserveAttachmentCount", ParameterName::IndexVector{ subpassIndex }), ParameterName("pCreateInfo->pSubpasses[%i].pPreserveAttachments", ParameterName::IndexVector{ subpassIndex }), pCreateInfo->pSubpasses[subpassIndex].preserveAttachmentCount, pCreateInfo->pSubpasses[subpassIndex].pPreserveAttachments, false, true);
}
}
skipCall |= validate_array(report_data, "vkCreateRenderPass", "pCreateInfo->dependencyCount", "pCreateInfo->pDependencies", pCreateInfo->dependencyCount, pCreateInfo->pDependencies, false, true);
if (pCreateInfo->pDependencies != NULL)
{
for (uint32_t dependencyIndex = 0; dependencyIndex < pCreateInfo->dependencyCount; ++dependencyIndex)
{
skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].srcStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcStageMask, true);
skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dstStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstStageMask, true);
skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].srcAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcAccessMask, false);
skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dstAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstAccessMask, false);
skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dependencyFlags", ParameterName::IndexVector{ dependencyIndex }), "VkDependencyFlagBits", AllVkDependencyFlagBits, pCreateInfo->pDependencies[dependencyIndex].dependencyFlags, false);
}
}
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateRenderPass", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateRenderPass", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateRenderPass", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateRenderPass", "pRenderPass", pRenderPass);
return skipCall;
}
static bool parameter_validation_vkDestroyRenderPass(
debug_report_data* report_data,
VkRenderPass renderPass,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(renderPass);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyRenderPass", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyRenderPass", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyRenderPass", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkGetRenderAreaGranularity(
debug_report_data* report_data,
VkRenderPass renderPass,
VkExtent2D* pGranularity)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetRenderAreaGranularity", "renderPass", renderPass);
skipCall |= validate_required_pointer(report_data, "vkGetRenderAreaGranularity", "pGranularity", pGranularity);
return skipCall;
}
static bool parameter_validation_vkCreateCommandPool(
debug_report_data* report_data,
const VkCommandPoolCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkCommandPool* pCommandPool)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateCommandPool", "pCreateInfo", "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateCommandPool", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCreateCommandPool", "pCreateInfo->flags", "VkCommandPoolCreateFlagBits", AllVkCommandPoolCreateFlagBits, pCreateInfo->flags, false);
}
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkCreateCommandPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkCreateCommandPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkCreateCommandPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
skipCall |= validate_required_pointer(report_data, "vkCreateCommandPool", "pCommandPool", pCommandPool);
return skipCall;
}
static bool parameter_validation_vkDestroyCommandPool(
debug_report_data* report_data,
VkCommandPool commandPool,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(commandPool);
bool skipCall = false;
if (pAllocator != NULL)
{
skipCall |= validate_required_pointer(report_data, "vkDestroyCommandPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyCommandPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation));
skipCall |= validate_required_pointer(report_data, "vkDestroyCommandPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree));
}
return skipCall;
}
static bool parameter_validation_vkResetCommandPool(
debug_report_data* report_data,
VkCommandPool commandPool,
VkCommandPoolResetFlags flags)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkResetCommandPool", "commandPool", commandPool);
skipCall |= validate_flags(report_data, "vkResetCommandPool", "flags", "VkCommandPoolResetFlagBits", AllVkCommandPoolResetFlagBits, flags, false);
return skipCall;
}
static bool parameter_validation_vkAllocateCommandBuffers(
debug_report_data* report_data,
const VkCommandBufferAllocateInfo* pAllocateInfo,
VkCommandBuffer* pCommandBuffers)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkAllocateCommandBuffers", "pAllocateInfo", "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, true);
if (pAllocateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkAllocateCommandBuffers", "pAllocateInfo->pNext", NULL, pAllocateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_required_handle(report_data, "vkAllocateCommandBuffers", "pAllocateInfo->commandPool", pAllocateInfo->commandPool);
skipCall |= validate_ranged_enum(report_data, "vkAllocateCommandBuffers", "pAllocateInfo->level", "VkCommandBufferLevel", VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE, VK_COMMAND_BUFFER_LEVEL_END_RANGE, pAllocateInfo->level);
}
if (pAllocateInfo != NULL) {
skipCall |= validate_array(report_data, "vkAllocateCommandBuffers", "pAllocateInfo->commandBufferCount", "pCommandBuffers", pAllocateInfo->commandBufferCount, pCommandBuffers, true, true);
}
return skipCall;
}
static bool parameter_validation_vkFreeCommandBuffers(
debug_report_data* report_data,
VkCommandPool commandPool,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers)
{
UNUSED_PARAMETER(pCommandBuffers);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkFreeCommandBuffers", "commandPool", commandPool);
return skipCall;
}
static bool parameter_validation_vkBeginCommandBuffer(
debug_report_data* report_data,
const VkCommandBufferBeginInfo* pBeginInfo)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkBeginCommandBuffer", "pBeginInfo", "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO", pBeginInfo, VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, true);
if (pBeginInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkBeginCommandBuffer", "pBeginInfo->pNext", NULL, pBeginInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkBeginCommandBuffer", "pBeginInfo->flags", "VkCommandBufferUsageFlagBits", AllVkCommandBufferUsageFlagBits, pBeginInfo->flags, false);
}
return skipCall;
}
static bool parameter_validation_vkResetCommandBuffer(
debug_report_data* report_data,
VkCommandBufferResetFlags flags)
{
bool skipCall = false;
skipCall |= validate_flags(report_data, "vkResetCommandBuffer", "flags", "VkCommandBufferResetFlagBits", AllVkCommandBufferResetFlagBits, flags, false);
return skipCall;
}
static bool parameter_validation_vkCmdBindPipeline(
debug_report_data* report_data,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline)
{
bool skipCall = false;
skipCall |= validate_ranged_enum(report_data, "vkCmdBindPipeline", "pipelineBindPoint", "VkPipelineBindPoint", VK_PIPELINE_BIND_POINT_BEGIN_RANGE, VK_PIPELINE_BIND_POINT_END_RANGE, pipelineBindPoint);
skipCall |= validate_required_handle(report_data, "vkCmdBindPipeline", "pipeline", pipeline);
return skipCall;
}
static bool parameter_validation_vkCmdSetViewport(
debug_report_data* report_data,
uint32_t firstViewport,
uint32_t viewportCount,
const VkViewport* pViewports)
{
UNUSED_PARAMETER(firstViewport);
bool skipCall = false;
skipCall |= validate_array(report_data, "vkCmdSetViewport", "viewportCount", "pViewports", viewportCount, pViewports, true, true);
return skipCall;
}
static bool parameter_validation_vkCmdSetScissor(
debug_report_data* report_data,
uint32_t firstScissor,
uint32_t scissorCount,
const VkRect2D* pScissors)
{
UNUSED_PARAMETER(firstScissor);
bool skipCall = false;
skipCall |= validate_array(report_data, "vkCmdSetScissor", "scissorCount", "pScissors", scissorCount, pScissors, true, true);
return skipCall;
}
static bool parameter_validation_vkCmdSetBlendConstants(
debug_report_data* report_data,
const float blendConstants[4])
{
bool skipCall = false;
skipCall |= validate_required_pointer(report_data, "vkCmdSetBlendConstants", "blendConstants", blendConstants);
return skipCall;
}
static bool parameter_validation_vkCmdSetStencilCompareMask(
debug_report_data* report_data,
VkStencilFaceFlags faceMask,
uint32_t compareMask)
{
UNUSED_PARAMETER(compareMask);
bool skipCall = false;
skipCall |= validate_flags(report_data, "vkCmdSetStencilCompareMask", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true);
return skipCall;
}
static bool parameter_validation_vkCmdSetStencilWriteMask(
debug_report_data* report_data,
VkStencilFaceFlags faceMask,
uint32_t writeMask)
{
UNUSED_PARAMETER(writeMask);
bool skipCall = false;
skipCall |= validate_flags(report_data, "vkCmdSetStencilWriteMask", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true);
return skipCall;
}
static bool parameter_validation_vkCmdSetStencilReference(
debug_report_data* report_data,
VkStencilFaceFlags faceMask,
uint32_t reference)
{
UNUSED_PARAMETER(reference);
bool skipCall = false;
skipCall |= validate_flags(report_data, "vkCmdSetStencilReference", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true);
return skipCall;
}
static bool parameter_validation_vkCmdBindDescriptorSets(
debug_report_data* report_data,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t firstSet,
uint32_t descriptorSetCount,
const VkDescriptorSet* pDescriptorSets,
uint32_t dynamicOffsetCount,
const uint32_t* pDynamicOffsets)
{
UNUSED_PARAMETER(firstSet);
bool skipCall = false;
skipCall |= validate_ranged_enum(report_data, "vkCmdBindDescriptorSets", "pipelineBindPoint", "VkPipelineBindPoint", VK_PIPELINE_BIND_POINT_BEGIN_RANGE, VK_PIPELINE_BIND_POINT_END_RANGE, pipelineBindPoint);
skipCall |= validate_required_handle(report_data, "vkCmdBindDescriptorSets", "layout", layout);
skipCall |= validate_handle_array(report_data, "vkCmdBindDescriptorSets", "descriptorSetCount", "pDescriptorSets", descriptorSetCount, pDescriptorSets, true, true);
skipCall |= validate_array(report_data, "vkCmdBindDescriptorSets", "dynamicOffsetCount", "pDynamicOffsets", dynamicOffsetCount, pDynamicOffsets, false, true);
return skipCall;
}
static bool parameter_validation_vkCmdBindIndexBuffer(
debug_report_data* report_data,
VkBuffer buffer,
VkDeviceSize offset,
VkIndexType indexType)
{
UNUSED_PARAMETER(offset);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdBindIndexBuffer", "buffer", buffer);
skipCall |= validate_ranged_enum(report_data, "vkCmdBindIndexBuffer", "indexType", "VkIndexType", VK_INDEX_TYPE_BEGIN_RANGE, VK_INDEX_TYPE_END_RANGE, indexType);
return skipCall;
}
static bool parameter_validation_vkCmdBindVertexBuffers(
debug_report_data* report_data,
uint32_t firstBinding,
uint32_t bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets)
{
UNUSED_PARAMETER(firstBinding);
bool skipCall = false;
skipCall |= validate_handle_array(report_data, "vkCmdBindVertexBuffers", "bindingCount", "pBuffers", bindingCount, pBuffers, true, true);
skipCall |= validate_array(report_data, "vkCmdBindVertexBuffers", "bindingCount", "pOffsets", bindingCount, pOffsets, true, true);
return skipCall;
}
static bool parameter_validation_vkCmdDrawIndirect(
debug_report_data* report_data,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride)
{
UNUSED_PARAMETER(offset);
UNUSED_PARAMETER(drawCount);
UNUSED_PARAMETER(stride);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdDrawIndirect", "buffer", buffer);
return skipCall;
}
static bool parameter_validation_vkCmdDrawIndexedIndirect(
debug_report_data* report_data,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride)
{
UNUSED_PARAMETER(offset);
UNUSED_PARAMETER(drawCount);
UNUSED_PARAMETER(stride);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdDrawIndexedIndirect", "buffer", buffer);
return skipCall;
}
static bool parameter_validation_vkCmdDispatchIndirect(
debug_report_data* report_data,
VkBuffer buffer,
VkDeviceSize offset)
{
UNUSED_PARAMETER(offset);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdDispatchIndirect", "buffer", buffer);
return skipCall;
}
static bool parameter_validation_vkCmdCopyBuffer(
debug_report_data* report_data,
VkBuffer srcBuffer,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferCopy* pRegions)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdCopyBuffer", "srcBuffer", srcBuffer);
skipCall |= validate_required_handle(report_data, "vkCmdCopyBuffer", "dstBuffer", dstBuffer);
skipCall |= validate_array(report_data, "vkCmdCopyBuffer", "regionCount", "pRegions", regionCount, pRegions, true, true);
return skipCall;
}
static bool parameter_validation_vkCmdCopyImage(
debug_report_data* report_data,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageCopy* pRegions)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdCopyImage", "srcImage", srcImage);
skipCall |= validate_ranged_enum(report_data, "vkCmdCopyImage", "srcImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, srcImageLayout);
skipCall |= validate_required_handle(report_data, "vkCmdCopyImage", "dstImage", dstImage);
skipCall |= validate_ranged_enum(report_data, "vkCmdCopyImage", "dstImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, dstImageLayout);
skipCall |= validate_array(report_data, "vkCmdCopyImage", "regionCount", "pRegions", regionCount, pRegions, true, true);
if (pRegions != NULL)
{
for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
{
skipCall |= validate_flags(report_data, "vkCmdCopyImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true);
skipCall |= validate_flags(report_data, "vkCmdCopyImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true);
}
}
return skipCall;
}
static bool parameter_validation_vkCmdBlitImage(
debug_report_data* report_data,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageBlit* pRegions,
VkFilter filter)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdBlitImage", "srcImage", srcImage);
skipCall |= validate_ranged_enum(report_data, "vkCmdBlitImage", "srcImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, srcImageLayout);
skipCall |= validate_required_handle(report_data, "vkCmdBlitImage", "dstImage", dstImage);
skipCall |= validate_ranged_enum(report_data, "vkCmdBlitImage", "dstImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, dstImageLayout);
skipCall |= validate_array(report_data, "vkCmdBlitImage", "regionCount", "pRegions", regionCount, pRegions, true, true);
if (pRegions != NULL)
{
for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
{
skipCall |= validate_flags(report_data, "vkCmdBlitImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true);
skipCall |= validate_flags(report_data, "vkCmdBlitImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true);
}
}
skipCall |= validate_ranged_enum(report_data, "vkCmdBlitImage", "filter", "VkFilter", VK_FILTER_BEGIN_RANGE, VK_FILTER_END_RANGE, filter);
return skipCall;
}
static bool parameter_validation_vkCmdCopyBufferToImage(
debug_report_data* report_data,
VkBuffer srcBuffer,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy* pRegions)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdCopyBufferToImage", "srcBuffer", srcBuffer);
skipCall |= validate_required_handle(report_data, "vkCmdCopyBufferToImage", "dstImage", dstImage);
skipCall |= validate_ranged_enum(report_data, "vkCmdCopyBufferToImage", "dstImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, dstImageLayout);
skipCall |= validate_array(report_data, "vkCmdCopyBufferToImage", "regionCount", "pRegions", regionCount, pRegions, true, true);
if (pRegions != NULL)
{
for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
{
skipCall |= validate_flags(report_data, "vkCmdCopyBufferToImage", ParameterName("pRegions[%i].imageSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].imageSubresource.aspectMask, true);
}
}
return skipCall;
}
static bool parameter_validation_vkCmdCopyImageToBuffer(
debug_report_data* report_data,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy* pRegions)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdCopyImageToBuffer", "srcImage", srcImage);
skipCall |= validate_ranged_enum(report_data, "vkCmdCopyImageToBuffer", "srcImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, srcImageLayout);
skipCall |= validate_required_handle(report_data, "vkCmdCopyImageToBuffer", "dstBuffer", dstBuffer);
skipCall |= validate_array(report_data, "vkCmdCopyImageToBuffer", "regionCount", "pRegions", regionCount, pRegions, true, true);
if (pRegions != NULL)
{
for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
{
skipCall |= validate_flags(report_data, "vkCmdCopyImageToBuffer", ParameterName("pRegions[%i].imageSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].imageSubresource.aspectMask, true);
}
}
return skipCall;
}
static bool parameter_validation_vkCmdUpdateBuffer(
debug_report_data* report_data,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const void* pData)
{
UNUSED_PARAMETER(dstOffset);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdUpdateBuffer", "dstBuffer", dstBuffer);
skipCall |= validate_array(report_data, "vkCmdUpdateBuffer", "dataSize", "pData", dataSize, pData, true, true);
return skipCall;
}
static bool parameter_validation_vkCmdFillBuffer(
debug_report_data* report_data,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize size,
uint32_t data)
{
UNUSED_PARAMETER(dstOffset);
UNUSED_PARAMETER(size);
UNUSED_PARAMETER(data);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdFillBuffer", "dstBuffer", dstBuffer);
return skipCall;
}
static bool parameter_validation_vkCmdClearColorImage(
debug_report_data* report_data,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue* pColor,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdClearColorImage", "image", image);
skipCall |= validate_ranged_enum(report_data, "vkCmdClearColorImage", "imageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, imageLayout);
skipCall |= validate_required_pointer(report_data, "vkCmdClearColorImage", "pColor", pColor);
skipCall |= validate_array(report_data, "vkCmdClearColorImage", "rangeCount", "pRanges", rangeCount, pRanges, true, true);
if (pRanges != NULL)
{
for (uint32_t rangeIndex = 0; rangeIndex < rangeCount; ++rangeIndex)
{
skipCall |= validate_flags(report_data, "vkCmdClearColorImage", ParameterName("pRanges[%i].aspectMask", ParameterName::IndexVector{ rangeIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRanges[rangeIndex].aspectMask, true);
}
}
return skipCall;
}
static bool parameter_validation_vkCmdClearDepthStencilImage(
debug_report_data* report_data,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue* pDepthStencil,
uint32_t rangeCount,
const VkImageSubresourceRange* pRanges)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdClearDepthStencilImage", "image", image);
skipCall |= validate_ranged_enum(report_data, "vkCmdClearDepthStencilImage", "imageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, imageLayout);
skipCall |= validate_required_pointer(report_data, "vkCmdClearDepthStencilImage", "pDepthStencil", pDepthStencil);
skipCall |= validate_array(report_data, "vkCmdClearDepthStencilImage", "rangeCount", "pRanges", rangeCount, pRanges, true, true);
if (pRanges != NULL)
{
for (uint32_t rangeIndex = 0; rangeIndex < rangeCount; ++rangeIndex)
{
skipCall |= validate_flags(report_data, "vkCmdClearDepthStencilImage", ParameterName("pRanges[%i].aspectMask", ParameterName::IndexVector{ rangeIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRanges[rangeIndex].aspectMask, true);
}
}
return skipCall;
}
static bool parameter_validation_vkCmdClearAttachments(
debug_report_data* report_data,
uint32_t attachmentCount,
const VkClearAttachment* pAttachments,
uint32_t rectCount,
const VkClearRect* pRects)
{
bool skipCall = false;
skipCall |= validate_array(report_data, "vkCmdClearAttachments", "attachmentCount", "pAttachments", attachmentCount, pAttachments, true, true);
if (pAttachments != NULL)
{
for (uint32_t attachmentIndex = 0; attachmentIndex < attachmentCount; ++attachmentIndex)
{
skipCall |= validate_flags(report_data, "vkCmdClearAttachments", ParameterName("pAttachments[%i].aspectMask", ParameterName::IndexVector{ attachmentIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pAttachments[attachmentIndex].aspectMask, true);
}
}
skipCall |= validate_array(report_data, "vkCmdClearAttachments", "rectCount", "pRects", rectCount, pRects, true, true);
return skipCall;
}
static bool parameter_validation_vkCmdResolveImage(
debug_report_data* report_data,
VkImage srcImage,
VkImageLayout srcImageLayout,
VkImage dstImage,
VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageResolve* pRegions)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdResolveImage", "srcImage", srcImage);
skipCall |= validate_ranged_enum(report_data, "vkCmdResolveImage", "srcImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, srcImageLayout);
skipCall |= validate_required_handle(report_data, "vkCmdResolveImage", "dstImage", dstImage);
skipCall |= validate_ranged_enum(report_data, "vkCmdResolveImage", "dstImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, dstImageLayout);
skipCall |= validate_array(report_data, "vkCmdResolveImage", "regionCount", "pRegions", regionCount, pRegions, true, true);
if (pRegions != NULL)
{
for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
{
skipCall |= validate_flags(report_data, "vkCmdResolveImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true);
skipCall |= validate_flags(report_data, "vkCmdResolveImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true);
}
}
return skipCall;
}
static bool parameter_validation_vkCmdSetEvent(
debug_report_data* report_data,
VkEvent event,
VkPipelineStageFlags stageMask)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdSetEvent", "event", event);
skipCall |= validate_flags(report_data, "vkCmdSetEvent", "stageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, stageMask, true);
return skipCall;
}
static bool parameter_validation_vkCmdResetEvent(
debug_report_data* report_data,
VkEvent event,
VkPipelineStageFlags stageMask)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdResetEvent", "event", event);
skipCall |= validate_flags(report_data, "vkCmdResetEvent", "stageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, stageMask, true);
return skipCall;
}
static bool parameter_validation_vkCmdWaitEvents(
debug_report_data* report_data,
uint32_t eventCount,
const VkEvent* pEvents,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
uint32_t memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers)
{
bool skipCall = false;
skipCall |= validate_handle_array(report_data, "vkCmdWaitEvents", "eventCount", "pEvents", eventCount, pEvents, true, true);
skipCall |= validate_flags(report_data, "vkCmdWaitEvents", "srcStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, srcStageMask, true);
skipCall |= validate_flags(report_data, "vkCmdWaitEvents", "dstStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, dstStageMask, true);
skipCall |= validate_struct_type_array(report_data, "vkCmdWaitEvents", "memoryBarrierCount", "pMemoryBarriers", "VK_STRUCTURE_TYPE_MEMORY_BARRIER", memoryBarrierCount, pMemoryBarriers, VK_STRUCTURE_TYPE_MEMORY_BARRIER, false, true);
if (pMemoryBarriers != NULL)
{
for (uint32_t memoryBarrierIndex = 0; memoryBarrierIndex < memoryBarrierCount; ++memoryBarrierIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].pNext", ParameterName::IndexVector{ memoryBarrierIndex }), NULL, pMemoryBarriers[memoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].srcAccessMask, false);
skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].dstAccessMask, false);
}
}
skipCall |= validate_struct_type_array(report_data, "vkCmdWaitEvents", "bufferMemoryBarrierCount", "pBufferMemoryBarriers", "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", bufferMemoryBarrierCount, pBufferMemoryBarriers, VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, false, true);
if (pBufferMemoryBarriers != NULL)
{
for (uint32_t bufferMemoryBarrierIndex = 0; bufferMemoryBarrierIndex < bufferMemoryBarrierCount; ++bufferMemoryBarrierIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].pNext", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), NULL, pBufferMemoryBarriers[bufferMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].srcAccessMask, false);
skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].dstAccessMask, false);
skipCall |= validate_required_handle(report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].buffer", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), pBufferMemoryBarriers[bufferMemoryBarrierIndex].buffer);
}
}
skipCall |= validate_struct_type_array(report_data, "vkCmdWaitEvents", "imageMemoryBarrierCount", "pImageMemoryBarriers", "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER", imageMemoryBarrierCount, pImageMemoryBarriers, VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, false, true);
if (pImageMemoryBarriers != NULL)
{
for (uint32_t imageMemoryBarrierIndex = 0; imageMemoryBarrierIndex < imageMemoryBarrierCount; ++imageMemoryBarrierIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].pNext", ParameterName::IndexVector{ imageMemoryBarrierIndex }), NULL, pImageMemoryBarriers[imageMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].srcAccessMask, false);
skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].dstAccessMask, false);
skipCall |= validate_ranged_enum(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].oldLayout", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pImageMemoryBarriers[imageMemoryBarrierIndex].oldLayout);
skipCall |= validate_ranged_enum(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].newLayout", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pImageMemoryBarriers[imageMemoryBarrierIndex].newLayout);
skipCall |= validate_required_handle(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].image", ParameterName::IndexVector{ imageMemoryBarrierIndex }), pImageMemoryBarriers[imageMemoryBarrierIndex].image);
skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].subresourceRange.aspectMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].subresourceRange.aspectMask, true);
}
}
return skipCall;
}
static bool parameter_validation_vkCmdPipelineBarrier(
debug_report_data* report_data,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
uint32_t memoryBarrierCount,
const VkMemoryBarrier* pMemoryBarriers,
uint32_t bufferMemoryBarrierCount,
const VkBufferMemoryBarrier* pBufferMemoryBarriers,
uint32_t imageMemoryBarrierCount,
const VkImageMemoryBarrier* pImageMemoryBarriers)
{
bool skipCall = false;
skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", "srcStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, srcStageMask, true);
skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", "dstStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, dstStageMask, true);
skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", "dependencyFlags", "VkDependencyFlagBits", AllVkDependencyFlagBits, dependencyFlags, false);
skipCall |= validate_struct_type_array(report_data, "vkCmdPipelineBarrier", "memoryBarrierCount", "pMemoryBarriers", "VK_STRUCTURE_TYPE_MEMORY_BARRIER", memoryBarrierCount, pMemoryBarriers, VK_STRUCTURE_TYPE_MEMORY_BARRIER, false, true);
if (pMemoryBarriers != NULL)
{
for (uint32_t memoryBarrierIndex = 0; memoryBarrierIndex < memoryBarrierCount; ++memoryBarrierIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].pNext", ParameterName::IndexVector{ memoryBarrierIndex }), NULL, pMemoryBarriers[memoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].srcAccessMask, false);
skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].dstAccessMask, false);
}
}
skipCall |= validate_struct_type_array(report_data, "vkCmdPipelineBarrier", "bufferMemoryBarrierCount", "pBufferMemoryBarriers", "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", bufferMemoryBarrierCount, pBufferMemoryBarriers, VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, false, true);
if (pBufferMemoryBarriers != NULL)
{
for (uint32_t bufferMemoryBarrierIndex = 0; bufferMemoryBarrierIndex < bufferMemoryBarrierCount; ++bufferMemoryBarrierIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].pNext", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), NULL, pBufferMemoryBarriers[bufferMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].srcAccessMask, false);
skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].dstAccessMask, false);
skipCall |= validate_required_handle(report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].buffer", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), pBufferMemoryBarriers[bufferMemoryBarrierIndex].buffer);
}
}
skipCall |= validate_struct_type_array(report_data, "vkCmdPipelineBarrier", "imageMemoryBarrierCount", "pImageMemoryBarriers", "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER", imageMemoryBarrierCount, pImageMemoryBarriers, VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, false, true);
if (pImageMemoryBarriers != NULL)
{
for (uint32_t imageMemoryBarrierIndex = 0; imageMemoryBarrierIndex < imageMemoryBarrierCount; ++imageMemoryBarrierIndex)
{
skipCall |= validate_struct_pnext(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].pNext", ParameterName::IndexVector{ imageMemoryBarrierIndex }), NULL, pImageMemoryBarriers[imageMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].srcAccessMask, false);
skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].dstAccessMask, false);
skipCall |= validate_ranged_enum(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].oldLayout", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pImageMemoryBarriers[imageMemoryBarrierIndex].oldLayout);
skipCall |= validate_ranged_enum(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].newLayout", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pImageMemoryBarriers[imageMemoryBarrierIndex].newLayout);
skipCall |= validate_required_handle(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].image", ParameterName::IndexVector{ imageMemoryBarrierIndex }), pImageMemoryBarriers[imageMemoryBarrierIndex].image);
skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].subresourceRange.aspectMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].subresourceRange.aspectMask, true);
}
}
return skipCall;
}
static bool parameter_validation_vkCmdBeginQuery(
debug_report_data* report_data,
VkQueryPool queryPool,
uint32_t query,
VkQueryControlFlags flags)
{
UNUSED_PARAMETER(query);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdBeginQuery", "queryPool", queryPool);
skipCall |= validate_flags(report_data, "vkCmdBeginQuery", "flags", "VkQueryControlFlagBits", AllVkQueryControlFlagBits, flags, false);
return skipCall;
}
static bool parameter_validation_vkCmdEndQuery(
debug_report_data* report_data,
VkQueryPool queryPool,
uint32_t query)
{
UNUSED_PARAMETER(query);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdEndQuery", "queryPool", queryPool);
return skipCall;
}
static bool parameter_validation_vkCmdResetQueryPool(
debug_report_data* report_data,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount)
{
UNUSED_PARAMETER(firstQuery);
UNUSED_PARAMETER(queryCount);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdResetQueryPool", "queryPool", queryPool);
return skipCall;
}
static bool parameter_validation_vkCmdWriteTimestamp(
debug_report_data* report_data,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t query)
{
UNUSED_PARAMETER(pipelineStage);
UNUSED_PARAMETER(query);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdWriteTimestamp", "queryPool", queryPool);
return skipCall;
}
static bool parameter_validation_vkCmdCopyQueryPoolResults(
debug_report_data* report_data,
VkQueryPool queryPool,
uint32_t firstQuery,
uint32_t queryCount,
VkBuffer dstBuffer,
VkDeviceSize dstOffset,
VkDeviceSize stride,
VkQueryResultFlags flags)
{
UNUSED_PARAMETER(firstQuery);
UNUSED_PARAMETER(queryCount);
UNUSED_PARAMETER(dstOffset);
UNUSED_PARAMETER(stride);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdCopyQueryPoolResults", "queryPool", queryPool);
skipCall |= validate_required_handle(report_data, "vkCmdCopyQueryPoolResults", "dstBuffer", dstBuffer);
skipCall |= validate_flags(report_data, "vkCmdCopyQueryPoolResults", "flags", "VkQueryResultFlagBits", AllVkQueryResultFlagBits, flags, false);
return skipCall;
}
static bool parameter_validation_vkCmdPushConstants(
debug_report_data* report_data,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
uint32_t offset,
uint32_t size,
const void* pValues)
{
UNUSED_PARAMETER(offset);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCmdPushConstants", "layout", layout);
skipCall |= validate_flags(report_data, "vkCmdPushConstants", "stageFlags", "VkShaderStageFlagBits", AllVkShaderStageFlagBits, stageFlags, true);
skipCall |= validate_array(report_data, "vkCmdPushConstants", "size", "pValues", size, pValues, true, true);
return skipCall;
}
static bool parameter_validation_vkCmdBeginRenderPass(
debug_report_data* report_data,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkSubpassContents contents)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCmdBeginRenderPass", "pRenderPassBegin", "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO", pRenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, true);
if (pRenderPassBegin != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCmdBeginRenderPass", "pRenderPassBegin->pNext", NULL, pRenderPassBegin->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_required_handle(report_data, "vkCmdBeginRenderPass", "pRenderPassBegin->renderPass", pRenderPassBegin->renderPass);
skipCall |= validate_required_handle(report_data, "vkCmdBeginRenderPass", "pRenderPassBegin->framebuffer", pRenderPassBegin->framebuffer);
skipCall |= validate_array(report_data, "vkCmdBeginRenderPass", "pRenderPassBegin->clearValueCount", "pRenderPassBegin->pClearValues", pRenderPassBegin->clearValueCount, pRenderPassBegin->pClearValues, false, true);
}
skipCall |= validate_ranged_enum(report_data, "vkCmdBeginRenderPass", "contents", "VkSubpassContents", VK_SUBPASS_CONTENTS_BEGIN_RANGE, VK_SUBPASS_CONTENTS_END_RANGE, contents);
return skipCall;
}
static bool parameter_validation_vkCmdNextSubpass(
debug_report_data* report_data,
VkSubpassContents contents)
{
bool skipCall = false;
skipCall |= validate_ranged_enum(report_data, "vkCmdNextSubpass", "contents", "VkSubpassContents", VK_SUBPASS_CONTENTS_BEGIN_RANGE, VK_SUBPASS_CONTENTS_END_RANGE, contents);
return skipCall;
}
static bool parameter_validation_vkCmdExecuteCommands(
debug_report_data* report_data,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers)
{
bool skipCall = false;
skipCall |= validate_handle_array(report_data, "vkCmdExecuteCommands", "commandBufferCount", "pCommandBuffers", commandBufferCount, pCommandBuffers, true, true);
return skipCall;
}
const VkCompositeAlphaFlagsKHR AllVkCompositeAlphaFlagBitsKHR = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR|VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR|VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR|VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
const VkSurfaceTransformFlagsKHR AllVkSurfaceTransformFlagBitsKHR = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR|VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR|VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR|VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR|VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR|VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR|VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR|VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR|VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR;
static bool parameter_validation_vkGetPhysicalDeviceSurfaceSupportKHR(
debug_report_data* report_data,
uint32_t queueFamilyIndex,
VkSurfaceKHR surface,
VkBool32* pSupported)
{
UNUSED_PARAMETER(queueFamilyIndex);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetPhysicalDeviceSurfaceSupportKHR", "surface", surface);
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceSurfaceSupportKHR", "pSupported", pSupported);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
debug_report_data* report_data,
VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", "surface", surface);
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", "pSurfaceCapabilities", pSurfaceCapabilities);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceSurfaceFormatsKHR(
debug_report_data* report_data,
VkSurfaceKHR surface,
uint32_t* pSurfaceFormatCount,
VkSurfaceFormatKHR* pSurfaceFormats)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetPhysicalDeviceSurfaceFormatsKHR", "surface", surface);
skipCall |= validate_array(report_data, "vkGetPhysicalDeviceSurfaceFormatsKHR", "pSurfaceFormatCount", "pSurfaceFormats", pSurfaceFormatCount, pSurfaceFormats, true, false, false);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceSurfacePresentModesKHR(
debug_report_data* report_data,
VkSurfaceKHR surface,
uint32_t* pPresentModeCount,
VkPresentModeKHR* pPresentModes)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetPhysicalDeviceSurfacePresentModesKHR", "surface", surface);
skipCall |= validate_array(report_data, "vkGetPhysicalDeviceSurfacePresentModesKHR", "pPresentModeCount", "pPresentModes", pPresentModeCount, pPresentModes, true, false, false);
return skipCall;
}
static bool parameter_validation_vkCreateSwapchainKHR(
debug_report_data* report_data,
const VkSwapchainCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchain)
{
UNUSED_PARAMETER(pAllocator);
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateSwapchainKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateSwapchainKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateSwapchainKHR", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_bool32(report_data, "vkCreateSwapchainKHR", "pCreateInfo->clipped", pCreateInfo->clipped);
}
skipCall |= validate_required_pointer(report_data, "vkCreateSwapchainKHR", "pSwapchain", pSwapchain);
return skipCall;
}
static bool parameter_validation_vkGetSwapchainImagesKHR(
debug_report_data* report_data,
VkSwapchainKHR swapchain,
uint32_t* pSwapchainImageCount,
VkImage* pSwapchainImages)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetSwapchainImagesKHR", "swapchain", swapchain);
skipCall |= validate_array(report_data, "vkGetSwapchainImagesKHR", "pSwapchainImageCount", "pSwapchainImages", pSwapchainImageCount, pSwapchainImages, true, false, false);
return skipCall;
}
static bool parameter_validation_vkAcquireNextImageKHR(
debug_report_data* report_data,
VkSwapchainKHR swapchain,
uint64_t timeout,
VkSemaphore semaphore,
VkFence fence,
uint32_t* pImageIndex)
{
UNUSED_PARAMETER(timeout);
UNUSED_PARAMETER(semaphore);
UNUSED_PARAMETER(fence);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkAcquireNextImageKHR", "swapchain", swapchain);
skipCall |= validate_required_pointer(report_data, "vkAcquireNextImageKHR", "pImageIndex", pImageIndex);
return skipCall;
}
static bool parameter_validation_vkQueuePresentKHR(
debug_report_data* report_data,
const VkPresentInfoKHR* pPresentInfo)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkQueuePresentKHR", "pPresentInfo", "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR", pPresentInfo, VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, true);
if (pPresentInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkQueuePresentKHR", "pPresentInfo->pNext", NULL, pPresentInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_handle_array(report_data, "vkQueuePresentKHR", "pPresentInfo->swapchainCount", "pPresentInfo->pSwapchains", pPresentInfo->swapchainCount, pPresentInfo->pSwapchains, true, true);
skipCall |= validate_array(report_data, "vkQueuePresentKHR", "pPresentInfo->swapchainCount", "pPresentInfo->pImageIndices", pPresentInfo->swapchainCount, pPresentInfo->pImageIndices, true, true);
skipCall |= validate_array(report_data, "vkQueuePresentKHR", "pPresentInfo->swapchainCount", "pPresentInfo->pResults", pPresentInfo->swapchainCount, pPresentInfo->pResults, true, false);
}
return skipCall;
}
const VkDisplayPlaneAlphaFlagsKHR AllVkDisplayPlaneAlphaFlagBitsKHR = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR|VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR|VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR|VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR;
static bool parameter_validation_vkGetPhysicalDeviceDisplayPropertiesKHR(
debug_report_data* report_data,
uint32_t* pPropertyCount,
VkDisplayPropertiesKHR* pProperties)
{
bool skipCall = false;
skipCall |= validate_array(report_data, "vkGetPhysicalDeviceDisplayPropertiesKHR", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
debug_report_data* report_data,
uint32_t* pPropertyCount,
VkDisplayPlanePropertiesKHR* pProperties)
{
bool skipCall = false;
skipCall |= validate_array(report_data, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false);
return skipCall;
}
static bool parameter_validation_vkGetDisplayPlaneSupportedDisplaysKHR(
debug_report_data* report_data,
uint32_t planeIndex,
uint32_t* pDisplayCount,
VkDisplayKHR* pDisplays)
{
UNUSED_PARAMETER(planeIndex);
bool skipCall = false;
skipCall |= validate_array(report_data, "vkGetDisplayPlaneSupportedDisplaysKHR", "pDisplayCount", "pDisplays", pDisplayCount, pDisplays, true, false, false);
return skipCall;
}
static bool parameter_validation_vkGetDisplayModePropertiesKHR(
debug_report_data* report_data,
VkDisplayKHR display,
uint32_t* pPropertyCount,
VkDisplayModePropertiesKHR* pProperties)
{
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetDisplayModePropertiesKHR", "display", display);
skipCall |= validate_array(report_data, "vkGetDisplayModePropertiesKHR", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false);
return skipCall;
}
static bool parameter_validation_vkCreateDisplayModeKHR(
debug_report_data* report_data,
VkDisplayKHR display,
const VkDisplayModeCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDisplayModeKHR* pMode)
{
UNUSED_PARAMETER(pAllocator);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkCreateDisplayModeKHR", "display", display);
skipCall |= validate_struct_type(report_data, "vkCreateDisplayModeKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateDisplayModeKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateDisplayModeKHR", "pCreateInfo->flags", pCreateInfo->flags);
}
skipCall |= validate_required_pointer(report_data, "vkCreateDisplayModeKHR", "pMode", pMode);
return skipCall;
}
static bool parameter_validation_vkGetDisplayPlaneCapabilitiesKHR(
debug_report_data* report_data,
VkDisplayModeKHR mode,
uint32_t planeIndex,
VkDisplayPlaneCapabilitiesKHR* pCapabilities)
{
UNUSED_PARAMETER(planeIndex);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkGetDisplayPlaneCapabilitiesKHR", "mode", mode);
skipCall |= validate_required_pointer(report_data, "vkGetDisplayPlaneCapabilitiesKHR", "pCapabilities", pCapabilities);
return skipCall;
}
static bool parameter_validation_vkCreateDisplayPlaneSurfaceKHR(
debug_report_data* report_data,
const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
UNUSED_PARAMETER(pAllocator);
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_required_handle(report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->displayMode", pCreateInfo->displayMode);
}
skipCall |= validate_required_pointer(report_data, "vkCreateDisplayPlaneSurfaceKHR", "pSurface", pSurface);
return skipCall;
}
static bool parameter_validation_vkCreateSharedSwapchainsKHR(
debug_report_data* report_data,
uint32_t swapchainCount,
const VkSwapchainCreateInfoKHR* pCreateInfos,
const VkAllocationCallbacks* pAllocator,
VkSwapchainKHR* pSwapchains)
{
UNUSED_PARAMETER(pAllocator);
bool skipCall = false;
skipCall |= validate_array(report_data, "vkCreateSharedSwapchainsKHR", "swapchainCount", "pCreateInfos", swapchainCount, pCreateInfos, true, true);
skipCall |= validate_array(report_data, "vkCreateSharedSwapchainsKHR", "swapchainCount", "pSwapchains", swapchainCount, pSwapchains, true, true);
return skipCall;
}
#ifdef VK_USE_PLATFORM_XLIB_KHR
static bool parameter_validation_vkCreateXlibSurfaceKHR(
debug_report_data* report_data,
const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
UNUSED_PARAMETER(pAllocator);
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateXlibSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateXlibSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateXlibSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_required_pointer(report_data, "vkCreateXlibSurfaceKHR", "pCreateInfo->dpy", pCreateInfo->dpy);
}
skipCall |= validate_required_pointer(report_data, "vkCreateXlibSurfaceKHR", "pSurface", pSurface);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceXlibPresentationSupportKHR(
debug_report_data* report_data,
uint32_t queueFamilyIndex,
Display* dpy,
VisualID visualID)
{
UNUSED_PARAMETER(queueFamilyIndex);
UNUSED_PARAMETER(visualID);
bool skipCall = false;
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceXlibPresentationSupportKHR", "dpy", dpy);
return skipCall;
}
#endif /* VK_USE_PLATFORM_XLIB_KHR */
#ifdef VK_USE_PLATFORM_XCB_KHR
static bool parameter_validation_vkCreateXcbSurfaceKHR(
debug_report_data* report_data,
const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
UNUSED_PARAMETER(pAllocator);
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateXcbSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateXcbSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateXcbSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_required_pointer(report_data, "vkCreateXcbSurfaceKHR", "pCreateInfo->connection", pCreateInfo->connection);
}
skipCall |= validate_required_pointer(report_data, "vkCreateXcbSurfaceKHR", "pSurface", pSurface);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceXcbPresentationSupportKHR(
debug_report_data* report_data,
uint32_t queueFamilyIndex,
xcb_connection_t* connection,
xcb_visualid_t visual_id)
{
UNUSED_PARAMETER(queueFamilyIndex);
UNUSED_PARAMETER(visual_id);
bool skipCall = false;
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceXcbPresentationSupportKHR", "connection", connection);
return skipCall;
}
#endif /* VK_USE_PLATFORM_XCB_KHR */
#ifdef VK_USE_PLATFORM_WAYLAND_KHR
static bool parameter_validation_vkCreateWaylandSurfaceKHR(
debug_report_data* report_data,
const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
UNUSED_PARAMETER(pAllocator);
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_required_pointer(report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo->display", pCreateInfo->display);
skipCall |= validate_required_pointer(report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo->surface", pCreateInfo->surface);
}
skipCall |= validate_required_pointer(report_data, "vkCreateWaylandSurfaceKHR", "pSurface", pSurface);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceWaylandPresentationSupportKHR(
debug_report_data* report_data,
uint32_t queueFamilyIndex,
struct wl_display* display)
{
UNUSED_PARAMETER(queueFamilyIndex);
bool skipCall = false;
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceWaylandPresentationSupportKHR", "display", display);
return skipCall;
}
#endif /* VK_USE_PLATFORM_WAYLAND_KHR */
#ifdef VK_USE_PLATFORM_MIR_KHR
static bool parameter_validation_vkCreateMirSurfaceKHR(
debug_report_data* report_data,
const VkMirSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
UNUSED_PARAMETER(pAllocator);
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateMirSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateMirSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateMirSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_required_pointer(report_data, "vkCreateMirSurfaceKHR", "pCreateInfo->connection", pCreateInfo->connection);
skipCall |= validate_required_pointer(report_data, "vkCreateMirSurfaceKHR", "pCreateInfo->mirSurface", pCreateInfo->mirSurface);
}
skipCall |= validate_required_pointer(report_data, "vkCreateMirSurfaceKHR", "pSurface", pSurface);
return skipCall;
}
static bool parameter_validation_vkGetPhysicalDeviceMirPresentationSupportKHR(
debug_report_data* report_data,
uint32_t queueFamilyIndex,
MirConnection* connection)
{
UNUSED_PARAMETER(queueFamilyIndex);
bool skipCall = false;
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceMirPresentationSupportKHR", "connection", connection);
return skipCall;
}
#endif /* VK_USE_PLATFORM_MIR_KHR */
#ifdef VK_USE_PLATFORM_ANDROID_KHR
static bool parameter_validation_vkCreateAndroidSurfaceKHR(
debug_report_data* report_data,
const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
UNUSED_PARAMETER(pAllocator);
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateAndroidSurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateAndroidSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateAndroidSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags);
skipCall |= validate_required_pointer(report_data, "vkCreateAndroidSurfaceKHR", "pCreateInfo->window", pCreateInfo->window);
}
skipCall |= validate_required_pointer(report_data, "vkCreateAndroidSurfaceKHR", "pSurface", pSurface);
return skipCall;
}
#endif /* VK_USE_PLATFORM_ANDROID_KHR */
#ifdef VK_USE_PLATFORM_WIN32_KHR
static bool parameter_validation_vkCreateWin32SurfaceKHR(
debug_report_data* report_data,
const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
UNUSED_PARAMETER(pAllocator);
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCreateWin32SurfaceKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, true);
if (pCreateInfo != NULL)
{
skipCall |= validate_struct_pnext(report_data, "vkCreateWin32SurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion);
skipCall |= validate_reserved_flags(report_data, "vkCreateWin32SurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags);
}
skipCall |= validate_required_pointer(report_data, "vkCreateWin32SurfaceKHR", "pSurface", pSurface);
return skipCall;
}
#endif /* VK_USE_PLATFORM_WIN32_KHR */
const VkDebugReportFlagsEXT AllVkDebugReportFlagBitsEXT = VK_DEBUG_REPORT_INFORMATION_BIT_EXT|VK_DEBUG_REPORT_WARNING_BIT_EXT|VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT|VK_DEBUG_REPORT_ERROR_BIT_EXT|VK_DEBUG_REPORT_DEBUG_BIT_EXT;
static bool parameter_validation_vkDestroyDebugReportCallbackEXT(
debug_report_data* report_data,
VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks* pAllocator)
{
UNUSED_PARAMETER(pAllocator);
bool skipCall = false;
skipCall |= validate_required_handle(report_data, "vkDestroyDebugReportCallbackEXT", "callback", callback);
return skipCall;
}
static bool parameter_validation_vkDebugMarkerSetObjectTagEXT(
debug_report_data* report_data,
VkDebugMarkerObjectTagInfoEXT* pTagInfo)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkDebugMarkerSetObjectTagEXT", "pTagInfo", "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT", pTagInfo, VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, true);
return skipCall;
}
static bool parameter_validation_vkDebugMarkerSetObjectNameEXT(
debug_report_data* report_data,
VkDebugMarkerObjectNameInfoEXT* pNameInfo)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkDebugMarkerSetObjectNameEXT", "pNameInfo", "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT", pNameInfo, VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT, true);
return skipCall;
}
static bool parameter_validation_vkCmdDebugMarkerBeginEXT(
debug_report_data* report_data,
VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCmdDebugMarkerBeginEXT", "pMarkerInfo", "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT", pMarkerInfo, VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, true);
return skipCall;
}
static bool parameter_validation_vkCmdDebugMarkerInsertEXT(
debug_report_data* report_data,
VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
bool skipCall = false;
skipCall |= validate_struct_type(report_data, "vkCmdDebugMarkerInsertEXT", "pMarkerInfo", "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT", pMarkerInfo, VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, true);
return skipCall;
}
const VkExternalMemoryFeatureFlagsNV AllVkExternalMemoryFeatureFlagBitsNV = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV;
const VkExternalMemoryHandleTypeFlagsNV AllVkExternalMemoryHandleTypeFlagBitsNV = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV|VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV|VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV;
static bool parameter_validation_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
debug_report_data* report_data,
VkFormat format,
VkImageType type,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
VkExternalMemoryHandleTypeFlagsNV externalHandleType,
VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
{
UNUSED_PARAMETER(format);
UNUSED_PARAMETER(type);
UNUSED_PARAMETER(tiling);
UNUSED_PARAMETER(usage);
UNUSED_PARAMETER(flags);
bool skipCall = false;
skipCall |= validate_flags(report_data, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "externalHandleType", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, externalHandleType, true);
skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "pExternalImageFormatProperties", pExternalImageFormatProperties);
return skipCall;
}
#ifdef VK_USE_PLATFORM_WIN32_KHR
static bool parameter_validation_vkGetMemoryWin32HandleNV(
debug_report_data* report_data,
VkDeviceMemory memory,
VkExternalMemoryHandleTypeFlagsNV handleType,
HANDLE* pHandle)
{
UNUSED_PARAMETER(memory);
UNUSED_PARAMETER(handleType);
bool skipCall = false;
skipCall |= validate_required_pointer(report_data, "vkGetMemoryWin32HandleNV", "pHandle", pHandle);
return skipCall;
}
#endif /* VK_USE_PLATFORM_WIN32_KHR */
#ifdef VK_USE_PLATFORM_WIN32_KHR
#endif /* VK_USE_PLATFORM_WIN32_KHR */
} // namespace parameter_validation
#endif