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