1 /* 2 ** Copyright (c) 2015-2016 The Khronos Group Inc. 3 ** 4 ** Licensed under the Apache License, Version 2.0 (the "License"); 5 ** you may not use this file except in compliance with the License. 6 ** You may obtain a copy of the License at 7 ** 8 ** http://www.apache.org/licenses/LICENSE-2.0 9 ** 10 ** Unless required by applicable law or agreed to in writing, software 11 ** distributed under the License is distributed on an "AS IS" BASIS, 12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 ** See the License for the specific language governing permissions and 14 ** limitations under the License. 15 */ 16 17 /* 18 ** This header is generated from the Khronos Vulkan XML API Registry. 19 ** 20 */ 21 22 #ifndef PARAMETER_VALIDATION_H 23 #define PARAMETER_VALIDATION_H 1 24 25 #include <string> 26 27 #include "vulkan/vulkan.h" 28 #include "vk_layer_extension_utils.h" 29 #include "parameter_validation_utils.h" 30 31 #ifndef UNUSED_PARAMETER 32 #define UNUSED_PARAMETER(x) (void)(x) 33 #endif // UNUSED_PARAMETER 34 35 namespace parameter_validation { 36 37 const uint32_t GeneratedHeaderVersion = 31; 38 39 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; 40 const VkAttachmentDescriptionFlags AllVkAttachmentDescriptionFlagBits = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT; 41 const VkBufferCreateFlags AllVkBufferCreateFlagBits = VK_BUFFER_CREATE_SPARSE_BINDING_BIT|VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT|VK_BUFFER_CREATE_SPARSE_ALIASED_BIT; 42 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; 43 const VkColorComponentFlags AllVkColorComponentFlagBits = VK_COLOR_COMPONENT_R_BIT|VK_COLOR_COMPONENT_G_BIT|VK_COLOR_COMPONENT_B_BIT|VK_COLOR_COMPONENT_A_BIT; 44 const VkCommandBufferResetFlags AllVkCommandBufferResetFlagBits = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT; 45 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; 46 const VkCommandPoolCreateFlags AllVkCommandPoolCreateFlagBits = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT|VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; 47 const VkCommandPoolResetFlags AllVkCommandPoolResetFlagBits = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT; 48 const VkCullModeFlags AllVkCullModeFlagBits = VK_CULL_MODE_NONE|VK_CULL_MODE_FRONT_BIT|VK_CULL_MODE_BACK_BIT|VK_CULL_MODE_FRONT_AND_BACK; 49 const VkDependencyFlags AllVkDependencyFlagBits = VK_DEPENDENCY_BY_REGION_BIT; 50 const VkDescriptorPoolCreateFlags AllVkDescriptorPoolCreateFlagBits = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; 51 const VkFenceCreateFlags AllVkFenceCreateFlagBits = VK_FENCE_CREATE_SIGNALED_BIT; 52 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; 53 const VkImageAspectFlags AllVkImageAspectFlagBits = VK_IMAGE_ASPECT_COLOR_BIT|VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT|VK_IMAGE_ASPECT_METADATA_BIT; 54 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; 55 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; 56 const VkMemoryHeapFlags AllVkMemoryHeapFlagBits = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; 57 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; 58 const VkPipelineCreateFlags AllVkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT|VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT|VK_PIPELINE_CREATE_DERIVATIVE_BIT; 59 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; 60 const VkQueryControlFlags AllVkQueryControlFlagBits = VK_QUERY_CONTROL_PRECISE_BIT; 61 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; 62 const VkQueryResultFlags AllVkQueryResultFlagBits = VK_QUERY_RESULT_64_BIT|VK_QUERY_RESULT_WAIT_BIT|VK_QUERY_RESULT_WITH_AVAILABILITY_BIT|VK_QUERY_RESULT_PARTIAL_BIT; 63 const VkQueueFlags AllVkQueueFlagBits = VK_QUEUE_GRAPHICS_BIT|VK_QUEUE_COMPUTE_BIT|VK_QUEUE_TRANSFER_BIT|VK_QUEUE_SPARSE_BINDING_BIT; 64 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; 65 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; 66 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; 67 const VkSparseMemoryBindFlags AllVkSparseMemoryBindFlagBits = VK_SPARSE_MEMORY_BIND_METADATA_BIT; 68 const VkStencilFaceFlags AllVkStencilFaceFlagBits = VK_STENCIL_FACE_FRONT_BIT|VK_STENCIL_FACE_BACK_BIT|VK_STENCIL_FRONT_AND_BACK; 69 70 static bool parameter_validation_vkCreateInstance( 71 debug_report_data* report_data, 72 const VkInstanceCreateInfo* pCreateInfo, 73 const VkAllocationCallbacks* pAllocator, 74 VkInstance* pInstance) 75 { 76 bool skipCall = false; 77 78 skipCall |= validate_struct_type(report_data, "vkCreateInstance", "pCreateInfo", "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, true); 79 80 if (pCreateInfo != NULL) 81 { 82 skipCall |= validate_reserved_flags(report_data, "vkCreateInstance", "pCreateInfo->flags", pCreateInfo->flags); 83 84 skipCall |= validate_struct_type(report_data, "vkCreateInstance", "pCreateInfo->pApplicationInfo", "VK_STRUCTURE_TYPE_APPLICATION_INFO", pCreateInfo->pApplicationInfo, VK_STRUCTURE_TYPE_APPLICATION_INFO, false); 85 86 if (pCreateInfo->pApplicationInfo != NULL) 87 { 88 skipCall |= validate_struct_pnext(report_data, "vkCreateInstance", "pCreateInfo->pApplicationInfo->pNext", NULL, pCreateInfo->pApplicationInfo->pNext, 0, NULL, GeneratedHeaderVersion); 89 } 90 91 skipCall |= validate_string_array(report_data, "vkCreateInstance", "pCreateInfo->enabledLayerCount", "pCreateInfo->ppEnabledLayerNames", pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames, false, true); 92 93 skipCall |= validate_string_array(report_data, "vkCreateInstance", "pCreateInfo->enabledExtensionCount", "pCreateInfo->ppEnabledExtensionNames", pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames, false, true); 94 } 95 96 if (pAllocator != NULL) 97 { 98 skipCall |= validate_required_pointer(report_data, "vkCreateInstance", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 99 100 skipCall |= validate_required_pointer(report_data, "vkCreateInstance", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 101 102 skipCall |= validate_required_pointer(report_data, "vkCreateInstance", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 103 } 104 105 skipCall |= validate_required_pointer(report_data, "vkCreateInstance", "pInstance", pInstance); 106 107 return skipCall; 108 } 109 110 static bool parameter_validation_vkDestroyInstance( 111 debug_report_data* report_data, 112 const VkAllocationCallbacks* pAllocator) 113 { 114 bool skipCall = false; 115 116 if (pAllocator != NULL) 117 { 118 skipCall |= validate_required_pointer(report_data, "vkDestroyInstance", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 119 120 skipCall |= validate_required_pointer(report_data, "vkDestroyInstance", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 121 122 skipCall |= validate_required_pointer(report_data, "vkDestroyInstance", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 123 } 124 125 return skipCall; 126 } 127 128 static bool parameter_validation_vkEnumeratePhysicalDevices( 129 debug_report_data* report_data, 130 uint32_t* pPhysicalDeviceCount, 131 VkPhysicalDevice* pPhysicalDevices) 132 { 133 bool skipCall = false; 134 135 skipCall |= validate_array(report_data, "vkEnumeratePhysicalDevices", "pPhysicalDeviceCount", "pPhysicalDevices", pPhysicalDeviceCount, pPhysicalDevices, true, false, false); 136 137 return skipCall; 138 } 139 140 static bool parameter_validation_vkGetPhysicalDeviceFeatures( 141 debug_report_data* report_data, 142 VkPhysicalDeviceFeatures* pFeatures) 143 { 144 bool skipCall = false; 145 146 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceFeatures", "pFeatures", pFeatures); 147 148 return skipCall; 149 } 150 151 static bool parameter_validation_vkGetPhysicalDeviceFormatProperties( 152 debug_report_data* report_data, 153 VkFormat format, 154 VkFormatProperties* pFormatProperties) 155 { 156 bool skipCall = false; 157 158 skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceFormatProperties", "format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, format); 159 160 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceFormatProperties", "pFormatProperties", pFormatProperties); 161 162 return skipCall; 163 } 164 165 static bool parameter_validation_vkGetPhysicalDeviceImageFormatProperties( 166 debug_report_data* report_data, 167 VkFormat format, 168 VkImageType type, 169 VkImageTiling tiling, 170 VkImageUsageFlags usage, 171 VkImageCreateFlags flags, 172 VkImageFormatProperties* pImageFormatProperties) 173 { 174 bool skipCall = false; 175 176 skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceImageFormatProperties", "format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, format); 177 178 skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceImageFormatProperties", "type", "VkImageType", VK_IMAGE_TYPE_BEGIN_RANGE, VK_IMAGE_TYPE_END_RANGE, type); 179 180 skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceImageFormatProperties", "tiling", "VkImageTiling", VK_IMAGE_TILING_BEGIN_RANGE, VK_IMAGE_TILING_END_RANGE, tiling); 181 182 skipCall |= validate_flags(report_data, "vkGetPhysicalDeviceImageFormatProperties", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, true); 183 184 skipCall |= validate_flags(report_data, "vkGetPhysicalDeviceImageFormatProperties", "flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, flags, false); 185 186 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceImageFormatProperties", "pImageFormatProperties", pImageFormatProperties); 187 188 return skipCall; 189 } 190 191 static bool parameter_validation_vkGetPhysicalDeviceProperties( 192 debug_report_data* report_data, 193 VkPhysicalDeviceProperties* pProperties) 194 { 195 bool skipCall = false; 196 197 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceProperties", "pProperties", pProperties); 198 199 return skipCall; 200 } 201 202 static bool parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties( 203 debug_report_data* report_data, 204 uint32_t* pQueueFamilyPropertyCount, 205 VkQueueFamilyProperties* pQueueFamilyProperties) 206 { 207 bool skipCall = false; 208 209 skipCall |= validate_array(report_data, "vkGetPhysicalDeviceQueueFamilyProperties", "pQueueFamilyPropertyCount", "pQueueFamilyProperties", pQueueFamilyPropertyCount, pQueueFamilyProperties, true, false, false); 210 211 return skipCall; 212 } 213 214 static bool parameter_validation_vkGetPhysicalDeviceMemoryProperties( 215 debug_report_data* report_data, 216 VkPhysicalDeviceMemoryProperties* pMemoryProperties) 217 { 218 bool skipCall = false; 219 220 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceMemoryProperties", "pMemoryProperties", pMemoryProperties); 221 222 return skipCall; 223 } 224 225 static bool parameter_validation_vkCreateDevice( 226 debug_report_data* report_data, 227 const VkDeviceCreateInfo* pCreateInfo, 228 const VkAllocationCallbacks* pAllocator, 229 VkDevice* pDevice) 230 { 231 bool skipCall = false; 232 233 skipCall |= validate_struct_type(report_data, "vkCreateDevice", "pCreateInfo", "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, true); 234 235 if (pCreateInfo != NULL) 236 { 237 skipCall |= validate_reserved_flags(report_data, "vkCreateDevice", "pCreateInfo->flags", pCreateInfo->flags); 238 239 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); 240 241 if (pCreateInfo->pQueueCreateInfos != NULL) 242 { 243 for (uint32_t queueCreateInfoIndex = 0; queueCreateInfoIndex < pCreateInfo->queueCreateInfoCount; ++queueCreateInfoIndex) 244 { 245 skipCall |= validate_struct_pnext(report_data, "vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].pNext", ParameterName::IndexVector{ queueCreateInfoIndex }), NULL, pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].pNext, 0, NULL, GeneratedHeaderVersion); 246 247 skipCall |= validate_reserved_flags(report_data, "vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].flags", ParameterName::IndexVector{ queueCreateInfoIndex }), pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].flags); 248 249 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); 250 } 251 } 252 253 skipCall |= validate_string_array(report_data, "vkCreateDevice", "pCreateInfo->enabledLayerCount", "pCreateInfo->ppEnabledLayerNames", pCreateInfo->enabledLayerCount, pCreateInfo->ppEnabledLayerNames, false, true); 254 255 skipCall |= validate_string_array(report_data, "vkCreateDevice", "pCreateInfo->enabledExtensionCount", "pCreateInfo->ppEnabledExtensionNames", pCreateInfo->enabledExtensionCount, pCreateInfo->ppEnabledExtensionNames, false, true); 256 257 if (pCreateInfo->pEnabledFeatures != NULL) 258 { 259 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->robustBufferAccess", pCreateInfo->pEnabledFeatures->robustBufferAccess); 260 261 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->fullDrawIndexUint32", pCreateInfo->pEnabledFeatures->fullDrawIndexUint32); 262 263 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->imageCubeArray", pCreateInfo->pEnabledFeatures->imageCubeArray); 264 265 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->independentBlend", pCreateInfo->pEnabledFeatures->independentBlend); 266 267 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->geometryShader", pCreateInfo->pEnabledFeatures->geometryShader); 268 269 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->tessellationShader", pCreateInfo->pEnabledFeatures->tessellationShader); 270 271 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sampleRateShading", pCreateInfo->pEnabledFeatures->sampleRateShading); 272 273 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->dualSrcBlend", pCreateInfo->pEnabledFeatures->dualSrcBlend); 274 275 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->logicOp", pCreateInfo->pEnabledFeatures->logicOp); 276 277 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->multiDrawIndirect", pCreateInfo->pEnabledFeatures->multiDrawIndirect); 278 279 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->drawIndirectFirstInstance", pCreateInfo->pEnabledFeatures->drawIndirectFirstInstance); 280 281 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->depthClamp", pCreateInfo->pEnabledFeatures->depthClamp); 282 283 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->depthBiasClamp", pCreateInfo->pEnabledFeatures->depthBiasClamp); 284 285 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->fillModeNonSolid", pCreateInfo->pEnabledFeatures->fillModeNonSolid); 286 287 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->depthBounds", pCreateInfo->pEnabledFeatures->depthBounds); 288 289 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->wideLines", pCreateInfo->pEnabledFeatures->wideLines); 290 291 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->largePoints", pCreateInfo->pEnabledFeatures->largePoints); 292 293 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->alphaToOne", pCreateInfo->pEnabledFeatures->alphaToOne); 294 295 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->multiViewport", pCreateInfo->pEnabledFeatures->multiViewport); 296 297 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->samplerAnisotropy", pCreateInfo->pEnabledFeatures->samplerAnisotropy); 298 299 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->textureCompressionETC2", pCreateInfo->pEnabledFeatures->textureCompressionETC2); 300 301 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->textureCompressionASTC_LDR", pCreateInfo->pEnabledFeatures->textureCompressionASTC_LDR); 302 303 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->textureCompressionBC", pCreateInfo->pEnabledFeatures->textureCompressionBC); 304 305 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->occlusionQueryPrecise", pCreateInfo->pEnabledFeatures->occlusionQueryPrecise); 306 307 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->pipelineStatisticsQuery", pCreateInfo->pEnabledFeatures->pipelineStatisticsQuery); 308 309 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->vertexPipelineStoresAndAtomics", pCreateInfo->pEnabledFeatures->vertexPipelineStoresAndAtomics); 310 311 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->fragmentStoresAndAtomics", pCreateInfo->pEnabledFeatures->fragmentStoresAndAtomics); 312 313 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderTessellationAndGeometryPointSize", pCreateInfo->pEnabledFeatures->shaderTessellationAndGeometryPointSize); 314 315 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderImageGatherExtended", pCreateInfo->pEnabledFeatures->shaderImageGatherExtended); 316 317 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageExtendedFormats", pCreateInfo->pEnabledFeatures->shaderStorageImageExtendedFormats); 318 319 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageMultisample", pCreateInfo->pEnabledFeatures->shaderStorageImageMultisample); 320 321 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageReadWithoutFormat", pCreateInfo->pEnabledFeatures->shaderStorageImageReadWithoutFormat); 322 323 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageWriteWithoutFormat", pCreateInfo->pEnabledFeatures->shaderStorageImageWriteWithoutFormat); 324 325 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderUniformBufferArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderUniformBufferArrayDynamicIndexing); 326 327 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderSampledImageArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderSampledImageArrayDynamicIndexing); 328 329 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageBufferArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderStorageBufferArrayDynamicIndexing); 330 331 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderStorageImageArrayDynamicIndexing", pCreateInfo->pEnabledFeatures->shaderStorageImageArrayDynamicIndexing); 332 333 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderClipDistance", pCreateInfo->pEnabledFeatures->shaderClipDistance); 334 335 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderCullDistance", pCreateInfo->pEnabledFeatures->shaderCullDistance); 336 337 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderFloat64", pCreateInfo->pEnabledFeatures->shaderFloat64); 338 339 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderInt64", pCreateInfo->pEnabledFeatures->shaderInt64); 340 341 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderInt16", pCreateInfo->pEnabledFeatures->shaderInt16); 342 343 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderResourceResidency", pCreateInfo->pEnabledFeatures->shaderResourceResidency); 344 345 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->shaderResourceMinLod", pCreateInfo->pEnabledFeatures->shaderResourceMinLod); 346 347 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseBinding", pCreateInfo->pEnabledFeatures->sparseBinding); 348 349 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyBuffer", pCreateInfo->pEnabledFeatures->sparseResidencyBuffer); 350 351 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyImage2D", pCreateInfo->pEnabledFeatures->sparseResidencyImage2D); 352 353 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyImage3D", pCreateInfo->pEnabledFeatures->sparseResidencyImage3D); 354 355 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency2Samples", pCreateInfo->pEnabledFeatures->sparseResidency2Samples); 356 357 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency4Samples", pCreateInfo->pEnabledFeatures->sparseResidency4Samples); 358 359 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency8Samples", pCreateInfo->pEnabledFeatures->sparseResidency8Samples); 360 361 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidency16Samples", pCreateInfo->pEnabledFeatures->sparseResidency16Samples); 362 363 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->sparseResidencyAliased", pCreateInfo->pEnabledFeatures->sparseResidencyAliased); 364 365 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->variableMultisampleRate", pCreateInfo->pEnabledFeatures->variableMultisampleRate); 366 367 skipCall |= validate_bool32(report_data, "vkCreateDevice", "pCreateInfo->pEnabledFeatures->inheritedQueries", pCreateInfo->pEnabledFeatures->inheritedQueries); 368 } 369 } 370 371 if (pAllocator != NULL) 372 { 373 skipCall |= validate_required_pointer(report_data, "vkCreateDevice", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 374 375 skipCall |= validate_required_pointer(report_data, "vkCreateDevice", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 376 377 skipCall |= validate_required_pointer(report_data, "vkCreateDevice", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 378 } 379 380 skipCall |= validate_required_pointer(report_data, "vkCreateDevice", "pDevice", pDevice); 381 382 return skipCall; 383 } 384 385 static bool parameter_validation_vkDestroyDevice( 386 debug_report_data* report_data, 387 const VkAllocationCallbacks* pAllocator) 388 { 389 bool skipCall = false; 390 391 if (pAllocator != NULL) 392 { 393 skipCall |= validate_required_pointer(report_data, "vkDestroyDevice", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 394 395 skipCall |= validate_required_pointer(report_data, "vkDestroyDevice", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 396 397 skipCall |= validate_required_pointer(report_data, "vkDestroyDevice", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 398 } 399 400 return skipCall; 401 } 402 403 static bool parameter_validation_vkEnumerateInstanceExtensionProperties( 404 debug_report_data* report_data, 405 uint32_t* pPropertyCount, 406 VkExtensionProperties* pProperties) 407 { 408 bool skipCall = false; 409 410 skipCall |= validate_array(report_data, "vkEnumerateInstanceExtensionProperties", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false); 411 412 return skipCall; 413 } 414 415 static bool parameter_validation_vkEnumerateDeviceExtensionProperties( 416 debug_report_data* report_data, 417 const char* pLayerName, 418 uint32_t* pPropertyCount, 419 VkExtensionProperties* pProperties) 420 { 421 UNUSED_PARAMETER(pLayerName); 422 423 bool skipCall = false; 424 425 skipCall |= validate_array(report_data, "vkEnumerateDeviceExtensionProperties", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false); 426 427 return skipCall; 428 } 429 430 static bool parameter_validation_vkGetDeviceQueue( 431 debug_report_data* report_data, 432 uint32_t queueFamilyIndex, 433 uint32_t queueIndex, 434 VkQueue* pQueue) 435 { 436 UNUSED_PARAMETER(queueFamilyIndex); 437 UNUSED_PARAMETER(queueIndex); 438 439 bool skipCall = false; 440 441 skipCall |= validate_required_pointer(report_data, "vkGetDeviceQueue", "pQueue", pQueue); 442 443 return skipCall; 444 } 445 446 static bool parameter_validation_vkQueueSubmit( 447 debug_report_data* report_data, 448 uint32_t submitCount, 449 const VkSubmitInfo* pSubmits, 450 VkFence fence) 451 { 452 UNUSED_PARAMETER(fence); 453 454 bool skipCall = false; 455 456 skipCall |= validate_struct_type_array(report_data, "vkQueueSubmit", "submitCount", "pSubmits", "VK_STRUCTURE_TYPE_SUBMIT_INFO", submitCount, pSubmits, VK_STRUCTURE_TYPE_SUBMIT_INFO, false, true); 457 458 if (pSubmits != NULL) 459 { 460 for (uint32_t submitIndex = 0; submitIndex < submitCount; ++submitIndex) 461 { 462 skipCall |= validate_struct_pnext(report_data, "vkQueueSubmit", ParameterName("pSubmits[%i].pNext", ParameterName::IndexVector{ submitIndex }), NULL, pSubmits[submitIndex].pNext, 0, NULL, GeneratedHeaderVersion); 463 464 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); 465 466 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); 467 468 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); 469 470 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); 471 } 472 } 473 474 return skipCall; 475 } 476 477 static bool parameter_validation_vkAllocateMemory( 478 debug_report_data* report_data, 479 const VkMemoryAllocateInfo* pAllocateInfo, 480 const VkAllocationCallbacks* pAllocator, 481 VkDeviceMemory* pMemory) 482 { 483 bool skipCall = false; 484 485 skipCall |= validate_struct_type(report_data, "vkAllocateMemory", "pAllocateInfo", "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, true); 486 487 if (pAllocateInfo != NULL) 488 { 489 const VkStructureType allowedStructs[] = {VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV}; 490 491 skipCall |= validate_struct_pnext(report_data, "vkAllocateMemory", "pAllocateInfo->pNext", "VkDedicatedAllocationMemoryAllocateInfoNV", pAllocateInfo->pNext, ARRAY_SIZE(allowedStructs), allowedStructs, GeneratedHeaderVersion); 492 } 493 494 if (pAllocator != NULL) 495 { 496 skipCall |= validate_required_pointer(report_data, "vkAllocateMemory", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 497 498 skipCall |= validate_required_pointer(report_data, "vkAllocateMemory", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 499 500 skipCall |= validate_required_pointer(report_data, "vkAllocateMemory", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 501 } 502 503 skipCall |= validate_required_pointer(report_data, "vkAllocateMemory", "pMemory", pMemory); 504 505 return skipCall; 506 } 507 508 static bool parameter_validation_vkFreeMemory( 509 debug_report_data* report_data, 510 VkDeviceMemory memory, 511 const VkAllocationCallbacks* pAllocator) 512 { 513 UNUSED_PARAMETER(memory); 514 515 bool skipCall = false; 516 517 if (pAllocator != NULL) 518 { 519 skipCall |= validate_required_pointer(report_data, "vkFreeMemory", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 520 521 skipCall |= validate_required_pointer(report_data, "vkFreeMemory", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 522 523 skipCall |= validate_required_pointer(report_data, "vkFreeMemory", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 524 } 525 526 return skipCall; 527 } 528 529 static bool parameter_validation_vkMapMemory( 530 debug_report_data* report_data, 531 VkDeviceMemory memory, 532 VkDeviceSize offset, 533 VkDeviceSize size, 534 VkMemoryMapFlags flags, 535 void** ppData) 536 { 537 UNUSED_PARAMETER(offset); 538 UNUSED_PARAMETER(size); 539 540 bool skipCall = false; 541 542 skipCall |= validate_required_handle(report_data, "vkMapMemory", "memory", memory); 543 544 skipCall |= validate_reserved_flags(report_data, "vkMapMemory", "flags", flags); 545 546 skipCall |= validate_required_pointer(report_data, "vkMapMemory", "ppData", ppData); 547 548 return skipCall; 549 } 550 551 static bool parameter_validation_vkUnmapMemory( 552 debug_report_data* report_data, 553 VkDeviceMemory memory) 554 { 555 bool skipCall = false; 556 557 skipCall |= validate_required_handle(report_data, "vkUnmapMemory", "memory", memory); 558 559 return skipCall; 560 } 561 562 static bool parameter_validation_vkFlushMappedMemoryRanges( 563 debug_report_data* report_data, 564 uint32_t memoryRangeCount, 565 const VkMappedMemoryRange* pMemoryRanges) 566 { 567 bool skipCall = false; 568 569 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); 570 571 if (pMemoryRanges != NULL) 572 { 573 for (uint32_t memoryRangeIndex = 0; memoryRangeIndex < memoryRangeCount; ++memoryRangeIndex) 574 { 575 skipCall |= validate_struct_pnext(report_data, "vkFlushMappedMemoryRanges", ParameterName("pMemoryRanges[%i].pNext", ParameterName::IndexVector{ memoryRangeIndex }), NULL, pMemoryRanges[memoryRangeIndex].pNext, 0, NULL, GeneratedHeaderVersion); 576 577 skipCall |= validate_required_handle(report_data, "vkFlushMappedMemoryRanges", ParameterName("pMemoryRanges[%i].memory", ParameterName::IndexVector{ memoryRangeIndex }), pMemoryRanges[memoryRangeIndex].memory); 578 } 579 } 580 581 return skipCall; 582 } 583 584 static bool parameter_validation_vkInvalidateMappedMemoryRanges( 585 debug_report_data* report_data, 586 uint32_t memoryRangeCount, 587 const VkMappedMemoryRange* pMemoryRanges) 588 { 589 bool skipCall = false; 590 591 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); 592 593 if (pMemoryRanges != NULL) 594 { 595 for (uint32_t memoryRangeIndex = 0; memoryRangeIndex < memoryRangeCount; ++memoryRangeIndex) 596 { 597 skipCall |= validate_struct_pnext(report_data, "vkInvalidateMappedMemoryRanges", ParameterName("pMemoryRanges[%i].pNext", ParameterName::IndexVector{ memoryRangeIndex }), NULL, pMemoryRanges[memoryRangeIndex].pNext, 0, NULL, GeneratedHeaderVersion); 598 599 skipCall |= validate_required_handle(report_data, "vkInvalidateMappedMemoryRanges", ParameterName("pMemoryRanges[%i].memory", ParameterName::IndexVector{ memoryRangeIndex }), pMemoryRanges[memoryRangeIndex].memory); 600 } 601 } 602 603 return skipCall; 604 } 605 606 static bool parameter_validation_vkGetDeviceMemoryCommitment( 607 debug_report_data* report_data, 608 VkDeviceMemory memory, 609 VkDeviceSize* pCommittedMemoryInBytes) 610 { 611 bool skipCall = false; 612 613 skipCall |= validate_required_handle(report_data, "vkGetDeviceMemoryCommitment", "memory", memory); 614 615 skipCall |= validate_required_pointer(report_data, "vkGetDeviceMemoryCommitment", "pCommittedMemoryInBytes", pCommittedMemoryInBytes); 616 617 return skipCall; 618 } 619 620 static bool parameter_validation_vkBindBufferMemory( 621 debug_report_data* report_data, 622 VkBuffer buffer, 623 VkDeviceMemory memory, 624 VkDeviceSize memoryOffset) 625 { 626 UNUSED_PARAMETER(memoryOffset); 627 628 bool skipCall = false; 629 630 skipCall |= validate_required_handle(report_data, "vkBindBufferMemory", "buffer", buffer); 631 632 skipCall |= validate_required_handle(report_data, "vkBindBufferMemory", "memory", memory); 633 634 return skipCall; 635 } 636 637 static bool parameter_validation_vkBindImageMemory( 638 debug_report_data* report_data, 639 VkImage image, 640 VkDeviceMemory memory, 641 VkDeviceSize memoryOffset) 642 { 643 UNUSED_PARAMETER(memoryOffset); 644 645 bool skipCall = false; 646 647 skipCall |= validate_required_handle(report_data, "vkBindImageMemory", "image", image); 648 649 skipCall |= validate_required_handle(report_data, "vkBindImageMemory", "memory", memory); 650 651 return skipCall; 652 } 653 654 static bool parameter_validation_vkGetBufferMemoryRequirements( 655 debug_report_data* report_data, 656 VkBuffer buffer, 657 VkMemoryRequirements* pMemoryRequirements) 658 { 659 bool skipCall = false; 660 661 skipCall |= validate_required_handle(report_data, "vkGetBufferMemoryRequirements", "buffer", buffer); 662 663 skipCall |= validate_required_pointer(report_data, "vkGetBufferMemoryRequirements", "pMemoryRequirements", pMemoryRequirements); 664 665 return skipCall; 666 } 667 668 static bool parameter_validation_vkGetImageMemoryRequirements( 669 debug_report_data* report_data, 670 VkImage image, 671 VkMemoryRequirements* pMemoryRequirements) 672 { 673 bool skipCall = false; 674 675 skipCall |= validate_required_handle(report_data, "vkGetImageMemoryRequirements", "image", image); 676 677 skipCall |= validate_required_pointer(report_data, "vkGetImageMemoryRequirements", "pMemoryRequirements", pMemoryRequirements); 678 679 return skipCall; 680 } 681 682 static bool parameter_validation_vkGetImageSparseMemoryRequirements( 683 debug_report_data* report_data, 684 VkImage image, 685 uint32_t* pSparseMemoryRequirementCount, 686 VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 687 { 688 bool skipCall = false; 689 690 skipCall |= validate_required_handle(report_data, "vkGetImageSparseMemoryRequirements", "image", image); 691 692 skipCall |= validate_array(report_data, "vkGetImageSparseMemoryRequirements", "pSparseMemoryRequirementCount", "pSparseMemoryRequirements", pSparseMemoryRequirementCount, pSparseMemoryRequirements, true, false, false); 693 694 return skipCall; 695 } 696 697 static bool parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties( 698 debug_report_data* report_data, 699 VkFormat format, 700 VkImageType type, 701 VkSampleCountFlagBits samples, 702 VkImageUsageFlags usage, 703 VkImageTiling tiling, 704 uint32_t* pPropertyCount, 705 VkSparseImageFormatProperties* pProperties) 706 { 707 UNUSED_PARAMETER(samples); 708 709 bool skipCall = false; 710 711 skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, format); 712 713 skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "type", "VkImageType", VK_IMAGE_TYPE_BEGIN_RANGE, VK_IMAGE_TYPE_END_RANGE, type); 714 715 skipCall |= validate_flags(report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, true); 716 717 skipCall |= validate_ranged_enum(report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "tiling", "VkImageTiling", VK_IMAGE_TILING_BEGIN_RANGE, VK_IMAGE_TILING_END_RANGE, tiling); 718 719 skipCall |= validate_array(report_data, "vkGetPhysicalDeviceSparseImageFormatProperties", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false); 720 721 return skipCall; 722 } 723 724 static bool parameter_validation_vkQueueBindSparse( 725 debug_report_data* report_data, 726 uint32_t bindInfoCount, 727 const VkBindSparseInfo* pBindInfo, 728 VkFence fence) 729 { 730 UNUSED_PARAMETER(fence); 731 732 bool skipCall = false; 733 734 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); 735 736 if (pBindInfo != NULL) 737 { 738 for (uint32_t bindInfoIndex = 0; bindInfoIndex < bindInfoCount; ++bindInfoIndex) 739 { 740 skipCall |= validate_struct_pnext(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pNext", ParameterName::IndexVector{ bindInfoIndex }), NULL, pBindInfo[bindInfoIndex].pNext, 0, NULL, GeneratedHeaderVersion); 741 742 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); 743 744 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); 745 746 if (pBindInfo[bindInfoIndex].pBufferBinds != NULL) 747 { 748 for (uint32_t bufferBindIndex = 0; bufferBindIndex < pBindInfo[bindInfoIndex].bufferBindCount; ++bufferBindIndex) 749 { 750 skipCall |= validate_required_handle(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pBufferBinds[%i].buffer", ParameterName::IndexVector{ bindInfoIndex, bufferBindIndex }), pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].buffer); 751 752 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); 753 754 if (pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].pBinds != NULL) 755 { 756 for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].bindCount; ++bindIndex) 757 { 758 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); 759 } 760 } 761 } 762 } 763 764 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); 765 766 if (pBindInfo[bindInfoIndex].pImageOpaqueBinds != NULL) 767 { 768 for (uint32_t imageOpaqueBindIndex = 0; imageOpaqueBindIndex < pBindInfo[bindInfoIndex].imageOpaqueBindCount; ++imageOpaqueBindIndex) 769 { 770 skipCall |= validate_required_handle(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageOpaqueBinds[%i].image", ParameterName::IndexVector{ bindInfoIndex, imageOpaqueBindIndex }), pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].image); 771 772 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); 773 774 if (pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].pBinds != NULL) 775 { 776 for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].bindCount; ++bindIndex) 777 { 778 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); 779 } 780 } 781 } 782 } 783 784 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); 785 786 if (pBindInfo[bindInfoIndex].pImageBinds != NULL) 787 { 788 for (uint32_t imageBindIndex = 0; imageBindIndex < pBindInfo[bindInfoIndex].imageBindCount; ++imageBindIndex) 789 { 790 skipCall |= validate_required_handle(report_data, "vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].image", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex }), pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].image); 791 792 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); 793 794 if (pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds != NULL) 795 { 796 for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].bindCount; ++bindIndex) 797 { 798 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); 799 800 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); 801 } 802 } 803 } 804 } 805 806 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); 807 } 808 } 809 810 return skipCall; 811 } 812 813 static bool parameter_validation_vkCreateFence( 814 debug_report_data* report_data, 815 const VkFenceCreateInfo* pCreateInfo, 816 const VkAllocationCallbacks* pAllocator, 817 VkFence* pFence) 818 { 819 bool skipCall = false; 820 821 skipCall |= validate_struct_type(report_data, "vkCreateFence", "pCreateInfo", "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, true); 822 823 if (pCreateInfo != NULL) 824 { 825 skipCall |= validate_struct_pnext(report_data, "vkCreateFence", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 826 827 skipCall |= validate_flags(report_data, "vkCreateFence", "pCreateInfo->flags", "VkFenceCreateFlagBits", AllVkFenceCreateFlagBits, pCreateInfo->flags, false); 828 } 829 830 if (pAllocator != NULL) 831 { 832 skipCall |= validate_required_pointer(report_data, "vkCreateFence", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 833 834 skipCall |= validate_required_pointer(report_data, "vkCreateFence", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 835 836 skipCall |= validate_required_pointer(report_data, "vkCreateFence", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 837 } 838 839 skipCall |= validate_required_pointer(report_data, "vkCreateFence", "pFence", pFence); 840 841 return skipCall; 842 } 843 844 static bool parameter_validation_vkDestroyFence( 845 debug_report_data* report_data, 846 VkFence fence, 847 const VkAllocationCallbacks* pAllocator) 848 { 849 UNUSED_PARAMETER(fence); 850 851 bool skipCall = false; 852 853 if (pAllocator != NULL) 854 { 855 skipCall |= validate_required_pointer(report_data, "vkDestroyFence", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 856 857 skipCall |= validate_required_pointer(report_data, "vkDestroyFence", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 858 859 skipCall |= validate_required_pointer(report_data, "vkDestroyFence", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 860 } 861 862 return skipCall; 863 } 864 865 static bool parameter_validation_vkResetFences( 866 debug_report_data* report_data, 867 uint32_t fenceCount, 868 const VkFence* pFences) 869 { 870 bool skipCall = false; 871 872 skipCall |= validate_handle_array(report_data, "vkResetFences", "fenceCount", "pFences", fenceCount, pFences, true, true); 873 874 return skipCall; 875 } 876 877 static bool parameter_validation_vkGetFenceStatus( 878 debug_report_data* report_data, 879 VkFence fence) 880 { 881 bool skipCall = false; 882 883 skipCall |= validate_required_handle(report_data, "vkGetFenceStatus", "fence", fence); 884 885 return skipCall; 886 } 887 888 static bool parameter_validation_vkWaitForFences( 889 debug_report_data* report_data, 890 uint32_t fenceCount, 891 const VkFence* pFences, 892 VkBool32 waitAll, 893 uint64_t timeout) 894 { 895 UNUSED_PARAMETER(timeout); 896 897 bool skipCall = false; 898 899 skipCall |= validate_handle_array(report_data, "vkWaitForFences", "fenceCount", "pFences", fenceCount, pFences, true, true); 900 901 skipCall |= validate_bool32(report_data, "vkWaitForFences", "waitAll", waitAll); 902 903 return skipCall; 904 } 905 906 static bool parameter_validation_vkCreateSemaphore( 907 debug_report_data* report_data, 908 const VkSemaphoreCreateInfo* pCreateInfo, 909 const VkAllocationCallbacks* pAllocator, 910 VkSemaphore* pSemaphore) 911 { 912 bool skipCall = false; 913 914 skipCall |= validate_struct_type(report_data, "vkCreateSemaphore", "pCreateInfo", "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, true); 915 916 if (pCreateInfo != NULL) 917 { 918 skipCall |= validate_struct_pnext(report_data, "vkCreateSemaphore", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 919 920 skipCall |= validate_reserved_flags(report_data, "vkCreateSemaphore", "pCreateInfo->flags", pCreateInfo->flags); 921 } 922 923 if (pAllocator != NULL) 924 { 925 skipCall |= validate_required_pointer(report_data, "vkCreateSemaphore", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 926 927 skipCall |= validate_required_pointer(report_data, "vkCreateSemaphore", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 928 929 skipCall |= validate_required_pointer(report_data, "vkCreateSemaphore", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 930 } 931 932 skipCall |= validate_required_pointer(report_data, "vkCreateSemaphore", "pSemaphore", pSemaphore); 933 934 return skipCall; 935 } 936 937 static bool parameter_validation_vkDestroySemaphore( 938 debug_report_data* report_data, 939 VkSemaphore semaphore, 940 const VkAllocationCallbacks* pAllocator) 941 { 942 UNUSED_PARAMETER(semaphore); 943 944 bool skipCall = false; 945 946 if (pAllocator != NULL) 947 { 948 skipCall |= validate_required_pointer(report_data, "vkDestroySemaphore", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 949 950 skipCall |= validate_required_pointer(report_data, "vkDestroySemaphore", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 951 952 skipCall |= validate_required_pointer(report_data, "vkDestroySemaphore", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 953 } 954 955 return skipCall; 956 } 957 958 static bool parameter_validation_vkCreateEvent( 959 debug_report_data* report_data, 960 const VkEventCreateInfo* pCreateInfo, 961 const VkAllocationCallbacks* pAllocator, 962 VkEvent* pEvent) 963 { 964 bool skipCall = false; 965 966 skipCall |= validate_struct_type(report_data, "vkCreateEvent", "pCreateInfo", "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, true); 967 968 if (pCreateInfo != NULL) 969 { 970 skipCall |= validate_struct_pnext(report_data, "vkCreateEvent", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 971 972 skipCall |= validate_reserved_flags(report_data, "vkCreateEvent", "pCreateInfo->flags", pCreateInfo->flags); 973 } 974 975 if (pAllocator != NULL) 976 { 977 skipCall |= validate_required_pointer(report_data, "vkCreateEvent", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 978 979 skipCall |= validate_required_pointer(report_data, "vkCreateEvent", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 980 981 skipCall |= validate_required_pointer(report_data, "vkCreateEvent", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 982 } 983 984 skipCall |= validate_required_pointer(report_data, "vkCreateEvent", "pEvent", pEvent); 985 986 return skipCall; 987 } 988 989 static bool parameter_validation_vkDestroyEvent( 990 debug_report_data* report_data, 991 VkEvent event, 992 const VkAllocationCallbacks* pAllocator) 993 { 994 UNUSED_PARAMETER(event); 995 996 bool skipCall = false; 997 998 if (pAllocator != NULL) 999 { 1000 skipCall |= validate_required_pointer(report_data, "vkDestroyEvent", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1001 1002 skipCall |= validate_required_pointer(report_data, "vkDestroyEvent", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1003 1004 skipCall |= validate_required_pointer(report_data, "vkDestroyEvent", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1005 } 1006 1007 return skipCall; 1008 } 1009 1010 static bool parameter_validation_vkGetEventStatus( 1011 debug_report_data* report_data, 1012 VkEvent event) 1013 { 1014 bool skipCall = false; 1015 1016 skipCall |= validate_required_handle(report_data, "vkGetEventStatus", "event", event); 1017 1018 return skipCall; 1019 } 1020 1021 static bool parameter_validation_vkSetEvent( 1022 debug_report_data* report_data, 1023 VkEvent event) 1024 { 1025 bool skipCall = false; 1026 1027 skipCall |= validate_required_handle(report_data, "vkSetEvent", "event", event); 1028 1029 return skipCall; 1030 } 1031 1032 static bool parameter_validation_vkResetEvent( 1033 debug_report_data* report_data, 1034 VkEvent event) 1035 { 1036 bool skipCall = false; 1037 1038 skipCall |= validate_required_handle(report_data, "vkResetEvent", "event", event); 1039 1040 return skipCall; 1041 } 1042 1043 static bool parameter_validation_vkCreateQueryPool( 1044 debug_report_data* report_data, 1045 const VkQueryPoolCreateInfo* pCreateInfo, 1046 const VkAllocationCallbacks* pAllocator, 1047 VkQueryPool* pQueryPool) 1048 { 1049 bool skipCall = false; 1050 1051 skipCall |= validate_struct_type(report_data, "vkCreateQueryPool", "pCreateInfo", "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, true); 1052 1053 if (pCreateInfo != NULL) 1054 { 1055 skipCall |= validate_struct_pnext(report_data, "vkCreateQueryPool", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 1056 1057 skipCall |= validate_reserved_flags(report_data, "vkCreateQueryPool", "pCreateInfo->flags", pCreateInfo->flags); 1058 1059 skipCall |= validate_ranged_enum(report_data, "vkCreateQueryPool", "pCreateInfo->queryType", "VkQueryType", VK_QUERY_TYPE_BEGIN_RANGE, VK_QUERY_TYPE_END_RANGE, pCreateInfo->queryType); 1060 } 1061 1062 if (pAllocator != NULL) 1063 { 1064 skipCall |= validate_required_pointer(report_data, "vkCreateQueryPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1065 1066 skipCall |= validate_required_pointer(report_data, "vkCreateQueryPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1067 1068 skipCall |= validate_required_pointer(report_data, "vkCreateQueryPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1069 } 1070 1071 skipCall |= validate_required_pointer(report_data, "vkCreateQueryPool", "pQueryPool", pQueryPool); 1072 1073 return skipCall; 1074 } 1075 1076 static bool parameter_validation_vkDestroyQueryPool( 1077 debug_report_data* report_data, 1078 VkQueryPool queryPool, 1079 const VkAllocationCallbacks* pAllocator) 1080 { 1081 UNUSED_PARAMETER(queryPool); 1082 1083 bool skipCall = false; 1084 1085 if (pAllocator != NULL) 1086 { 1087 skipCall |= validate_required_pointer(report_data, "vkDestroyQueryPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1088 1089 skipCall |= validate_required_pointer(report_data, "vkDestroyQueryPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1090 1091 skipCall |= validate_required_pointer(report_data, "vkDestroyQueryPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1092 } 1093 1094 return skipCall; 1095 } 1096 1097 static bool parameter_validation_vkGetQueryPoolResults( 1098 debug_report_data* report_data, 1099 VkQueryPool queryPool, 1100 uint32_t firstQuery, 1101 uint32_t queryCount, 1102 size_t dataSize, 1103 void* pData, 1104 VkDeviceSize stride, 1105 VkQueryResultFlags flags) 1106 { 1107 UNUSED_PARAMETER(firstQuery); 1108 UNUSED_PARAMETER(queryCount); 1109 UNUSED_PARAMETER(stride); 1110 1111 bool skipCall = false; 1112 1113 skipCall |= validate_required_handle(report_data, "vkGetQueryPoolResults", "queryPool", queryPool); 1114 1115 skipCall |= validate_array(report_data, "vkGetQueryPoolResults", "dataSize", "pData", dataSize, pData, true, true); 1116 1117 skipCall |= validate_flags(report_data, "vkGetQueryPoolResults", "flags", "VkQueryResultFlagBits", AllVkQueryResultFlagBits, flags, false); 1118 1119 return skipCall; 1120 } 1121 1122 static bool parameter_validation_vkCreateBuffer( 1123 debug_report_data* report_data, 1124 const VkBufferCreateInfo* pCreateInfo, 1125 const VkAllocationCallbacks* pAllocator, 1126 VkBuffer* pBuffer) 1127 { 1128 bool skipCall = false; 1129 1130 skipCall |= validate_struct_type(report_data, "vkCreateBuffer", "pCreateInfo", "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, true); 1131 1132 if (pCreateInfo != NULL) 1133 { 1134 const VkStructureType allowedStructs[] = {VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV}; 1135 1136 skipCall |= validate_struct_pnext(report_data, "vkCreateBuffer", "pCreateInfo->pNext", "VkDedicatedAllocationBufferCreateInfoNV", pCreateInfo->pNext, ARRAY_SIZE(allowedStructs), allowedStructs, GeneratedHeaderVersion); 1137 1138 skipCall |= validate_flags(report_data, "vkCreateBuffer", "pCreateInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pCreateInfo->flags, false); 1139 1140 skipCall |= validate_flags(report_data, "vkCreateBuffer", "pCreateInfo->usage", "VkBufferUsageFlagBits", AllVkBufferUsageFlagBits, pCreateInfo->usage, true); 1141 1142 skipCall |= validate_ranged_enum(report_data, "vkCreateBuffer", "pCreateInfo->sharingMode", "VkSharingMode", VK_SHARING_MODE_BEGIN_RANGE, VK_SHARING_MODE_END_RANGE, pCreateInfo->sharingMode); 1143 } 1144 1145 if (pAllocator != NULL) 1146 { 1147 skipCall |= validate_required_pointer(report_data, "vkCreateBuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1148 1149 skipCall |= validate_required_pointer(report_data, "vkCreateBuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1150 1151 skipCall |= validate_required_pointer(report_data, "vkCreateBuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1152 } 1153 1154 skipCall |= validate_required_pointer(report_data, "vkCreateBuffer", "pBuffer", pBuffer); 1155 1156 return skipCall; 1157 } 1158 1159 static bool parameter_validation_vkDestroyBuffer( 1160 debug_report_data* report_data, 1161 VkBuffer buffer, 1162 const VkAllocationCallbacks* pAllocator) 1163 { 1164 UNUSED_PARAMETER(buffer); 1165 1166 bool skipCall = false; 1167 1168 if (pAllocator != NULL) 1169 { 1170 skipCall |= validate_required_pointer(report_data, "vkDestroyBuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1171 1172 skipCall |= validate_required_pointer(report_data, "vkDestroyBuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1173 1174 skipCall |= validate_required_pointer(report_data, "vkDestroyBuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1175 } 1176 1177 return skipCall; 1178 } 1179 1180 static bool parameter_validation_vkCreateBufferView( 1181 debug_report_data* report_data, 1182 const VkBufferViewCreateInfo* pCreateInfo, 1183 const VkAllocationCallbacks* pAllocator, 1184 VkBufferView* pView) 1185 { 1186 bool skipCall = false; 1187 1188 skipCall |= validate_struct_type(report_data, "vkCreateBufferView", "pCreateInfo", "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, true); 1189 1190 if (pCreateInfo != NULL) 1191 { 1192 skipCall |= validate_struct_pnext(report_data, "vkCreateBufferView", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 1193 1194 skipCall |= validate_reserved_flags(report_data, "vkCreateBufferView", "pCreateInfo->flags", pCreateInfo->flags); 1195 1196 skipCall |= validate_required_handle(report_data, "vkCreateBufferView", "pCreateInfo->buffer", pCreateInfo->buffer); 1197 1198 skipCall |= validate_ranged_enum(report_data, "vkCreateBufferView", "pCreateInfo->format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, pCreateInfo->format); 1199 } 1200 1201 if (pAllocator != NULL) 1202 { 1203 skipCall |= validate_required_pointer(report_data, "vkCreateBufferView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1204 1205 skipCall |= validate_required_pointer(report_data, "vkCreateBufferView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1206 1207 skipCall |= validate_required_pointer(report_data, "vkCreateBufferView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1208 } 1209 1210 skipCall |= validate_required_pointer(report_data, "vkCreateBufferView", "pView", pView); 1211 1212 return skipCall; 1213 } 1214 1215 static bool parameter_validation_vkDestroyBufferView( 1216 debug_report_data* report_data, 1217 VkBufferView bufferView, 1218 const VkAllocationCallbacks* pAllocator) 1219 { 1220 UNUSED_PARAMETER(bufferView); 1221 1222 bool skipCall = false; 1223 1224 if (pAllocator != NULL) 1225 { 1226 skipCall |= validate_required_pointer(report_data, "vkDestroyBufferView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1227 1228 skipCall |= validate_required_pointer(report_data, "vkDestroyBufferView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1229 1230 skipCall |= validate_required_pointer(report_data, "vkDestroyBufferView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1231 } 1232 1233 return skipCall; 1234 } 1235 1236 static bool parameter_validation_vkCreateImage( 1237 debug_report_data* report_data, 1238 const VkImageCreateInfo* pCreateInfo, 1239 const VkAllocationCallbacks* pAllocator, 1240 VkImage* pImage) 1241 { 1242 bool skipCall = false; 1243 1244 skipCall |= validate_struct_type(report_data, "vkCreateImage", "pCreateInfo", "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, true); 1245 1246 if (pCreateInfo != NULL) 1247 { 1248 const VkStructureType allowedStructs[] = {VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV}; 1249 1250 skipCall |= validate_struct_pnext(report_data, "vkCreateImage", "pCreateInfo->pNext", "VkDedicatedAllocationImageCreateInfoNV", pCreateInfo->pNext, ARRAY_SIZE(allowedStructs), allowedStructs, GeneratedHeaderVersion); 1251 1252 skipCall |= validate_flags(report_data, "vkCreateImage", "pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pCreateInfo->flags, false); 1253 1254 skipCall |= validate_ranged_enum(report_data, "vkCreateImage", "pCreateInfo->imageType", "VkImageType", VK_IMAGE_TYPE_BEGIN_RANGE, VK_IMAGE_TYPE_END_RANGE, pCreateInfo->imageType); 1255 1256 skipCall |= validate_ranged_enum(report_data, "vkCreateImage", "pCreateInfo->format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, pCreateInfo->format); 1257 1258 skipCall |= validate_ranged_enum(report_data, "vkCreateImage", "pCreateInfo->tiling", "VkImageTiling", VK_IMAGE_TILING_BEGIN_RANGE, VK_IMAGE_TILING_END_RANGE, pCreateInfo->tiling); 1259 1260 skipCall |= validate_flags(report_data, "vkCreateImage", "pCreateInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pCreateInfo->usage, true); 1261 1262 skipCall |= validate_ranged_enum(report_data, "vkCreateImage", "pCreateInfo->sharingMode", "VkSharingMode", VK_SHARING_MODE_BEGIN_RANGE, VK_SHARING_MODE_END_RANGE, pCreateInfo->sharingMode); 1263 1264 skipCall |= validate_ranged_enum(report_data, "vkCreateImage", "pCreateInfo->initialLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, pCreateInfo->initialLayout); 1265 } 1266 1267 if (pAllocator != NULL) 1268 { 1269 skipCall |= validate_required_pointer(report_data, "vkCreateImage", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1270 1271 skipCall |= validate_required_pointer(report_data, "vkCreateImage", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1272 1273 skipCall |= validate_required_pointer(report_data, "vkCreateImage", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1274 } 1275 1276 skipCall |= validate_required_pointer(report_data, "vkCreateImage", "pImage", pImage); 1277 1278 return skipCall; 1279 } 1280 1281 static bool parameter_validation_vkDestroyImage( 1282 debug_report_data* report_data, 1283 VkImage image, 1284 const VkAllocationCallbacks* pAllocator) 1285 { 1286 UNUSED_PARAMETER(image); 1287 1288 bool skipCall = false; 1289 1290 if (pAllocator != NULL) 1291 { 1292 skipCall |= validate_required_pointer(report_data, "vkDestroyImage", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1293 1294 skipCall |= validate_required_pointer(report_data, "vkDestroyImage", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1295 1296 skipCall |= validate_required_pointer(report_data, "vkDestroyImage", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1297 } 1298 1299 return skipCall; 1300 } 1301 1302 static bool parameter_validation_vkGetImageSubresourceLayout( 1303 debug_report_data* report_data, 1304 VkImage image, 1305 const VkImageSubresource* pSubresource, 1306 VkSubresourceLayout* pLayout) 1307 { 1308 bool skipCall = false; 1309 1310 skipCall |= validate_required_handle(report_data, "vkGetImageSubresourceLayout", "image", image); 1311 1312 skipCall |= validate_required_pointer(report_data, "vkGetImageSubresourceLayout", "pSubresource", pSubresource); 1313 1314 if (pSubresource != NULL) 1315 { 1316 skipCall |= validate_flags(report_data, "vkGetImageSubresourceLayout", "pSubresource->aspectMask", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pSubresource->aspectMask, true); 1317 } 1318 1319 skipCall |= validate_required_pointer(report_data, "vkGetImageSubresourceLayout", "pLayout", pLayout); 1320 1321 return skipCall; 1322 } 1323 1324 static bool parameter_validation_vkCreateImageView( 1325 debug_report_data* report_data, 1326 const VkImageViewCreateInfo* pCreateInfo, 1327 const VkAllocationCallbacks* pAllocator, 1328 VkImageView* pView) 1329 { 1330 bool skipCall = false; 1331 1332 skipCall |= validate_struct_type(report_data, "vkCreateImageView", "pCreateInfo", "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, true); 1333 1334 if (pCreateInfo != NULL) 1335 { 1336 skipCall |= validate_struct_pnext(report_data, "vkCreateImageView", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 1337 1338 skipCall |= validate_reserved_flags(report_data, "vkCreateImageView", "pCreateInfo->flags", pCreateInfo->flags); 1339 1340 skipCall |= validate_required_handle(report_data, "vkCreateImageView", "pCreateInfo->image", pCreateInfo->image); 1341 1342 skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->viewType", "VkImageViewType", VK_IMAGE_VIEW_TYPE_BEGIN_RANGE, VK_IMAGE_VIEW_TYPE_END_RANGE, pCreateInfo->viewType); 1343 1344 skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->format", "VkFormat", VK_FORMAT_BEGIN_RANGE, VK_FORMAT_END_RANGE, pCreateInfo->format); 1345 1346 skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->components.r", "VkComponentSwizzle", VK_COMPONENT_SWIZZLE_BEGIN_RANGE, VK_COMPONENT_SWIZZLE_END_RANGE, pCreateInfo->components.r); 1347 1348 skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->components.g", "VkComponentSwizzle", VK_COMPONENT_SWIZZLE_BEGIN_RANGE, VK_COMPONENT_SWIZZLE_END_RANGE, pCreateInfo->components.g); 1349 1350 skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->components.b", "VkComponentSwizzle", VK_COMPONENT_SWIZZLE_BEGIN_RANGE, VK_COMPONENT_SWIZZLE_END_RANGE, pCreateInfo->components.b); 1351 1352 skipCall |= validate_ranged_enum(report_data, "vkCreateImageView", "pCreateInfo->components.a", "VkComponentSwizzle", VK_COMPONENT_SWIZZLE_BEGIN_RANGE, VK_COMPONENT_SWIZZLE_END_RANGE, pCreateInfo->components.a); 1353 1354 skipCall |= validate_flags(report_data, "vkCreateImageView", "pCreateInfo->subresourceRange.aspectMask", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pCreateInfo->subresourceRange.aspectMask, true); 1355 } 1356 1357 if (pAllocator != NULL) 1358 { 1359 skipCall |= validate_required_pointer(report_data, "vkCreateImageView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1360 1361 skipCall |= validate_required_pointer(report_data, "vkCreateImageView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1362 1363 skipCall |= validate_required_pointer(report_data, "vkCreateImageView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1364 } 1365 1366 skipCall |= validate_required_pointer(report_data, "vkCreateImageView", "pView", pView); 1367 1368 return skipCall; 1369 } 1370 1371 static bool parameter_validation_vkDestroyImageView( 1372 debug_report_data* report_data, 1373 VkImageView imageView, 1374 const VkAllocationCallbacks* pAllocator) 1375 { 1376 UNUSED_PARAMETER(imageView); 1377 1378 bool skipCall = false; 1379 1380 if (pAllocator != NULL) 1381 { 1382 skipCall |= validate_required_pointer(report_data, "vkDestroyImageView", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1383 1384 skipCall |= validate_required_pointer(report_data, "vkDestroyImageView", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1385 1386 skipCall |= validate_required_pointer(report_data, "vkDestroyImageView", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1387 } 1388 1389 return skipCall; 1390 } 1391 1392 static bool parameter_validation_vkCreateShaderModule( 1393 debug_report_data* report_data, 1394 const VkShaderModuleCreateInfo* pCreateInfo, 1395 const VkAllocationCallbacks* pAllocator, 1396 VkShaderModule* pShaderModule) 1397 { 1398 bool skipCall = false; 1399 1400 skipCall |= validate_struct_type(report_data, "vkCreateShaderModule", "pCreateInfo", "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, true); 1401 1402 if (pCreateInfo != NULL) 1403 { 1404 skipCall |= validate_struct_pnext(report_data, "vkCreateShaderModule", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 1405 1406 skipCall |= validate_reserved_flags(report_data, "vkCreateShaderModule", "pCreateInfo->flags", pCreateInfo->flags); 1407 1408 skipCall |= validate_array(report_data, "vkCreateShaderModule", "pCreateInfo->codeSize", "pCreateInfo->pCode", pCreateInfo->codeSize, pCreateInfo->pCode, true, true); 1409 } 1410 1411 if (pAllocator != NULL) 1412 { 1413 skipCall |= validate_required_pointer(report_data, "vkCreateShaderModule", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1414 1415 skipCall |= validate_required_pointer(report_data, "vkCreateShaderModule", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1416 1417 skipCall |= validate_required_pointer(report_data, "vkCreateShaderModule", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1418 } 1419 1420 skipCall |= validate_required_pointer(report_data, "vkCreateShaderModule", "pShaderModule", pShaderModule); 1421 1422 return skipCall; 1423 } 1424 1425 static bool parameter_validation_vkDestroyShaderModule( 1426 debug_report_data* report_data, 1427 VkShaderModule shaderModule, 1428 const VkAllocationCallbacks* pAllocator) 1429 { 1430 UNUSED_PARAMETER(shaderModule); 1431 1432 bool skipCall = false; 1433 1434 if (pAllocator != NULL) 1435 { 1436 skipCall |= validate_required_pointer(report_data, "vkDestroyShaderModule", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1437 1438 skipCall |= validate_required_pointer(report_data, "vkDestroyShaderModule", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1439 1440 skipCall |= validate_required_pointer(report_data, "vkDestroyShaderModule", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1441 } 1442 1443 return skipCall; 1444 } 1445 1446 static bool parameter_validation_vkCreatePipelineCache( 1447 debug_report_data* report_data, 1448 const VkPipelineCacheCreateInfo* pCreateInfo, 1449 const VkAllocationCallbacks* pAllocator, 1450 VkPipelineCache* pPipelineCache) 1451 { 1452 bool skipCall = false; 1453 1454 skipCall |= validate_struct_type(report_data, "vkCreatePipelineCache", "pCreateInfo", "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, true); 1455 1456 if (pCreateInfo != NULL) 1457 { 1458 skipCall |= validate_struct_pnext(report_data, "vkCreatePipelineCache", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 1459 1460 skipCall |= validate_reserved_flags(report_data, "vkCreatePipelineCache", "pCreateInfo->flags", pCreateInfo->flags); 1461 1462 skipCall |= validate_array(report_data, "vkCreatePipelineCache", "pCreateInfo->initialDataSize", "pCreateInfo->pInitialData", pCreateInfo->initialDataSize, pCreateInfo->pInitialData, false, true); 1463 } 1464 1465 if (pAllocator != NULL) 1466 { 1467 skipCall |= validate_required_pointer(report_data, "vkCreatePipelineCache", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1468 1469 skipCall |= validate_required_pointer(report_data, "vkCreatePipelineCache", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1470 1471 skipCall |= validate_required_pointer(report_data, "vkCreatePipelineCache", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1472 } 1473 1474 skipCall |= validate_required_pointer(report_data, "vkCreatePipelineCache", "pPipelineCache", pPipelineCache); 1475 1476 return skipCall; 1477 } 1478 1479 static bool parameter_validation_vkDestroyPipelineCache( 1480 debug_report_data* report_data, 1481 VkPipelineCache pipelineCache, 1482 const VkAllocationCallbacks* pAllocator) 1483 { 1484 UNUSED_PARAMETER(pipelineCache); 1485 1486 bool skipCall = false; 1487 1488 if (pAllocator != NULL) 1489 { 1490 skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineCache", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1491 1492 skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineCache", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1493 1494 skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineCache", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1495 } 1496 1497 return skipCall; 1498 } 1499 1500 static bool parameter_validation_vkGetPipelineCacheData( 1501 debug_report_data* report_data, 1502 VkPipelineCache pipelineCache, 1503 size_t* pDataSize, 1504 void* pData) 1505 { 1506 bool skipCall = false; 1507 1508 skipCall |= validate_required_handle(report_data, "vkGetPipelineCacheData", "pipelineCache", pipelineCache); 1509 1510 skipCall |= validate_array(report_data, "vkGetPipelineCacheData", "pDataSize", "pData", pDataSize, pData, true, false, false); 1511 1512 return skipCall; 1513 } 1514 1515 static bool parameter_validation_vkMergePipelineCaches( 1516 debug_report_data* report_data, 1517 VkPipelineCache dstCache, 1518 uint32_t srcCacheCount, 1519 const VkPipelineCache* pSrcCaches) 1520 { 1521 bool skipCall = false; 1522 1523 skipCall |= validate_required_handle(report_data, "vkMergePipelineCaches", "dstCache", dstCache); 1524 1525 skipCall |= validate_handle_array(report_data, "vkMergePipelineCaches", "srcCacheCount", "pSrcCaches", srcCacheCount, pSrcCaches, true, true); 1526 1527 return skipCall; 1528 } 1529 1530 static bool parameter_validation_vkCreateGraphicsPipelines( 1531 debug_report_data* report_data, 1532 VkPipelineCache pipelineCache, 1533 uint32_t createInfoCount, 1534 const VkGraphicsPipelineCreateInfo* pCreateInfos, 1535 const VkAllocationCallbacks* pAllocator, 1536 VkPipeline* pPipelines) 1537 { 1538 UNUSED_PARAMETER(pipelineCache); 1539 1540 bool skipCall = false; 1541 1542 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); 1543 1544 if (pCreateInfos != NULL) 1545 { 1546 for (uint32_t createInfoIndex = 0; createInfoIndex < createInfoCount; ++createInfoIndex) 1547 { 1548 skipCall |= validate_struct_pnext(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pNext, 0, NULL, GeneratedHeaderVersion); 1549 1550 skipCall |= validate_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, false); 1551 1552 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); 1553 1554 if (pCreateInfos[createInfoIndex].pStages != NULL) 1555 { 1556 for (uint32_t stageIndex = 0; stageIndex < pCreateInfos[createInfoIndex].stageCount; ++stageIndex) 1557 { 1558 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); 1559 1560 skipCall |= validate_reserved_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].flags", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].flags); 1561 1562 skipCall |= validate_required_handle(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].module", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].module); 1563 1564 skipCall |= validate_required_pointer(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].pName", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].pName); 1565 1566 if (pCreateInfos[createInfoIndex].pStages[stageIndex].pSpecializationInfo != NULL) 1567 { 1568 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); 1569 1570 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); 1571 } 1572 } 1573 } 1574 1575 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); 1576 1577 if (pCreateInfos[createInfoIndex].pVertexInputState != NULL) 1578 { 1579 skipCall |= validate_struct_pnext(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pVertexInputState->pNext, 0, NULL, GeneratedHeaderVersion); 1580 1581 skipCall |= validate_reserved_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pVertexInputState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pVertexInputState->flags); 1582 1583 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); 1584 1585 if (pCreateInfos[createInfoIndex].pVertexInputState->pVertexBindingDescriptions != NULL) 1586 { 1587 for (uint32_t vertexBindingDescriptionIndex = 0; vertexBindingDescriptionIndex < pCreateInfos[createInfoIndex].pVertexInputState->vertexBindingDescriptionCount; ++vertexBindingDescriptionIndex) 1588 { 1589 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); 1590 } 1591 } 1592 1593 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); 1594 1595 if (pCreateInfos[createInfoIndex].pVertexInputState->pVertexAttributeDescriptions != NULL) 1596 { 1597 for (uint32_t vertexAttributeDescriptionIndex = 0; vertexAttributeDescriptionIndex < pCreateInfos[createInfoIndex].pVertexInputState->vertexAttributeDescriptionCount; ++vertexAttributeDescriptionIndex) 1598 { 1599 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); 1600 } 1601 } 1602 } 1603 1604 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); 1605 1606 if (pCreateInfos[createInfoIndex].pInputAssemblyState != NULL) 1607 { 1608 skipCall |= validate_struct_pnext(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState->pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pInputAssemblyState->pNext, 0, NULL, GeneratedHeaderVersion); 1609 1610 skipCall |= validate_reserved_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pInputAssemblyState->flags); 1611 1612 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); 1613 1614 skipCall |= validate_bool32(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pInputAssemblyState->primitiveRestartEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pInputAssemblyState->primitiveRestartEnable); 1615 } 1616 1617 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); 1618 1619 if (pCreateInfos[createInfoIndex].pRasterizationState != NULL) 1620 { 1621 const VkStructureType allowedStructs[] = {VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD}; 1622 1623 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); 1624 1625 skipCall |= validate_reserved_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->flags); 1626 1627 skipCall |= validate_bool32(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->depthClampEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->depthClampEnable); 1628 1629 skipCall |= validate_bool32(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->rasterizerDiscardEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->rasterizerDiscardEnable); 1630 1631 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); 1632 1633 skipCall |= validate_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->cullMode", ParameterName::IndexVector{ createInfoIndex }), "VkCullModeFlagBits", AllVkCullModeFlagBits, pCreateInfos[createInfoIndex].pRasterizationState->cullMode, false); 1634 1635 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); 1636 1637 skipCall |= validate_bool32(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->depthBiasEnable", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->depthBiasEnable); 1638 } 1639 1640 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); 1641 1642 if (pCreateInfos[createInfoIndex].pDynamicState != NULL) 1643 { 1644 skipCall |= validate_struct_pnext(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pDynamicState->pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pDynamicState->pNext, 0, NULL, GeneratedHeaderVersion); 1645 1646 skipCall |= validate_reserved_flags(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pDynamicState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pDynamicState->flags); 1647 1648 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); 1649 } 1650 1651 skipCall |= validate_required_handle(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].layout", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].layout); 1652 1653 skipCall |= validate_required_handle(report_data, "vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].renderPass", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].renderPass); 1654 } 1655 } 1656 1657 if (pAllocator != NULL) 1658 { 1659 skipCall |= validate_required_pointer(report_data, "vkCreateGraphicsPipelines", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1660 1661 skipCall |= validate_required_pointer(report_data, "vkCreateGraphicsPipelines", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1662 1663 skipCall |= validate_required_pointer(report_data, "vkCreateGraphicsPipelines", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1664 } 1665 1666 skipCall |= validate_array(report_data, "vkCreateGraphicsPipelines", "createInfoCount", "pPipelines", createInfoCount, pPipelines, true, true); 1667 1668 return skipCall; 1669 } 1670 1671 static bool parameter_validation_vkCreateComputePipelines( 1672 debug_report_data* report_data, 1673 VkPipelineCache pipelineCache, 1674 uint32_t createInfoCount, 1675 const VkComputePipelineCreateInfo* pCreateInfos, 1676 const VkAllocationCallbacks* pAllocator, 1677 VkPipeline* pPipelines) 1678 { 1679 UNUSED_PARAMETER(pipelineCache); 1680 1681 bool skipCall = false; 1682 1683 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); 1684 1685 if (pCreateInfos != NULL) 1686 { 1687 for (uint32_t createInfoIndex = 0; createInfoIndex < createInfoCount; ++createInfoIndex) 1688 { 1689 skipCall |= validate_struct_pnext(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].pNext, 0, NULL, GeneratedHeaderVersion); 1690 1691 skipCall |= validate_flags(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, false); 1692 1693 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); 1694 1695 skipCall |= validate_struct_pnext(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].stage.pNext, 0, NULL, GeneratedHeaderVersion); 1696 1697 skipCall |= validate_reserved_flags(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.flags); 1698 1699 skipCall |= validate_required_handle(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.module", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.module); 1700 1701 skipCall |= validate_required_pointer(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.pName", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.pName); 1702 1703 if (pCreateInfos[createInfoIndex].stage.pSpecializationInfo != NULL) 1704 { 1705 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); 1706 1707 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); 1708 } 1709 1710 skipCall |= validate_required_handle(report_data, "vkCreateComputePipelines", ParameterName("pCreateInfos[%i].layout", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].layout); 1711 } 1712 } 1713 1714 if (pAllocator != NULL) 1715 { 1716 skipCall |= validate_required_pointer(report_data, "vkCreateComputePipelines", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1717 1718 skipCall |= validate_required_pointer(report_data, "vkCreateComputePipelines", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1719 1720 skipCall |= validate_required_pointer(report_data, "vkCreateComputePipelines", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1721 } 1722 1723 skipCall |= validate_array(report_data, "vkCreateComputePipelines", "createInfoCount", "pPipelines", createInfoCount, pPipelines, true, true); 1724 1725 return skipCall; 1726 } 1727 1728 static bool parameter_validation_vkDestroyPipeline( 1729 debug_report_data* report_data, 1730 VkPipeline pipeline, 1731 const VkAllocationCallbacks* pAllocator) 1732 { 1733 UNUSED_PARAMETER(pipeline); 1734 1735 bool skipCall = false; 1736 1737 if (pAllocator != NULL) 1738 { 1739 skipCall |= validate_required_pointer(report_data, "vkDestroyPipeline", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1740 1741 skipCall |= validate_required_pointer(report_data, "vkDestroyPipeline", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1742 1743 skipCall |= validate_required_pointer(report_data, "vkDestroyPipeline", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1744 } 1745 1746 return skipCall; 1747 } 1748 1749 static bool parameter_validation_vkCreatePipelineLayout( 1750 debug_report_data* report_data, 1751 const VkPipelineLayoutCreateInfo* pCreateInfo, 1752 const VkAllocationCallbacks* pAllocator, 1753 VkPipelineLayout* pPipelineLayout) 1754 { 1755 bool skipCall = false; 1756 1757 skipCall |= validate_struct_type(report_data, "vkCreatePipelineLayout", "pCreateInfo", "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, true); 1758 1759 if (pCreateInfo != NULL) 1760 { 1761 skipCall |= validate_struct_pnext(report_data, "vkCreatePipelineLayout", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 1762 1763 skipCall |= validate_reserved_flags(report_data, "vkCreatePipelineLayout", "pCreateInfo->flags", pCreateInfo->flags); 1764 1765 skipCall |= validate_array(report_data, "vkCreatePipelineLayout", "pCreateInfo->setLayoutCount", "pCreateInfo->pSetLayouts", pCreateInfo->setLayoutCount, pCreateInfo->pSetLayouts, false, true); 1766 1767 skipCall |= validate_array(report_data, "vkCreatePipelineLayout", "pCreateInfo->pushConstantRangeCount", "pCreateInfo->pPushConstantRanges", pCreateInfo->pushConstantRangeCount, pCreateInfo->pPushConstantRanges, false, true); 1768 1769 if (pCreateInfo->pPushConstantRanges != NULL) 1770 { 1771 for (uint32_t pushConstantRangeIndex = 0; pushConstantRangeIndex < pCreateInfo->pushConstantRangeCount; ++pushConstantRangeIndex) 1772 { 1773 skipCall |= validate_flags(report_data, "vkCreatePipelineLayout", ParameterName("pCreateInfo->pPushConstantRanges[%i].stageFlags", ParameterName::IndexVector{ pushConstantRangeIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfo->pPushConstantRanges[pushConstantRangeIndex].stageFlags, true); 1774 } 1775 } 1776 } 1777 1778 if (pAllocator != NULL) 1779 { 1780 skipCall |= validate_required_pointer(report_data, "vkCreatePipelineLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1781 1782 skipCall |= validate_required_pointer(report_data, "vkCreatePipelineLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1783 1784 skipCall |= validate_required_pointer(report_data, "vkCreatePipelineLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1785 } 1786 1787 skipCall |= validate_required_pointer(report_data, "vkCreatePipelineLayout", "pPipelineLayout", pPipelineLayout); 1788 1789 return skipCall; 1790 } 1791 1792 static bool parameter_validation_vkDestroyPipelineLayout( 1793 debug_report_data* report_data, 1794 VkPipelineLayout pipelineLayout, 1795 const VkAllocationCallbacks* pAllocator) 1796 { 1797 UNUSED_PARAMETER(pipelineLayout); 1798 1799 bool skipCall = false; 1800 1801 if (pAllocator != NULL) 1802 { 1803 skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1804 1805 skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1806 1807 skipCall |= validate_required_pointer(report_data, "vkDestroyPipelineLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1808 } 1809 1810 return skipCall; 1811 } 1812 1813 static bool parameter_validation_vkCreateSampler( 1814 debug_report_data* report_data, 1815 const VkSamplerCreateInfo* pCreateInfo, 1816 const VkAllocationCallbacks* pAllocator, 1817 VkSampler* pSampler) 1818 { 1819 bool skipCall = false; 1820 1821 skipCall |= validate_struct_type(report_data, "vkCreateSampler", "pCreateInfo", "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, true); 1822 1823 if (pCreateInfo != NULL) 1824 { 1825 skipCall |= validate_struct_pnext(report_data, "vkCreateSampler", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 1826 1827 skipCall |= validate_reserved_flags(report_data, "vkCreateSampler", "pCreateInfo->flags", pCreateInfo->flags); 1828 1829 skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->magFilter", "VkFilter", VK_FILTER_BEGIN_RANGE, VK_FILTER_END_RANGE, pCreateInfo->magFilter); 1830 1831 skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->minFilter", "VkFilter", VK_FILTER_BEGIN_RANGE, VK_FILTER_END_RANGE, pCreateInfo->minFilter); 1832 1833 skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->mipmapMode", "VkSamplerMipmapMode", VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE, VK_SAMPLER_MIPMAP_MODE_END_RANGE, pCreateInfo->mipmapMode); 1834 1835 skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->addressModeU", "VkSamplerAddressMode", VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE, VK_SAMPLER_ADDRESS_MODE_END_RANGE, pCreateInfo->addressModeU); 1836 1837 skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->addressModeV", "VkSamplerAddressMode", VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE, VK_SAMPLER_ADDRESS_MODE_END_RANGE, pCreateInfo->addressModeV); 1838 1839 skipCall |= validate_ranged_enum(report_data, "vkCreateSampler", "pCreateInfo->addressModeW", "VkSamplerAddressMode", VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE, VK_SAMPLER_ADDRESS_MODE_END_RANGE, pCreateInfo->addressModeW); 1840 1841 skipCall |= validate_bool32(report_data, "vkCreateSampler", "pCreateInfo->anisotropyEnable", pCreateInfo->anisotropyEnable); 1842 1843 skipCall |= validate_bool32(report_data, "vkCreateSampler", "pCreateInfo->compareEnable", pCreateInfo->compareEnable); 1844 1845 skipCall |= validate_bool32(report_data, "vkCreateSampler", "pCreateInfo->unnormalizedCoordinates", pCreateInfo->unnormalizedCoordinates); 1846 } 1847 1848 if (pAllocator != NULL) 1849 { 1850 skipCall |= validate_required_pointer(report_data, "vkCreateSampler", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1851 1852 skipCall |= validate_required_pointer(report_data, "vkCreateSampler", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1853 1854 skipCall |= validate_required_pointer(report_data, "vkCreateSampler", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1855 } 1856 1857 skipCall |= validate_required_pointer(report_data, "vkCreateSampler", "pSampler", pSampler); 1858 1859 return skipCall; 1860 } 1861 1862 static bool parameter_validation_vkDestroySampler( 1863 debug_report_data* report_data, 1864 VkSampler sampler, 1865 const VkAllocationCallbacks* pAllocator) 1866 { 1867 UNUSED_PARAMETER(sampler); 1868 1869 bool skipCall = false; 1870 1871 if (pAllocator != NULL) 1872 { 1873 skipCall |= validate_required_pointer(report_data, "vkDestroySampler", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1874 1875 skipCall |= validate_required_pointer(report_data, "vkDestroySampler", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1876 1877 skipCall |= validate_required_pointer(report_data, "vkDestroySampler", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1878 } 1879 1880 return skipCall; 1881 } 1882 1883 static bool parameter_validation_vkCreateDescriptorSetLayout( 1884 debug_report_data* report_data, 1885 const VkDescriptorSetLayoutCreateInfo* pCreateInfo, 1886 const VkAllocationCallbacks* pAllocator, 1887 VkDescriptorSetLayout* pSetLayout) 1888 { 1889 bool skipCall = false; 1890 1891 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); 1892 1893 if (pCreateInfo != NULL) 1894 { 1895 skipCall |= validate_struct_pnext(report_data, "vkCreateDescriptorSetLayout", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 1896 1897 skipCall |= validate_reserved_flags(report_data, "vkCreateDescriptorSetLayout", "pCreateInfo->flags", pCreateInfo->flags); 1898 1899 skipCall |= validate_array(report_data, "vkCreateDescriptorSetLayout", "pCreateInfo->bindingCount", "pCreateInfo->pBindings", pCreateInfo->bindingCount, pCreateInfo->pBindings, false, true); 1900 1901 if (pCreateInfo->pBindings != NULL) 1902 { 1903 for (uint32_t bindingIndex = 0; bindingIndex < pCreateInfo->bindingCount; ++bindingIndex) 1904 { 1905 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); 1906 } 1907 } 1908 } 1909 1910 if (pAllocator != NULL) 1911 { 1912 skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorSetLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1913 1914 skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorSetLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1915 1916 skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorSetLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1917 } 1918 1919 skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorSetLayout", "pSetLayout", pSetLayout); 1920 1921 return skipCall; 1922 } 1923 1924 static bool parameter_validation_vkDestroyDescriptorSetLayout( 1925 debug_report_data* report_data, 1926 VkDescriptorSetLayout descriptorSetLayout, 1927 const VkAllocationCallbacks* pAllocator) 1928 { 1929 UNUSED_PARAMETER(descriptorSetLayout); 1930 1931 bool skipCall = false; 1932 1933 if (pAllocator != NULL) 1934 { 1935 skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorSetLayout", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1936 1937 skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorSetLayout", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1938 1939 skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorSetLayout", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1940 } 1941 1942 return skipCall; 1943 } 1944 1945 static bool parameter_validation_vkCreateDescriptorPool( 1946 debug_report_data* report_data, 1947 const VkDescriptorPoolCreateInfo* pCreateInfo, 1948 const VkAllocationCallbacks* pAllocator, 1949 VkDescriptorPool* pDescriptorPool) 1950 { 1951 bool skipCall = false; 1952 1953 skipCall |= validate_struct_type(report_data, "vkCreateDescriptorPool", "pCreateInfo", "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, true); 1954 1955 if (pCreateInfo != NULL) 1956 { 1957 skipCall |= validate_struct_pnext(report_data, "vkCreateDescriptorPool", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 1958 1959 skipCall |= validate_flags(report_data, "vkCreateDescriptorPool", "pCreateInfo->flags", "VkDescriptorPoolCreateFlagBits", AllVkDescriptorPoolCreateFlagBits, pCreateInfo->flags, false); 1960 1961 skipCall |= validate_array(report_data, "vkCreateDescriptorPool", "pCreateInfo->poolSizeCount", "pCreateInfo->pPoolSizes", pCreateInfo->poolSizeCount, pCreateInfo->pPoolSizes, true, true); 1962 1963 if (pCreateInfo->pPoolSizes != NULL) 1964 { 1965 for (uint32_t poolSizeIndex = 0; poolSizeIndex < pCreateInfo->poolSizeCount; ++poolSizeIndex) 1966 { 1967 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); 1968 } 1969 } 1970 } 1971 1972 if (pAllocator != NULL) 1973 { 1974 skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1975 1976 skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 1977 1978 skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 1979 } 1980 1981 skipCall |= validate_required_pointer(report_data, "vkCreateDescriptorPool", "pDescriptorPool", pDescriptorPool); 1982 1983 return skipCall; 1984 } 1985 1986 static bool parameter_validation_vkDestroyDescriptorPool( 1987 debug_report_data* report_data, 1988 VkDescriptorPool descriptorPool, 1989 const VkAllocationCallbacks* pAllocator) 1990 { 1991 UNUSED_PARAMETER(descriptorPool); 1992 1993 bool skipCall = false; 1994 1995 if (pAllocator != NULL) 1996 { 1997 skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 1998 1999 skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 2000 2001 skipCall |= validate_required_pointer(report_data, "vkDestroyDescriptorPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 2002 } 2003 2004 return skipCall; 2005 } 2006 2007 static bool parameter_validation_vkResetDescriptorPool( 2008 debug_report_data* report_data, 2009 VkDescriptorPool descriptorPool, 2010 VkDescriptorPoolResetFlags flags) 2011 { 2012 bool skipCall = false; 2013 2014 skipCall |= validate_required_handle(report_data, "vkResetDescriptorPool", "descriptorPool", descriptorPool); 2015 2016 skipCall |= validate_reserved_flags(report_data, "vkResetDescriptorPool", "flags", flags); 2017 2018 return skipCall; 2019 } 2020 2021 static bool parameter_validation_vkAllocateDescriptorSets( 2022 debug_report_data* report_data, 2023 const VkDescriptorSetAllocateInfo* pAllocateInfo, 2024 VkDescriptorSet* pDescriptorSets) 2025 { 2026 bool skipCall = false; 2027 2028 skipCall |= validate_struct_type(report_data, "vkAllocateDescriptorSets", "pAllocateInfo", "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, true); 2029 2030 if (pAllocateInfo != NULL) 2031 { 2032 skipCall |= validate_struct_pnext(report_data, "vkAllocateDescriptorSets", "pAllocateInfo->pNext", NULL, pAllocateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 2033 2034 skipCall |= validate_required_handle(report_data, "vkAllocateDescriptorSets", "pAllocateInfo->descriptorPool", pAllocateInfo->descriptorPool); 2035 2036 skipCall |= validate_handle_array(report_data, "vkAllocateDescriptorSets", "pAllocateInfo->descriptorSetCount", "pAllocateInfo->pSetLayouts", pAllocateInfo->descriptorSetCount, pAllocateInfo->pSetLayouts, true, true); 2037 } 2038 2039 if (pAllocateInfo != NULL) { 2040 skipCall |= validate_array(report_data, "vkAllocateDescriptorSets", "pAllocateInfo->descriptorSetCount", "pDescriptorSets", pAllocateInfo->descriptorSetCount, pDescriptorSets, true, true); 2041 } 2042 2043 return skipCall; 2044 } 2045 2046 static bool parameter_validation_vkFreeDescriptorSets( 2047 debug_report_data* report_data, 2048 VkDescriptorPool descriptorPool, 2049 uint32_t descriptorSetCount, 2050 const VkDescriptorSet* pDescriptorSets) 2051 { 2052 UNUSED_PARAMETER(pDescriptorSets); 2053 2054 bool skipCall = false; 2055 2056 skipCall |= validate_required_handle(report_data, "vkFreeDescriptorSets", "descriptorPool", descriptorPool); 2057 2058 return skipCall; 2059 } 2060 2061 static bool parameter_validation_vkUpdateDescriptorSets( 2062 debug_report_data* report_data, 2063 uint32_t descriptorWriteCount, 2064 const VkWriteDescriptorSet* pDescriptorWrites, 2065 uint32_t descriptorCopyCount, 2066 const VkCopyDescriptorSet* pDescriptorCopies) 2067 { 2068 bool skipCall = false; 2069 2070 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); 2071 2072 if (pDescriptorWrites != NULL) 2073 { 2074 for (uint32_t descriptorWriteIndex = 0; descriptorWriteIndex < descriptorWriteCount; ++descriptorWriteIndex) 2075 { 2076 skipCall |= validate_struct_pnext(report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorWrites[%i].pNext", ParameterName::IndexVector{ descriptorWriteIndex }), NULL, pDescriptorWrites[descriptorWriteIndex].pNext, 0, NULL, GeneratedHeaderVersion); 2077 2078 skipCall |= validate_required_handle(report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorWrites[%i].dstSet", ParameterName::IndexVector{ descriptorWriteIndex }), pDescriptorWrites[descriptorWriteIndex].dstSet); 2079 2080 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); 2081 } 2082 } 2083 2084 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); 2085 2086 if (pDescriptorCopies != NULL) 2087 { 2088 for (uint32_t descriptorCopyIndex = 0; descriptorCopyIndex < descriptorCopyCount; ++descriptorCopyIndex) 2089 { 2090 skipCall |= validate_struct_pnext(report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorCopies[%i].pNext", ParameterName::IndexVector{ descriptorCopyIndex }), NULL, pDescriptorCopies[descriptorCopyIndex].pNext, 0, NULL, GeneratedHeaderVersion); 2091 2092 skipCall |= validate_required_handle(report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorCopies[%i].srcSet", ParameterName::IndexVector{ descriptorCopyIndex }), pDescriptorCopies[descriptorCopyIndex].srcSet); 2093 2094 skipCall |= validate_required_handle(report_data, "vkUpdateDescriptorSets", ParameterName("pDescriptorCopies[%i].dstSet", ParameterName::IndexVector{ descriptorCopyIndex }), pDescriptorCopies[descriptorCopyIndex].dstSet); 2095 } 2096 } 2097 2098 return skipCall; 2099 } 2100 2101 static bool parameter_validation_vkCreateFramebuffer( 2102 debug_report_data* report_data, 2103 const VkFramebufferCreateInfo* pCreateInfo, 2104 const VkAllocationCallbacks* pAllocator, 2105 VkFramebuffer* pFramebuffer) 2106 { 2107 bool skipCall = false; 2108 2109 skipCall |= validate_struct_type(report_data, "vkCreateFramebuffer", "pCreateInfo", "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, true); 2110 2111 if (pCreateInfo != NULL) 2112 { 2113 skipCall |= validate_struct_pnext(report_data, "vkCreateFramebuffer", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 2114 2115 skipCall |= validate_reserved_flags(report_data, "vkCreateFramebuffer", "pCreateInfo->flags", pCreateInfo->flags); 2116 2117 skipCall |= validate_required_handle(report_data, "vkCreateFramebuffer", "pCreateInfo->renderPass", pCreateInfo->renderPass); 2118 2119 skipCall |= validate_array(report_data, "vkCreateFramebuffer", "pCreateInfo->attachmentCount", "pCreateInfo->pAttachments", pCreateInfo->attachmentCount, pCreateInfo->pAttachments, false, true); 2120 } 2121 2122 if (pAllocator != NULL) 2123 { 2124 skipCall |= validate_required_pointer(report_data, "vkCreateFramebuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 2125 2126 skipCall |= validate_required_pointer(report_data, "vkCreateFramebuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 2127 2128 skipCall |= validate_required_pointer(report_data, "vkCreateFramebuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 2129 } 2130 2131 skipCall |= validate_required_pointer(report_data, "vkCreateFramebuffer", "pFramebuffer", pFramebuffer); 2132 2133 return skipCall; 2134 } 2135 2136 static bool parameter_validation_vkDestroyFramebuffer( 2137 debug_report_data* report_data, 2138 VkFramebuffer framebuffer, 2139 const VkAllocationCallbacks* pAllocator) 2140 { 2141 UNUSED_PARAMETER(framebuffer); 2142 2143 bool skipCall = false; 2144 2145 if (pAllocator != NULL) 2146 { 2147 skipCall |= validate_required_pointer(report_data, "vkDestroyFramebuffer", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 2148 2149 skipCall |= validate_required_pointer(report_data, "vkDestroyFramebuffer", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 2150 2151 skipCall |= validate_required_pointer(report_data, "vkDestroyFramebuffer", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 2152 } 2153 2154 return skipCall; 2155 } 2156 2157 static bool parameter_validation_vkCreateRenderPass( 2158 debug_report_data* report_data, 2159 const VkRenderPassCreateInfo* pCreateInfo, 2160 const VkAllocationCallbacks* pAllocator, 2161 VkRenderPass* pRenderPass) 2162 { 2163 bool skipCall = false; 2164 2165 skipCall |= validate_struct_type(report_data, "vkCreateRenderPass", "pCreateInfo", "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, true); 2166 2167 if (pCreateInfo != NULL) 2168 { 2169 skipCall |= validate_struct_pnext(report_data, "vkCreateRenderPass", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 2170 2171 skipCall |= validate_reserved_flags(report_data, "vkCreateRenderPass", "pCreateInfo->flags", pCreateInfo->flags); 2172 2173 skipCall |= validate_array(report_data, "vkCreateRenderPass", "pCreateInfo->attachmentCount", "pCreateInfo->pAttachments", pCreateInfo->attachmentCount, pCreateInfo->pAttachments, false, true); 2174 2175 if (pCreateInfo->pAttachments != NULL) 2176 { 2177 for (uint32_t attachmentIndex = 0; attachmentIndex < pCreateInfo->attachmentCount; ++attachmentIndex) 2178 { 2179 skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].flags", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentDescriptionFlagBits", AllVkAttachmentDescriptionFlagBits, pCreateInfo->pAttachments[attachmentIndex].flags, false); 2180 2181 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); 2182 2183 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); 2184 2185 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); 2186 2187 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); 2188 2189 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); 2190 2191 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); 2192 2193 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); 2194 } 2195 } 2196 2197 skipCall |= validate_array(report_data, "vkCreateRenderPass", "pCreateInfo->subpassCount", "pCreateInfo->pSubpasses", pCreateInfo->subpassCount, pCreateInfo->pSubpasses, true, true); 2198 2199 if (pCreateInfo->pSubpasses != NULL) 2200 { 2201 for (uint32_t subpassIndex = 0; subpassIndex < pCreateInfo->subpassCount; ++subpassIndex) 2202 { 2203 skipCall |= validate_reserved_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].flags", ParameterName::IndexVector{ subpassIndex }), pCreateInfo->pSubpasses[subpassIndex].flags); 2204 2205 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); 2206 2207 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); 2208 2209 if (pCreateInfo->pSubpasses[subpassIndex].pInputAttachments != NULL) 2210 { 2211 for (uint32_t inputAttachmentIndex = 0; inputAttachmentIndex < pCreateInfo->pSubpasses[subpassIndex].inputAttachmentCount; ++inputAttachmentIndex) 2212 { 2213 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); 2214 } 2215 } 2216 2217 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); 2218 2219 if (pCreateInfo->pSubpasses[subpassIndex].pColorAttachments != NULL) 2220 { 2221 for (uint32_t colorAttachmentIndex = 0; colorAttachmentIndex < pCreateInfo->pSubpasses[subpassIndex].colorAttachmentCount; ++colorAttachmentIndex) 2222 { 2223 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); 2224 } 2225 } 2226 2227 if (pCreateInfo->pSubpasses[subpassIndex].pResolveAttachments != NULL) 2228 { 2229 for (uint32_t colorAttachmentIndex = 0; colorAttachmentIndex < pCreateInfo->pSubpasses[subpassIndex].colorAttachmentCount; ++colorAttachmentIndex) 2230 { 2231 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); 2232 } 2233 } 2234 2235 if (pCreateInfo->pSubpasses[subpassIndex].pDepthStencilAttachment != NULL) 2236 { 2237 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); 2238 } 2239 2240 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); 2241 } 2242 } 2243 2244 skipCall |= validate_array(report_data, "vkCreateRenderPass", "pCreateInfo->dependencyCount", "pCreateInfo->pDependencies", pCreateInfo->dependencyCount, pCreateInfo->pDependencies, false, true); 2245 2246 if (pCreateInfo->pDependencies != NULL) 2247 { 2248 for (uint32_t dependencyIndex = 0; dependencyIndex < pCreateInfo->dependencyCount; ++dependencyIndex) 2249 { 2250 skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].srcStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcStageMask, true); 2251 2252 skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dstStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstStageMask, true); 2253 2254 skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].srcAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcAccessMask, false); 2255 2256 skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dstAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstAccessMask, false); 2257 2258 skipCall |= validate_flags(report_data, "vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dependencyFlags", ParameterName::IndexVector{ dependencyIndex }), "VkDependencyFlagBits", AllVkDependencyFlagBits, pCreateInfo->pDependencies[dependencyIndex].dependencyFlags, false); 2259 } 2260 } 2261 } 2262 2263 if (pAllocator != NULL) 2264 { 2265 skipCall |= validate_required_pointer(report_data, "vkCreateRenderPass", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 2266 2267 skipCall |= validate_required_pointer(report_data, "vkCreateRenderPass", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 2268 2269 skipCall |= validate_required_pointer(report_data, "vkCreateRenderPass", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 2270 } 2271 2272 skipCall |= validate_required_pointer(report_data, "vkCreateRenderPass", "pRenderPass", pRenderPass); 2273 2274 return skipCall; 2275 } 2276 2277 static bool parameter_validation_vkDestroyRenderPass( 2278 debug_report_data* report_data, 2279 VkRenderPass renderPass, 2280 const VkAllocationCallbacks* pAllocator) 2281 { 2282 UNUSED_PARAMETER(renderPass); 2283 2284 bool skipCall = false; 2285 2286 if (pAllocator != NULL) 2287 { 2288 skipCall |= validate_required_pointer(report_data, "vkDestroyRenderPass", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 2289 2290 skipCall |= validate_required_pointer(report_data, "vkDestroyRenderPass", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 2291 2292 skipCall |= validate_required_pointer(report_data, "vkDestroyRenderPass", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 2293 } 2294 2295 return skipCall; 2296 } 2297 2298 static bool parameter_validation_vkGetRenderAreaGranularity( 2299 debug_report_data* report_data, 2300 VkRenderPass renderPass, 2301 VkExtent2D* pGranularity) 2302 { 2303 bool skipCall = false; 2304 2305 skipCall |= validate_required_handle(report_data, "vkGetRenderAreaGranularity", "renderPass", renderPass); 2306 2307 skipCall |= validate_required_pointer(report_data, "vkGetRenderAreaGranularity", "pGranularity", pGranularity); 2308 2309 return skipCall; 2310 } 2311 2312 static bool parameter_validation_vkCreateCommandPool( 2313 debug_report_data* report_data, 2314 const VkCommandPoolCreateInfo* pCreateInfo, 2315 const VkAllocationCallbacks* pAllocator, 2316 VkCommandPool* pCommandPool) 2317 { 2318 bool skipCall = false; 2319 2320 skipCall |= validate_struct_type(report_data, "vkCreateCommandPool", "pCreateInfo", "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, true); 2321 2322 if (pCreateInfo != NULL) 2323 { 2324 skipCall |= validate_struct_pnext(report_data, "vkCreateCommandPool", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 2325 2326 skipCall |= validate_flags(report_data, "vkCreateCommandPool", "pCreateInfo->flags", "VkCommandPoolCreateFlagBits", AllVkCommandPoolCreateFlagBits, pCreateInfo->flags, false); 2327 } 2328 2329 if (pAllocator != NULL) 2330 { 2331 skipCall |= validate_required_pointer(report_data, "vkCreateCommandPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 2332 2333 skipCall |= validate_required_pointer(report_data, "vkCreateCommandPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 2334 2335 skipCall |= validate_required_pointer(report_data, "vkCreateCommandPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 2336 } 2337 2338 skipCall |= validate_required_pointer(report_data, "vkCreateCommandPool", "pCommandPool", pCommandPool); 2339 2340 return skipCall; 2341 } 2342 2343 static bool parameter_validation_vkDestroyCommandPool( 2344 debug_report_data* report_data, 2345 VkCommandPool commandPool, 2346 const VkAllocationCallbacks* pAllocator) 2347 { 2348 UNUSED_PARAMETER(commandPool); 2349 2350 bool skipCall = false; 2351 2352 if (pAllocator != NULL) 2353 { 2354 skipCall |= validate_required_pointer(report_data, "vkDestroyCommandPool", "pAllocator->pfnAllocation", reinterpret_cast<const void*>(pAllocator->pfnAllocation)); 2355 2356 skipCall |= validate_required_pointer(report_data, "vkDestroyCommandPool", "pAllocator->pfnReallocation", reinterpret_cast<const void*>(pAllocator->pfnReallocation)); 2357 2358 skipCall |= validate_required_pointer(report_data, "vkDestroyCommandPool", "pAllocator->pfnFree", reinterpret_cast<const void*>(pAllocator->pfnFree)); 2359 } 2360 2361 return skipCall; 2362 } 2363 2364 static bool parameter_validation_vkResetCommandPool( 2365 debug_report_data* report_data, 2366 VkCommandPool commandPool, 2367 VkCommandPoolResetFlags flags) 2368 { 2369 bool skipCall = false; 2370 2371 skipCall |= validate_required_handle(report_data, "vkResetCommandPool", "commandPool", commandPool); 2372 2373 skipCall |= validate_flags(report_data, "vkResetCommandPool", "flags", "VkCommandPoolResetFlagBits", AllVkCommandPoolResetFlagBits, flags, false); 2374 2375 return skipCall; 2376 } 2377 2378 static bool parameter_validation_vkAllocateCommandBuffers( 2379 debug_report_data* report_data, 2380 const VkCommandBufferAllocateInfo* pAllocateInfo, 2381 VkCommandBuffer* pCommandBuffers) 2382 { 2383 bool skipCall = false; 2384 2385 skipCall |= validate_struct_type(report_data, "vkAllocateCommandBuffers", "pAllocateInfo", "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO", pAllocateInfo, VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, true); 2386 2387 if (pAllocateInfo != NULL) 2388 { 2389 skipCall |= validate_struct_pnext(report_data, "vkAllocateCommandBuffers", "pAllocateInfo->pNext", NULL, pAllocateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 2390 2391 skipCall |= validate_required_handle(report_data, "vkAllocateCommandBuffers", "pAllocateInfo->commandPool", pAllocateInfo->commandPool); 2392 2393 skipCall |= validate_ranged_enum(report_data, "vkAllocateCommandBuffers", "pAllocateInfo->level", "VkCommandBufferLevel", VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE, VK_COMMAND_BUFFER_LEVEL_END_RANGE, pAllocateInfo->level); 2394 } 2395 2396 if (pAllocateInfo != NULL) { 2397 skipCall |= validate_array(report_data, "vkAllocateCommandBuffers", "pAllocateInfo->commandBufferCount", "pCommandBuffers", pAllocateInfo->commandBufferCount, pCommandBuffers, true, true); 2398 } 2399 2400 return skipCall; 2401 } 2402 2403 static bool parameter_validation_vkFreeCommandBuffers( 2404 debug_report_data* report_data, 2405 VkCommandPool commandPool, 2406 uint32_t commandBufferCount, 2407 const VkCommandBuffer* pCommandBuffers) 2408 { 2409 UNUSED_PARAMETER(pCommandBuffers); 2410 2411 bool skipCall = false; 2412 2413 skipCall |= validate_required_handle(report_data, "vkFreeCommandBuffers", "commandPool", commandPool); 2414 2415 return skipCall; 2416 } 2417 2418 static bool parameter_validation_vkBeginCommandBuffer( 2419 debug_report_data* report_data, 2420 const VkCommandBufferBeginInfo* pBeginInfo) 2421 { 2422 bool skipCall = false; 2423 2424 skipCall |= validate_struct_type(report_data, "vkBeginCommandBuffer", "pBeginInfo", "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO", pBeginInfo, VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, true); 2425 2426 if (pBeginInfo != NULL) 2427 { 2428 skipCall |= validate_struct_pnext(report_data, "vkBeginCommandBuffer", "pBeginInfo->pNext", NULL, pBeginInfo->pNext, 0, NULL, GeneratedHeaderVersion); 2429 2430 skipCall |= validate_flags(report_data, "vkBeginCommandBuffer", "pBeginInfo->flags", "VkCommandBufferUsageFlagBits", AllVkCommandBufferUsageFlagBits, pBeginInfo->flags, false); 2431 } 2432 2433 return skipCall; 2434 } 2435 2436 static bool parameter_validation_vkResetCommandBuffer( 2437 debug_report_data* report_data, 2438 VkCommandBufferResetFlags flags) 2439 { 2440 bool skipCall = false; 2441 2442 skipCall |= validate_flags(report_data, "vkResetCommandBuffer", "flags", "VkCommandBufferResetFlagBits", AllVkCommandBufferResetFlagBits, flags, false); 2443 2444 return skipCall; 2445 } 2446 2447 static bool parameter_validation_vkCmdBindPipeline( 2448 debug_report_data* report_data, 2449 VkPipelineBindPoint pipelineBindPoint, 2450 VkPipeline pipeline) 2451 { 2452 bool skipCall = false; 2453 2454 skipCall |= validate_ranged_enum(report_data, "vkCmdBindPipeline", "pipelineBindPoint", "VkPipelineBindPoint", VK_PIPELINE_BIND_POINT_BEGIN_RANGE, VK_PIPELINE_BIND_POINT_END_RANGE, pipelineBindPoint); 2455 2456 skipCall |= validate_required_handle(report_data, "vkCmdBindPipeline", "pipeline", pipeline); 2457 2458 return skipCall; 2459 } 2460 2461 static bool parameter_validation_vkCmdSetViewport( 2462 debug_report_data* report_data, 2463 uint32_t firstViewport, 2464 uint32_t viewportCount, 2465 const VkViewport* pViewports) 2466 { 2467 UNUSED_PARAMETER(firstViewport); 2468 2469 bool skipCall = false; 2470 2471 skipCall |= validate_array(report_data, "vkCmdSetViewport", "viewportCount", "pViewports", viewportCount, pViewports, true, true); 2472 2473 return skipCall; 2474 } 2475 2476 static bool parameter_validation_vkCmdSetScissor( 2477 debug_report_data* report_data, 2478 uint32_t firstScissor, 2479 uint32_t scissorCount, 2480 const VkRect2D* pScissors) 2481 { 2482 UNUSED_PARAMETER(firstScissor); 2483 2484 bool skipCall = false; 2485 2486 skipCall |= validate_array(report_data, "vkCmdSetScissor", "scissorCount", "pScissors", scissorCount, pScissors, true, true); 2487 2488 return skipCall; 2489 } 2490 2491 static bool parameter_validation_vkCmdSetBlendConstants( 2492 debug_report_data* report_data, 2493 const float blendConstants[4]) 2494 { 2495 bool skipCall = false; 2496 2497 skipCall |= validate_required_pointer(report_data, "vkCmdSetBlendConstants", "blendConstants", blendConstants); 2498 2499 return skipCall; 2500 } 2501 2502 static bool parameter_validation_vkCmdSetStencilCompareMask( 2503 debug_report_data* report_data, 2504 VkStencilFaceFlags faceMask, 2505 uint32_t compareMask) 2506 { 2507 UNUSED_PARAMETER(compareMask); 2508 2509 bool skipCall = false; 2510 2511 skipCall |= validate_flags(report_data, "vkCmdSetStencilCompareMask", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true); 2512 2513 return skipCall; 2514 } 2515 2516 static bool parameter_validation_vkCmdSetStencilWriteMask( 2517 debug_report_data* report_data, 2518 VkStencilFaceFlags faceMask, 2519 uint32_t writeMask) 2520 { 2521 UNUSED_PARAMETER(writeMask); 2522 2523 bool skipCall = false; 2524 2525 skipCall |= validate_flags(report_data, "vkCmdSetStencilWriteMask", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true); 2526 2527 return skipCall; 2528 } 2529 2530 static bool parameter_validation_vkCmdSetStencilReference( 2531 debug_report_data* report_data, 2532 VkStencilFaceFlags faceMask, 2533 uint32_t reference) 2534 { 2535 UNUSED_PARAMETER(reference); 2536 2537 bool skipCall = false; 2538 2539 skipCall |= validate_flags(report_data, "vkCmdSetStencilReference", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true); 2540 2541 return skipCall; 2542 } 2543 2544 static bool parameter_validation_vkCmdBindDescriptorSets( 2545 debug_report_data* report_data, 2546 VkPipelineBindPoint pipelineBindPoint, 2547 VkPipelineLayout layout, 2548 uint32_t firstSet, 2549 uint32_t descriptorSetCount, 2550 const VkDescriptorSet* pDescriptorSets, 2551 uint32_t dynamicOffsetCount, 2552 const uint32_t* pDynamicOffsets) 2553 { 2554 UNUSED_PARAMETER(firstSet); 2555 2556 bool skipCall = false; 2557 2558 skipCall |= validate_ranged_enum(report_data, "vkCmdBindDescriptorSets", "pipelineBindPoint", "VkPipelineBindPoint", VK_PIPELINE_BIND_POINT_BEGIN_RANGE, VK_PIPELINE_BIND_POINT_END_RANGE, pipelineBindPoint); 2559 2560 skipCall |= validate_required_handle(report_data, "vkCmdBindDescriptorSets", "layout", layout); 2561 2562 skipCall |= validate_handle_array(report_data, "vkCmdBindDescriptorSets", "descriptorSetCount", "pDescriptorSets", descriptorSetCount, pDescriptorSets, true, true); 2563 2564 skipCall |= validate_array(report_data, "vkCmdBindDescriptorSets", "dynamicOffsetCount", "pDynamicOffsets", dynamicOffsetCount, pDynamicOffsets, false, true); 2565 2566 return skipCall; 2567 } 2568 2569 static bool parameter_validation_vkCmdBindIndexBuffer( 2570 debug_report_data* report_data, 2571 VkBuffer buffer, 2572 VkDeviceSize offset, 2573 VkIndexType indexType) 2574 { 2575 UNUSED_PARAMETER(offset); 2576 2577 bool skipCall = false; 2578 2579 skipCall |= validate_required_handle(report_data, "vkCmdBindIndexBuffer", "buffer", buffer); 2580 2581 skipCall |= validate_ranged_enum(report_data, "vkCmdBindIndexBuffer", "indexType", "VkIndexType", VK_INDEX_TYPE_BEGIN_RANGE, VK_INDEX_TYPE_END_RANGE, indexType); 2582 2583 return skipCall; 2584 } 2585 2586 static bool parameter_validation_vkCmdBindVertexBuffers( 2587 debug_report_data* report_data, 2588 uint32_t firstBinding, 2589 uint32_t bindingCount, 2590 const VkBuffer* pBuffers, 2591 const VkDeviceSize* pOffsets) 2592 { 2593 UNUSED_PARAMETER(firstBinding); 2594 2595 bool skipCall = false; 2596 2597 skipCall |= validate_handle_array(report_data, "vkCmdBindVertexBuffers", "bindingCount", "pBuffers", bindingCount, pBuffers, true, true); 2598 2599 skipCall |= validate_array(report_data, "vkCmdBindVertexBuffers", "bindingCount", "pOffsets", bindingCount, pOffsets, true, true); 2600 2601 return skipCall; 2602 } 2603 2604 static bool parameter_validation_vkCmdDrawIndirect( 2605 debug_report_data* report_data, 2606 VkBuffer buffer, 2607 VkDeviceSize offset, 2608 uint32_t drawCount, 2609 uint32_t stride) 2610 { 2611 UNUSED_PARAMETER(offset); 2612 UNUSED_PARAMETER(drawCount); 2613 UNUSED_PARAMETER(stride); 2614 2615 bool skipCall = false; 2616 2617 skipCall |= validate_required_handle(report_data, "vkCmdDrawIndirect", "buffer", buffer); 2618 2619 return skipCall; 2620 } 2621 2622 static bool parameter_validation_vkCmdDrawIndexedIndirect( 2623 debug_report_data* report_data, 2624 VkBuffer buffer, 2625 VkDeviceSize offset, 2626 uint32_t drawCount, 2627 uint32_t stride) 2628 { 2629 UNUSED_PARAMETER(offset); 2630 UNUSED_PARAMETER(drawCount); 2631 UNUSED_PARAMETER(stride); 2632 2633 bool skipCall = false; 2634 2635 skipCall |= validate_required_handle(report_data, "vkCmdDrawIndexedIndirect", "buffer", buffer); 2636 2637 return skipCall; 2638 } 2639 2640 static bool parameter_validation_vkCmdDispatchIndirect( 2641 debug_report_data* report_data, 2642 VkBuffer buffer, 2643 VkDeviceSize offset) 2644 { 2645 UNUSED_PARAMETER(offset); 2646 2647 bool skipCall = false; 2648 2649 skipCall |= validate_required_handle(report_data, "vkCmdDispatchIndirect", "buffer", buffer); 2650 2651 return skipCall; 2652 } 2653 2654 static bool parameter_validation_vkCmdCopyBuffer( 2655 debug_report_data* report_data, 2656 VkBuffer srcBuffer, 2657 VkBuffer dstBuffer, 2658 uint32_t regionCount, 2659 const VkBufferCopy* pRegions) 2660 { 2661 bool skipCall = false; 2662 2663 skipCall |= validate_required_handle(report_data, "vkCmdCopyBuffer", "srcBuffer", srcBuffer); 2664 2665 skipCall |= validate_required_handle(report_data, "vkCmdCopyBuffer", "dstBuffer", dstBuffer); 2666 2667 skipCall |= validate_array(report_data, "vkCmdCopyBuffer", "regionCount", "pRegions", regionCount, pRegions, true, true); 2668 2669 return skipCall; 2670 } 2671 2672 static bool parameter_validation_vkCmdCopyImage( 2673 debug_report_data* report_data, 2674 VkImage srcImage, 2675 VkImageLayout srcImageLayout, 2676 VkImage dstImage, 2677 VkImageLayout dstImageLayout, 2678 uint32_t regionCount, 2679 const VkImageCopy* pRegions) 2680 { 2681 bool skipCall = false; 2682 2683 skipCall |= validate_required_handle(report_data, "vkCmdCopyImage", "srcImage", srcImage); 2684 2685 skipCall |= validate_ranged_enum(report_data, "vkCmdCopyImage", "srcImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, srcImageLayout); 2686 2687 skipCall |= validate_required_handle(report_data, "vkCmdCopyImage", "dstImage", dstImage); 2688 2689 skipCall |= validate_ranged_enum(report_data, "vkCmdCopyImage", "dstImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, dstImageLayout); 2690 2691 skipCall |= validate_array(report_data, "vkCmdCopyImage", "regionCount", "pRegions", regionCount, pRegions, true, true); 2692 2693 if (pRegions != NULL) 2694 { 2695 for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex) 2696 { 2697 skipCall |= validate_flags(report_data, "vkCmdCopyImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true); 2698 2699 skipCall |= validate_flags(report_data, "vkCmdCopyImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true); 2700 } 2701 } 2702 2703 return skipCall; 2704 } 2705 2706 static bool parameter_validation_vkCmdBlitImage( 2707 debug_report_data* report_data, 2708 VkImage srcImage, 2709 VkImageLayout srcImageLayout, 2710 VkImage dstImage, 2711 VkImageLayout dstImageLayout, 2712 uint32_t regionCount, 2713 const VkImageBlit* pRegions, 2714 VkFilter filter) 2715 { 2716 bool skipCall = false; 2717 2718 skipCall |= validate_required_handle(report_data, "vkCmdBlitImage", "srcImage", srcImage); 2719 2720 skipCall |= validate_ranged_enum(report_data, "vkCmdBlitImage", "srcImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, srcImageLayout); 2721 2722 skipCall |= validate_required_handle(report_data, "vkCmdBlitImage", "dstImage", dstImage); 2723 2724 skipCall |= validate_ranged_enum(report_data, "vkCmdBlitImage", "dstImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, dstImageLayout); 2725 2726 skipCall |= validate_array(report_data, "vkCmdBlitImage", "regionCount", "pRegions", regionCount, pRegions, true, true); 2727 2728 if (pRegions != NULL) 2729 { 2730 for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex) 2731 { 2732 skipCall |= validate_flags(report_data, "vkCmdBlitImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true); 2733 2734 skipCall |= validate_flags(report_data, "vkCmdBlitImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true); 2735 } 2736 } 2737 2738 skipCall |= validate_ranged_enum(report_data, "vkCmdBlitImage", "filter", "VkFilter", VK_FILTER_BEGIN_RANGE, VK_FILTER_END_RANGE, filter); 2739 2740 return skipCall; 2741 } 2742 2743 static bool parameter_validation_vkCmdCopyBufferToImage( 2744 debug_report_data* report_data, 2745 VkBuffer srcBuffer, 2746 VkImage dstImage, 2747 VkImageLayout dstImageLayout, 2748 uint32_t regionCount, 2749 const VkBufferImageCopy* pRegions) 2750 { 2751 bool skipCall = false; 2752 2753 skipCall |= validate_required_handle(report_data, "vkCmdCopyBufferToImage", "srcBuffer", srcBuffer); 2754 2755 skipCall |= validate_required_handle(report_data, "vkCmdCopyBufferToImage", "dstImage", dstImage); 2756 2757 skipCall |= validate_ranged_enum(report_data, "vkCmdCopyBufferToImage", "dstImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, dstImageLayout); 2758 2759 skipCall |= validate_array(report_data, "vkCmdCopyBufferToImage", "regionCount", "pRegions", regionCount, pRegions, true, true); 2760 2761 if (pRegions != NULL) 2762 { 2763 for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex) 2764 { 2765 skipCall |= validate_flags(report_data, "vkCmdCopyBufferToImage", ParameterName("pRegions[%i].imageSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].imageSubresource.aspectMask, true); 2766 } 2767 } 2768 2769 return skipCall; 2770 } 2771 2772 static bool parameter_validation_vkCmdCopyImageToBuffer( 2773 debug_report_data* report_data, 2774 VkImage srcImage, 2775 VkImageLayout srcImageLayout, 2776 VkBuffer dstBuffer, 2777 uint32_t regionCount, 2778 const VkBufferImageCopy* pRegions) 2779 { 2780 bool skipCall = false; 2781 2782 skipCall |= validate_required_handle(report_data, "vkCmdCopyImageToBuffer", "srcImage", srcImage); 2783 2784 skipCall |= validate_ranged_enum(report_data, "vkCmdCopyImageToBuffer", "srcImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, srcImageLayout); 2785 2786 skipCall |= validate_required_handle(report_data, "vkCmdCopyImageToBuffer", "dstBuffer", dstBuffer); 2787 2788 skipCall |= validate_array(report_data, "vkCmdCopyImageToBuffer", "regionCount", "pRegions", regionCount, pRegions, true, true); 2789 2790 if (pRegions != NULL) 2791 { 2792 for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex) 2793 { 2794 skipCall |= validate_flags(report_data, "vkCmdCopyImageToBuffer", ParameterName("pRegions[%i].imageSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].imageSubresource.aspectMask, true); 2795 } 2796 } 2797 2798 return skipCall; 2799 } 2800 2801 static bool parameter_validation_vkCmdUpdateBuffer( 2802 debug_report_data* report_data, 2803 VkBuffer dstBuffer, 2804 VkDeviceSize dstOffset, 2805 VkDeviceSize dataSize, 2806 const void* pData) 2807 { 2808 UNUSED_PARAMETER(dstOffset); 2809 2810 bool skipCall = false; 2811 2812 skipCall |= validate_required_handle(report_data, "vkCmdUpdateBuffer", "dstBuffer", dstBuffer); 2813 2814 skipCall |= validate_array(report_data, "vkCmdUpdateBuffer", "dataSize", "pData", dataSize, pData, true, true); 2815 2816 return skipCall; 2817 } 2818 2819 static bool parameter_validation_vkCmdFillBuffer( 2820 debug_report_data* report_data, 2821 VkBuffer dstBuffer, 2822 VkDeviceSize dstOffset, 2823 VkDeviceSize size, 2824 uint32_t data) 2825 { 2826 UNUSED_PARAMETER(dstOffset); 2827 UNUSED_PARAMETER(size); 2828 UNUSED_PARAMETER(data); 2829 2830 bool skipCall = false; 2831 2832 skipCall |= validate_required_handle(report_data, "vkCmdFillBuffer", "dstBuffer", dstBuffer); 2833 2834 return skipCall; 2835 } 2836 2837 static bool parameter_validation_vkCmdClearColorImage( 2838 debug_report_data* report_data, 2839 VkImage image, 2840 VkImageLayout imageLayout, 2841 const VkClearColorValue* pColor, 2842 uint32_t rangeCount, 2843 const VkImageSubresourceRange* pRanges) 2844 { 2845 bool skipCall = false; 2846 2847 skipCall |= validate_required_handle(report_data, "vkCmdClearColorImage", "image", image); 2848 2849 skipCall |= validate_ranged_enum(report_data, "vkCmdClearColorImage", "imageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, imageLayout); 2850 2851 skipCall |= validate_required_pointer(report_data, "vkCmdClearColorImage", "pColor", pColor); 2852 2853 skipCall |= validate_array(report_data, "vkCmdClearColorImage", "rangeCount", "pRanges", rangeCount, pRanges, true, true); 2854 2855 if (pRanges != NULL) 2856 { 2857 for (uint32_t rangeIndex = 0; rangeIndex < rangeCount; ++rangeIndex) 2858 { 2859 skipCall |= validate_flags(report_data, "vkCmdClearColorImage", ParameterName("pRanges[%i].aspectMask", ParameterName::IndexVector{ rangeIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRanges[rangeIndex].aspectMask, true); 2860 } 2861 } 2862 2863 return skipCall; 2864 } 2865 2866 static bool parameter_validation_vkCmdClearDepthStencilImage( 2867 debug_report_data* report_data, 2868 VkImage image, 2869 VkImageLayout imageLayout, 2870 const VkClearDepthStencilValue* pDepthStencil, 2871 uint32_t rangeCount, 2872 const VkImageSubresourceRange* pRanges) 2873 { 2874 bool skipCall = false; 2875 2876 skipCall |= validate_required_handle(report_data, "vkCmdClearDepthStencilImage", "image", image); 2877 2878 skipCall |= validate_ranged_enum(report_data, "vkCmdClearDepthStencilImage", "imageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, imageLayout); 2879 2880 skipCall |= validate_required_pointer(report_data, "vkCmdClearDepthStencilImage", "pDepthStencil", pDepthStencil); 2881 2882 skipCall |= validate_array(report_data, "vkCmdClearDepthStencilImage", "rangeCount", "pRanges", rangeCount, pRanges, true, true); 2883 2884 if (pRanges != NULL) 2885 { 2886 for (uint32_t rangeIndex = 0; rangeIndex < rangeCount; ++rangeIndex) 2887 { 2888 skipCall |= validate_flags(report_data, "vkCmdClearDepthStencilImage", ParameterName("pRanges[%i].aspectMask", ParameterName::IndexVector{ rangeIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRanges[rangeIndex].aspectMask, true); 2889 } 2890 } 2891 2892 return skipCall; 2893 } 2894 2895 static bool parameter_validation_vkCmdClearAttachments( 2896 debug_report_data* report_data, 2897 uint32_t attachmentCount, 2898 const VkClearAttachment* pAttachments, 2899 uint32_t rectCount, 2900 const VkClearRect* pRects) 2901 { 2902 bool skipCall = false; 2903 2904 skipCall |= validate_array(report_data, "vkCmdClearAttachments", "attachmentCount", "pAttachments", attachmentCount, pAttachments, true, true); 2905 2906 if (pAttachments != NULL) 2907 { 2908 for (uint32_t attachmentIndex = 0; attachmentIndex < attachmentCount; ++attachmentIndex) 2909 { 2910 skipCall |= validate_flags(report_data, "vkCmdClearAttachments", ParameterName("pAttachments[%i].aspectMask", ParameterName::IndexVector{ attachmentIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pAttachments[attachmentIndex].aspectMask, true); 2911 } 2912 } 2913 2914 skipCall |= validate_array(report_data, "vkCmdClearAttachments", "rectCount", "pRects", rectCount, pRects, true, true); 2915 2916 return skipCall; 2917 } 2918 2919 static bool parameter_validation_vkCmdResolveImage( 2920 debug_report_data* report_data, 2921 VkImage srcImage, 2922 VkImageLayout srcImageLayout, 2923 VkImage dstImage, 2924 VkImageLayout dstImageLayout, 2925 uint32_t regionCount, 2926 const VkImageResolve* pRegions) 2927 { 2928 bool skipCall = false; 2929 2930 skipCall |= validate_required_handle(report_data, "vkCmdResolveImage", "srcImage", srcImage); 2931 2932 skipCall |= validate_ranged_enum(report_data, "vkCmdResolveImage", "srcImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, srcImageLayout); 2933 2934 skipCall |= validate_required_handle(report_data, "vkCmdResolveImage", "dstImage", dstImage); 2935 2936 skipCall |= validate_ranged_enum(report_data, "vkCmdResolveImage", "dstImageLayout", "VkImageLayout", VK_IMAGE_LAYOUT_BEGIN_RANGE, VK_IMAGE_LAYOUT_END_RANGE, dstImageLayout); 2937 2938 skipCall |= validate_array(report_data, "vkCmdResolveImage", "regionCount", "pRegions", regionCount, pRegions, true, true); 2939 2940 if (pRegions != NULL) 2941 { 2942 for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex) 2943 { 2944 skipCall |= validate_flags(report_data, "vkCmdResolveImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true); 2945 2946 skipCall |= validate_flags(report_data, "vkCmdResolveImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true); 2947 } 2948 } 2949 2950 return skipCall; 2951 } 2952 2953 static bool parameter_validation_vkCmdSetEvent( 2954 debug_report_data* report_data, 2955 VkEvent event, 2956 VkPipelineStageFlags stageMask) 2957 { 2958 bool skipCall = false; 2959 2960 skipCall |= validate_required_handle(report_data, "vkCmdSetEvent", "event", event); 2961 2962 skipCall |= validate_flags(report_data, "vkCmdSetEvent", "stageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, stageMask, true); 2963 2964 return skipCall; 2965 } 2966 2967 static bool parameter_validation_vkCmdResetEvent( 2968 debug_report_data* report_data, 2969 VkEvent event, 2970 VkPipelineStageFlags stageMask) 2971 { 2972 bool skipCall = false; 2973 2974 skipCall |= validate_required_handle(report_data, "vkCmdResetEvent", "event", event); 2975 2976 skipCall |= validate_flags(report_data, "vkCmdResetEvent", "stageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, stageMask, true); 2977 2978 return skipCall; 2979 } 2980 2981 static bool parameter_validation_vkCmdWaitEvents( 2982 debug_report_data* report_data, 2983 uint32_t eventCount, 2984 const VkEvent* pEvents, 2985 VkPipelineStageFlags srcStageMask, 2986 VkPipelineStageFlags dstStageMask, 2987 uint32_t memoryBarrierCount, 2988 const VkMemoryBarrier* pMemoryBarriers, 2989 uint32_t bufferMemoryBarrierCount, 2990 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 2991 uint32_t imageMemoryBarrierCount, 2992 const VkImageMemoryBarrier* pImageMemoryBarriers) 2993 { 2994 bool skipCall = false; 2995 2996 skipCall |= validate_handle_array(report_data, "vkCmdWaitEvents", "eventCount", "pEvents", eventCount, pEvents, true, true); 2997 2998 skipCall |= validate_flags(report_data, "vkCmdWaitEvents", "srcStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, srcStageMask, true); 2999 3000 skipCall |= validate_flags(report_data, "vkCmdWaitEvents", "dstStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, dstStageMask, true); 3001 3002 skipCall |= validate_struct_type_array(report_data, "vkCmdWaitEvents", "memoryBarrierCount", "pMemoryBarriers", "VK_STRUCTURE_TYPE_MEMORY_BARRIER", memoryBarrierCount, pMemoryBarriers, VK_STRUCTURE_TYPE_MEMORY_BARRIER, false, true); 3003 3004 if (pMemoryBarriers != NULL) 3005 { 3006 for (uint32_t memoryBarrierIndex = 0; memoryBarrierIndex < memoryBarrierCount; ++memoryBarrierIndex) 3007 { 3008 skipCall |= validate_struct_pnext(report_data, "vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].pNext", ParameterName::IndexVector{ memoryBarrierIndex }), NULL, pMemoryBarriers[memoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion); 3009 3010 skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].srcAccessMask, false); 3011 3012 skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].dstAccessMask, false); 3013 } 3014 } 3015 3016 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); 3017 3018 if (pBufferMemoryBarriers != NULL) 3019 { 3020 for (uint32_t bufferMemoryBarrierIndex = 0; bufferMemoryBarrierIndex < bufferMemoryBarrierCount; ++bufferMemoryBarrierIndex) 3021 { 3022 skipCall |= validate_struct_pnext(report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].pNext", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), NULL, pBufferMemoryBarriers[bufferMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion); 3023 3024 skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].srcAccessMask, false); 3025 3026 skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].dstAccessMask, false); 3027 3028 skipCall |= validate_required_handle(report_data, "vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].buffer", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), pBufferMemoryBarriers[bufferMemoryBarrierIndex].buffer); 3029 } 3030 } 3031 3032 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); 3033 3034 if (pImageMemoryBarriers != NULL) 3035 { 3036 for (uint32_t imageMemoryBarrierIndex = 0; imageMemoryBarrierIndex < imageMemoryBarrierCount; ++imageMemoryBarrierIndex) 3037 { 3038 skipCall |= validate_struct_pnext(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].pNext", ParameterName::IndexVector{ imageMemoryBarrierIndex }), NULL, pImageMemoryBarriers[imageMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion); 3039 3040 skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].srcAccessMask, false); 3041 3042 skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].dstAccessMask, false); 3043 3044 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); 3045 3046 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); 3047 3048 skipCall |= validate_required_handle(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].image", ParameterName::IndexVector{ imageMemoryBarrierIndex }), pImageMemoryBarriers[imageMemoryBarrierIndex].image); 3049 3050 skipCall |= validate_flags(report_data, "vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].subresourceRange.aspectMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].subresourceRange.aspectMask, true); 3051 } 3052 } 3053 3054 return skipCall; 3055 } 3056 3057 static bool parameter_validation_vkCmdPipelineBarrier( 3058 debug_report_data* report_data, 3059 VkPipelineStageFlags srcStageMask, 3060 VkPipelineStageFlags dstStageMask, 3061 VkDependencyFlags dependencyFlags, 3062 uint32_t memoryBarrierCount, 3063 const VkMemoryBarrier* pMemoryBarriers, 3064 uint32_t bufferMemoryBarrierCount, 3065 const VkBufferMemoryBarrier* pBufferMemoryBarriers, 3066 uint32_t imageMemoryBarrierCount, 3067 const VkImageMemoryBarrier* pImageMemoryBarriers) 3068 { 3069 bool skipCall = false; 3070 3071 skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", "srcStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, srcStageMask, true); 3072 3073 skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", "dstStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, dstStageMask, true); 3074 3075 skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", "dependencyFlags", "VkDependencyFlagBits", AllVkDependencyFlagBits, dependencyFlags, false); 3076 3077 skipCall |= validate_struct_type_array(report_data, "vkCmdPipelineBarrier", "memoryBarrierCount", "pMemoryBarriers", "VK_STRUCTURE_TYPE_MEMORY_BARRIER", memoryBarrierCount, pMemoryBarriers, VK_STRUCTURE_TYPE_MEMORY_BARRIER, false, true); 3078 3079 if (pMemoryBarriers != NULL) 3080 { 3081 for (uint32_t memoryBarrierIndex = 0; memoryBarrierIndex < memoryBarrierCount; ++memoryBarrierIndex) 3082 { 3083 skipCall |= validate_struct_pnext(report_data, "vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].pNext", ParameterName::IndexVector{ memoryBarrierIndex }), NULL, pMemoryBarriers[memoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion); 3084 3085 skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].srcAccessMask, false); 3086 3087 skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].dstAccessMask, false); 3088 } 3089 } 3090 3091 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); 3092 3093 if (pBufferMemoryBarriers != NULL) 3094 { 3095 for (uint32_t bufferMemoryBarrierIndex = 0; bufferMemoryBarrierIndex < bufferMemoryBarrierCount; ++bufferMemoryBarrierIndex) 3096 { 3097 skipCall |= validate_struct_pnext(report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].pNext", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), NULL, pBufferMemoryBarriers[bufferMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion); 3098 3099 skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].srcAccessMask, false); 3100 3101 skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].dstAccessMask, false); 3102 3103 skipCall |= validate_required_handle(report_data, "vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].buffer", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), pBufferMemoryBarriers[bufferMemoryBarrierIndex].buffer); 3104 } 3105 } 3106 3107 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); 3108 3109 if (pImageMemoryBarriers != NULL) 3110 { 3111 for (uint32_t imageMemoryBarrierIndex = 0; imageMemoryBarrierIndex < imageMemoryBarrierCount; ++imageMemoryBarrierIndex) 3112 { 3113 skipCall |= validate_struct_pnext(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].pNext", ParameterName::IndexVector{ imageMemoryBarrierIndex }), NULL, pImageMemoryBarriers[imageMemoryBarrierIndex].pNext, 0, NULL, GeneratedHeaderVersion); 3114 3115 skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].srcAccessMask, false); 3116 3117 skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].dstAccessMask, false); 3118 3119 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); 3120 3121 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); 3122 3123 skipCall |= validate_required_handle(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].image", ParameterName::IndexVector{ imageMemoryBarrierIndex }), pImageMemoryBarriers[imageMemoryBarrierIndex].image); 3124 3125 skipCall |= validate_flags(report_data, "vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].subresourceRange.aspectMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].subresourceRange.aspectMask, true); 3126 } 3127 } 3128 3129 return skipCall; 3130 } 3131 3132 static bool parameter_validation_vkCmdBeginQuery( 3133 debug_report_data* report_data, 3134 VkQueryPool queryPool, 3135 uint32_t query, 3136 VkQueryControlFlags flags) 3137 { 3138 UNUSED_PARAMETER(query); 3139 3140 bool skipCall = false; 3141 3142 skipCall |= validate_required_handle(report_data, "vkCmdBeginQuery", "queryPool", queryPool); 3143 3144 skipCall |= validate_flags(report_data, "vkCmdBeginQuery", "flags", "VkQueryControlFlagBits", AllVkQueryControlFlagBits, flags, false); 3145 3146 return skipCall; 3147 } 3148 3149 static bool parameter_validation_vkCmdEndQuery( 3150 debug_report_data* report_data, 3151 VkQueryPool queryPool, 3152 uint32_t query) 3153 { 3154 UNUSED_PARAMETER(query); 3155 3156 bool skipCall = false; 3157 3158 skipCall |= validate_required_handle(report_data, "vkCmdEndQuery", "queryPool", queryPool); 3159 3160 return skipCall; 3161 } 3162 3163 static bool parameter_validation_vkCmdResetQueryPool( 3164 debug_report_data* report_data, 3165 VkQueryPool queryPool, 3166 uint32_t firstQuery, 3167 uint32_t queryCount) 3168 { 3169 UNUSED_PARAMETER(firstQuery); 3170 UNUSED_PARAMETER(queryCount); 3171 3172 bool skipCall = false; 3173 3174 skipCall |= validate_required_handle(report_data, "vkCmdResetQueryPool", "queryPool", queryPool); 3175 3176 return skipCall; 3177 } 3178 3179 static bool parameter_validation_vkCmdWriteTimestamp( 3180 debug_report_data* report_data, 3181 VkPipelineStageFlagBits pipelineStage, 3182 VkQueryPool queryPool, 3183 uint32_t query) 3184 { 3185 UNUSED_PARAMETER(pipelineStage); 3186 UNUSED_PARAMETER(query); 3187 3188 bool skipCall = false; 3189 3190 skipCall |= validate_required_handle(report_data, "vkCmdWriteTimestamp", "queryPool", queryPool); 3191 3192 return skipCall; 3193 } 3194 3195 static bool parameter_validation_vkCmdCopyQueryPoolResults( 3196 debug_report_data* report_data, 3197 VkQueryPool queryPool, 3198 uint32_t firstQuery, 3199 uint32_t queryCount, 3200 VkBuffer dstBuffer, 3201 VkDeviceSize dstOffset, 3202 VkDeviceSize stride, 3203 VkQueryResultFlags flags) 3204 { 3205 UNUSED_PARAMETER(firstQuery); 3206 UNUSED_PARAMETER(queryCount); 3207 UNUSED_PARAMETER(dstOffset); 3208 UNUSED_PARAMETER(stride); 3209 3210 bool skipCall = false; 3211 3212 skipCall |= validate_required_handle(report_data, "vkCmdCopyQueryPoolResults", "queryPool", queryPool); 3213 3214 skipCall |= validate_required_handle(report_data, "vkCmdCopyQueryPoolResults", "dstBuffer", dstBuffer); 3215 3216 skipCall |= validate_flags(report_data, "vkCmdCopyQueryPoolResults", "flags", "VkQueryResultFlagBits", AllVkQueryResultFlagBits, flags, false); 3217 3218 return skipCall; 3219 } 3220 3221 static bool parameter_validation_vkCmdPushConstants( 3222 debug_report_data* report_data, 3223 VkPipelineLayout layout, 3224 VkShaderStageFlags stageFlags, 3225 uint32_t offset, 3226 uint32_t size, 3227 const void* pValues) 3228 { 3229 UNUSED_PARAMETER(offset); 3230 3231 bool skipCall = false; 3232 3233 skipCall |= validate_required_handle(report_data, "vkCmdPushConstants", "layout", layout); 3234 3235 skipCall |= validate_flags(report_data, "vkCmdPushConstants", "stageFlags", "VkShaderStageFlagBits", AllVkShaderStageFlagBits, stageFlags, true); 3236 3237 skipCall |= validate_array(report_data, "vkCmdPushConstants", "size", "pValues", size, pValues, true, true); 3238 3239 return skipCall; 3240 } 3241 3242 static bool parameter_validation_vkCmdBeginRenderPass( 3243 debug_report_data* report_data, 3244 const VkRenderPassBeginInfo* pRenderPassBegin, 3245 VkSubpassContents contents) 3246 { 3247 bool skipCall = false; 3248 3249 skipCall |= validate_struct_type(report_data, "vkCmdBeginRenderPass", "pRenderPassBegin", "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO", pRenderPassBegin, VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, true); 3250 3251 if (pRenderPassBegin != NULL) 3252 { 3253 skipCall |= validate_struct_pnext(report_data, "vkCmdBeginRenderPass", "pRenderPassBegin->pNext", NULL, pRenderPassBegin->pNext, 0, NULL, GeneratedHeaderVersion); 3254 3255 skipCall |= validate_required_handle(report_data, "vkCmdBeginRenderPass", "pRenderPassBegin->renderPass", pRenderPassBegin->renderPass); 3256 3257 skipCall |= validate_required_handle(report_data, "vkCmdBeginRenderPass", "pRenderPassBegin->framebuffer", pRenderPassBegin->framebuffer); 3258 3259 skipCall |= validate_array(report_data, "vkCmdBeginRenderPass", "pRenderPassBegin->clearValueCount", "pRenderPassBegin->pClearValues", pRenderPassBegin->clearValueCount, pRenderPassBegin->pClearValues, false, true); 3260 } 3261 3262 skipCall |= validate_ranged_enum(report_data, "vkCmdBeginRenderPass", "contents", "VkSubpassContents", VK_SUBPASS_CONTENTS_BEGIN_RANGE, VK_SUBPASS_CONTENTS_END_RANGE, contents); 3263 3264 return skipCall; 3265 } 3266 3267 static bool parameter_validation_vkCmdNextSubpass( 3268 debug_report_data* report_data, 3269 VkSubpassContents contents) 3270 { 3271 bool skipCall = false; 3272 3273 skipCall |= validate_ranged_enum(report_data, "vkCmdNextSubpass", "contents", "VkSubpassContents", VK_SUBPASS_CONTENTS_BEGIN_RANGE, VK_SUBPASS_CONTENTS_END_RANGE, contents); 3274 3275 return skipCall; 3276 } 3277 3278 static bool parameter_validation_vkCmdExecuteCommands( 3279 debug_report_data* report_data, 3280 uint32_t commandBufferCount, 3281 const VkCommandBuffer* pCommandBuffers) 3282 { 3283 bool skipCall = false; 3284 3285 skipCall |= validate_handle_array(report_data, "vkCmdExecuteCommands", "commandBufferCount", "pCommandBuffers", commandBufferCount, pCommandBuffers, true, true); 3286 3287 return skipCall; 3288 } 3289 3290 3291 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; 3292 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; 3293 3294 static bool parameter_validation_vkGetPhysicalDeviceSurfaceSupportKHR( 3295 debug_report_data* report_data, 3296 uint32_t queueFamilyIndex, 3297 VkSurfaceKHR surface, 3298 VkBool32* pSupported) 3299 { 3300 UNUSED_PARAMETER(queueFamilyIndex); 3301 3302 bool skipCall = false; 3303 3304 skipCall |= validate_required_handle(report_data, "vkGetPhysicalDeviceSurfaceSupportKHR", "surface", surface); 3305 3306 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceSurfaceSupportKHR", "pSupported", pSupported); 3307 3308 return skipCall; 3309 } 3310 3311 static bool parameter_validation_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( 3312 debug_report_data* report_data, 3313 VkSurfaceKHR surface, 3314 VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) 3315 { 3316 bool skipCall = false; 3317 3318 skipCall |= validate_required_handle(report_data, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", "surface", surface); 3319 3320 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", "pSurfaceCapabilities", pSurfaceCapabilities); 3321 3322 return skipCall; 3323 } 3324 3325 static bool parameter_validation_vkGetPhysicalDeviceSurfaceFormatsKHR( 3326 debug_report_data* report_data, 3327 VkSurfaceKHR surface, 3328 uint32_t* pSurfaceFormatCount, 3329 VkSurfaceFormatKHR* pSurfaceFormats) 3330 { 3331 bool skipCall = false; 3332 3333 skipCall |= validate_required_handle(report_data, "vkGetPhysicalDeviceSurfaceFormatsKHR", "surface", surface); 3334 3335 skipCall |= validate_array(report_data, "vkGetPhysicalDeviceSurfaceFormatsKHR", "pSurfaceFormatCount", "pSurfaceFormats", pSurfaceFormatCount, pSurfaceFormats, true, false, false); 3336 3337 return skipCall; 3338 } 3339 3340 static bool parameter_validation_vkGetPhysicalDeviceSurfacePresentModesKHR( 3341 debug_report_data* report_data, 3342 VkSurfaceKHR surface, 3343 uint32_t* pPresentModeCount, 3344 VkPresentModeKHR* pPresentModes) 3345 { 3346 bool skipCall = false; 3347 3348 skipCall |= validate_required_handle(report_data, "vkGetPhysicalDeviceSurfacePresentModesKHR", "surface", surface); 3349 3350 skipCall |= validate_array(report_data, "vkGetPhysicalDeviceSurfacePresentModesKHR", "pPresentModeCount", "pPresentModes", pPresentModeCount, pPresentModes, true, false, false); 3351 3352 return skipCall; 3353 } 3354 3355 3356 3357 static bool parameter_validation_vkCreateSwapchainKHR( 3358 debug_report_data* report_data, 3359 const VkSwapchainCreateInfoKHR* pCreateInfo, 3360 const VkAllocationCallbacks* pAllocator, 3361 VkSwapchainKHR* pSwapchain) 3362 { 3363 UNUSED_PARAMETER(pAllocator); 3364 3365 bool skipCall = false; 3366 3367 skipCall |= validate_struct_type(report_data, "vkCreateSwapchainKHR", "pCreateInfo", "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR", pCreateInfo, VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, true); 3368 3369 if (pCreateInfo != NULL) 3370 { 3371 skipCall |= validate_struct_pnext(report_data, "vkCreateSwapchainKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 3372 3373 skipCall |= validate_reserved_flags(report_data, "vkCreateSwapchainKHR", "pCreateInfo->flags", pCreateInfo->flags); 3374 3375 skipCall |= validate_bool32(report_data, "vkCreateSwapchainKHR", "pCreateInfo->clipped", pCreateInfo->clipped); 3376 } 3377 3378 skipCall |= validate_required_pointer(report_data, "vkCreateSwapchainKHR", "pSwapchain", pSwapchain); 3379 3380 return skipCall; 3381 } 3382 3383 static bool parameter_validation_vkGetSwapchainImagesKHR( 3384 debug_report_data* report_data, 3385 VkSwapchainKHR swapchain, 3386 uint32_t* pSwapchainImageCount, 3387 VkImage* pSwapchainImages) 3388 { 3389 bool skipCall = false; 3390 3391 skipCall |= validate_required_handle(report_data, "vkGetSwapchainImagesKHR", "swapchain", swapchain); 3392 3393 skipCall |= validate_array(report_data, "vkGetSwapchainImagesKHR", "pSwapchainImageCount", "pSwapchainImages", pSwapchainImageCount, pSwapchainImages, true, false, false); 3394 3395 return skipCall; 3396 } 3397 3398 static bool parameter_validation_vkAcquireNextImageKHR( 3399 debug_report_data* report_data, 3400 VkSwapchainKHR swapchain, 3401 uint64_t timeout, 3402 VkSemaphore semaphore, 3403 VkFence fence, 3404 uint32_t* pImageIndex) 3405 { 3406 UNUSED_PARAMETER(timeout); 3407 UNUSED_PARAMETER(semaphore); 3408 UNUSED_PARAMETER(fence); 3409 3410 bool skipCall = false; 3411 3412 skipCall |= validate_required_handle(report_data, "vkAcquireNextImageKHR", "swapchain", swapchain); 3413 3414 skipCall |= validate_required_pointer(report_data, "vkAcquireNextImageKHR", "pImageIndex", pImageIndex); 3415 3416 return skipCall; 3417 } 3418 3419 static bool parameter_validation_vkQueuePresentKHR( 3420 debug_report_data* report_data, 3421 const VkPresentInfoKHR* pPresentInfo) 3422 { 3423 bool skipCall = false; 3424 3425 skipCall |= validate_struct_type(report_data, "vkQueuePresentKHR", "pPresentInfo", "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR", pPresentInfo, VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, true); 3426 3427 if (pPresentInfo != NULL) 3428 { 3429 skipCall |= validate_struct_pnext(report_data, "vkQueuePresentKHR", "pPresentInfo->pNext", NULL, pPresentInfo->pNext, 0, NULL, GeneratedHeaderVersion); 3430 3431 skipCall |= validate_handle_array(report_data, "vkQueuePresentKHR", "pPresentInfo->swapchainCount", "pPresentInfo->pSwapchains", pPresentInfo->swapchainCount, pPresentInfo->pSwapchains, true, true); 3432 3433 skipCall |= validate_array(report_data, "vkQueuePresentKHR", "pPresentInfo->swapchainCount", "pPresentInfo->pImageIndices", pPresentInfo->swapchainCount, pPresentInfo->pImageIndices, true, true); 3434 3435 skipCall |= validate_array(report_data, "vkQueuePresentKHR", "pPresentInfo->swapchainCount", "pPresentInfo->pResults", pPresentInfo->swapchainCount, pPresentInfo->pResults, true, false); 3436 } 3437 3438 return skipCall; 3439 } 3440 3441 3442 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; 3443 3444 static bool parameter_validation_vkGetPhysicalDeviceDisplayPropertiesKHR( 3445 debug_report_data* report_data, 3446 uint32_t* pPropertyCount, 3447 VkDisplayPropertiesKHR* pProperties) 3448 { 3449 bool skipCall = false; 3450 3451 skipCall |= validate_array(report_data, "vkGetPhysicalDeviceDisplayPropertiesKHR", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false); 3452 3453 return skipCall; 3454 } 3455 3456 static bool parameter_validation_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( 3457 debug_report_data* report_data, 3458 uint32_t* pPropertyCount, 3459 VkDisplayPlanePropertiesKHR* pProperties) 3460 { 3461 bool skipCall = false; 3462 3463 skipCall |= validate_array(report_data, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false); 3464 3465 return skipCall; 3466 } 3467 3468 static bool parameter_validation_vkGetDisplayPlaneSupportedDisplaysKHR( 3469 debug_report_data* report_data, 3470 uint32_t planeIndex, 3471 uint32_t* pDisplayCount, 3472 VkDisplayKHR* pDisplays) 3473 { 3474 UNUSED_PARAMETER(planeIndex); 3475 3476 bool skipCall = false; 3477 3478 skipCall |= validate_array(report_data, "vkGetDisplayPlaneSupportedDisplaysKHR", "pDisplayCount", "pDisplays", pDisplayCount, pDisplays, true, false, false); 3479 3480 return skipCall; 3481 } 3482 3483 static bool parameter_validation_vkGetDisplayModePropertiesKHR( 3484 debug_report_data* report_data, 3485 VkDisplayKHR display, 3486 uint32_t* pPropertyCount, 3487 VkDisplayModePropertiesKHR* pProperties) 3488 { 3489 bool skipCall = false; 3490 3491 skipCall |= validate_required_handle(report_data, "vkGetDisplayModePropertiesKHR", "display", display); 3492 3493 skipCall |= validate_array(report_data, "vkGetDisplayModePropertiesKHR", "pPropertyCount", "pProperties", pPropertyCount, pProperties, true, false, false); 3494 3495 return skipCall; 3496 } 3497 3498 static bool parameter_validation_vkCreateDisplayModeKHR( 3499 debug_report_data* report_data, 3500 VkDisplayKHR display, 3501 const VkDisplayModeCreateInfoKHR* pCreateInfo, 3502 const VkAllocationCallbacks* pAllocator, 3503 VkDisplayModeKHR* pMode) 3504 { 3505 UNUSED_PARAMETER(pAllocator); 3506 3507 bool skipCall = false; 3508 3509 skipCall |= validate_required_handle(report_data, "vkCreateDisplayModeKHR", "display", display); 3510 3511 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); 3512 3513 if (pCreateInfo != NULL) 3514 { 3515 skipCall |= validate_struct_pnext(report_data, "vkCreateDisplayModeKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 3516 3517 skipCall |= validate_reserved_flags(report_data, "vkCreateDisplayModeKHR", "pCreateInfo->flags", pCreateInfo->flags); 3518 } 3519 3520 skipCall |= validate_required_pointer(report_data, "vkCreateDisplayModeKHR", "pMode", pMode); 3521 3522 return skipCall; 3523 } 3524 3525 static bool parameter_validation_vkGetDisplayPlaneCapabilitiesKHR( 3526 debug_report_data* report_data, 3527 VkDisplayModeKHR mode, 3528 uint32_t planeIndex, 3529 VkDisplayPlaneCapabilitiesKHR* pCapabilities) 3530 { 3531 UNUSED_PARAMETER(planeIndex); 3532 3533 bool skipCall = false; 3534 3535 skipCall |= validate_required_handle(report_data, "vkGetDisplayPlaneCapabilitiesKHR", "mode", mode); 3536 3537 skipCall |= validate_required_pointer(report_data, "vkGetDisplayPlaneCapabilitiesKHR", "pCapabilities", pCapabilities); 3538 3539 return skipCall; 3540 } 3541 3542 static bool parameter_validation_vkCreateDisplayPlaneSurfaceKHR( 3543 debug_report_data* report_data, 3544 const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, 3545 const VkAllocationCallbacks* pAllocator, 3546 VkSurfaceKHR* pSurface) 3547 { 3548 UNUSED_PARAMETER(pAllocator); 3549 3550 bool skipCall = false; 3551 3552 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); 3553 3554 if (pCreateInfo != NULL) 3555 { 3556 skipCall |= validate_struct_pnext(report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 3557 3558 skipCall |= validate_reserved_flags(report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags); 3559 3560 skipCall |= validate_required_handle(report_data, "vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->displayMode", pCreateInfo->displayMode); 3561 } 3562 3563 skipCall |= validate_required_pointer(report_data, "vkCreateDisplayPlaneSurfaceKHR", "pSurface", pSurface); 3564 3565 return skipCall; 3566 } 3567 3568 3569 3570 static bool parameter_validation_vkCreateSharedSwapchainsKHR( 3571 debug_report_data* report_data, 3572 uint32_t swapchainCount, 3573 const VkSwapchainCreateInfoKHR* pCreateInfos, 3574 const VkAllocationCallbacks* pAllocator, 3575 VkSwapchainKHR* pSwapchains) 3576 { 3577 UNUSED_PARAMETER(pAllocator); 3578 3579 bool skipCall = false; 3580 3581 skipCall |= validate_array(report_data, "vkCreateSharedSwapchainsKHR", "swapchainCount", "pCreateInfos", swapchainCount, pCreateInfos, true, true); 3582 3583 skipCall |= validate_array(report_data, "vkCreateSharedSwapchainsKHR", "swapchainCount", "pSwapchains", swapchainCount, pSwapchains, true, true); 3584 3585 return skipCall; 3586 } 3587 3588 3589 #ifdef VK_USE_PLATFORM_XLIB_KHR 3590 3591 static bool parameter_validation_vkCreateXlibSurfaceKHR( 3592 debug_report_data* report_data, 3593 const VkXlibSurfaceCreateInfoKHR* pCreateInfo, 3594 const VkAllocationCallbacks* pAllocator, 3595 VkSurfaceKHR* pSurface) 3596 { 3597 UNUSED_PARAMETER(pAllocator); 3598 3599 bool skipCall = false; 3600 3601 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); 3602 3603 if (pCreateInfo != NULL) 3604 { 3605 skipCall |= validate_struct_pnext(report_data, "vkCreateXlibSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 3606 3607 skipCall |= validate_reserved_flags(report_data, "vkCreateXlibSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags); 3608 3609 skipCall |= validate_required_pointer(report_data, "vkCreateXlibSurfaceKHR", "pCreateInfo->dpy", pCreateInfo->dpy); 3610 } 3611 3612 skipCall |= validate_required_pointer(report_data, "vkCreateXlibSurfaceKHR", "pSurface", pSurface); 3613 3614 return skipCall; 3615 } 3616 3617 static bool parameter_validation_vkGetPhysicalDeviceXlibPresentationSupportKHR( 3618 debug_report_data* report_data, 3619 uint32_t queueFamilyIndex, 3620 Display* dpy, 3621 VisualID visualID) 3622 { 3623 UNUSED_PARAMETER(queueFamilyIndex); 3624 UNUSED_PARAMETER(visualID); 3625 3626 bool skipCall = false; 3627 3628 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceXlibPresentationSupportKHR", "dpy", dpy); 3629 3630 return skipCall; 3631 } 3632 #endif /* VK_USE_PLATFORM_XLIB_KHR */ 3633 3634 #ifdef VK_USE_PLATFORM_XCB_KHR 3635 3636 static bool parameter_validation_vkCreateXcbSurfaceKHR( 3637 debug_report_data* report_data, 3638 const VkXcbSurfaceCreateInfoKHR* pCreateInfo, 3639 const VkAllocationCallbacks* pAllocator, 3640 VkSurfaceKHR* pSurface) 3641 { 3642 UNUSED_PARAMETER(pAllocator); 3643 3644 bool skipCall = false; 3645 3646 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); 3647 3648 if (pCreateInfo != NULL) 3649 { 3650 skipCall |= validate_struct_pnext(report_data, "vkCreateXcbSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 3651 3652 skipCall |= validate_reserved_flags(report_data, "vkCreateXcbSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags); 3653 3654 skipCall |= validate_required_pointer(report_data, "vkCreateXcbSurfaceKHR", "pCreateInfo->connection", pCreateInfo->connection); 3655 } 3656 3657 skipCall |= validate_required_pointer(report_data, "vkCreateXcbSurfaceKHR", "pSurface", pSurface); 3658 3659 return skipCall; 3660 } 3661 3662 static bool parameter_validation_vkGetPhysicalDeviceXcbPresentationSupportKHR( 3663 debug_report_data* report_data, 3664 uint32_t queueFamilyIndex, 3665 xcb_connection_t* connection, 3666 xcb_visualid_t visual_id) 3667 { 3668 UNUSED_PARAMETER(queueFamilyIndex); 3669 UNUSED_PARAMETER(visual_id); 3670 3671 bool skipCall = false; 3672 3673 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceXcbPresentationSupportKHR", "connection", connection); 3674 3675 return skipCall; 3676 } 3677 #endif /* VK_USE_PLATFORM_XCB_KHR */ 3678 3679 #ifdef VK_USE_PLATFORM_WAYLAND_KHR 3680 3681 static bool parameter_validation_vkCreateWaylandSurfaceKHR( 3682 debug_report_data* report_data, 3683 const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, 3684 const VkAllocationCallbacks* pAllocator, 3685 VkSurfaceKHR* pSurface) 3686 { 3687 UNUSED_PARAMETER(pAllocator); 3688 3689 bool skipCall = false; 3690 3691 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); 3692 3693 if (pCreateInfo != NULL) 3694 { 3695 skipCall |= validate_struct_pnext(report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 3696 3697 skipCall |= validate_reserved_flags(report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags); 3698 3699 skipCall |= validate_required_pointer(report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo->display", pCreateInfo->display); 3700 3701 skipCall |= validate_required_pointer(report_data, "vkCreateWaylandSurfaceKHR", "pCreateInfo->surface", pCreateInfo->surface); 3702 } 3703 3704 skipCall |= validate_required_pointer(report_data, "vkCreateWaylandSurfaceKHR", "pSurface", pSurface); 3705 3706 return skipCall; 3707 } 3708 3709 static bool parameter_validation_vkGetPhysicalDeviceWaylandPresentationSupportKHR( 3710 debug_report_data* report_data, 3711 uint32_t queueFamilyIndex, 3712 struct wl_display* display) 3713 { 3714 UNUSED_PARAMETER(queueFamilyIndex); 3715 3716 bool skipCall = false; 3717 3718 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceWaylandPresentationSupportKHR", "display", display); 3719 3720 return skipCall; 3721 } 3722 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */ 3723 3724 #ifdef VK_USE_PLATFORM_MIR_KHR 3725 3726 static bool parameter_validation_vkCreateMirSurfaceKHR( 3727 debug_report_data* report_data, 3728 const VkMirSurfaceCreateInfoKHR* pCreateInfo, 3729 const VkAllocationCallbacks* pAllocator, 3730 VkSurfaceKHR* pSurface) 3731 { 3732 UNUSED_PARAMETER(pAllocator); 3733 3734 bool skipCall = false; 3735 3736 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); 3737 3738 if (pCreateInfo != NULL) 3739 { 3740 skipCall |= validate_struct_pnext(report_data, "vkCreateMirSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 3741 3742 skipCall |= validate_reserved_flags(report_data, "vkCreateMirSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags); 3743 3744 skipCall |= validate_required_pointer(report_data, "vkCreateMirSurfaceKHR", "pCreateInfo->connection", pCreateInfo->connection); 3745 3746 skipCall |= validate_required_pointer(report_data, "vkCreateMirSurfaceKHR", "pCreateInfo->mirSurface", pCreateInfo->mirSurface); 3747 } 3748 3749 skipCall |= validate_required_pointer(report_data, "vkCreateMirSurfaceKHR", "pSurface", pSurface); 3750 3751 return skipCall; 3752 } 3753 3754 static bool parameter_validation_vkGetPhysicalDeviceMirPresentationSupportKHR( 3755 debug_report_data* report_data, 3756 uint32_t queueFamilyIndex, 3757 MirConnection* connection) 3758 { 3759 UNUSED_PARAMETER(queueFamilyIndex); 3760 3761 bool skipCall = false; 3762 3763 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceMirPresentationSupportKHR", "connection", connection); 3764 3765 return skipCall; 3766 } 3767 #endif /* VK_USE_PLATFORM_MIR_KHR */ 3768 3769 #ifdef VK_USE_PLATFORM_ANDROID_KHR 3770 3771 static bool parameter_validation_vkCreateAndroidSurfaceKHR( 3772 debug_report_data* report_data, 3773 const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, 3774 const VkAllocationCallbacks* pAllocator, 3775 VkSurfaceKHR* pSurface) 3776 { 3777 UNUSED_PARAMETER(pAllocator); 3778 3779 bool skipCall = false; 3780 3781 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); 3782 3783 if (pCreateInfo != NULL) 3784 { 3785 skipCall |= validate_struct_pnext(report_data, "vkCreateAndroidSurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 3786 3787 skipCall |= validate_reserved_flags(report_data, "vkCreateAndroidSurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags); 3788 3789 skipCall |= validate_required_pointer(report_data, "vkCreateAndroidSurfaceKHR", "pCreateInfo->window", pCreateInfo->window); 3790 } 3791 3792 skipCall |= validate_required_pointer(report_data, "vkCreateAndroidSurfaceKHR", "pSurface", pSurface); 3793 3794 return skipCall; 3795 } 3796 #endif /* VK_USE_PLATFORM_ANDROID_KHR */ 3797 3798 #ifdef VK_USE_PLATFORM_WIN32_KHR 3799 3800 static bool parameter_validation_vkCreateWin32SurfaceKHR( 3801 debug_report_data* report_data, 3802 const VkWin32SurfaceCreateInfoKHR* pCreateInfo, 3803 const VkAllocationCallbacks* pAllocator, 3804 VkSurfaceKHR* pSurface) 3805 { 3806 UNUSED_PARAMETER(pAllocator); 3807 3808 bool skipCall = false; 3809 3810 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); 3811 3812 if (pCreateInfo != NULL) 3813 { 3814 skipCall |= validate_struct_pnext(report_data, "vkCreateWin32SurfaceKHR", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedHeaderVersion); 3815 3816 skipCall |= validate_reserved_flags(report_data, "vkCreateWin32SurfaceKHR", "pCreateInfo->flags", pCreateInfo->flags); 3817 } 3818 3819 skipCall |= validate_required_pointer(report_data, "vkCreateWin32SurfaceKHR", "pSurface", pSurface); 3820 3821 return skipCall; 3822 } 3823 #endif /* VK_USE_PLATFORM_WIN32_KHR */ 3824 3825 3826 3827 3828 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; 3829 3830 static bool parameter_validation_vkDestroyDebugReportCallbackEXT( 3831 debug_report_data* report_data, 3832 VkDebugReportCallbackEXT callback, 3833 const VkAllocationCallbacks* pAllocator) 3834 { 3835 UNUSED_PARAMETER(pAllocator); 3836 3837 bool skipCall = false; 3838 3839 skipCall |= validate_required_handle(report_data, "vkDestroyDebugReportCallbackEXT", "callback", callback); 3840 3841 return skipCall; 3842 } 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 static bool parameter_validation_vkDebugMarkerSetObjectTagEXT( 3862 debug_report_data* report_data, 3863 VkDebugMarkerObjectTagInfoEXT* pTagInfo) 3864 { 3865 bool skipCall = false; 3866 3867 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); 3868 3869 return skipCall; 3870 } 3871 3872 static bool parameter_validation_vkDebugMarkerSetObjectNameEXT( 3873 debug_report_data* report_data, 3874 VkDebugMarkerObjectNameInfoEXT* pNameInfo) 3875 { 3876 bool skipCall = false; 3877 3878 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); 3879 3880 return skipCall; 3881 } 3882 3883 static bool parameter_validation_vkCmdDebugMarkerBeginEXT( 3884 debug_report_data* report_data, 3885 VkDebugMarkerMarkerInfoEXT* pMarkerInfo) 3886 { 3887 bool skipCall = false; 3888 3889 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); 3890 3891 return skipCall; 3892 } 3893 3894 static bool parameter_validation_vkCmdDebugMarkerInsertEXT( 3895 debug_report_data* report_data, 3896 VkDebugMarkerMarkerInfoEXT* pMarkerInfo) 3897 { 3898 bool skipCall = false; 3899 3900 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); 3901 3902 return skipCall; 3903 } 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 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; 3928 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; 3929 3930 static bool parameter_validation_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( 3931 debug_report_data* report_data, 3932 VkFormat format, 3933 VkImageType type, 3934 VkImageTiling tiling, 3935 VkImageUsageFlags usage, 3936 VkImageCreateFlags flags, 3937 VkExternalMemoryHandleTypeFlagsNV externalHandleType, 3938 VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) 3939 { 3940 UNUSED_PARAMETER(format); 3941 UNUSED_PARAMETER(type); 3942 UNUSED_PARAMETER(tiling); 3943 UNUSED_PARAMETER(usage); 3944 UNUSED_PARAMETER(flags); 3945 3946 bool skipCall = false; 3947 3948 skipCall |= validate_flags(report_data, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "externalHandleType", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, externalHandleType, true); 3949 3950 skipCall |= validate_required_pointer(report_data, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "pExternalImageFormatProperties", pExternalImageFormatProperties); 3951 3952 return skipCall; 3953 } 3954 3955 3956 3957 3958 3959 #ifdef VK_USE_PLATFORM_WIN32_KHR 3960 3961 static bool parameter_validation_vkGetMemoryWin32HandleNV( 3962 debug_report_data* report_data, 3963 VkDeviceMemory memory, 3964 VkExternalMemoryHandleTypeFlagsNV handleType, 3965 HANDLE* pHandle) 3966 { 3967 UNUSED_PARAMETER(memory); 3968 UNUSED_PARAMETER(handleType); 3969 3970 bool skipCall = false; 3971 3972 skipCall |= validate_required_pointer(report_data, "vkGetMemoryWin32HandleNV", "pHandle", pHandle); 3973 3974 return skipCall; 3975 } 3976 #endif /* VK_USE_PLATFORM_WIN32_KHR */ 3977 3978 #ifdef VK_USE_PLATFORM_WIN32_KHR 3979 3980 #endif /* VK_USE_PLATFORM_WIN32_KHR */ 3981 3982 3983 3984 3985 } // namespace parameter_validation 3986 3987 #endif 3988
